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, 0);
  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)
  55 {
  56     int bps, blkalign, bytespersec, frame_size;
  57     int hdrsize = 18;
  58     int waveformatextensible;
  59     uint8_t temp[256];
  60     uint8_t *riff_extradata       = temp;
  61     uint8_t *riff_extradata_start = temp;
  62
  63     if (!enc->codec_tag || enc->codec_tag > 0xffff)
  64         return -1;
  65
  66     /* We use the known constant frame size for the codec if known, otherwise
  67      * fall back on using AVCodecContext.frame_size, which is not as reliable
  68      * for indicating packet duration. */
  69     frame_size = av_get_audio_frame_duration(enc, 0);
  70     if (!frame_size)
  71         frame_size = enc->frame_size;
  72
  73     waveformatextensible = (enc->channels > 2 && enc->channel_layout) ||
  74                            enc->sample_rate > 48000 ||
  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         enc->codec_id == AV_CODEC_ID_MP3) {
 107         /* This is wrong, but it seems many demuxers do not work if this
 108          * is set correctly. */
 109         blkalign = frame_size;
 110         // blkalign = 144 * enc->bit_rate/enc->sample_rate;
 111     } else if (enc->codec_id == AV_CODEC_ID_AC3) {
 112         blkalign = 3840;                /* maximum bytes per frame */
 113     } else if (enc->codec_id == AV_CODEC_ID_AAC) {
 114         blkalign = 768 * enc->channels; /* maximum bytes per frame */
 115     } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
 116         blkalign = 24;
 117     } else if (enc->block_align != 0) { /* specified by the codec */
 118         blkalign = enc->block_align;
 119     } else
 120         blkalign = bps * enc->channels / av_gcd(8, bps);
 121     if (enc->codec_id == AV_CODEC_ID_PCM_U8 ||
 122         enc->codec_id == AV_CODEC_ID_PCM_S24LE ||
 123         enc->codec_id == AV_CODEC_ID_PCM_S32LE ||
 124         enc->codec_id == AV_CODEC_ID_PCM_F32LE ||
 125         enc->codec_id == AV_CODEC_ID_PCM_F64LE ||
 126         enc->codec_id == AV_CODEC_ID_PCM_S16LE) {
 127         bytespersec = enc->sample_rate * blkalign;
 128     } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
 129         bytespersec = 800;
 130     } else {
 131         bytespersec = enc->bit_rate / 8;
 132     }
 133     avio_wl32(pb, bytespersec); /* bytes per second */
 134     avio_wl16(pb, blkalign);    /* block align */
 135     avio_wl16(pb, bps);         /* bits per sample */
 136     if (enc->codec_id == AV_CODEC_ID_MP3) {
 137         hdrsize += 12;
 138         bytestream_put_le16(&riff_extradata, 1);    /* wID */
 139         bytestream_put_le32(&riff_extradata, 2);    /* fdwFlags */
 140         bytestream_put_le16(&riff_extradata, 1152); /* nBlockSize */
 141         bytestream_put_le16(&riff_extradata, 1);    /* nFramesPerBlock */
 142         bytestream_put_le16(&riff_extradata, 1393); /* nCodecDelay */
 143     } else if (enc->codec_id == AV_CODEC_ID_MP2) {
 144         hdrsize += 22;
 145         /* fwHeadLayer */
 146         bytestream_put_le16(&riff_extradata, 2);
 147         /* dwHeadBitrate */
 148         bytestream_put_le32(&riff_extradata, enc->bit_rate);
 149         /* fwHeadMode */
 150         bytestream_put_le16(&riff_extradata, enc->channels == 2 ? 1 : 8);
 151         /* fwHeadModeExt */
 152         bytestream_put_le16(&riff_extradata, 0);
 153         /* wHeadEmphasis */
 154         bytestream_put_le16(&riff_extradata, 1);
 155         /* fwHeadFlags */
 156         bytestream_put_le16(&riff_extradata, 16);
 157         /* dwPTSLow */
 158         bytestream_put_le32(&riff_extradata, 0);
 159         /* dwPTSHigh */
 160         bytestream_put_le32(&riff_extradata, 0);
 161     } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
 162         hdrsize += 20;
 163         bytestream_put_le32(&riff_extradata, 0x9ace0002); /* extradata needed for msacm g723.1 codec */
 164         bytestream_put_le32(&riff_extradata, 0xaea2f732);
 165         bytestream_put_le16(&riff_extradata, 0xacde);
 166     } else if (enc->codec_id == AV_CODEC_ID_GSM_MS ||
 167                enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
 168         hdrsize += 2;
 169         /* wSamplesPerBlock */
 170         bytestream_put_le16(&riff_extradata, frame_size);
 171     } else if (enc->extradata_size) {
 172         riff_extradata_start = enc->extradata;
 173         riff_extradata       = enc->extradata + enc->extradata_size;
 174         hdrsize             += enc->extradata_size;
 175     }
 176     /* write WAVEFORMATEXTENSIBLE extensions */
 177     if (waveformatextensible) {
 178         hdrsize += 22;
 179         /* 22 is WAVEFORMATEXTENSIBLE size */
 180         avio_wl16(pb, riff_extradata - riff_extradata_start + 22);
 181         /* ValidBitsPerSample || SamplesPerBlock || Reserved */
 182         avio_wl16(pb, bps);
 183         /* dwChannelMask */
 184         avio_wl32(pb, enc->channel_layout);
 185         /* GUID + next 3 */
 186         avio_wl32(pb, enc->codec_tag);
 187         avio_wl32(pb, 0x00100000);
 188         avio_wl32(pb, 0xAA000080);
 189         avio_wl32(pb, 0x719B3800);
 190     } else {
 191         avio_wl16(pb, riff_extradata - riff_extradata_start); /* cbSize */
 192     }
 193     avio_write(pb, riff_extradata_start, riff_extradata - riff_extradata_start);
 194     if (hdrsize & 1) {
 195         hdrsize++;
 196         avio_w8(pb, 0);
 197     }
 198
 199     return hdrsize;
 200 }
 201
 202 /* BITMAPINFOHEADER header */
 203 void ff_put_bmp_header(AVIOContext *pb, AVCodecContext *enc,
 204                        const AVCodecTag *tags, int for_asf, int ignore_extradata)
 205 {
 206     /* size */
 207     avio_wl32(pb, 40 + (ignore_extradata ? 0 : enc->extradata_size));
 208     avio_wl32(pb, enc->width);
 209     //We always store RGB TopDown
 210     avio_wl32(pb, enc->codec_tag ? enc->height : -enc->height);
 211     /* planes */
 212     avio_wl16(pb, 1);
 213     /* depth */
 214     avio_wl16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24);
 215     /* compression type */
 216     avio_wl32(pb, enc->codec_tag);
 217     avio_wl32(pb, (enc->width * enc->height * (enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24)+7) / 8);
 218     avio_wl32(pb, 0);
 219     avio_wl32(pb, 0);
 220     avio_wl32(pb, 0);
 221     avio_wl32(pb, 0);
 222
 223     if (!ignore_extradata) {
 224         avio_write(pb, enc->extradata, enc->extradata_size);
 225
 226         if (!for_asf && enc->extradata_size & 1)
 227             avio_w8(pb, 0);
 228     }
 229 }
 230
 231 void ff_parse_specific_params(AVCodecContext *stream, int *au_rate,
 232                               int *au_ssize, int *au_scale)
 233 {
 234     int gcd;
 235     int audio_frame_size;
 236
 237     /* We use the known constant frame size for the codec if known, otherwise
 238      * fall back on using AVCodecContext.frame_size, which is not as reliable
 239      * for indicating packet duration. */
 240     audio_frame_size = av_get_audio_frame_duration(stream, 0);
 241     if (!audio_frame_size)
 242         audio_frame_size = stream->frame_size;
 243
 244     *au_ssize = stream->block_align;
 245     if (audio_frame_size && stream->sample_rate) {
 246         *au_scale = audio_frame_size;
 247         *au_rate  = stream->sample_rate;
 248     } else if (stream->codec_type == AVMEDIA_TYPE_VIDEO ||
 249                stream->codec_type == AVMEDIA_TYPE_DATA ||
 250                stream->codec_type == AVMEDIA_TYPE_SUBTITLE) {
 251         *au_scale = stream->time_base.num;
 252         *au_rate  = stream->time_base.den;
 253     } else {
 254         *au_scale = stream->block_align ? stream->block_align * 8 : 8;
 255         *au_rate  = stream->bit_rate ? stream->bit_rate :
 256                     8 * stream->sample_rate;
 257     }
 258     gcd        = av_gcd(*au_scale, *au_rate);
 259     *au_scale /= gcd;
 260     *au_rate  /= gcd;
 261 }
 262
 263 void ff_riff_write_info_tag(AVIOContext *pb, const char *tag, const char *str)
 264 {
 265     int len = strlen(str);
 266     if (len > 0) {
 267         len++;
 268         ffio_wfourcc(pb, tag);
 269         avio_wl32(pb, len);
 270         avio_put_str(pb, str);
 271         if (len & 1)
 272             avio_w8(pb, 0);
 273     }
 274 }
 275
 276 static const char riff_tags[][5] = {
 277     "IARL", "IART", "ICMS", "ICMT", "ICOP", "ICRD", "ICRP", "IDIM", "IDPI",
 278     "IENG", "IGNR", "IKEY", "ILGT", "ILNG", "IMED", "INAM", "IPLT", "IPRD",
 279     "IPRT", "ITRK", "ISBJ", "ISFT", "ISHP", "ISMP", "ISRC", "ISRF", "ITCH",
 280     { 0 }
 281 };
 282
 283 static int riff_has_valid_tags(AVFormatContext *s)
 284 {
 285     int i;
 286
 287     for (i = 0; *riff_tags[i]; i++)
 288         if (av_dict_get(s->metadata, riff_tags[i], NULL, AV_DICT_MATCH_CASE))
 289             return 1;
 290
 291     return 0;
 292 }
 293
 294 void ff_riff_write_info(AVFormatContext *s)
 295 {
 296     AVIOContext *pb = s->pb;
 297     int i;
 298     int64_t list_pos;
 299     AVDictionaryEntry *t = NULL;
 300
 301     ff_metadata_conv(&s->metadata, ff_riff_info_conv, NULL);
 302
 303     /* writing empty LIST is not nice and may cause problems */
 304     if (!riff_has_valid_tags(s))
 305         return;
 306
 307     list_pos = ff_start_tag(pb, "LIST");
 308     ffio_wfourcc(pb, "INFO");
 309     for (i = 0; *riff_tags[i]; i++)
 310         if ((t = av_dict_get(s->metadata, riff_tags[i],
 311                              NULL, AV_DICT_MATCH_CASE)))
 312             ff_riff_write_info_tag(s->pb, t->key, t->value);
 313     ff_end_tag(pb, list_pos);
 314 }