Main Page
Related Pages
Modules
Data Structures
Files
Examples
File List
Globals
libavcodec
libmp3lame.c
Go to the documentation of this file.
1
/*
2
* Interface to libmp3lame for mp3 encoding
3
* Copyright (c) 2002 Lennert Buytenhek <buytenh@gnu.org>
4
*
5
* This file is part of Libav.
6
*
7
* Libav is free software; you can redistribute it and/or
8
* modify it under the terms of the GNU Lesser General Public
9
* License as published by the Free Software Foundation; either
10
* version 2.1 of the License, or (at your option) any later version.
11
*
12
* Libav is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15
* Lesser General Public License for more details.
16
*
17
* You should have received a copy of the GNU Lesser General Public
18
* License along with Libav; if not, write to the Free Software
19
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
*/
21
27
#include <lame/lame.h>
28
29
#include "
libavutil/channel_layout.h
"
30
#include "
libavutil/common.h
"
31
#include "
libavutil/float_dsp.h
"
32
#include "
libavutil/intreadwrite.h
"
33
#include "
libavutil/log.h
"
34
#include "
libavutil/opt.h
"
35
#include "
avcodec.h
"
36
#include "
audio_frame_queue.h
"
37
#include "
internal.h
"
38
#include "
mpegaudio.h
"
39
#include "
mpegaudiodecheader.h
"
40
41
#define BUFFER_SIZE (7200 + 2 * MPA_FRAME_SIZE + MPA_FRAME_SIZE / 4)
42
43
typedef
struct
LAMEContext
{
44
AVClass
*
class
;
45
AVCodecContext
*
avctx
;
46
lame_global_flags *
gfp
;
47
uint8_t
*
buffer
;
48
int
buffer_index
;
49
int
buffer_size
;
50
int
reservoir
;
51
float
*
samples_flt
[2];
52
AudioFrameQueue
afq
;
53
AVFloatDSPContext
fdsp
;
54
}
LAMEContext
;
55
56
57
static
int
realloc_buffer
(
LAMEContext
*s)
58
{
59
if
(!s->
buffer
|| s->
buffer_size
- s->
buffer_index
<
BUFFER_SIZE
) {
60
uint8_t
*tmp;
61
int
new_size = s->
buffer_index
+ 2 *
BUFFER_SIZE
;
62
63
av_dlog
(s->
avctx
,
"resizing output buffer: %d -> %d\n"
, s->
buffer_size
,
64
new_size);
65
tmp =
av_realloc
(s->
buffer
, new_size);
66
if
(!tmp) {
67
av_freep
(&s->
buffer
);
68
s->
buffer_size
= s->
buffer_index
= 0;
69
return
AVERROR
(ENOMEM);
70
}
71
s->
buffer
= tmp;
72
s->
buffer_size
= new_size;
73
}
74
return
0;
75
}
76
77
static
av_cold
int
mp3lame_encode_close
(
AVCodecContext
*avctx)
78
{
79
LAMEContext
*s = avctx->
priv_data
;
80
81
#if FF_API_OLD_ENCODE_AUDIO
82
av_freep
(&avctx->
coded_frame
);
83
#endif
84
av_freep
(&s->
samples_flt
[0]);
85
av_freep
(&s->
samples_flt
[1]);
86
av_freep
(&s->
buffer
);
87
88
ff_af_queue_close
(&s->
afq
);
89
90
lame_close(s->
gfp
);
91
return
0;
92
}
93
94
static
av_cold
int
mp3lame_encode_init
(
AVCodecContext
*avctx)
95
{
96
LAMEContext
*s = avctx->
priv_data
;
97
int
ret;
98
99
s->
avctx
= avctx;
100
101
/* initialize LAME and get defaults */
102
if
((s->
gfp
= lame_init()) ==
NULL
)
103
return
AVERROR
(ENOMEM);
104
105
lame_set_num_channels(s->
gfp
, avctx->
channels
);
106
lame_set_mode(s->
gfp
, avctx->
channels
> 1 ?
JOINT_STEREO
:
MONO
);
107
108
/* sample rate */
109
lame_set_in_samplerate (s->
gfp
, avctx->
sample_rate
);
110
lame_set_out_samplerate(s->
gfp
, avctx->
sample_rate
);
111
112
/* algorithmic quality */
113
if
(avctx->
compression_level
==
FF_COMPRESSION_DEFAULT
)
114
lame_set_quality(s->
gfp
, 5);
115
else
116
lame_set_quality(s->
gfp
, avctx->
compression_level
);
117
118
/* rate control */
119
if
(avctx->
flags
&
CODEC_FLAG_QSCALE
) {
120
lame_set_VBR(s->
gfp
, vbr_default);
121
lame_set_VBR_quality(s->
gfp
, avctx->
global_quality
/ (
float
)
FF_QP2LAMBDA
);
122
}
else
{
123
if
(avctx->
bit_rate
)
124
lame_set_brate(s->
gfp
, avctx->
bit_rate
/ 1000);
125
}
126
127
/* do not get a Xing VBR header frame from LAME */
128
lame_set_bWriteVbrTag(s->
gfp
,0);
129
130
/* bit reservoir usage */
131
lame_set_disable_reservoir(s->
gfp
, !s->
reservoir
);
132
133
/* set specified parameters */
134
if
(lame_init_params(s->
gfp
) < 0) {
135
ret = -1;
136
goto
error;
137
}
138
139
/* get encoder delay */
140
avctx->
delay
= lame_get_encoder_delay(s->
gfp
) + 528 + 1;
141
ff_af_queue_init
(avctx, &s->
afq
);
142
143
avctx->
frame_size
= lame_get_framesize(s->
gfp
);
144
145
#if FF_API_OLD_ENCODE_AUDIO
146
avctx->
coded_frame
=
avcodec_alloc_frame
();
147
if
(!avctx->
coded_frame
) {
148
ret =
AVERROR
(ENOMEM);
149
goto
error;
150
}
151
#endif
152
153
/* allocate float sample buffers */
154
if
(avctx->
sample_fmt
==
AV_SAMPLE_FMT_FLTP
) {
155
int
ch;
156
for
(ch = 0; ch < avctx->
channels
; ch++) {
157
s->
samples_flt
[ch] =
av_malloc
(avctx->
frame_size
*
158
sizeof
(*s->
samples_flt
[ch]));
159
if
(!s->
samples_flt
[ch]) {
160
ret =
AVERROR
(ENOMEM);
161
goto
error;
162
}
163
}
164
}
165
166
ret =
realloc_buffer
(s);
167
if
(ret < 0)
168
goto
error;
169
170
avpriv_float_dsp_init
(&s->
fdsp
, avctx->
flags
&
CODEC_FLAG_BITEXACT
);
171
172
return
0;
173
error:
174
mp3lame_encode_close
(avctx);
175
return
ret;
176
}
177
178
#define ENCODE_BUFFER(func, buf_type, buf_name) do { \
179
lame_result = func(s->gfp, \
180
(const buf_type *)buf_name[0], \
181
(const buf_type *)buf_name[1], frame->nb_samples, \
182
s->buffer + s->buffer_index, \
183
s->buffer_size - s->buffer_index); \
184
} while (0)
185
186
static
int
mp3lame_encode_frame
(
AVCodecContext
*avctx,
AVPacket
*avpkt,
187
const
AVFrame
*frame,
int
*got_packet_ptr)
188
{
189
LAMEContext
*s = avctx->
priv_data
;
190
MPADecodeHeader
hdr;
191
int
len
, ret, ch;
192
int
lame_result;
193
uint32_t h;
194
195
if
(frame) {
196
switch
(avctx->
sample_fmt
) {
197
case
AV_SAMPLE_FMT_S16P
:
198
ENCODE_BUFFER
(lame_encode_buffer, int16_t, frame->
data
);
199
break
;
200
case
AV_SAMPLE_FMT_S32P
:
201
ENCODE_BUFFER
(lame_encode_buffer_int,
int32_t
, frame->
data
);
202
break
;
203
case
AV_SAMPLE_FMT_FLTP
:
204
if
(frame->
linesize
[0] < 4 *
FFALIGN
(frame->
nb_samples
, 8)) {
205
av_log
(avctx,
AV_LOG_ERROR
,
"inadequate AVFrame plane padding\n"
);
206
return
AVERROR
(EINVAL);
207
}
208
for
(ch = 0; ch < avctx->
channels
; ch++) {
209
s->
fdsp
.
vector_fmul_scalar
(s->
samples_flt
[ch],
210
(
const
float
*)frame->
data
[ch],
211
32768.0f,
212
FFALIGN
(frame->
nb_samples
, 8));
213
}
214
ENCODE_BUFFER
(lame_encode_buffer_float,
float
, s->
samples_flt
);
215
break
;
216
default
:
217
return
AVERROR_BUG
;
218
}
219
}
else
{
220
lame_result = lame_encode_flush(s->
gfp
, s->
buffer
+ s->
buffer_index
,
221
s->
buffer_size
- s->
buffer_index
);
222
}
223
if
(lame_result < 0) {
224
if
(lame_result == -1) {
225
av_log
(avctx,
AV_LOG_ERROR
,
226
"lame: output buffer too small (buffer index: %d, free bytes: %d)\n"
,
227
s->
buffer_index
, s->
buffer_size
- s->
buffer_index
);
228
}
229
return
-1;
230
}
231
s->
buffer_index
+= lame_result;
232
ret =
realloc_buffer
(s);
233
if
(ret < 0) {
234
av_log
(avctx,
AV_LOG_ERROR
,
"error reallocating output buffer\n"
);
235
return
ret;
236
}
237
238
/* add current frame to the queue */
239
if
(frame) {
240
if
((ret =
ff_af_queue_add
(&s->
afq
, frame)) < 0)
241
return
ret;
242
}
243
244
/* Move 1 frame from the LAME buffer to the output packet, if available.
245
We have to parse the first frame header in the output buffer to
246
determine the frame size. */
247
if
(s->
buffer_index
< 4)
248
return
0;
249
h =
AV_RB32
(s->
buffer
);
250
if
(
ff_mpa_check_header
(h) < 0) {
251
av_log
(avctx,
AV_LOG_ERROR
,
"Invalid mp3 header at start of buffer\n"
);
252
return
AVERROR_BUG
;
253
}
254
if
(
avpriv_mpegaudio_decode_header
(&hdr, h)) {
255
av_log
(avctx,
AV_LOG_ERROR
,
"free format output not supported\n"
);
256
return
-1;
257
}
258
len = hdr.frame_size;
259
av_dlog
(avctx,
"in:%d packet-len:%d index:%d\n"
, avctx->
frame_size
, len,
260
s->
buffer_index
);
261
if
(len <= s->buffer_index) {
262
if
((ret =
ff_alloc_packet
(avpkt, len))) {
263
av_log
(avctx,
AV_LOG_ERROR
,
"Error getting output packet\n"
);
264
return
ret;
265
}
266
memcpy(avpkt->
data
, s->
buffer
, len);
267
s->
buffer_index
-=
len
;
268
memmove(s->
buffer
, s->
buffer
+ len, s->
buffer_index
);
269
270
/* Get the next frame pts/duration */
271
ff_af_queue_remove
(&s->
afq
, avctx->
frame_size
, &avpkt->
pts
,
272
&avpkt->
duration
);
273
274
avpkt->
size
=
len
;
275
*got_packet_ptr = 1;
276
}
277
return
0;
278
}
279
280
#define OFFSET(x) offsetof(LAMEContext, x)
281
#define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
282
static
const
AVOption
options
[] = {
283
{
"reservoir"
,
"Use bit reservoir."
,
OFFSET
(reservoir),
AV_OPT_TYPE_INT
, { .i64 = 1 }, 0, 1,
AE
},
284
{
NULL
},
285
};
286
287
static
const
AVClass
libmp3lame_class
= {
288
.
class_name
=
"libmp3lame encoder"
,
289
.item_name =
av_default_item_name
,
290
.option =
options
,
291
.version =
LIBAVUTIL_VERSION_INT
,
292
};
293
294
static
const
AVCodecDefault
libmp3lame_defaults
[] = {
295
{
"b"
,
"0"
},
296
{
NULL
},
297
};
298
299
static
const
int
libmp3lame_sample_rates
[] = {
300
44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000, 0
301
};
302
303
AVCodec
ff_libmp3lame_encoder
= {
304
.
name
=
"libmp3lame"
,
305
.type =
AVMEDIA_TYPE_AUDIO
,
306
.id =
AV_CODEC_ID_MP3
,
307
.priv_data_size =
sizeof
(
LAMEContext
),
308
.
init
=
mp3lame_encode_init
,
309
.encode2 =
mp3lame_encode_frame
,
310
.
close
=
mp3lame_encode_close
,
311
.capabilities =
CODEC_CAP_DELAY
|
CODEC_CAP_SMALL_LAST_FRAME
,
312
.
sample_fmts
= (
const
enum
AVSampleFormat
[]) {
AV_SAMPLE_FMT_S32P
,
313
AV_SAMPLE_FMT_FLTP
,
314
AV_SAMPLE_FMT_S16P
,
315
AV_SAMPLE_FMT_NONE
},
316
.supported_samplerates =
libmp3lame_sample_rates
,
317
.channel_layouts = (
const
uint64_t[]) {
AV_CH_LAYOUT_MONO
,
318
AV_CH_LAYOUT_STEREO
,
319
0 },
320
.long_name =
NULL_IF_CONFIG_SMALL
(
"libmp3lame MP3 (MPEG audio layer 3)"
),
321
.priv_class = &
libmp3lame_class
,
322
.defaults =
libmp3lame_defaults
,
323
};