Merge remote-tracking branch 'qatar/master'
[ffmpeg.git] / libavcodec / libmp3lame.c
1 /*
2  * Interface to libmp3lame for mp3 encoding
3  * Copyright (c) 2002 Lennert Buytenhek <buytenh@gnu.org>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg 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  * FFmpeg 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 FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * Interface to libmp3lame for mp3 encoding.
25  */
26
27 #include "libavutil/intreadwrite.h"
28 #include "libavutil/log.h"
29 #include "libavutil/opt.h"
30 #include "avcodec.h"
31 #include "mpegaudio.h"
32 #include <lame/lame.h>
33
34 #define BUFFER_SIZE (7200 + 2*MPA_FRAME_SIZE + MPA_FRAME_SIZE/4)
35 typedef struct Mp3AudioContext {
36     AVClass *class;
37     lame_global_flags *gfp;
38     int stereo;
39     uint8_t buffer[BUFFER_SIZE];
40     int buffer_index;
41     struct {
42         int *left;
43         int *right;
44     } s32_data;
45     int reservoir;
46 } Mp3AudioContext;
47
48 static av_cold int MP3lame_encode_init(AVCodecContext *avctx)
49 {
50     Mp3AudioContext *s = avctx->priv_data;
51
52     if (avctx->channels > 2)
53         return -1;
54
55     s->stereo = avctx->channels > 1 ? 1 : 0;
56
57     if ((s->gfp = lame_init()) == NULL)
58         goto err;
59     lame_set_in_samplerate(s->gfp, avctx->sample_rate);
60     lame_set_out_samplerate(s->gfp, avctx->sample_rate);
61     lame_set_num_channels(s->gfp, avctx->channels);
62     if(avctx->compression_level == FF_COMPRESSION_DEFAULT) {
63         lame_set_quality(s->gfp, 5);
64     } else {
65         lame_set_quality(s->gfp, avctx->compression_level);
66     }
67     lame_set_mode(s->gfp, s->stereo ? JOINT_STEREO : MONO);
68     lame_set_brate(s->gfp, avctx->bit_rate/1000);
69     if(avctx->flags & CODEC_FLAG_QSCALE) {
70         lame_set_brate(s->gfp, 0);
71         lame_set_VBR(s->gfp, vbr_default);
72         lame_set_VBR_quality(s->gfp, avctx->global_quality/(float)FF_QP2LAMBDA);
73     }
74     lame_set_bWriteVbrTag(s->gfp,0);
75 #if FF_API_LAME_GLOBAL_OPTIONS
76     s->reservoir = avctx->flags2 & CODEC_FLAG2_BIT_RESERVOIR;
77 #endif
78     lame_set_disable_reservoir(s->gfp, !s->reservoir);
79     if (lame_init_params(s->gfp) < 0)
80         goto err_close;
81
82     avctx->frame_size = lame_get_framesize(s->gfp);
83
84     if(!(avctx->coded_frame= avcodec_alloc_frame())) {
85         lame_close(s->gfp);
86
87         return AVERROR(ENOMEM);
88     }
89     avctx->coded_frame->key_frame= 1;
90
91     if(AV_SAMPLE_FMT_S32 == avctx->sample_fmt && s->stereo) {
92         int nelem = 2 * avctx->frame_size;
93
94         if(! (s->s32_data.left = av_malloc(nelem * sizeof(int)))) {
95             av_freep(&avctx->coded_frame);
96             lame_close(s->gfp);
97
98             return AVERROR(ENOMEM);
99         }
100
101         s->s32_data.right = s->s32_data.left + avctx->frame_size;
102     }
103
104     return 0;
105
106 err_close:
107     lame_close(s->gfp);
108 err:
109     return -1;
110 }
111
112 static const int sSampleRates[] = {
113     44100, 48000,  32000, 22050, 24000, 16000, 11025, 12000, 8000, 0
114 };
115
116 static const int sBitRates[2][3][15] = {
117     {   {  0, 32, 64, 96,128,160,192,224,256,288,320,352,384,416,448},
118         {  0, 32, 48, 56, 64, 80, 96,112,128,160,192,224,256,320,384},
119         {  0, 32, 40, 48, 56, 64, 80, 96,112,128,160,192,224,256,320}
120     },
121     {   {  0, 32, 48, 56, 64, 80, 96,112,128,144,160,176,192,224,256},
122         {  0,  8, 16, 24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160},
123         {  0,  8, 16, 24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160}
124     },
125 };
126
127 static const int sSamplesPerFrame[2][3] =
128 {
129     {  384,     1152,    1152 },
130     {  384,     1152,     576 }
131 };
132
133 static const int sBitsPerSlot[3] = {
134     32,
135     8,
136     8
137 };
138
139 static int mp3len(void *data, int *samplesPerFrame, int *sampleRate)
140 {
141     uint32_t header = AV_RB32(data);
142     int layerID = 3 - ((header >> 17) & 0x03);
143     int bitRateID = ((header >> 12) & 0x0f);
144     int sampleRateID = ((header >> 10) & 0x03);
145     int bitsPerSlot = sBitsPerSlot[layerID];
146     int isPadded = ((header >> 9) & 0x01);
147     static int const mode_tab[4]= {2,3,1,0};
148     int mode= mode_tab[(header >> 19) & 0x03];
149     int mpeg_id= mode>0;
150     int temp0, temp1, bitRate;
151
152     if ( (( header >> 21 ) & 0x7ff) != 0x7ff || mode == 3 || layerID==3 || sampleRateID==3) {
153         return -1;
154     }
155
156     if(!samplesPerFrame) samplesPerFrame= &temp0;
157     if(!sampleRate     ) sampleRate     = &temp1;
158
159 //    *isMono = ((header >>  6) & 0x03) == 0x03;
160
161     *sampleRate = sSampleRates[sampleRateID]>>mode;
162     bitRate = sBitRates[mpeg_id][layerID][bitRateID] * 1000;
163     *samplesPerFrame = sSamplesPerFrame[mpeg_id][layerID];
164 //av_log(NULL, AV_LOG_DEBUG, "sr:%d br:%d spf:%d l:%d m:%d\n", *sampleRate, bitRate, *samplesPerFrame, layerID, mode);
165
166     return *samplesPerFrame * bitRate / (bitsPerSlot * *sampleRate) + isPadded;
167 }
168
169 static int MP3lame_encode_frame(AVCodecContext *avctx,
170                                 unsigned char *frame, int buf_size, void *data)
171 {
172     Mp3AudioContext *s = avctx->priv_data;
173     int len;
174     int lame_result;
175
176     /* lame 3.91 dies on '1-channel interleaved' data */
177
178     if(!data){
179         lame_result= lame_encode_flush(
180                 s->gfp,
181                 s->buffer + s->buffer_index,
182                 BUFFER_SIZE - s->buffer_index
183                 );
184 #if 2147483647 == INT_MAX
185     }else if(AV_SAMPLE_FMT_S32 == avctx->sample_fmt){
186         if (s->stereo) {
187             int32_t *rp = data;
188             int32_t *mp = rp + 2*avctx->frame_size;
189             int *wpl = s->s32_data.left;
190             int *wpr = s->s32_data.right;
191
192             while (rp < mp) {
193                 *wpl++ = *rp++;
194                 *wpr++ = *rp++;
195             }
196
197             lame_result = lame_encode_buffer_int(
198                 s->gfp,
199                 s->s32_data.left,
200                 s->s32_data.right,
201                 avctx->frame_size,
202                 s->buffer + s->buffer_index,
203                 BUFFER_SIZE - s->buffer_index
204                 );
205         } else {
206             lame_result = lame_encode_buffer_int(
207                 s->gfp,
208                 data,
209                 data,
210                 avctx->frame_size,
211                 s->buffer + s->buffer_index,
212                 BUFFER_SIZE - s->buffer_index
213                 );
214         }
215 #endif
216     }else{
217         if (s->stereo) {
218             lame_result = lame_encode_buffer_interleaved(
219                 s->gfp,
220                 data,
221                 avctx->frame_size,
222                 s->buffer + s->buffer_index,
223                 BUFFER_SIZE - s->buffer_index
224                 );
225         } else {
226             lame_result = lame_encode_buffer(
227                 s->gfp,
228                 data,
229                 data,
230                 avctx->frame_size,
231                 s->buffer + s->buffer_index,
232                 BUFFER_SIZE - s->buffer_index
233                 );
234         }
235     }
236
237     if(lame_result < 0){
238         if(lame_result==-1) {
239             /* output buffer too small */
240             av_log(avctx, AV_LOG_ERROR, "lame: output buffer too small (buffer index: %d, free bytes: %d)\n", s->buffer_index, BUFFER_SIZE - s->buffer_index);
241         }
242         return -1;
243     }
244
245     s->buffer_index += lame_result;
246
247     if(s->buffer_index<4)
248         return 0;
249
250     len= mp3len(s->buffer, NULL, NULL);
251 //av_log(avctx, AV_LOG_DEBUG, "in:%d packet-len:%d index:%d\n", avctx->frame_size, len, s->buffer_index);
252     if(len <= s->buffer_index){
253         memcpy(frame, s->buffer, len);
254         s->buffer_index -= len;
255
256         memmove(s->buffer, s->buffer+len, s->buffer_index);
257             //FIXME fix the audio codec API, so we do not need the memcpy()
258 /*for(i=0; i<len; i++){
259     av_log(avctx, AV_LOG_DEBUG, "%2X ", frame[i]);
260 }*/
261         return len;
262     }else
263         return 0;
264 }
265
266 static av_cold int MP3lame_encode_close(AVCodecContext *avctx)
267 {
268     Mp3AudioContext *s = avctx->priv_data;
269
270     av_freep(&s->s32_data.left);
271     av_freep(&avctx->coded_frame);
272
273     lame_close(s->gfp);
274     return 0;
275 }
276
277 #define OFFSET(x) offsetof(Mp3AudioContext, x)
278 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
279 static const AVOption options[] = {
280     { "reservoir",      "Use bit reservoir.",   OFFSET(reservoir),  FF_OPT_TYPE_INT, { 1 }, 0, 1, AE },
281     { NULL },
282 };
283
284 static const AVClass libmp3lame_class = {
285     .class_name = "libmp3lame encoder",
286     .item_name  = av_default_item_name,
287     .option     = options,
288     .version    = LIBAVUTIL_VERSION_INT,
289 };
290
291 AVCodec ff_libmp3lame_encoder = {
292     .name           = "libmp3lame",
293     .type           = AVMEDIA_TYPE_AUDIO,
294     .id             = CODEC_ID_MP3,
295     .priv_data_size = sizeof(Mp3AudioContext),
296     .init           = MP3lame_encode_init,
297     .encode         = MP3lame_encode_frame,
298     .close          = MP3lame_encode_close,
299     .capabilities= CODEC_CAP_DELAY,
300     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,
301 #if 2147483647 == INT_MAX
302     AV_SAMPLE_FMT_S32,
303 #endif
304     AV_SAMPLE_FMT_NONE},
305     .supported_samplerates= sSampleRates,
306     .long_name= NULL_IF_CONFIG_SMALL("libmp3lame MP3 (MPEG audio layer 3)"),
307     .priv_class     = &libmp3lame_class,
308 };