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 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
  22 /**
  23  * @file
  24  * Interface to libmp3lame for mp3 encoding.
  25  */
  26
  27 #include <lame/lame.h>
  28
  29 #include "libavutil/audioconvert.h"
  30 #include "libavutil/intreadwrite.h"
  31 #include "libavutil/log.h"
  32 #include "libavutil/opt.h"
  33 #include "avcodec.h"
  34 #include "audio_frame_queue.h"
  35 #include "internal.h"
  36 #include "mpegaudio.h"
  37 #include "mpegaudiodecheader.h"
  38
  39 #define BUFFER_SIZE (7200 + 2 * MPA_FRAME_SIZE + MPA_FRAME_SIZE / 4)
  40
  41 typedef struct LAMEContext {
  42     AVClass *class;
  43     AVCodecContext *avctx;
  44     lame_global_flags *gfp;
  45     uint8_t buffer[BUFFER_SIZE];
  46     int buffer_index;
  47     int reservoir;
  48     void *planar_samples[2];
  49     AudioFrameQueue afq;
  50 } LAMEContext;
  51
  52
  53 static av_cold int mp3lame_encode_close(AVCodecContext *avctx)
  54 {
  55     LAMEContext *s = avctx->priv_data;
  56
  57 #if FF_API_OLD_ENCODE_AUDIO
  58     av_freep(&avctx->coded_frame);
  59 #endif
  60     av_freep(&s->planar_samples[0]);
  61     av_freep(&s->planar_samples[1]);
  62
  63     ff_af_queue_close(&s->afq);
  64
  65     lame_close(s->gfp);
  66     return 0;
  67 }
  68
  69 static av_cold int mp3lame_encode_init(AVCodecContext *avctx)
  70 {
  71     LAMEContext *s = avctx->priv_data;
  72     int ret;
  73
  74     s->avctx = avctx;
  75
  76     /* initialize LAME and get defaults */
  77     if ((s->gfp = lame_init()) == NULL)
  78         return AVERROR(ENOMEM);
  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     /* get encoder delay */
 115     avctx->delay = lame_get_encoder_delay(s->gfp) + 528 + 1;
 116     ff_af_queue_init(avctx, &s->afq);
 117
 118     avctx->frame_size  = lame_get_framesize(s->gfp);
 119
 120 #if FF_API_OLD_ENCODE_AUDIO
 121     avctx->coded_frame = avcodec_alloc_frame();
 122     if (!avctx->coded_frame) {
 123         ret = AVERROR(ENOMEM);
 124         goto error;
 125     }
 126 #endif
 127
 128     /* sample format */
 129     if (avctx->sample_fmt == AV_SAMPLE_FMT_S32 ||
 130         avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
 131         int ch;
 132         for (ch = 0; ch < avctx->channels; ch++) {
 133             s->planar_samples[ch] = av_malloc(avctx->frame_size *
 134                                               av_get_bytes_per_sample(avctx->sample_fmt));
 135             if (!s->planar_samples[ch]) {
 136                 ret = AVERROR(ENOMEM);
 137                 goto error;
 138             }
 139         }
 140     }
 141
 142     return 0;
 143 error:
 144     mp3lame_encode_close(avctx);
 145     return ret;
 146 }
 147
 148 #define DEINTERLEAVE(type, scale) do {                  \
 149     int ch, i;                                          \
 150     for (ch = 0; ch < s->avctx->channels; ch++) {       \
 151         const type *input = samples;                    \
 152         type      *output = s->planar_samples[ch];      \
 153         input += ch;                                    \
 154         for (i = 0; i < nb_samples; i++) {              \
 155             output[i] = *input * scale;                 \
 156             input += s->avctx->channels;                \
 157         }                                               \
 158     }                                                   \
 159 } while (0)
 160
 161 static int encode_frame_int16(LAMEContext *s, void *samples, int nb_samples)
 162 {
 163     if (s->avctx->channels > 1) {
 164         return lame_encode_buffer_interleaved(s->gfp, samples,
 165                                               nb_samples,
 166                                               s->buffer + s->buffer_index,
 167                                               BUFFER_SIZE - s->buffer_index);
 168     } else {
 169         return lame_encode_buffer(s->gfp, samples, NULL, nb_samples,
 170                                   s->buffer + s->buffer_index,
 171                                   BUFFER_SIZE - s->buffer_index);
 172     }
 173 }
 174
 175 static int encode_frame_int32(LAMEContext *s, void *samples, int nb_samples)
 176 {
 177     DEINTERLEAVE(int32_t, 1);
 178
 179     return lame_encode_buffer_int(s->gfp,
 180                                   s->planar_samples[0], s->planar_samples[1],
 181                                   nb_samples,
 182                                   s->buffer + s->buffer_index,
 183                                   BUFFER_SIZE - s->buffer_index);
 184 }
 185
 186 static int encode_frame_float(LAMEContext *s, void *samples, int nb_samples)
 187 {
 188     DEINTERLEAVE(float, 32768.0f);
 189
 190     return lame_encode_buffer_float(s->gfp,
 191                                     s->planar_samples[0], s->planar_samples[1],
 192                                     nb_samples,
 193                                     s->buffer + s->buffer_index,
 194                                     BUFFER_SIZE - s->buffer_index);
 195 }
 196
 197 static int mp3lame_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 198                                 const AVFrame *frame, int *got_packet_ptr)
 199 {
 200     LAMEContext *s = avctx->priv_data;
 201     MPADecodeHeader hdr;
 202     int len, ret;
 203     int lame_result;
 204
 205     if (frame) {
 206         switch (avctx->sample_fmt) {
 207         case AV_SAMPLE_FMT_S16:
 208             lame_result = encode_frame_int16(s, frame->data[0], frame->nb_samples);
 209             break;
 210         case AV_SAMPLE_FMT_S32:
 211             lame_result = encode_frame_int32(s, frame->data[0], frame->nb_samples);
 212             break;
 213         case AV_SAMPLE_FMT_FLT:
 214             lame_result = encode_frame_float(s, frame->data[0], frame->nb_samples);
 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                                         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, BUFFER_SIZE - s->buffer_index);
 228         }
 229         return -1;
 230     }
 231     s->buffer_index += lame_result;
 232
 233     /* add current frame to the queue */
 234     if (frame) {
 235         if ((ret = ff_af_queue_add(&s->afq, frame) < 0))
 236             return ret;
 237     }
 238
 239     /* Move 1 frame from the LAME buffer to the output packet, if available.
 240        We have to parse the first frame header in the output buffer to
 241        determine the frame size. */
 242     if (s->buffer_index < 4)
 243         return 0;
 244     if (avpriv_mpegaudio_decode_header(&hdr, AV_RB32(s->buffer))) {
 245         av_log(avctx, AV_LOG_ERROR, "free format output not supported\n");
 246         return -1;
 247     }
 248     len = hdr.frame_size;
 249     av_dlog(avctx, "in:%d packet-len:%d index:%d\n", avctx->frame_size, len,
 250             s->buffer_index);
 251     if (len <= s->buffer_index) {
 252         if ((ret = ff_alloc_packet(avpkt, len))) {
 253             av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
 254             return ret;
 255         }
 256         memcpy(avpkt->data, s->buffer, len);
 257         s->buffer_index -= len;
 258         memmove(s->buffer, s->buffer + len, s->buffer_index);
 259
 260         /* Get the next frame pts/duration */
 261         ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
 262                            &avpkt->duration);
 263
 264         avpkt->size = len;
 265         *got_packet_ptr = 1;
 266     }
 267     return 0;
 268 }
 269
 270 #define OFFSET(x) offsetof(LAMEContext, x)
 271 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 272 static const AVOption options[] = {
 273     { "reservoir", "Use bit reservoir.", OFFSET(reservoir), AV_OPT_TYPE_INT, { 1 }, 0, 1, AE },
 274     { NULL },
 275 };
 276
 277 static const AVClass libmp3lame_class = {
 278     .class_name = "libmp3lame encoder",
 279     .item_name  = av_default_item_name,
 280     .option     = options,
 281     .version    = LIBAVUTIL_VERSION_INT,
 282 };
 283
 284 static const AVCodecDefault libmp3lame_defaults[] = {
 285     { "b",          "0" },
 286     { NULL },
 287 };
 288
 289 static const int libmp3lame_sample_rates[] = {
 290     44100, 48000,  32000, 22050, 24000, 16000, 11025, 12000, 8000, 0
 291 };
 292
 293 AVCodec ff_libmp3lame_encoder = {
 294     .name                  = "libmp3lame",
 295     .type                  = AVMEDIA_TYPE_AUDIO,
 296     .id                    = AV_CODEC_ID_MP3,
 297     .priv_data_size        = sizeof(LAMEContext),
 298     .init                  = mp3lame_encode_init,
 299     .encode2               = mp3lame_encode_frame,
 300     .close                 = mp3lame_encode_close,
 301     .capabilities          = CODEC_CAP_DELAY | CODEC_CAP_SMALL_LAST_FRAME,
 302     .sample_fmts           = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32,
 303                                                              AV_SAMPLE_FMT_FLT,
 304                                                              AV_SAMPLE_FMT_S16,
 305                                                              AV_SAMPLE_FMT_NONE },
 306     .supported_samplerates = libmp3lame_sample_rates,
 307     .channel_layouts       = (const uint64_t[]) { AV_CH_LAYOUT_MONO,
 308                                                   AV_CH_LAYOUT_STEREO,
 309                                                   0 },
 310     .long_name             = NULL_IF_CONFIG_SMALL("libmp3lame MP3 (MPEG audio layer 3)"),
 311     .priv_class            = &libmp3lame_class,
 312     .defaults              = libmp3lame_defaults,
 313 };