libavformat/mp3enc.c

   1 /*
   2  * MP3 muxer
   3  * Copyright (c) 2003 Fabrice Bellard
   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 #include "avformat.h"
  23 #include "avio_internal.h"
  24 #include "id3v1.h"
  25 #include "id3v2.h"
  26 #include "rawenc.h"
  27 #include "libavutil/avstring.h"
  28 #include "libavcodec/mpegaudio.h"
  29 #include "libavcodec/mpegaudiodata.h"
  30 #include "libavcodec/mpegaudiodecheader.h"
  31 #include "libavutil/intreadwrite.h"
  32 #include "libavutil/opt.h"
  33 #include "libavutil/dict.h"
  34 #include "libavutil/avassert.h"
  35
  36 static int id3v1_set_string(AVFormatContext *s, const char *key,
  37                             uint8_t *buf, int buf_size)
  38 {
  39     AVDictionaryEntry *tag;
  40     if ((tag = av_dict_get(s->metadata, key, NULL, 0)))
  41         av_strlcpy(buf, tag->value, buf_size);
  42     return !!tag;
  43 }
  44
  45 static int id3v1_create_tag(AVFormatContext *s, uint8_t *buf)
  46 {
  47     AVDictionaryEntry *tag;
  48     int i, count = 0;
  49
  50     memset(buf, 0, ID3v1_TAG_SIZE); /* fail safe */
  51     buf[0] = 'T';
  52     buf[1] = 'A';
  53     buf[2] = 'G';
  54     count += id3v1_set_string(s, "TIT2",    buf +  3, 30);       //title
  55     count += id3v1_set_string(s, "TPE1",    buf + 33, 30);       //author|artist
  56     count += id3v1_set_string(s, "TALB",    buf + 63, 30);       //album
  57     count += id3v1_set_string(s, "TDRL",    buf + 93,  4);       //date
  58     count += id3v1_set_string(s, "comment", buf + 97, 30);
  59     if ((tag = av_dict_get(s->metadata, "TRCK", NULL, 0))) { //track
  60         buf[125] = 0;
  61         buf[126] = atoi(tag->value);
  62         count++;
  63     }
  64     buf[127] = 0xFF; /* default to unknown genre */
  65     if ((tag = av_dict_get(s->metadata, "TCON", NULL, 0))) { //genre
  66         for(i = 0; i <= ID3v1_GENRE_MAX; i++) {
  67             if (!av_strcasecmp(tag->value, ff_id3v1_genre_str[i])) {
  68                 buf[127] = i;
  69                 count++;
  70                 break;
  71             }
  72         }
  73     }
  74     return count;
  75 }
  76
  77 #define XING_NUM_BAGS 400
  78 #define XING_TOC_SIZE 100
  79 // maximum size of the xing frame: offset/Xing/flags/frames/size/TOC
  80 #define XING_MAX_SIZE (32 + 4 + 4 + 4 + 4 + XING_TOC_SIZE)
  81
  82 typedef struct MP3Context {
  83     const AVClass *class;
  84     ID3v2EncContext id3;
  85     int id3v2_version;
  86     int write_id3v1;
  87     int write_xing;
  88
  89     /* xing header */
  90     int64_t xing_offset;
  91     int32_t frames;
  92     int32_t size;
  93     uint32_t want;
  94     uint32_t seen;
  95     uint32_t pos;
  96     uint64_t bag[XING_NUM_BAGS];
  97     int initial_bitrate;
  98     int has_variable_bitrate;
  99
 100     /* index of the audio stream */
 101     int audio_stream_idx;
 102     /* number of attached pictures we still need to write */
 103     int pics_to_write;
 104
 105     /* audio packets are queued here until we get all the attached pictures */
 106     AVPacketList *queue, *queue_end;
 107 } MP3Context;
 108
 109 static const uint8_t xing_offtbl[2][2] = {{32, 17}, {17, 9}};
 110
 111 /*
 112  * Write an empty XING header and initialize respective data.
 113  */
 114 static void mp3_write_xing(AVFormatContext *s)
 115 {
 116     MP3Context       *mp3 = s->priv_data;
 117     AVCodecContext *codec = s->streams[mp3->audio_stream_idx]->codec;
 118     int32_t        header;
 119     MPADecodeHeader  mpah;
 120     int srate_idx, i, channels;
 121     int bitrate_idx;
 122     int xing_offset;
 123     int ver = 0;
 124
 125     if (!s->pb->seekable || !mp3->write_xing)
 126         return;
 127
 128     for (i = 0; i < FF_ARRAY_ELEMS(avpriv_mpa_freq_tab); i++) {
 129         const uint16_t base_freq = avpriv_mpa_freq_tab[i];
 130
 131         if      (codec->sample_rate == base_freq)     ver = 0x3; // MPEG 1
 132         else if (codec->sample_rate == base_freq / 2) ver = 0x2; // MPEG 2
 133         else if (codec->sample_rate == base_freq / 4) ver = 0x0; // MPEG 2.5
 134         else continue;
 135
 136         srate_idx = i;
 137         break;
 138     }
 139     if (i == FF_ARRAY_ELEMS(avpriv_mpa_freq_tab)) {
 140         av_log(s, AV_LOG_WARNING, "Unsupported sample rate, not writing Xing "
 141                "header.\n");
 142         return;
 143     }
 144
 145     switch (codec->channels) {
 146     case 1:  channels = MPA_MONO;                                          break;
 147     case 2:  channels = MPA_STEREO;                                        break;
 148     default: av_log(s, AV_LOG_WARNING, "Unsupported number of channels, "
 149                     "not writing Xing header.\n");
 150              return;
 151     }
 152
 153     /* 64 kbps frame, should be large enough */
 154     bitrate_idx = (ver == 3) ? 5 : 8;
 155
 156     /* dummy MPEG audio header */
 157     header  =  0xff                                  << 24; // sync
 158     header |= (0x7 << 5 | ver << 3 | 0x1 << 1 | 0x1) << 16; // sync/audio-version/layer 3/no crc*/
 159     header |= (bitrate_idx << 4 | srate_idx << 2)    <<  8;
 160     header |= channels << 6;
 161     avio_wb32(s->pb, header);
 162
 163     avpriv_mpegaudio_decode_header(&mpah, header);
 164
 165     av_assert0(mpah.frame_size >= XING_MAX_SIZE);
 166
 167     xing_offset = xing_offtbl[ver != 3][codec->channels == 1];
 168     ffio_fill(s->pb, 0, xing_offset);
 169     mp3->xing_offset = avio_tell(s->pb);
 170     ffio_wfourcc(s->pb, "Xing");
 171     avio_wb32(s->pb, 0x01 | 0x02 | 0x04);  // frames / size / TOC
 172
 173     mp3->size = mpah.frame_size;
 174     mp3->want = 1;
 175
 176     avio_wb32(s->pb, 0);  // frames
 177     avio_wb32(s->pb, 0);  // size
 178
 179     // TOC
 180     for (i = 0; i < XING_TOC_SIZE; i++)
 181         avio_w8(s->pb, 255 * i / XING_TOC_SIZE);
 182
 183     mpah.frame_size -= 4 + xing_offset + 4 + 4 + 4 + 4 + XING_TOC_SIZE;
 184     ffio_fill(s->pb, 0, mpah.frame_size);
 185 }
 186
 187 /*
 188  * Add a frame to XING data.
 189  * Following lame's "VbrTag.c".
 190  */
 191 static void mp3_xing_add_frame(MP3Context *mp3, AVPacket *pkt)
 192 {
 193     int i;
 194
 195     mp3->frames++;
 196     mp3->seen++;
 197     mp3->size += pkt->size;
 198
 199     if (mp3->want == mp3->seen) {
 200         mp3->bag[mp3->pos] = mp3->size;
 201
 202         if (XING_NUM_BAGS == ++mp3->pos) {
 203             /* shrink table to half size by throwing away each second bag. */
 204             for (i = 1; i < XING_NUM_BAGS; i += 2)
 205                 mp3->bag[i / 2] = mp3->bag[i];
 206
 207             /* double wanted amount per bag. */
 208             mp3->want *= 2;
 209             /* adjust current position to half of table size. */
 210             mp3->pos = XING_NUM_BAGS / 2;
 211         }
 212
 213         mp3->seen = 0;
 214     }
 215 }
 216
 217 static int mp3_write_audio_packet(AVFormatContext *s, AVPacket *pkt)
 218 {
 219     MP3Context  *mp3 = s->priv_data;
 220
 221     if (mp3->xing_offset && pkt->size >= 4) {
 222         MPADecodeHeader c;
 223
 224         avpriv_mpegaudio_decode_header(&c, AV_RB32(pkt->data));
 225
 226         if (!mp3->initial_bitrate)
 227             mp3->initial_bitrate = c.bit_rate;
 228         if ((c.bit_rate == 0) || (mp3->initial_bitrate != c.bit_rate))
 229             mp3->has_variable_bitrate = 1;
 230
 231         mp3_xing_add_frame(mp3, pkt);
 232     }
 233
 234     return ff_raw_write_packet(s, pkt);
 235 }
 236
 237 static int mp3_queue_flush(AVFormatContext *s)
 238 {
 239     MP3Context *mp3 = s->priv_data;
 240     AVPacketList *pktl;
 241     int ret = 0, write = 1;
 242
 243     ff_id3v2_finish(&mp3->id3, s->pb);
 244     mp3_write_xing(s);
 245
 246     while ((pktl = mp3->queue)) {
 247         if (write && (ret = mp3_write_audio_packet(s, &pktl->pkt)) < 0)
 248             write = 0;
 249         av_free_packet(&pktl->pkt);
 250         mp3->queue = pktl->next;
 251         av_freep(&pktl);
 252     }
 253     mp3->queue_end = NULL;
 254     return ret;
 255 }
 256
 257 static void mp3_update_xing(AVFormatContext *s)
 258 {
 259     MP3Context  *mp3 = s->priv_data;
 260     int i;
 261
 262     /* replace "Xing" identification string with "Info" for CBR files. */
 263     if (!mp3->has_variable_bitrate) {
 264         avio_seek(s->pb, mp3->xing_offset, SEEK_SET);
 265         ffio_wfourcc(s->pb, "Info");
 266     }
 267
 268     avio_seek(s->pb, mp3->xing_offset + 8, SEEK_SET);
 269     avio_wb32(s->pb, mp3->frames);
 270     avio_wb32(s->pb, mp3->size);
 271
 272     avio_w8(s->pb, 0);  // first toc entry has to be zero.
 273
 274     for (i = 1; i < XING_TOC_SIZE; ++i) {
 275         int j = i * mp3->pos / XING_TOC_SIZE;
 276         int seek_point = 256LL * mp3->bag[j] / mp3->size;
 277         avio_w8(s->pb, FFMIN(seek_point, 255));
 278     }
 279
 280     avio_seek(s->pb, 0, SEEK_END);
 281 }
 282
 283 static int mp3_write_trailer(struct AVFormatContext *s)
 284 {
 285     uint8_t buf[ID3v1_TAG_SIZE];
 286     MP3Context *mp3 = s->priv_data;
 287
 288     if (mp3->pics_to_write) {
 289         av_log(s, AV_LOG_WARNING, "No packets were sent for some of the "
 290                "attached pictures.\n");
 291         mp3_queue_flush(s);
 292     }
 293
 294     /* write the id3v1 tag */
 295     if (mp3->write_id3v1 && id3v1_create_tag(s, buf) > 0) {
 296         avio_write(s->pb, buf, ID3v1_TAG_SIZE);
 297     }
 298
 299     if (mp3->xing_offset)
 300         mp3_update_xing(s);
 301
 302     return 0;
 303 }
 304
 305 #if CONFIG_MP2_MUXER
 306 AVOutputFormat ff_mp2_muxer = {
 307     .name              = "mp2",
 308     .long_name         = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
 309     .mime_type         = "audio/x-mpeg",
 310     .extensions        = "mp2,m2a,mpa",
 311     .audio_codec       = AV_CODEC_ID_MP2,
 312     .video_codec       = AV_CODEC_ID_NONE,
 313     .write_packet      = ff_raw_write_packet,
 314     .flags             = AVFMT_NOTIMESTAMPS,
 315 };
 316 #endif
 317
 318 #if CONFIG_MP3_MUXER
 319
 320 static const AVOption options[] = {
 321     { "id3v2_version", "Select ID3v2 version to write. Currently 3 and 4 are supported.",
 322       offsetof(MP3Context, id3v2_version), AV_OPT_TYPE_INT, {.i64 = 4}, 3, 4, AV_OPT_FLAG_ENCODING_PARAM},
 323     { "write_id3v1", "Enable ID3v1 writing. ID3v1 tags are written in UTF-8 which may not be supported by most software.",
 324       offsetof(MP3Context, write_id3v1), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
 325     { "write_xing",  "Write the Xing header containing file duration.",
 326       offsetof(MP3Context, write_xing),  AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
 327     { NULL },
 328 };
 329
 330 static const AVClass mp3_muxer_class = {
 331     .class_name     = "MP3 muxer",
 332     .item_name      = av_default_item_name,
 333     .option         = options,
 334     .version        = LIBAVUTIL_VERSION_INT,
 335 };
 336
 337 static int mp3_write_packet(AVFormatContext *s, AVPacket *pkt)
 338 {
 339     MP3Context *mp3 = s->priv_data;
 340
 341     if (pkt->stream_index == mp3->audio_stream_idx) {
 342         if (mp3->pics_to_write) {
 343             /* buffer audio packets until we get all the pictures */
 344             AVPacketList *pktl = av_mallocz(sizeof(*pktl));
 345             if (!pktl)
 346                 return AVERROR(ENOMEM);
 347
 348             pktl->pkt     = *pkt;
 349             pktl->pkt.buf = av_buffer_ref(pkt->buf);
 350             if (!pktl->pkt.buf) {
 351                 av_freep(&pktl);
 352                 return AVERROR(ENOMEM);
 353             }
 354
 355             if (mp3->queue_end)
 356                 mp3->queue_end->next = pktl;
 357             else
 358                 mp3->queue = pktl;
 359             mp3->queue_end = pktl;
 360         } else
 361             return mp3_write_audio_packet(s, pkt);
 362     } else {
 363         int ret;
 364
 365         /* warn only once for each stream */
 366         if (s->streams[pkt->stream_index]->nb_frames == 1) {
 367             av_log(s, AV_LOG_WARNING, "Got more than one picture in stream %d,"
 368                    " ignoring.\n", pkt->stream_index);
 369         }
 370         if (!mp3->pics_to_write || s->streams[pkt->stream_index]->nb_frames >= 1)
 371             return 0;
 372
 373         if ((ret = ff_id3v2_write_apic(s, &mp3->id3, pkt)) < 0)
 374             return ret;
 375         mp3->pics_to_write--;
 376
 377         /* flush the buffered audio packets */
 378         if (!mp3->pics_to_write &&
 379             (ret = mp3_queue_flush(s)) < 0)
 380             return ret;
 381     }
 382
 383     return 0;
 384 }
 385
 386 /**
 387  * Write an ID3v2 header at beginning of stream
 388  */
 389
 390 static int mp3_write_header(struct AVFormatContext *s)
 391 {
 392     MP3Context  *mp3 = s->priv_data;
 393     int ret, i;
 394
 395     /* check the streams -- we want exactly one audio and arbitrary number of
 396      * video (attached pictures) */
 397     mp3->audio_stream_idx = -1;
 398     for (i = 0; i < s->nb_streams; i++) {
 399         AVStream *st = s->streams[i];
 400         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
 401             if (mp3->audio_stream_idx >= 0 || st->codec->codec_id != AV_CODEC_ID_MP3) {
 402                 av_log(s, AV_LOG_ERROR, "Invalid audio stream. Exactly one MP3 "
 403                        "audio stream is required.\n");
 404                 return AVERROR(EINVAL);
 405             }
 406             mp3->audio_stream_idx = i;
 407         } else if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO) {
 408             av_log(s, AV_LOG_ERROR, "Only audio streams and pictures are allowed in MP3.\n");
 409             return AVERROR(EINVAL);
 410         }
 411     }
 412     if (mp3->audio_stream_idx < 0) {
 413         av_log(s, AV_LOG_ERROR, "No audio stream present.\n");
 414         return AVERROR(EINVAL);
 415     }
 416     mp3->pics_to_write = s->nb_streams - 1;
 417
 418     ff_id3v2_start(&mp3->id3, s->pb, mp3->id3v2_version, ID3v2_DEFAULT_MAGIC);
 419     ret = ff_id3v2_write_metadata(s, &mp3->id3);
 420     if (ret < 0)
 421         return ret;
 422
 423     if (!mp3->pics_to_write) {
 424         ff_id3v2_finish(&mp3->id3, s->pb);
 425         mp3_write_xing(s);
 426     }
 427
 428     return 0;
 429 }
 430
 431 AVOutputFormat ff_mp3_muxer = {
 432     .name              = "mp3",
 433     .long_name         = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
 434     .mime_type         = "audio/x-mpeg",
 435     .extensions        = "mp3",
 436     .priv_data_size    = sizeof(MP3Context),
 437     .audio_codec       = AV_CODEC_ID_MP3,
 438     .video_codec       = AV_CODEC_ID_PNG,
 439     .write_header      = mp3_write_header,
 440     .write_packet      = mp3_write_packet,
 441     .write_trailer     = mp3_write_trailer,
 442     .flags             = AVFMT_NOTIMESTAMPS,
 443     .priv_class        = &mp3_muxer_class,
 444 };
 445 #endif