2 * WAV muxer and demuxer
3 * Copyright (c) 2001, 2002 Fabrice Bellard
6 * Copyright (c) 2009 Daniel Verkamp
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
38 static int wav_write_header(AVFormatContext
*s
)
40 WAVContext
*wav
= s
->priv_data
;
41 ByteIOContext
*pb
= s
->pb
;
45 put_le32(pb
, 0); /* file length */
49 fmt
= ff_start_tag(pb
, "fmt ");
50 if (ff_put_wav_header(pb
, s
->streams
[0]->codec
) < 0) {
51 av_log(s
, AV_LOG_ERROR
, "%s codec not supported in WAVE format\n",
52 s
->streams
[0]->codec
->codec
? s
->streams
[0]->codec
->codec
->name
: "NONE");
58 if (s
->streams
[0]->codec
->codec_tag
!= 0x01 /* hence for all other than PCM */
59 && !url_is_streamed(s
->pb
)) {
60 fact
= ff_start_tag(pb
, "fact");
65 av_set_pts_info(s
->streams
[0], 64, 1, s
->streams
[0]->codec
->sample_rate
);
66 wav
->maxpts
= wav
->last_duration
= 0;
67 wav
->minpts
= INT64_MAX
;
70 wav
->data
= ff_start_tag(pb
, "data");
77 static int wav_write_packet(AVFormatContext
*s
, AVPacket
*pkt
)
79 ByteIOContext
*pb
= s
->pb
;
80 WAVContext
*wav
= s
->priv_data
;
81 put_buffer(pb
, pkt
->data
, pkt
->size
);
82 if(pkt
->pts
!= AV_NOPTS_VALUE
) {
83 wav
->minpts
= FFMIN(wav
->minpts
, pkt
->pts
);
84 wav
->maxpts
= FFMAX(wav
->maxpts
, pkt
->pts
);
85 wav
->last_duration
= pkt
->duration
;
87 av_log(s
, AV_LOG_ERROR
, "wav_write_packet: NOPTS\n");
91 static int wav_write_trailer(AVFormatContext
*s
)
93 ByteIOContext
*pb
= s
->pb
;
94 WAVContext
*wav
= s
->priv_data
;
97 if (!url_is_streamed(s
->pb
)) {
98 ff_end_tag(pb
, wav
->data
);
100 /* update file size */
101 file_size
= url_ftell(pb
);
102 url_fseek(pb
, 4, SEEK_SET
);
103 put_le32(pb
, (uint32_t)(file_size
- 8));
104 url_fseek(pb
, file_size
, SEEK_SET
);
106 put_flush_packet(pb
);
108 if(s
->streams
[0]->codec
->codec_tag
!= 0x01) {
109 /* Update num_samps in fact chunk */
110 int number_of_samples
;
111 number_of_samples
= av_rescale(wav
->maxpts
- wav
->minpts
+ wav
->last_duration
,
112 s
->streams
[0]->codec
->sample_rate
* (int64_t)s
->streams
[0]->time_base
.num
,
113 s
->streams
[0]->time_base
.den
);
114 url_fseek(pb
, wav
->data
-12, SEEK_SET
);
115 put_le32(pb
, number_of_samples
);
116 url_fseek(pb
, file_size
, SEEK_SET
);
117 put_flush_packet(pb
);
123 AVOutputFormat wav_muxer
= {
125 NULL_IF_CONFIG_SMALL("WAV format"),
134 .codec_tag
= (const AVCodecTag
* const []){ff_codec_wav_tags
, 0},
136 #endif /* CONFIG_WAV_MUXER */
139 #if CONFIG_WAV_DEMUXER
140 /* return the size of the found tag */
141 static int64_t find_tag(ByteIOContext
*pb
, uint32_t tag1
)
153 url_fseek(pb
, size
, SEEK_CUR
);
158 static int wav_probe(AVProbeData
*p
)
160 /* check file header */
161 if (p
->buf_size
<= 32)
163 if (p
->buf
[ 0] == 'R' && p
->buf
[ 1] == 'I' &&
164 p
->buf
[ 2] == 'F' && p
->buf
[ 3] == 'F' &&
165 p
->buf
[ 8] == 'W' && p
->buf
[ 9] == 'A' &&
166 p
->buf
[10] == 'V' && p
->buf
[11] == 'E')
168 Since ACT demuxer has standard WAV header at top of it's own,
169 returning score is decreased to avoid probe conflict
172 return AVPROBE_SCORE_MAX
- 1;
178 static int wav_read_header(AVFormatContext
*s
,
179 AVFormatParameters
*ap
)
183 ByteIOContext
*pb
= s
->pb
;
185 WAVContext
*wav
= s
->priv_data
;
187 /* check RIFF header */
190 if (tag
!= MKTAG('R', 'I', 'F', 'F'))
192 get_le32(pb
); /* file size */
194 if (tag
!= MKTAG('W', 'A', 'V', 'E'))
197 /* parse fmt header */
198 size
= find_tag(pb
, MKTAG('f', 'm', 't', ' '));
201 st
= av_new_stream(s
, 0);
203 return AVERROR(ENOMEM
);
205 ff_get_wav_header(pb
, st
->codec
, size
);
206 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
208 av_set_pts_info(st
, 64, 1, st
->codec
->sample_rate
);
210 size
= find_tag(pb
, MKTAG('d', 'a', 't', 'a'));
213 wav
->data_end
= url_ftell(pb
) + size
;
217 /** Find chunk with w64 GUID by skipping over other chunks
218 * @return the size of the found chunk
220 static int64_t find_guid(ByteIOContext
*pb
, const uint8_t guid1
[16])
225 while (!url_feof(pb
)) {
226 get_buffer(pb
, guid
, 16);
230 if (!memcmp(guid
, guid1
, 16))
232 url_fskip(pb
, FFALIGN(size
, INT64_C(8)) - 24);
237 static const uint8_t guid_data
[16] = { 'd', 'a', 't', 'a',
238 0xF3, 0xAC, 0xD3, 0x11, 0x8C, 0xD1, 0x00, 0xC0, 0x4F, 0x8E, 0xDB, 0x8A };
240 #define MAX_SIZE 4096
242 static int wav_read_packet(AVFormatContext
*s
,
248 WAVContext
*wav
= s
->priv_data
;
252 left
= wav
->data_end
- url_ftell(s
->pb
);
254 if (CONFIG_W64_DEMUXER
&& wav
->w64
)
255 left
= find_guid(s
->pb
, guid_data
) - 24;
257 left
= find_tag(s
->pb
, MKTAG('d', 'a', 't', 'a'));
260 wav
->data_end
= url_ftell(s
->pb
) + left
;
264 if (st
->codec
->block_align
> 1) {
265 if (size
< st
->codec
->block_align
)
266 size
= st
->codec
->block_align
;
267 size
= (size
/ st
->codec
->block_align
) * st
->codec
->block_align
;
269 size
= FFMIN(size
, left
);
270 ret
= av_get_packet(s
->pb
, pkt
, size
);
273 pkt
->stream_index
= 0;
278 static int wav_read_seek(AVFormatContext
*s
,
279 int stream_index
, int64_t timestamp
, int flags
)
284 switch (st
->codec
->codec_id
) {
289 /* use generic seeking with dynamically generated indexes */
294 return pcm_read_seek(s
, stream_index
, timestamp
, flags
);
297 AVInputFormat wav_demuxer
= {
299 NULL_IF_CONFIG_SMALL("WAV format"),
306 .flags
= AVFMT_GENERIC_INDEX
,
307 .codec_tag
= (const AVCodecTag
* const []){ff_codec_wav_tags
, 0},
309 #endif /* CONFIG_WAV_DEMUXER */
312 #if CONFIG_W64_DEMUXER
313 static const uint8_t guid_riff
[16] = { 'r', 'i', 'f', 'f',
314 0x2E, 0x91, 0xCF, 0x11, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00 };
316 static const uint8_t guid_wave
[16] = { 'w', 'a', 'v', 'e',
317 0xF3, 0xAC, 0xD3, 0x11, 0x8C, 0xD1, 0x00, 0xC0, 0x4F, 0x8E, 0xDB, 0x8A };
319 static const uint8_t guid_fmt
[16] = { 'f', 'm', 't', ' ',
320 0xF3, 0xAC, 0xD3, 0x11, 0x8C, 0xD1, 0x00, 0xC0, 0x4F, 0x8E, 0xDB, 0x8A };
322 static int w64_probe(AVProbeData
*p
)
324 if (p
->buf_size
<= 40)
326 if (!memcmp(p
->buf
, guid_riff
, 16) &&
327 !memcmp(p
->buf
+ 24, guid_wave
, 16))
328 return AVPROBE_SCORE_MAX
;
333 static int w64_read_header(AVFormatContext
*s
, AVFormatParameters
*ap
)
336 ByteIOContext
*pb
= s
->pb
;
337 WAVContext
*wav
= s
->priv_data
;
341 get_buffer(pb
, guid
, 16);
342 if (memcmp(guid
, guid_riff
, 16))
345 if (get_le64(pb
) < 16 + 8 + 16 + 8 + 16 + 8) /* riff + wave + fmt + sizes */
348 get_buffer(pb
, guid
, 16);
349 if (memcmp(guid
, guid_wave
, 16)) {
350 av_log(s
, AV_LOG_ERROR
, "could not find wave guid\n");
354 size
= find_guid(pb
, guid_fmt
);
356 av_log(s
, AV_LOG_ERROR
, "could not find fmt guid\n");
360 st
= av_new_stream(s
, 0);
362 return AVERROR(ENOMEM
);
364 /* subtract chunk header size - normal wav file doesn't count it */
365 ff_get_wav_header(pb
, st
->codec
, size
- 24);
366 url_fskip(pb
, FFALIGN(size
, INT64_C(8)) - size
);
368 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
370 av_set_pts_info(st
, 64, 1, st
->codec
->sample_rate
);
372 size
= find_guid(pb
, guid_data
);
374 av_log(s
, AV_LOG_ERROR
, "could not find data guid\n");
377 wav
->data_end
= url_ftell(pb
) + size
- 24;
383 AVInputFormat w64_demuxer
= {
385 NULL_IF_CONFIG_SMALL("Sony Wave64 format"),
392 .flags
= AVFMT_GENERIC_INDEX
,
393 .codec_tag
= (const AVCodecTag
* const []){ff_codec_wav_tags
, 0},
395 #endif /* CONFIG_W64_DEMUXER */