riffenc: take an AVStream instead of an AVCodecContext
[libav.git] / libavformat / riffenc.c
1 /*
2 * RIFF muxing functions
3 * Copyright (c) 2000 Fabrice Bellard
4 *
5 * This file is part of Libav.
6 *
7 * Libav 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 * Libav 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 Libav; 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 pos = avio_tell(pb);
43 avio_seek(pb, start - 4, SEEK_SET);
44 avio_wl32(pb, (uint32_t)(pos - start));
45 avio_seek(pb, pos, SEEK_SET);
46 }
47
48 /* WAVEFORMATEX header */
49 /* returns the size or -1 on error */
50 int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc)
51 {
52 int bps, blkalign, bytespersec, frame_size;
53 int hdrsize = 18;
54 int waveformatextensible;
55 uint8_t temp[256];
56 uint8_t *riff_extradata = temp;
57 uint8_t *riff_extradata_start = temp;
58
59 if (!enc->codec_tag || enc->codec_tag > 0xffff)
60 return -1;
61
62 /* We use the known constant frame size for the codec if known, otherwise
63 * fall back on using AVCodecContext.frame_size, which is not as reliable
64 * for indicating packet duration. */
65 frame_size = av_get_audio_frame_duration(enc, enc->block_align);
66 if (!frame_size)
67 frame_size = enc->frame_size;
68
69 waveformatextensible = (enc->channels > 2 && enc->channel_layout) ||
70 enc->sample_rate > 48000 ||
71 av_get_bits_per_sample(enc->codec_id) > 16;
72
73 if (waveformatextensible)
74 avio_wl16(pb, 0xfffe);
75 else
76 avio_wl16(pb, enc->codec_tag);
77
78 avio_wl16(pb, enc->channels);
79 avio_wl32(pb, enc->sample_rate);
80 if (enc->codec_id == AV_CODEC_ID_MP2 ||
81 enc->codec_id == AV_CODEC_ID_MP3 ||
82 enc->codec_id == AV_CODEC_ID_GSM_MS) {
83 bps = 0;
84 } else {
85 if (!(bps = av_get_bits_per_sample(enc->codec_id))) {
86 if (enc->bits_per_coded_sample)
87 bps = enc->bits_per_coded_sample;
88 else
89 bps = 16; // default to 16
90 }
91 }
92 if (bps != enc->bits_per_coded_sample && enc->bits_per_coded_sample) {
93 av_log(enc, AV_LOG_WARNING,
94 "requested bits_per_coded_sample (%d) "
95 "and actually stored (%d) differ\n",
96 enc->bits_per_coded_sample, bps);
97 }
98
99 if (enc->codec_id == AV_CODEC_ID_MP2 ||
100 enc->codec_id == AV_CODEC_ID_MP3) {
101 /* This is wrong, but it seems many demuxers do not work if this
102 * is set correctly. */
103 blkalign = frame_size;
104 // blkalign = 144 * enc->bit_rate/enc->sample_rate;
105 } else if (enc->codec_id == AV_CODEC_ID_AC3) {
106 blkalign = 3840; /* maximum bytes per frame */
107 } else if (enc->block_align != 0) { /* specified by the codec */
108 blkalign = enc->block_align;
109 } else
110 blkalign = bps * enc->channels / av_gcd(8, bps);
111 if (enc->codec_id == AV_CODEC_ID_PCM_U8 ||
112 enc->codec_id == AV_CODEC_ID_PCM_S24LE ||
113 enc->codec_id == AV_CODEC_ID_PCM_S32LE ||
114 enc->codec_id == AV_CODEC_ID_PCM_F32LE ||
115 enc->codec_id == AV_CODEC_ID_PCM_F64LE ||
116 enc->codec_id == AV_CODEC_ID_PCM_S16LE) {
117 bytespersec = enc->sample_rate * blkalign;
118 } else {
119 bytespersec = enc->bit_rate / 8;
120 }
121 avio_wl32(pb, bytespersec); /* bytes per second */
122 avio_wl16(pb, blkalign); /* block align */
123 avio_wl16(pb, bps); /* bits per sample */
124 if (enc->codec_id == AV_CODEC_ID_MP3) {
125 hdrsize += 12;
126 bytestream_put_le16(&riff_extradata, 1); /* wID */
127 bytestream_put_le32(&riff_extradata, 2); /* fdwFlags */
128 bytestream_put_le16(&riff_extradata, 1152); /* nBlockSize */
129 bytestream_put_le16(&riff_extradata, 1); /* nFramesPerBlock */
130 bytestream_put_le16(&riff_extradata, 1393); /* nCodecDelay */
131 } else if (enc->codec_id == AV_CODEC_ID_MP2) {
132 hdrsize += 22;
133 /* fwHeadLayer */
134 bytestream_put_le16(&riff_extradata, 2);
135 /* dwHeadBitrate */
136 bytestream_put_le32(&riff_extradata, enc->bit_rate);
137 /* fwHeadMode */
138 bytestream_put_le16(&riff_extradata, enc->channels == 2 ? 1 : 8);
139 /* fwHeadModeExt */
140 bytestream_put_le16(&riff_extradata, 0);
141 /* wHeadEmphasis */
142 bytestream_put_le16(&riff_extradata, 1);
143 /* fwHeadFlags */
144 bytestream_put_le16(&riff_extradata, 16);
145 /* dwPTSLow */
146 bytestream_put_le32(&riff_extradata, 0);
147 /* dwPTSHigh */
148 bytestream_put_le32(&riff_extradata, 0);
149 } else if (enc->codec_id == AV_CODEC_ID_GSM_MS ||
150 enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
151 hdrsize += 2;
152 /* wSamplesPerBlock */
153 bytestream_put_le16(&riff_extradata, frame_size);
154 } else if (enc->extradata_size) {
155 riff_extradata_start = enc->extradata;
156 riff_extradata = enc->extradata + enc->extradata_size;
157 hdrsize += enc->extradata_size;
158 }
159 /* write WAVEFORMATEXTENSIBLE extensions */
160 if (waveformatextensible) {
161 hdrsize += 22;
162 /* 22 is WAVEFORMATEXTENSIBLE size */
163 avio_wl16(pb, riff_extradata - riff_extradata_start + 22);
164 /* ValidBitsPerSample || SamplesPerBlock || Reserved */
165 avio_wl16(pb, bps);
166 /* dwChannelMask */
167 avio_wl32(pb, enc->channel_layout);
168 /* GUID + next 3 */
169 avio_wl32(pb, enc->codec_tag);
170 avio_wl32(pb, 0x00100000);
171 avio_wl32(pb, 0xAA000080);
172 avio_wl32(pb, 0x719B3800);
173 } else {
174 avio_wl16(pb, riff_extradata - riff_extradata_start); /* cbSize */
175 }
176 avio_write(pb, riff_extradata_start, riff_extradata - riff_extradata_start);
177 if (hdrsize & 1) {
178 hdrsize++;
179 avio_w8(pb, 0);
180 }
181
182 return hdrsize;
183 }
184
185 /* BITMAPINFOHEADER header */
186 void ff_put_bmp_header(AVIOContext *pb, AVCodecContext *enc,
187 const AVCodecTag *tags, int for_asf)
188 {
189 /* size */
190 avio_wl32(pb, 40 + enc->extradata_size);
191 avio_wl32(pb, enc->width);
192 //We always store RGB TopDown
193 avio_wl32(pb, enc->codec_tag ? enc->height : -enc->height);
194 /* planes */
195 avio_wl16(pb, 1);
196 /* depth */
197 avio_wl16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24);
198 /* compression type */
199 avio_wl32(pb, enc->codec_tag);
200 avio_wl32(pb, enc->width * enc->height * 3);
201 avio_wl32(pb, 0);
202 avio_wl32(pb, 0);
203 avio_wl32(pb, 0);
204 avio_wl32(pb, 0);
205
206 avio_write(pb, enc->extradata, enc->extradata_size);
207
208 if (!for_asf && enc->extradata_size & 1)
209 avio_w8(pb, 0);
210 }
211
212 void ff_parse_specific_params(AVStream *st, int *au_rate,
213 int *au_ssize, int *au_scale)
214 {
215 AVCodecContext *codec = st->codec;
216 int gcd;
217 int audio_frame_size;
218
219 /* We use the known constant frame size for the codec if known, otherwise
220 * fall back on using AVCodecContext.frame_size, which is not as reliable
221 * for indicating packet duration. */
222 audio_frame_size = av_get_audio_frame_duration(codec, 0);
223 if (!audio_frame_size)
224 audio_frame_size = codec->frame_size;
225
226 *au_ssize = codec->block_align;
227 if (audio_frame_size && codec->sample_rate) {
228 *au_scale = audio_frame_size;
229 *au_rate = codec->sample_rate;
230 } else if (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
231 codec->codec_type == AVMEDIA_TYPE_DATA ||
232 codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
233 *au_scale = codec->time_base.num;
234 *au_rate = codec->time_base.den;
235 } else {
236 *au_scale = codec->block_align ? codec->block_align * 8 : 8;
237 *au_rate = codec->bit_rate ? codec->bit_rate :
238 8 * codec->sample_rate;
239 }
240 gcd = av_gcd(*au_scale, *au_rate);
241 *au_scale /= gcd;
242 *au_rate /= gcd;
243 }
244
245 void ff_riff_write_info_tag(AVIOContext *pb, const char *tag, const char *str)
246 {
247 int len = strlen(str);
248 if (len > 0) {
249 len++;
250 ffio_wfourcc(pb, tag);
251 avio_wl32(pb, len);
252 avio_put_str(pb, str);
253 if (len & 1)
254 avio_w8(pb, 0);
255 }
256 }
257
258 static const char riff_tags[][5] = {
259 "IARL", "IART", "ICMS", "ICMT", "ICOP", "ICRD", "ICRP", "IDIM", "IDPI",
260 "IENG", "IGNR", "IKEY", "ILGT", "ILNG", "IMED", "INAM", "IPLT", "IPRD",
261 "IPRT", "ITRK", "ISBJ", "ISFT", "ISHP", "ISMP", "ISRC", "ISRF", "ITCH",
262 { 0 }
263 };
264
265 static int riff_has_valid_tags(AVFormatContext *s)
266 {
267 int i;
268
269 for (i = 0; *riff_tags[i]; i++)
270 if (av_dict_get(s->metadata, riff_tags[i], NULL, AV_DICT_MATCH_CASE))
271 return 1;
272
273 return 0;
274 }
275
276 void ff_riff_write_info(AVFormatContext *s)
277 {
278 AVIOContext *pb = s->pb;
279 int i;
280 int64_t list_pos;
281 AVDictionaryEntry *t = NULL;
282
283 ff_metadata_conv(&s->metadata, ff_riff_info_conv, NULL);
284
285 /* writing empty LIST is not nice and may cause problems */
286 if (!riff_has_valid_tags(s))
287 return;
288
289 list_pos = ff_start_tag(pb, "LIST");
290 ffio_wfourcc(pb, "INFO");
291 for (i = 0; *riff_tags[i]; i++)
292 if ((t = av_dict_get(s->metadata, riff_tags[i],
293 NULL, AV_DICT_MATCH_CASE)))
294 ff_riff_write_info_tag(s->pb, t->key, t->value);
295 ff_end_tag(pb, list_pos);
296 }