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
194
if
(frame) {
195
switch
(avctx->
sample_fmt
) {
196
case
AV_SAMPLE_FMT_S16P
:
197
ENCODE_BUFFER
(lame_encode_buffer, int16_t, frame->
data
);
198
break
;
199
case
AV_SAMPLE_FMT_S32P
:
200
ENCODE_BUFFER
(lame_encode_buffer_int,
int32_t
, frame->
data
);
201
break
;
202
case
AV_SAMPLE_FMT_FLTP
:
203
if
(frame->
linesize
[0] < 4 *
FFALIGN
(frame->
nb_samples
, 8)) {
204
av_log
(avctx,
AV_LOG_ERROR
,
"inadequate AVFrame plane padding\n"
);
205
return
AVERROR
(EINVAL);
206
}
207
for
(ch = 0; ch < avctx->
channels
; ch++) {
208
s->
fdsp
.
vector_fmul_scalar
(s->
samples_flt
[ch],
209
(
const
float
*)frame->
data
[ch],
210
32768.0f,
211
FFALIGN
(frame->
nb_samples
, 8));
212
}
213
ENCODE_BUFFER
(lame_encode_buffer_float,
float
, s->
samples_flt
);
214
break
;
215
default
:
216
return
AVERROR_BUG
;
217
}
218
}
else
{
219
lame_result = lame_encode_flush(s->
gfp
, s->
buffer
+ s->
buffer_index
,
220
s->
buffer_size
- s->
buffer_index
);
221
}
222
if
(lame_result < 0) {
223
if
(lame_result == -1) {
224
av_log
(avctx,
AV_LOG_ERROR
,
225
"lame: output buffer too small (buffer index: %d, free bytes: %d)\n"
,
226
s->
buffer_index
, s->
buffer_size
- s->
buffer_index
);
227
}
228
return
-1;
229
}
230
s->
buffer_index
+= lame_result;
231
ret =
realloc_buffer
(s);
232
if
(ret < 0) {
233
av_log
(avctx,
AV_LOG_ERROR
,
"error reallocating output buffer\n"
);
234
return
ret;
235
}
236
237
/* add current frame to the queue */
238
if
(frame) {
239
if
((ret =
ff_af_queue_add
(&s->
afq
, frame)) < 0)
240
return
ret;
241
}
242
243
/* Move 1 frame from the LAME buffer to the output packet, if available.
244
We have to parse the first frame header in the output buffer to
245
determine the frame size. */
246
if
(s->
buffer_index
< 4)
247
return
0;
248
if
(
avpriv_mpegaudio_decode_header
(&hdr,
AV_RB32
(s->
buffer
))) {
249
av_log
(avctx,
AV_LOG_ERROR
,
"free format output not supported\n"
);
250
return
-1;
251
}
252
len = hdr.frame_size;
253
av_dlog
(avctx,
"in:%d packet-len:%d index:%d\n"
, avctx->
frame_size
, len,
254
s->
buffer_index
);
255
if
(len <= s->buffer_index) {
256
if
((ret =
ff_alloc_packet
(avpkt, len))) {
257
av_log
(avctx,
AV_LOG_ERROR
,
"Error getting output packet\n"
);
258
return
ret;
259
}
260
memcpy(avpkt->
data
, s->
buffer
, len);
261
s->
buffer_index
-=
len
;
262
memmove(s->
buffer
, s->
buffer
+ len, s->
buffer_index
);
263
264
/* Get the next frame pts/duration */
265
ff_af_queue_remove
(&s->
afq
, avctx->
frame_size
, &avpkt->
pts
,
266
&avpkt->
duration
);
267
268
avpkt->
size
=
len
;
269
*got_packet_ptr = 1;
270
}
271
return
0;
272
}
273
274
#define OFFSET(x) offsetof(LAMEContext, x)
275
#define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
276
static
const
AVOption
options
[] = {
277
{
"reservoir"
,
"Use bit reservoir."
,
OFFSET
(reservoir),
AV_OPT_TYPE_INT
, { .i64 = 1 }, 0, 1,
AE
},
278
{
NULL
},
279
};
280
281
static
const
AVClass
libmp3lame_class
= {
282
.
class_name
=
"libmp3lame encoder"
,
283
.item_name =
av_default_item_name
,
284
.option =
options
,
285
.version =
LIBAVUTIL_VERSION_INT
,
286
};
287
288
static
const
AVCodecDefault
libmp3lame_defaults
[] = {
289
{
"b"
,
"0"
},
290
{
NULL
},
291
};
292
293
static
const
int
libmp3lame_sample_rates
[] = {
294
44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000, 0
295
};
296
297
AVCodec
ff_libmp3lame_encoder
= {
298
.
name
=
"libmp3lame"
,
299
.type =
AVMEDIA_TYPE_AUDIO
,
300
.id =
AV_CODEC_ID_MP3
,
301
.priv_data_size =
sizeof
(
LAMEContext
),
302
.
init
=
mp3lame_encode_init
,
303
.encode2 =
mp3lame_encode_frame
,
304
.
close
=
mp3lame_encode_close
,
305
.capabilities =
CODEC_CAP_DELAY
|
CODEC_CAP_SMALL_LAST_FRAME
,
306
.
sample_fmts
= (
const
enum
AVSampleFormat
[]) {
AV_SAMPLE_FMT_S32P
,
307
AV_SAMPLE_FMT_FLTP
,
308
AV_SAMPLE_FMT_S16P
,
309
AV_SAMPLE_FMT_NONE
},
310
.supported_samplerates =
libmp3lame_sample_rates
,
311
.channel_layouts = (
const
uint64_t[]) {
AV_CH_LAYOUT_MONO
,
312
AV_CH_LAYOUT_STEREO
,
313
0 },
314
.long_name =
NULL_IF_CONFIG_SMALL
(
"libmp3lame MP3 (MPEG audio layer 3)"
),
315
.priv_class = &
libmp3lame_class
,
316
.defaults =
libmp3lame_defaults
,
317
};