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