git.sesse.net Git - ffmpeg/blob - 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 <lame/lame.h>
  28
  29 #include "libavutil/intreadwrite.h"
  30 #include "libavutil/log.h"
  31 #include "libavutil/opt.h"
  32 #include "avcodec.h"
  33 #include "internal.h"
  34 #include "mpegaudio.h"
  35 #include "mpegaudiodecheader.h"
  36
  37 #define BUFFER_SIZE (7200 + 2 * MPA_FRAME_SIZE + MPA_FRAME_SIZE / 4+1000) // FIXME: Buffer size to small? Adding 1000 to make up for it.
  38
  39 typedef struct LAMEContext {
  40     AVClass *class;
  41     AVCodecContext *avctx;
  42     lame_global_flags *gfp;
  43     uint8_t buffer[BUFFER_SIZE];
  44     int buffer_index;
  45     int reservoir;
  46     void *planar_samples[2];
  47 } LAMEContext;
  48
  49
  50 static av_cold int mp3lame_encode_close(AVCodecContext *avctx)
  51 {
  52     LAMEContext *s = avctx->priv_data;
  53
  54     av_freep(&avctx->coded_frame);
  55     av_freep(&s->planar_samples[0]);
  56     av_freep(&s->planar_samples[1]);
  57
  58     lame_close(s->gfp);
  59     return 0;
  60 }
  61
  62 static av_cold int mp3lame_encode_init(AVCodecContext *avctx)
  63 {
  64     LAMEContext *s = avctx->priv_data;
  65     int ret;
  66
  67     s->avctx = avctx;
  68
  69     /* initialize LAME and get defaults */
  70     if ((s->gfp = lame_init()) == NULL)
  71         return AVERROR(ENOMEM);
  72
  73     /* channels */
  74     if (avctx->channels > 2) {
  75         av_log(avctx, AV_LOG_ERROR,
  76                "Invalid number of channels %d, must be <= 2\n", avctx->channels);
  77         ret =  AVERROR(EINVAL);
  78         goto error;
  79     }
  80     lame_set_num_channels(s->gfp, avctx->channels);
  81     lame_set_mode(s->gfp, avctx->channels > 1 ? JOINT_STEREO : MONO);
  82
  83     /* sample rate */
  84     lame_set_in_samplerate (s->gfp, avctx->sample_rate);
  85     lame_set_out_samplerate(s->gfp, avctx->sample_rate);
  86
  87     /* algorithmic quality */
  88     if (avctx->compression_level == FF_COMPRESSION_DEFAULT)
  89         lame_set_quality(s->gfp, 5);
  90     else
  91         lame_set_quality(s->gfp, avctx->compression_level);
  92
  93     /* rate control */
  94     if (avctx->flags & CODEC_FLAG_QSCALE) {
  95         lame_set_VBR(s->gfp, vbr_default);
  96         lame_set_VBR_quality(s->gfp, avctx->global_quality / (float)FF_QP2LAMBDA);
  97     } else {
  98         if (avctx->bit_rate)
  99             lame_set_brate(s->gfp, avctx->bit_rate / 1000);
 100     }
 101
 102     /* do not get a Xing VBR header frame from LAME */
 103     lame_set_bWriteVbrTag(s->gfp,0);
 104
 105     /* bit reservoir usage */
 106     lame_set_disable_reservoir(s->gfp, !s->reservoir);
 107
 108     /* set specified parameters */
 109     if (lame_init_params(s->gfp) < 0) {
 110         ret = -1;
 111         goto error;
 112     }
 113
 114     avctx->frame_size  = lame_get_framesize(s->gfp);
 115     avctx->coded_frame = avcodec_alloc_frame();
 116     if (!avctx->coded_frame) {
 117         ret = AVERROR(ENOMEM);
 118         goto error;
 119     }
 120
 121     /* sample format */
 122     if (avctx->sample_fmt == AV_SAMPLE_FMT_S32 ||
 123         avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
 124         int ch;
 125         for (ch = 0; ch < avctx->channels; ch++) {
 126             s->planar_samples[ch] = av_malloc(avctx->frame_size *
 127                                               av_get_bytes_per_sample(avctx->sample_fmt));
 128             if (!s->planar_samples[ch]) {
 129                 ret = AVERROR(ENOMEM);
 130                 goto error;
 131             }
 132         }
 133     }
 134
 135     return 0;
 136 error:
 137     mp3lame_encode_close(avctx);
 138     return ret;
 139 }
 140
 141 #define DEINTERLEAVE(type, scale) do {                  \
 142     int ch, i;                                          \
 143     for (ch = 0; ch < s->avctx->channels; ch++) {       \
 144         const type *input = samples;                    \
 145         type      *output = s->planar_samples[ch];      \
 146         input += ch;                                    \
 147         for (i = 0; i < s->avctx->frame_size; i++) {    \
 148             output[i] = *input * scale;                 \
 149             input += s->avctx->channels;                \
 150         }                                               \
 151     }                                                   \
 152 } while (0)
 153
 154 static int encode_frame_int16(LAMEContext *s, void *samples)
 155 {
 156     if (s->avctx->channels > 1) {
 157         return lame_encode_buffer_interleaved(s->gfp, samples,
 158                                               s->avctx->frame_size,
 159                                               s->buffer + s->buffer_index,
 160                                               BUFFER_SIZE - s->buffer_index);
 161     } else {
 162         return lame_encode_buffer(s->gfp, samples, NULL, s->avctx->frame_size,
 163                                   s->buffer + s->buffer_index,
 164                                   BUFFER_SIZE - s->buffer_index);
 165     }
 166 }
 167
 168 static int encode_frame_int32(LAMEContext *s, void *samples)
 169 {
 170     DEINTERLEAVE(int32_t, 1);
 171
 172     return lame_encode_buffer_int(s->gfp,
 173                                   s->planar_samples[0], s->planar_samples[1],
 174                                   s->avctx->frame_size,
 175                                   s->buffer + s->buffer_index,
 176                                   BUFFER_SIZE - s->buffer_index);
 177 }
 178
 179 static int encode_frame_float(LAMEContext *s, void *samples)
 180 {
 181     DEINTERLEAVE(float, 32768.0f);
 182
 183     return lame_encode_buffer_float(s->gfp,
 184                                     s->planar_samples[0], s->planar_samples[1],
 185                                     s->avctx->frame_size,
 186                                     s->buffer + s->buffer_index,
 187                                     BUFFER_SIZE - s->buffer_index);
 188 }
 189
 190 static int mp3lame_encode_frame(AVCodecContext *avctx, unsigned char *frame,
 191                                 int buf_size, void *data)
 192 {
 193     LAMEContext *s = avctx->priv_data;
 194     MPADecodeHeader hdr;
 195     int len;
 196     int lame_result;
 197
 198     if (data) {
 199         switch (avctx->sample_fmt) {
 200         case AV_SAMPLE_FMT_S16:
 201             lame_result = encode_frame_int16(s, data);
 202             break;
 203         case AV_SAMPLE_FMT_S32:
 204             lame_result = encode_frame_int32(s, data);
 205             break;
 206         case AV_SAMPLE_FMT_FLT:
 207             lame_result = encode_frame_float(s, data);
 208             break;
 209         default:
 210             return AVERROR_BUG;
 211         }
 212     } else {
 213         lame_result = lame_encode_flush(s->gfp, s->buffer + s->buffer_index,
 214                                         BUFFER_SIZE - s->buffer_index);
 215     }
 216     if (lame_result < 0) {
 217         if (lame_result == -1) {
 218             av_log(avctx, AV_LOG_ERROR,
 219                    "lame: output buffer too small (buffer index: %d, free bytes: %d)\n",
 220                    s->buffer_index, BUFFER_SIZE - s->buffer_index);
 221         }
 222         return -1;
 223     }
 224     s->buffer_index += lame_result;
 225
 226     /* Move 1 frame from the LAME buffer to the output packet, if available.
 227        We have to parse the first frame header in the output buffer to
 228        determine the frame size. */
 229     if (s->buffer_index < 4)
 230         return 0;
 231     if (avpriv_mpegaudio_decode_header(&hdr, AV_RB32(s->buffer))) {
 232         av_log(avctx, AV_LOG_ERROR, "free format output not supported\n");
 233         return -1;
 234     }
 235     len = hdr.frame_size;
 236     av_dlog(avctx, "in:%d packet-len:%d index:%d\n", avctx->frame_size, len,
 237             s->buffer_index);
 238     if (len <= s->buffer_index) {
 239         memcpy(frame, s->buffer, len);
 240         s->buffer_index -= len;
 241         memmove(s->buffer, s->buffer + len, s->buffer_index);
 242         return len;
 243     } else
 244         return 0;
 245 }
 246
 247 #define OFFSET(x) offsetof(LAMEContext, x)
 248 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 249 static const AVOption options[] = {
 250     { "reservoir", "Use bit reservoir.", OFFSET(reservoir), AV_OPT_TYPE_INT, { 1 }, 0, 1, AE },
 251     { NULL },
 252 };
 253
 254 static const AVClass libmp3lame_class = {
 255     .class_name = "libmp3lame encoder",
 256     .item_name  = av_default_item_name,
 257     .option     = options,
 258     .version    = LIBAVUTIL_VERSION_INT,
 259 };
 260
 261 static const AVCodecDefault libmp3lame_defaults[] = {
 262     { "b",          "0" },
 263     { NULL },
 264 };
 265
 266 static const int libmp3lame_sample_rates[] = {
 267     44100, 48000,  32000, 22050, 24000, 16000, 11025, 12000, 8000, 0
 268 };
 269
 270 AVCodec ff_libmp3lame_encoder = {
 271     .name                  = "libmp3lame",
 272     .type                  = AVMEDIA_TYPE_AUDIO,
 273     .id                    = CODEC_ID_MP3,
 274     .priv_data_size        = sizeof(LAMEContext),
 275     .init                  = mp3lame_encode_init,
 276     .encode                = mp3lame_encode_frame,
 277     .close                 = mp3lame_encode_close,
 278     .capabilities          = CODEC_CAP_DELAY,
 279     .sample_fmts           = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32,
 280                                                              AV_SAMPLE_FMT_FLT,
 281                                                              AV_SAMPLE_FMT_S16,
 282                                                              AV_SAMPLE_FMT_NONE },
 283     .supported_samplerates = libmp3lame_sample_rates,
 284     .long_name             = NULL_IF_CONFIG_SMALL("libmp3lame MP3 (MPEG audio layer 3)"),
 285     .priv_class            = &libmp3lame_class,
 286     .defaults              = libmp3lame_defaults,
 287 };