git.sesse.net Git - ffmpeg/blob - libavformat/riffenc.c

   1 /*
   2  * RIFF muxing functions
   3  * Copyright (c) 2000 Fabrice Bellard
   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 #include "libavutil/dict.h"
  23 #include "libavutil/log.h"
  24 #include "libavutil/mathematics.h"
  25 #include "libavcodec/avcodec.h"
  26 #include "libavcodec/bytestream.h"
  27 #include "avformat.h"
  28 #include "avio_internal.h"
  29 #include "riff.h"
  30
  31 int64_t ff_start_tag(AVIOContext *pb, const char *tag)
  32 {
  33     ffio_wfourcc(pb, tag);
  34     avio_wl32(pb, -1);
  35     return avio_tell(pb);
  36 }
  37
  38 void ff_end_tag(AVIOContext *pb, int64_t start)
  39 {
  40     int64_t pos;
  41
  42     av_assert0((start&1) == 0);
  43
  44     pos = avio_tell(pb);
  45     if (pos & 1)
  46         avio_w8(pb, 0);
  47     avio_seek(pb, start - 4, SEEK_SET);
  48     avio_wl32(pb, (uint32_t)(pos - start));
  49     avio_seek(pb, FFALIGN(pos, 2), SEEK_SET);
  50 }
  51
  52 /* WAVEFORMATEX header */
  53 /* returns the size or -1 on error */
  54 int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc, int flags)
  55 {
  56     int bps, blkalign, bytespersec, frame_size;
  57     int hdrsize;
  58     int64_t hdrstart = avio_tell(pb);
  59     int waveformatextensible;
  60     uint8_t temp[256];
  61     uint8_t *riff_extradata       = temp;
  62     uint8_t *riff_extradata_start = temp;
  63
  64     if (!enc->codec_tag || enc->codec_tag > 0xffff)
  65         return -1;
  66
  67     /* We use the known constant frame size for the codec if known, otherwise
  68      * fall back on using AVCodecContext.frame_size, which is not as reliable
  69      * for indicating packet duration. */
  70     frame_size = av_get_audio_frame_duration(enc, enc->block_align);
  71
  72     waveformatextensible = (enc->channels > 2 && enc->channel_layout) ||
  73                            enc->sample_rate > 48000 ||
  74                            enc->codec_id == AV_CODEC_ID_EAC3 ||
  75                            av_get_bits_per_sample(enc->codec_id) > 16;
  76
  77     if (waveformatextensible)
  78         avio_wl16(pb, 0xfffe);
  79     else
  80         avio_wl16(pb, enc->codec_tag);
  81
  82     avio_wl16(pb, enc->channels);
  83     avio_wl32(pb, enc->sample_rate);
  84     if (enc->codec_id == AV_CODEC_ID_ATRAC3 ||
  85         enc->codec_id == AV_CODEC_ID_G723_1 ||
  86         enc->codec_id == AV_CODEC_ID_MP2    ||
  87         enc->codec_id == AV_CODEC_ID_MP3    ||
  88         enc->codec_id == AV_CODEC_ID_GSM_MS) {
  89         bps = 0;
  90     } else {
  91         if (!(bps = av_get_bits_per_sample(enc->codec_id))) {
  92             if (enc->bits_per_coded_sample)
  93                 bps = enc->bits_per_coded_sample;
  94             else
  95                 bps = 16;  // default to 16
  96         }
  97     }
  98     if (bps != enc->bits_per_coded_sample && enc->bits_per_coded_sample) {
  99         av_log(enc, AV_LOG_WARNING,
 100                "requested bits_per_coded_sample (%d) "
 101                "and actually stored (%d) differ\n",
 102                enc->bits_per_coded_sample, bps);
 103     }
 104
 105     if (enc->codec_id == AV_CODEC_ID_MP2) {
 106         blkalign = (144 * enc->bit_rate - 1)/enc->sample_rate + 1;
 107     } else if (enc->codec_id == AV_CODEC_ID_MP3) {
 108         blkalign = 576 * (enc->sample_rate <= (24000 + 32000)/2 ? 1 : 2);
 109     } else if (enc->codec_id == AV_CODEC_ID_AC3) {
 110         blkalign = 3840;                /* maximum bytes per frame */
 111     } else if (enc->codec_id == AV_CODEC_ID_AAC) {
 112         blkalign = 768 * enc->channels; /* maximum bytes per frame */
 113     } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
 114         blkalign = 24;
 115     } else if (enc->block_align != 0) { /* specified by the codec */
 116         blkalign = enc->block_align;
 117     } else
 118         blkalign = bps * enc->channels / av_gcd(8, bps);
 119     if (enc->codec_id == AV_CODEC_ID_PCM_U8 ||
 120         enc->codec_id == AV_CODEC_ID_PCM_S24LE ||
 121         enc->codec_id == AV_CODEC_ID_PCM_S32LE ||
 122         enc->codec_id == AV_CODEC_ID_PCM_F32LE ||
 123         enc->codec_id == AV_CODEC_ID_PCM_F64LE ||
 124         enc->codec_id == AV_CODEC_ID_PCM_S16LE) {
 125         bytespersec = enc->sample_rate * blkalign;
 126     } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
 127         bytespersec = 800;
 128     } else {
 129         bytespersec = enc->bit_rate / 8;
 130     }
 131     avio_wl32(pb, bytespersec); /* bytes per second */
 132     avio_wl16(pb, blkalign);    /* block align */
 133     avio_wl16(pb, bps);         /* bits per sample */
 134     if (enc->codec_id == AV_CODEC_ID_MP3) {
 135         bytestream_put_le16(&riff_extradata, 1);    /* wID */
 136         bytestream_put_le32(&riff_extradata, 2);    /* fdwFlags */
 137         bytestream_put_le16(&riff_extradata, 1152); /* nBlockSize */
 138         bytestream_put_le16(&riff_extradata, 1);    /* nFramesPerBlock */
 139         bytestream_put_le16(&riff_extradata, 1393); /* nCodecDelay */
 140     } else if (enc->codec_id == AV_CODEC_ID_MP2) {
 141         /* fwHeadLayer */
 142         bytestream_put_le16(&riff_extradata, 2);
 143         /* dwHeadBitrate */
 144         bytestream_put_le32(&riff_extradata, enc->bit_rate);
 145         /* fwHeadMode */
 146         bytestream_put_le16(&riff_extradata, enc->channels == 2 ? 1 : 8);
 147         /* fwHeadModeExt */
 148         bytestream_put_le16(&riff_extradata, 0);
 149         /* wHeadEmphasis */
 150         bytestream_put_le16(&riff_extradata, 1);
 151         /* fwHeadFlags */
 152         bytestream_put_le16(&riff_extradata, 16);
 153         /* dwPTSLow */
 154         bytestream_put_le32(&riff_extradata, 0);
 155         /* dwPTSHigh */
 156         bytestream_put_le32(&riff_extradata, 0);
 157     } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
 158         bytestream_put_le32(&riff_extradata, 0x9ace0002); /* extradata needed for msacm g723.1 codec */
 159         bytestream_put_le32(&riff_extradata, 0xaea2f732);
 160         bytestream_put_le16(&riff_extradata, 0xacde);
 161     } else if (enc->codec_id == AV_CODEC_ID_GSM_MS ||
 162                enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
 163         /* wSamplesPerBlock */
 164         bytestream_put_le16(&riff_extradata, frame_size);
 165     } else if (enc->extradata_size) {
 166         riff_extradata_start = enc->extradata;
 167         riff_extradata       = enc->extradata + enc->extradata_size;
 168     }
 169     /* write WAVEFORMATEXTENSIBLE extensions */
 170     if (waveformatextensible) {
 171         int write_channel_mask = !(flags & FF_PUT_WAV_HEADER_SKIP_CHANNELMASK) &&
 172                                  (enc->strict_std_compliance < FF_COMPLIANCE_NORMAL ||
 173                                   enc->channel_layout < 0x40000);
 174         /* 22 is WAVEFORMATEXTENSIBLE size */
 175         avio_wl16(pb, riff_extradata - riff_extradata_start + 22);
 176         /* ValidBitsPerSample || SamplesPerBlock || Reserved */
 177         avio_wl16(pb, bps);
 178         /* dwChannelMask */
 179         avio_wl32(pb, write_channel_mask ? enc->channel_layout : 0);
 180         /* GUID + next 3 */
 181         if (enc->codec_id == AV_CODEC_ID_EAC3) {
 182             ff_put_guid(pb, ff_get_codec_guid(enc->codec_id, ff_codec_wav_guids));
 183         } else {
 184         avio_wl32(pb, enc->codec_tag);
 185         avio_wl32(pb, 0x00100000);
 186         avio_wl32(pb, 0xAA000080);
 187         avio_wl32(pb, 0x719B3800);
 188         }
 189     } else if ((flags & FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX) ||
 190                enc->codec_tag != 0x0001 /* PCM */ ||
 191                riff_extradata - riff_extradata_start) {
 192         /* WAVEFORMATEX */
 193         avio_wl16(pb, riff_extradata - riff_extradata_start); /* cbSize */
 194     } /* else PCMWAVEFORMAT */
 195     avio_write(pb, riff_extradata_start, riff_extradata - riff_extradata_start);
 196     hdrsize = avio_tell(pb) - hdrstart;
 197     if (hdrsize & 1) {
 198         hdrsize++;
 199         avio_w8(pb, 0);
 200     }
 201
 202     return hdrsize;
 203 }
 204
 205 /* BITMAPINFOHEADER header */
 206 void ff_put_bmp_header(AVIOContext *pb, AVCodecContext *enc,
 207                        const AVCodecTag *tags, int for_asf, int ignore_extradata)
 208 {
 209     int keep_height = enc->extradata_size >= 9 &&
 210                       !memcmp(enc->extradata + enc->extradata_size - 9, "BottomUp", 9);
 211     int extradata_size = enc->extradata_size - 9*keep_height;
 212     enum AVPixelFormat pix_fmt = enc->pix_fmt;
 213     int pal_avi;
 214
 215     if (pix_fmt == AV_PIX_FMT_NONE && enc->bits_per_coded_sample == 1)
 216         pix_fmt = AV_PIX_FMT_MONOWHITE;
 217     pal_avi = !for_asf &&
 218               (pix_fmt == AV_PIX_FMT_PAL8 ||
 219                pix_fmt == AV_PIX_FMT_MONOWHITE ||
 220                pix_fmt == AV_PIX_FMT_MONOBLACK);
 221
 222     /* Size (not including the size of the color table or color masks) */
 223     avio_wl32(pb, 40 + (ignore_extradata || pal_avi ? 0 : extradata_size));
 224     avio_wl32(pb, enc->width);
 225     //We always store RGB TopDown
 226     avio_wl32(pb, enc->codec_tag || keep_height ? enc->height : -enc->height);
 227     /* planes */
 228     avio_wl16(pb, 1);
 229     /* depth */
 230     avio_wl16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24);
 231     /* compression type */
 232     avio_wl32(pb, enc->codec_tag);
 233     avio_wl32(pb, (enc->width * enc->height * (enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24)+7) / 8);
 234     avio_wl32(pb, 0);
 235     avio_wl32(pb, 0);
 236     /* Number of color indices in the color table that are used.
 237      * A value of 0 means 2^biBitCount indices, but this doesn't work
 238      * with Windows Media Player and files containing xxpc chunks. */
 239     avio_wl32(pb, pal_avi ? 1 << enc->bits_per_coded_sample : 0);
 240     avio_wl32(pb, 0);
 241
 242     if (!ignore_extradata) {
 243         if (enc->extradata_size) {
 244             avio_write(pb, enc->extradata, extradata_size);
 245             if (!for_asf && extradata_size & 1)
 246                 avio_w8(pb, 0);
 247         } else if (pal_avi) {
 248             int i;
 249             for (i = 0; i < 1 << enc->bits_per_coded_sample; i++) {
 250                 /* Initialize 1 bpp palette to black & white */
 251                 if (i == 0 && pix_fmt == AV_PIX_FMT_MONOWHITE)
 252                     avio_wl32(pb, 0xffffff);
 253                 else if (i == 1 && pix_fmt == AV_PIX_FMT_MONOBLACK)
 254                     avio_wl32(pb, 0xffffff);
 255                 else
 256                     avio_wl32(pb, 0);
 257             }
 258         }
 259     }
 260 }
 261
 262 void ff_parse_specific_params(AVStream *st, int *au_rate,
 263                               int *au_ssize, int *au_scale)
 264 {
 265     AVCodecContext *codec = st->codec;
 266     int gcd;
 267     int audio_frame_size;
 268
 269     /* We use the known constant frame size for the codec if known, otherwise
 270      * fall back on using AVCodecContext.frame_size, which is not as reliable
 271      * for indicating packet duration. */
 272     audio_frame_size = av_get_audio_frame_duration(codec, 0);
 273     if (!audio_frame_size)
 274         audio_frame_size = codec->frame_size;
 275
 276     *au_ssize = codec->block_align;
 277     if (audio_frame_size && codec->sample_rate) {
 278         *au_scale = audio_frame_size;
 279         *au_rate  = codec->sample_rate;
 280     } else if (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
 281                codec->codec_type == AVMEDIA_TYPE_DATA ||
 282                codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
 283         *au_scale = st->time_base.num;
 284         *au_rate  = st->time_base.den;
 285     } else {
 286         *au_scale = codec->block_align ? codec->block_align * 8 : 8;
 287         *au_rate  = codec->bit_rate ? codec->bit_rate :
 288                     8 * codec->sample_rate;
 289     }
 290     gcd        = av_gcd(*au_scale, *au_rate);
 291     *au_scale /= gcd;
 292     *au_rate  /= gcd;
 293 }
 294
 295 void ff_riff_write_info_tag(AVIOContext *pb, const char *tag, const char *str)
 296 {
 297     size_t len = strlen(str);
 298     if (len > 0 && len < UINT32_MAX) {
 299         len++;
 300         ffio_wfourcc(pb, tag);
 301         avio_wl32(pb, len);
 302         avio_put_str(pb, str);
 303         if (len & 1)
 304             avio_w8(pb, 0);
 305     }
 306 }
 307
 308 static const char riff_tags[][5] = {
 309     "IARL", "IART", "ICMS", "ICMT", "ICOP", "ICRD", "ICRP", "IDIM", "IDPI",
 310     "IENG", "IGNR", "IKEY", "ILGT", "ILNG", "IMED", "INAM", "IPLT", "IPRD",
 311     "IPRT", "ITRK", "ISBJ", "ISFT", "ISHP", "ISMP", "ISRC", "ISRF", "ITCH",
 312     { 0 }
 313 };
 314
 315 static int riff_has_valid_tags(AVFormatContext *s)
 316 {
 317     int i;
 318
 319     for (i = 0; *riff_tags[i]; i++)
 320         if (av_dict_get(s->metadata, riff_tags[i], NULL, AV_DICT_MATCH_CASE))
 321             return 1;
 322
 323     return 0;
 324 }
 325
 326 void ff_riff_write_info(AVFormatContext *s)
 327 {
 328     AVIOContext *pb = s->pb;
 329     int i;
 330     int64_t list_pos;
 331     AVDictionaryEntry *t = NULL;
 332
 333     ff_metadata_conv(&s->metadata, ff_riff_info_conv, NULL);
 334
 335     /* writing empty LIST is not nice and may cause problems */
 336     if (!riff_has_valid_tags(s))
 337         return;
 338
 339     list_pos = ff_start_tag(pb, "LIST");
 340     ffio_wfourcc(pb, "INFO");
 341     for (i = 0; *riff_tags[i]; i++)
 342         if ((t = av_dict_get(s->metadata, riff_tags[i],
 343                              NULL, AV_DICT_MATCH_CASE)))
 344             ff_riff_write_info_tag(s->pb, t->key, t->value);
 345     ff_end_tag(pb, list_pos);
 346 }
 347
 348 void ff_put_guid(AVIOContext *s, const ff_asf_guid *g)
 349 {
 350     av_assert0(sizeof(*g) == 16);
 351     avio_write(s, *g, sizeof(*g));
 352 }
 353
 354 const ff_asf_guid *ff_get_codec_guid(enum AVCodecID id, const AVCodecGuid *av_guid)
 355 {
 356     int i;
 357     for (i = 0; av_guid[i].id != AV_CODEC_ID_NONE; i++) {
 358         if (id == av_guid[i].id)
 359             return &(av_guid[i].guid);
 360     }
 361     return NULL;
 362 }