Libav
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
int
new_size = s->
buffer_index
+ 2 *
BUFFER_SIZE
, err;
61
62
av_dlog
(s->
avctx
,
"resizing output buffer: %d -> %d\n"
, s->
buffer_size
,
63
new_size);
64
if
((err =
av_reallocp
(&s->
buffer
, new_size)) < 0) {
65
s->
buffer_size
= s->
buffer_index
= 0;
66
return
err;
67
}
68
s->
buffer_size
= new_size;
69
}
70
return
0;
71
}
72
73
static
av_cold
int
mp3lame_encode_close
(
AVCodecContext
*avctx)
74
{
75
LAMEContext
*s = avctx->
priv_data
;
76
77
av_freep
(&s->
samples_flt
[0]);
78
av_freep
(&s->
samples_flt
[1]);
79
av_freep
(&s->
buffer
);
80
81
ff_af_queue_close
(&s->
afq
);
82
83
lame_close(s->
gfp
);
84
return
0;
85
}
86
87
static
av_cold
int
mp3lame_encode_init
(
AVCodecContext
*avctx)
88
{
89
LAMEContext
*s = avctx->
priv_data
;
90
int
ret;
91
92
s->
avctx
= avctx;
93
94
/* initialize LAME and get defaults */
95
if
((s->
gfp
= lame_init()) ==
NULL
)
96
return
AVERROR
(ENOMEM);
97
98
lame_set_num_channels(s->
gfp
, avctx->
channels
);
99
lame_set_mode(s->
gfp
, avctx->
channels
> 1 ?
JOINT_STEREO
:
MONO
);
100
101
/* sample rate */
102
lame_set_in_samplerate (s->
gfp
, avctx->
sample_rate
);
103
lame_set_out_samplerate(s->
gfp
, avctx->
sample_rate
);
104
105
/* algorithmic quality */
106
if
(avctx->
compression_level
==
FF_COMPRESSION_DEFAULT
)
107
lame_set_quality(s->
gfp
, 5);
108
else
109
lame_set_quality(s->
gfp
, avctx->
compression_level
);
110
111
/* rate control */
112
if
(avctx->
flags
&
CODEC_FLAG_QSCALE
) {
113
lame_set_VBR(s->
gfp
, vbr_default);
114
lame_set_VBR_quality(s->
gfp
, avctx->
global_quality
/ (
float
)
FF_QP2LAMBDA
);
115
}
else
{
116
if
(avctx->
bit_rate
)
117
lame_set_brate(s->
gfp
, avctx->
bit_rate
/ 1000);
118
}
119
120
/* do not get a Xing VBR header frame from LAME */
121
lame_set_bWriteVbrTag(s->
gfp
,0);
122
123
/* bit reservoir usage */
124
lame_set_disable_reservoir(s->
gfp
, !s->
reservoir
);
125
126
/* set specified parameters */
127
if
(lame_init_params(s->
gfp
) < 0) {
128
ret = -1;
129
goto
error;
130
}
131
132
/* get encoder delay */
133
avctx->
delay
= lame_get_encoder_delay(s->
gfp
) + 528 + 1;
134
ff_af_queue_init
(avctx, &s->
afq
);
135
136
avctx->
frame_size
= lame_get_framesize(s->
gfp
);
137
138
/* allocate float sample buffers */
139
if
(avctx->
sample_fmt
==
AV_SAMPLE_FMT_FLTP
) {
140
int
ch;
141
for
(ch = 0; ch < avctx->
channels
; ch++) {
142
s->
samples_flt
[ch] =
av_malloc
(avctx->
frame_size
*
143
sizeof
(*s->
samples_flt
[ch]));
144
if
(!s->
samples_flt
[ch]) {
145
ret =
AVERROR
(ENOMEM);
146
goto
error;
147
}
148
}
149
}
150
151
ret =
realloc_buffer
(s);
152
if
(ret < 0)
153
goto
error;
154
155
avpriv_float_dsp_init
(&s->
fdsp
, avctx->
flags
&
CODEC_FLAG_BITEXACT
);
156
157
return
0;
158
error:
159
mp3lame_encode_close
(avctx);
160
return
ret;
161
}
162
163
#define ENCODE_BUFFER(func, buf_type, buf_name) do { \
164
lame_result = func(s->gfp, \
165
(const buf_type *)buf_name[0], \
166
(const buf_type *)buf_name[1], frame->nb_samples, \
167
s->buffer + s->buffer_index, \
168
s->buffer_size - s->buffer_index); \
169
} while (0)
170
171
static
int
mp3lame_encode_frame
(
AVCodecContext
*avctx,
AVPacket
*avpkt,
172
const
AVFrame
*frame,
int
*got_packet_ptr)
173
{
174
LAMEContext
*s = avctx->
priv_data
;
175
MPADecodeHeader
hdr;
176
int
len
, ret, ch;
177
int
lame_result;
178
179
if
(frame) {
180
switch
(avctx->
sample_fmt
) {
181
case
AV_SAMPLE_FMT_S16P
:
182
ENCODE_BUFFER
(lame_encode_buffer, int16_t, frame->
data
);
183
break
;
184
case
AV_SAMPLE_FMT_S32P
:
185
ENCODE_BUFFER
(lame_encode_buffer_int,
int32_t
, frame->
data
);
186
break
;
187
case
AV_SAMPLE_FMT_FLTP
:
188
if
(frame->
linesize
[0] < 4 *
FFALIGN
(frame->
nb_samples
, 8)) {
189
av_log
(avctx,
AV_LOG_ERROR
,
"inadequate AVFrame plane padding\n"
);
190
return
AVERROR
(EINVAL);
191
}
192
for
(ch = 0; ch < avctx->
channels
; ch++) {
193
s->
fdsp
.
vector_fmul_scalar
(s->
samples_flt
[ch],
194
(
const
float
*)frame->
data
[ch],
195
32768.0f,
196
FFALIGN
(frame->
nb_samples
, 8));
197
}
198
ENCODE_BUFFER
(lame_encode_buffer_float,
float
, s->
samples_flt
);
199
break
;
200
default
:
201
return
AVERROR_BUG
;
202
}
203
}
else
{
204
lame_result = lame_encode_flush(s->
gfp
, s->
buffer
+ s->
buffer_index
,
205
s->
buffer_size
- s->
buffer_index
);
206
}
207
if
(lame_result < 0) {
208
if
(lame_result == -1) {
209
av_log
(avctx,
AV_LOG_ERROR
,
210
"lame: output buffer too small (buffer index: %d, free bytes: %d)\n"
,
211
s->
buffer_index
, s->
buffer_size
- s->
buffer_index
);
212
}
213
return
-1;
214
}
215
s->
buffer_index
+= lame_result;
216
ret =
realloc_buffer
(s);
217
if
(ret < 0) {
218
av_log
(avctx,
AV_LOG_ERROR
,
"error reallocating output buffer\n"
);
219
return
ret;
220
}
221
222
/* add current frame to the queue */
223
if
(frame) {
224
if
((ret =
ff_af_queue_add
(&s->
afq
, frame)) < 0)
225
return
ret;
226
}
227
228
/* Move 1 frame from the LAME buffer to the output packet, if available.
229
We have to parse the first frame header in the output buffer to
230
determine the frame size. */
231
if
(s->
buffer_index
< 4)
232
return
0;
233
if
(
avpriv_mpegaudio_decode_header
(&hdr,
AV_RB32
(s->
buffer
))) {
234
av_log
(avctx,
AV_LOG_ERROR
,
"free format output not supported\n"
);
235
return
-1;
236
}
237
len = hdr.frame_size;
238
av_dlog
(avctx,
"in:%d packet-len:%d index:%d\n"
, avctx->
frame_size
, len,
239
s->
buffer_index
);
240
if
(len <= s->buffer_index) {
241
if
((ret =
ff_alloc_packet
(avpkt, len))) {
242
av_log
(avctx,
AV_LOG_ERROR
,
"Error getting output packet\n"
);
243
return
ret;
244
}
245
memcpy(avpkt->
data
, s->
buffer
, len);
246
s->
buffer_index
-=
len
;
247
memmove(s->
buffer
, s->
buffer
+ len, s->
buffer_index
);
248
249
/* Get the next frame pts/duration */
250
ff_af_queue_remove
(&s->
afq
, avctx->
frame_size
, &avpkt->
pts
,
251
&avpkt->
duration
);
252
253
avpkt->
size
=
len
;
254
*got_packet_ptr = 1;
255
}
256
return
0;
257
}
258
259
#define OFFSET(x) offsetof(LAMEContext, x)
260
#define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
261
static
const
AVOption
options
[] = {
262
{
"reservoir"
,
"Use bit reservoir."
,
OFFSET
(reservoir),
AV_OPT_TYPE_INT
, { .i64 = 1 }, 0, 1,
AE
},
263
{
NULL
},
264
};
265
266
static
const
AVClass
libmp3lame_class
= {
267
.
class_name
=
"libmp3lame encoder"
,
268
.item_name =
av_default_item_name
,
269
.option =
options
,
270
.version =
LIBAVUTIL_VERSION_INT
,
271
};
272
273
static
const
AVCodecDefault
libmp3lame_defaults
[] = {
274
{
"b"
,
"0"
},
275
{
NULL
},
276
};
277
278
static
const
int
libmp3lame_sample_rates
[] = {
279
44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000, 0
280
};
281
282
AVCodec
ff_libmp3lame_encoder
= {
283
.
name
=
"libmp3lame"
,
284
.long_name =
NULL_IF_CONFIG_SMALL
(
"libmp3lame MP3 (MPEG audio layer 3)"
),
285
.type =
AVMEDIA_TYPE_AUDIO
,
286
.id =
AV_CODEC_ID_MP3
,
287
.priv_data_size =
sizeof
(
LAMEContext
),
288
.
init
=
mp3lame_encode_init
,
289
.encode2 =
mp3lame_encode_frame
,
290
.
close
=
mp3lame_encode_close
,
291
.capabilities =
CODEC_CAP_DELAY
|
CODEC_CAP_SMALL_LAST_FRAME
,
292
.
sample_fmts
= (
const
enum
AVSampleFormat
[]) {
AV_SAMPLE_FMT_S32P
,
293
AV_SAMPLE_FMT_FLTP
,
294
AV_SAMPLE_FMT_S16P
,
295
AV_SAMPLE_FMT_NONE
},
296
.supported_samplerates =
libmp3lame_sample_rates
,
297
.channel_layouts = (
const
uint64_t[]) {
AV_CH_LAYOUT_MONO
,
298
AV_CH_LAYOUT_STEREO
,
299
0 },
300
.priv_class = &
libmp3lame_class
,
301
.defaults =
libmp3lame_defaults
,
302
};
Generated on Thu Sep 30 2021 23:03:12 for Libav by
1.8.1.2