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
31int64_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
38void 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 */
54int 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    if (!frame_size)
72        frame_size = enc->frame_size;
73
74    waveformatextensible = (enc->channels > 2 && enc->channel_layout) ||
75                           enc->sample_rate > 48000 ||
76                           enc->codec_id == AV_CODEC_ID_EAC3 ||
77                           av_get_bits_per_sample(enc->codec_id) > 16;
78
79    if (waveformatextensible)
80        avio_wl16(pb, 0xfffe);
81    else
82        avio_wl16(pb, enc->codec_tag);
83
84    avio_wl16(pb, enc->channels);
85    avio_wl32(pb, enc->sample_rate);
86    if (enc->codec_id == AV_CODEC_ID_ATRAC3 ||
87        enc->codec_id == AV_CODEC_ID_G723_1 ||
88        enc->codec_id == AV_CODEC_ID_MP2    ||
89        enc->codec_id == AV_CODEC_ID_MP3    ||
90        enc->codec_id == AV_CODEC_ID_GSM_MS) {
91        bps = 0;
92    } else {
93        if (!(bps = av_get_bits_per_sample(enc->codec_id))) {
94            if (enc->bits_per_coded_sample)
95                bps = enc->bits_per_coded_sample;
96            else
97                bps = 16;  // default to 16
98        }
99    }
100    if (bps != enc->bits_per_coded_sample && enc->bits_per_coded_sample) {
101        av_log(enc, AV_LOG_WARNING,
102               "requested bits_per_coded_sample (%d) "
103               "and actually stored (%d) differ\n",
104               enc->bits_per_coded_sample, bps);
105    }
106
107    if (enc->codec_id == AV_CODEC_ID_MP2 ||
108        enc->codec_id == AV_CODEC_ID_MP3) {
109        /* This is wrong, but it seems many demuxers do not work if this
110         * is set correctly. */
111        blkalign = frame_size;
112        // blkalign = 144 * enc->bit_rate/enc->sample_rate;
113    } else if (enc->codec_id == AV_CODEC_ID_AC3) {
114        blkalign = 3840;                /* maximum bytes per frame */
115    } else if (enc->codec_id == AV_CODEC_ID_AAC) {
116        blkalign = 768 * enc->channels; /* maximum bytes per frame */
117    } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
118        blkalign = 24;
119    } else if (enc->block_align != 0) { /* specified by the codec */
120        blkalign = enc->block_align;
121    } else
122        blkalign = bps * enc->channels / av_gcd(8, bps);
123    if (enc->codec_id == AV_CODEC_ID_PCM_U8 ||
124        enc->codec_id == AV_CODEC_ID_PCM_S24LE ||
125        enc->codec_id == AV_CODEC_ID_PCM_S32LE ||
126        enc->codec_id == AV_CODEC_ID_PCM_F32LE ||
127        enc->codec_id == AV_CODEC_ID_PCM_F64LE ||
128        enc->codec_id == AV_CODEC_ID_PCM_S16LE) {
129        bytespersec = enc->sample_rate * blkalign;
130    } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
131        bytespersec = 800;
132    } else {
133        bytespersec = enc->bit_rate / 8;
134    }
135    avio_wl32(pb, bytespersec); /* bytes per second */
136    avio_wl16(pb, blkalign);    /* block align */
137    avio_wl16(pb, bps);         /* bits per sample */
138    if (enc->codec_id == AV_CODEC_ID_MP3) {
139        bytestream_put_le16(&riff_extradata, 1);    /* wID */
140        bytestream_put_le32(&riff_extradata, 2);    /* fdwFlags */
141        bytestream_put_le16(&riff_extradata, 1152); /* nBlockSize */
142        bytestream_put_le16(&riff_extradata, 1);    /* nFramesPerBlock */
143        bytestream_put_le16(&riff_extradata, 1393); /* nCodecDelay */
144    } else if (enc->codec_id == AV_CODEC_ID_MP2) {
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        bytestream_put_le32(&riff_extradata, 0x9ace0002); /* extradata needed for msacm g723.1 codec */
163        bytestream_put_le32(&riff_extradata, 0xaea2f732);
164        bytestream_put_le16(&riff_extradata, 0xacde);
165    } else if (enc->codec_id == AV_CODEC_ID_GSM_MS ||
166               enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
167        /* wSamplesPerBlock */
168        bytestream_put_le16(&riff_extradata, frame_size);
169    } else if (enc->extradata_size) {
170        riff_extradata_start = enc->extradata;
171        riff_extradata       = enc->extradata + enc->extradata_size;
172    }
173    /* write WAVEFORMATEXTENSIBLE extensions */
174    if (waveformatextensible) {
175        int write_channel_mask = enc->strict_std_compliance < FF_COMPLIANCE_NORMAL ||
176                                 enc->channel_layout < 0x40000;
177        /* 22 is WAVEFORMATEXTENSIBLE size */
178        avio_wl16(pb, riff_extradata - riff_extradata_start + 22);
179        /* ValidBitsPerSample || SamplesPerBlock || Reserved */
180        avio_wl16(pb, bps);
181        /* dwChannelMask */
182        avio_wl32(pb, write_channel_mask ? enc->channel_layout : 0);
183        /* GUID + next 3 */
184        if (enc->codec_id == AV_CODEC_ID_EAC3) {
185            ff_put_guid(pb, get_codec_guid(enc->codec_id, ff_codec_wav_guids));
186        } else {
187        avio_wl32(pb, enc->codec_tag);
188        avio_wl32(pb, 0x00100000);
189        avio_wl32(pb, 0xAA000080);
190        avio_wl32(pb, 0x719B3800);
191        }
192    } else if ((flags & FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX) ||
193               enc->codec_tag != 0x0001 /* PCM */ ||
194               riff_extradata - riff_extradata_start) {
195        /* WAVEFORMATEX */
196        avio_wl16(pb, riff_extradata - riff_extradata_start); /* cbSize */
197    } /* else PCMWAVEFORMAT */
198    avio_write(pb, riff_extradata_start, riff_extradata - riff_extradata_start);
199    hdrsize = avio_tell(pb) - hdrstart;
200    if (hdrsize & 1) {
201        hdrsize++;
202        avio_w8(pb, 0);
203    }
204
205    return hdrsize;
206}
207
208/* BITMAPINFOHEADER header */
209void ff_put_bmp_header(AVIOContext *pb, AVCodecContext *enc,
210                       const AVCodecTag *tags, int for_asf, int ignore_extradata)
211{
212    int keep_height = enc->extradata_size >= 9 &&
213                      !memcmp(enc->extradata + enc->extradata_size - 9, "BottomUp", 9);
214    int extradata_size = enc->extradata_size - 9*keep_height;
215
216    /* size */
217    avio_wl32(pb, 40 + (ignore_extradata ? 0 :extradata_size));
218    avio_wl32(pb, enc->width);
219    //We always store RGB TopDown
220    avio_wl32(pb, enc->codec_tag || keep_height ? enc->height : -enc->height);
221    /* planes */
222    avio_wl16(pb, 1);
223    /* depth */
224    avio_wl16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24);
225    /* compression type */
226    avio_wl32(pb, enc->codec_tag);
227    avio_wl32(pb, (enc->width * enc->height * (enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24)+7) / 8);
228    avio_wl32(pb, 0);
229    avio_wl32(pb, 0);
230    avio_wl32(pb, 0);
231    avio_wl32(pb, 0);
232
233    if (!ignore_extradata) {
234        avio_write(pb, enc->extradata, extradata_size);
235
236        if (!for_asf && extradata_size & 1)
237            avio_w8(pb, 0);
238    }
239}
240
241void ff_parse_specific_params(AVStream *st, int *au_rate,
242                              int *au_ssize, int *au_scale)
243{
244    AVCodecContext *codec = st->codec;
245    int gcd;
246    int audio_frame_size;
247
248    /* We use the known constant frame size for the codec if known, otherwise
249     * fall back on using AVCodecContext.frame_size, which is not as reliable
250     * for indicating packet duration. */
251    audio_frame_size = av_get_audio_frame_duration(codec, 0);
252    if (!audio_frame_size)
253        audio_frame_size = codec->frame_size;
254
255    *au_ssize = codec->block_align;
256    if (audio_frame_size && codec->sample_rate) {
257        *au_scale = audio_frame_size;
258        *au_rate  = codec->sample_rate;
259    } else if (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
260               codec->codec_type == AVMEDIA_TYPE_DATA ||
261               codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
262        *au_scale = st->time_base.num;
263        *au_rate  = st->time_base.den;
264    } else {
265        *au_scale = codec->block_align ? codec->block_align * 8 : 8;
266        *au_rate  = codec->bit_rate ? codec->bit_rate :
267                    8 * codec->sample_rate;
268    }
269    gcd        = av_gcd(*au_scale, *au_rate);
270    *au_scale /= gcd;
271    *au_rate  /= gcd;
272}
273
274void ff_riff_write_info_tag(AVIOContext *pb, const char *tag, const char *str)
275{
276    int len = strlen(str);
277    if (len > 0) {
278        len++;
279        ffio_wfourcc(pb, tag);
280        avio_wl32(pb, len);
281        avio_put_str(pb, str);
282        if (len & 1)
283            avio_w8(pb, 0);
284    }
285}
286
287static const char riff_tags[][5] = {
288    "IARL", "IART", "ICMS", "ICMT", "ICOP", "ICRD", "ICRP", "IDIM", "IDPI",
289    "IENG", "IGNR", "IKEY", "ILGT", "ILNG", "IMED", "INAM", "IPLT", "IPRD",
290    "IPRT", "ITRK", "ISBJ", "ISFT", "ISHP", "ISMP", "ISRC", "ISRF", "ITCH",
291    { 0 }
292};
293
294static int riff_has_valid_tags(AVFormatContext *s)
295{
296    int i;
297
298    for (i = 0; *riff_tags[i]; i++)
299        if (av_dict_get(s->metadata, riff_tags[i], NULL, AV_DICT_MATCH_CASE))
300            return 1;
301
302    return 0;
303}
304
305void ff_riff_write_info(AVFormatContext *s)
306{
307    AVIOContext *pb = s->pb;
308    int i;
309    int64_t list_pos;
310    AVDictionaryEntry *t = NULL;
311
312    ff_metadata_conv(&s->metadata, ff_riff_info_conv, NULL);
313
314    /* writing empty LIST is not nice and may cause problems */
315    if (!riff_has_valid_tags(s))
316        return;
317
318    list_pos = ff_start_tag(pb, "LIST");
319    ffio_wfourcc(pb, "INFO");
320    for (i = 0; *riff_tags[i]; i++)
321        if ((t = av_dict_get(s->metadata, riff_tags[i],
322                             NULL, AV_DICT_MATCH_CASE)))
323            ff_riff_write_info_tag(s->pb, t->key, t->value);
324    ff_end_tag(pb, list_pos);
325}
326
327void ff_put_guid(AVIOContext *s, const ff_asf_guid *g)
328{
329    av_assert0(sizeof(*g) == 16);
330    avio_write(s, *g, sizeof(*g));
331}
332
333const ff_asf_guid *get_codec_guid(enum AVCodecID id, const AVCodecGuid *av_guid)
334{
335    int i;
336    for (i = 0; av_guid[i].id != AV_CODEC_ID_NONE; i++) {
337        if (id == av_guid[i].id)
338            return &(av_guid[i].guid);
339    }
340    return NULL;
341}
342