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