lavf: Constify the probe function argument.
[ffmpeg.git] / libavformat / wavdec.c
1 /*
2  * WAV demuxer
3  * Copyright (c) 2001, 2002 Fabrice Bellard
4  *
5  * Sony Wave64 demuxer
6  * RF64 demuxer
7  * Copyright (c) 2009 Daniel Verkamp
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25
26 #include <stdint.h>
27
28 #include "libavutil/avassert.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/log.h"
32 #include "libavutil/mathematics.h"
33 #include "libavutil/opt.h"
34 #include "avformat.h"
35 #include "avio.h"
36 #include "avio_internal.h"
37 #include "id3v2.h"
38 #include "internal.h"
39 #include "metadata.h"
40 #include "pcm.h"
41 #include "riff.h"
42 #include "w64.h"
43 #include "spdif.h"
44
45 typedef struct WAVDemuxContext {
46     const AVClass *class;
47     int64_t data_end;
48     int w64;
49     int64_t smv_data_ofs;
50     int smv_block_size;
51     int smv_frames_per_jpeg;
52     int smv_block;
53     int smv_last_stream;
54     int smv_eof;
55     int audio_eof;
56     int ignore_length;
57     int spdif;
58     int smv_cur_pt;
59     int smv_given_first;
60     int unaligned; // e.g. if an odd number of bytes ID3 tag was prepended
61     int rifx; // RIFX: integer byte order for parameters is big endian
62 } WAVDemuxContext;
63
64 static void set_spdif(AVFormatContext *s, WAVDemuxContext *wav)
65 {
66     if (CONFIG_SPDIF_DEMUXER && s->streams[0]->codecpar->codec_tag == 1) {
67         enum AVCodecID codec;
68         int len = 1<<16;
69         int ret = ffio_ensure_seekback(s->pb, len);
70
71         if (ret >= 0) {
72             uint8_t *buf = av_malloc(len);
73             if (!buf) {
74                 ret = AVERROR(ENOMEM);
75             } else {
76                 int64_t pos = avio_tell(s->pb);
77                 len = ret = avio_read(s->pb, buf, len);
78                 if (len >= 0) {
79                     ret = ff_spdif_probe(buf, len, &codec);
80                     if (ret > AVPROBE_SCORE_EXTENSION) {
81                         s->streams[0]->codecpar->codec_id = codec;
82                         wav->spdif = 1;
83                     }
84                 }
85                 avio_seek(s->pb, pos, SEEK_SET);
86                 av_free(buf);
87             }
88         }
89
90         if (ret < 0)
91             av_log(s, AV_LOG_WARNING, "Cannot check for SPDIF\n");
92     }
93 }
94
95 #if CONFIG_WAV_DEMUXER
96
97 static int64_t next_tag(AVIOContext *pb, uint32_t *tag, int big_endian)
98 {
99     *tag = avio_rl32(pb);
100     if (!big_endian) {
101         return avio_rl32(pb);
102     } else {
103         return avio_rb32(pb);
104     }
105 }
106
107 /* RIFF chunks are always at even offsets relative to where they start. */
108 static int64_t wav_seek_tag(WAVDemuxContext * wav, AVIOContext *s, int64_t offset, int whence)
109 {
110     offset += offset < INT64_MAX && offset + wav->unaligned & 1;
111
112     return avio_seek(s, offset, whence);
113 }
114
115 /* return the size of the found tag */
116 static int64_t find_tag(WAVDemuxContext * wav, AVIOContext *pb, uint32_t tag1)
117 {
118     unsigned int tag;
119     int64_t size;
120
121     for (;;) {
122         if (avio_feof(pb))
123             return AVERROR_EOF;
124         size = next_tag(pb, &tag, wav->rifx);
125         if (tag == tag1)
126             break;
127         wav_seek_tag(wav, pb, size, SEEK_CUR);
128     }
129     return size;
130 }
131
132 static int wav_probe(const AVProbeData *p)
133 {
134     /* check file header */
135     if (p->buf_size <= 32)
136         return 0;
137     if (!memcmp(p->buf + 8, "WAVE", 4)) {
138         if (!memcmp(p->buf, "RIFF", 4) || !memcmp(p->buf, "RIFX", 4))
139             /* Since the ACT demuxer has a standard WAV header at the top of
140              * its own, the returned score is decreased to avoid a probe
141              * conflict between ACT and WAV. */
142             return AVPROBE_SCORE_MAX - 1;
143         else if (!memcmp(p->buf,      "RF64", 4) &&
144                  !memcmp(p->buf + 12, "ds64", 4))
145             return AVPROBE_SCORE_MAX;
146     }
147     return 0;
148 }
149
150 static void handle_stream_probing(AVStream *st)
151 {
152     if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
153         st->request_probe = AVPROBE_SCORE_EXTENSION;
154         st->probe_packets = FFMIN(st->probe_packets, 32);
155     }
156 }
157
158 static int wav_parse_fmt_tag(AVFormatContext *s, int64_t size, AVStream **st)
159 {
160     AVIOContext *pb = s->pb;
161     WAVDemuxContext *wav = s->priv_data;
162     int ret;
163
164     /* parse fmt header */
165     *st = avformat_new_stream(s, NULL);
166     if (!*st)
167         return AVERROR(ENOMEM);
168
169     ret = ff_get_wav_header(s, pb, (*st)->codecpar, size, wav->rifx);
170     if (ret < 0)
171         return ret;
172     handle_stream_probing(*st);
173
174     (*st)->need_parsing = AVSTREAM_PARSE_FULL_RAW;
175
176     avpriv_set_pts_info(*st, 64, 1, (*st)->codecpar->sample_rate);
177
178     return 0;
179 }
180
181 static int wav_parse_xma2_tag(AVFormatContext *s, int64_t size, AVStream **st)
182 {
183     AVIOContext *pb = s->pb;
184     int version, num_streams, i, channels = 0;
185
186     if (size < 36)
187         return AVERROR_INVALIDDATA;
188
189     *st = avformat_new_stream(s, NULL);
190     if (!*st)
191         return AVERROR(ENOMEM);
192
193     (*st)->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
194     (*st)->codecpar->codec_id   = AV_CODEC_ID_XMA2;
195     (*st)->need_parsing         = AVSTREAM_PARSE_FULL_RAW;
196
197     version = avio_r8(pb);
198     if (version != 3 && version != 4)
199         return AVERROR_INVALIDDATA;
200     num_streams = avio_r8(pb);
201     if (size != (32 + ((version==3)?0:8) + 4*num_streams))
202         return AVERROR_INVALIDDATA;
203     avio_skip(pb, 10);
204     (*st)->codecpar->sample_rate = avio_rb32(pb);
205     if (version == 4)
206         avio_skip(pb, 8);
207     avio_skip(pb, 4);
208     (*st)->duration = avio_rb32(pb);
209     avio_skip(pb, 8);
210
211     for (i = 0; i < num_streams; i++) {
212         channels += avio_r8(pb);
213         avio_skip(pb, 3);
214     }
215     (*st)->codecpar->channels = channels;
216
217     if ((*st)->codecpar->channels <= 0 || (*st)->codecpar->sample_rate <= 0)
218         return AVERROR_INVALIDDATA;
219
220     avpriv_set_pts_info(*st, 64, 1, (*st)->codecpar->sample_rate);
221
222     avio_seek(pb, -size, SEEK_CUR);
223     av_freep(&(*st)->codecpar->extradata);
224     if (ff_get_extradata(s, (*st)->codecpar, pb, size) < 0)
225         return AVERROR(ENOMEM);
226
227     return 0;
228 }
229
230 static inline int wav_parse_bext_string(AVFormatContext *s, const char *key,
231                                         int length)
232 {
233     char temp[257];
234     int ret;
235
236     av_assert0(length <= sizeof(temp));
237     if ((ret = avio_read(s->pb, temp, length)) < 0)
238         return ret;
239
240     temp[length] = 0;
241
242     if (strlen(temp))
243         return av_dict_set(&s->metadata, key, temp, 0);
244
245     return 0;
246 }
247
248 static int wav_parse_bext_tag(AVFormatContext *s, int64_t size)
249 {
250     char temp[131], *coding_history;
251     int ret, x;
252     uint64_t time_reference;
253     int64_t umid_parts[8], umid_mask = 0;
254
255     if ((ret = wav_parse_bext_string(s, "description", 256)) < 0 ||
256         (ret = wav_parse_bext_string(s, "originator", 32)) < 0 ||
257         (ret = wav_parse_bext_string(s, "originator_reference", 32)) < 0 ||
258         (ret = wav_parse_bext_string(s, "origination_date", 10)) < 0 ||
259         (ret = wav_parse_bext_string(s, "origination_time", 8)) < 0)
260         return ret;
261
262     time_reference = avio_rl64(s->pb);
263     snprintf(temp, sizeof(temp), "%"PRIu64, time_reference);
264     if ((ret = av_dict_set(&s->metadata, "time_reference", temp, 0)) < 0)
265         return ret;
266
267     /* check if version is >= 1, in which case an UMID may be present */
268     if (avio_rl16(s->pb) >= 1) {
269         for (x = 0; x < 8; x++)
270             umid_mask |= umid_parts[x] = avio_rb64(s->pb);
271
272         if (umid_mask) {
273             /* the string formatting below is per SMPTE 330M-2004 Annex C */
274             if (umid_parts[4] == 0 && umid_parts[5] == 0 &&
275                 umid_parts[6] == 0 && umid_parts[7] == 0) {
276                 /* basic UMID */
277                 snprintf(temp, sizeof(temp),
278                          "0x%016"PRIX64"%016"PRIX64"%016"PRIX64"%016"PRIX64,
279                          umid_parts[0], umid_parts[1],
280                          umid_parts[2], umid_parts[3]);
281             } else {
282                 /* extended UMID */
283                 snprintf(temp, sizeof(temp),
284                          "0x%016"PRIX64"%016"PRIX64"%016"PRIX64"%016"PRIX64
285                          "%016"PRIX64"%016"PRIX64"%016"PRIX64"%016"PRIX64,
286                          umid_parts[0], umid_parts[1],
287                          umid_parts[2], umid_parts[3],
288                          umid_parts[4], umid_parts[5],
289                          umid_parts[6], umid_parts[7]);
290             }
291
292             if ((ret = av_dict_set(&s->metadata, "umid", temp, 0)) < 0)
293                 return ret;
294         }
295
296         avio_skip(s->pb, 190);
297     } else
298         avio_skip(s->pb, 254);
299
300     if (size > 602) {
301         /* CodingHistory present */
302         size -= 602;
303
304         if (!(coding_history = av_malloc(size + 1)))
305             return AVERROR(ENOMEM);
306
307         if ((ret = avio_read(s->pb, coding_history, size)) < 0)
308             return ret;
309
310         coding_history[size] = 0;
311         if ((ret = av_dict_set(&s->metadata, "coding_history", coding_history,
312                                AV_DICT_DONT_STRDUP_VAL)) < 0)
313             return ret;
314     }
315
316     return 0;
317 }
318
319 static const AVMetadataConv wav_metadata_conv[] = {
320     { "description",      "comment"       },
321     { "originator",       "encoded_by"    },
322     { "origination_date", "date"          },
323     { "origination_time", "creation_time" },
324     { 0 },
325 };
326
327 /* wav input */
328 static int wav_read_header(AVFormatContext *s)
329 {
330     int64_t size, av_uninit(data_size);
331     int64_t sample_count = 0;
332     int rf64 = 0;
333     uint32_t tag;
334     AVIOContext *pb      = s->pb;
335     AVStream *st         = NULL;
336     WAVDemuxContext *wav = s->priv_data;
337     int ret, got_fmt = 0, got_xma2 = 0;
338     int64_t next_tag_ofs, data_ofs = -1;
339
340     wav->unaligned = avio_tell(s->pb) & 1;
341
342     wav->smv_data_ofs = -1;
343
344     /* read chunk ID */
345     tag = avio_rl32(pb);
346     switch (tag) {
347     case MKTAG('R', 'I', 'F', 'F'):
348         break;
349     case MKTAG('R', 'I', 'F', 'X'):
350         wav->rifx = 1;
351         break;
352     case MKTAG('R', 'F', '6', '4'):
353         rf64 = 1;
354         break;
355     default:
356         av_log(s, AV_LOG_ERROR, "invalid start code %s in RIFF header\n",
357                av_fourcc2str(tag));
358         return AVERROR_INVALIDDATA;
359     }
360
361     /* read chunk size */
362     avio_rl32(pb);
363
364     /* read format */
365     if (avio_rl32(pb) != MKTAG('W', 'A', 'V', 'E')) {
366         av_log(s, AV_LOG_ERROR, "invalid format in RIFF header\n");
367         return AVERROR_INVALIDDATA;
368     }
369
370     if (rf64) {
371         if (avio_rl32(pb) != MKTAG('d', 's', '6', '4'))
372             return AVERROR_INVALIDDATA;
373         size = avio_rl32(pb);
374         if (size < 24)
375             return AVERROR_INVALIDDATA;
376         avio_rl64(pb); /* RIFF size */
377
378         data_size    = avio_rl64(pb);
379         sample_count = avio_rl64(pb);
380
381         if (data_size < 0 || sample_count < 0) {
382             av_log(s, AV_LOG_ERROR, "negative data_size and/or sample_count in "
383                    "ds64: data_size = %"PRId64", sample_count = %"PRId64"\n",
384                    data_size, sample_count);
385             return AVERROR_INVALIDDATA;
386         }
387         avio_skip(pb, size - 24); /* skip rest of ds64 chunk */
388
389     }
390
391     for (;;) {
392         AVStream *vst;
393         size         = next_tag(pb, &tag, wav->rifx);
394         next_tag_ofs = avio_tell(pb) + size;
395
396         if (avio_feof(pb))
397             break;
398
399         switch (tag) {
400         case MKTAG('f', 'm', 't', ' '):
401             /* only parse the first 'fmt ' tag found */
402             if (!got_xma2 && !got_fmt && (ret = wav_parse_fmt_tag(s, size, &st)) < 0) {
403                 return ret;
404             } else if (got_fmt)
405                 av_log(s, AV_LOG_WARNING, "found more than one 'fmt ' tag\n");
406
407             got_fmt = 1;
408             break;
409         case MKTAG('X', 'M', 'A', '2'):
410             /* only parse the first 'XMA2' tag found */
411             if (!got_fmt && !got_xma2 && (ret = wav_parse_xma2_tag(s, size, &st)) < 0) {
412                 return ret;
413             } else if (got_xma2)
414                 av_log(s, AV_LOG_WARNING, "found more than one 'XMA2' tag\n");
415
416             got_xma2 = 1;
417             break;
418         case MKTAG('d', 'a', 't', 'a'):
419             if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) && !got_fmt && !got_xma2) {
420                 av_log(s, AV_LOG_ERROR,
421                        "found no 'fmt ' tag before the 'data' tag\n");
422                 return AVERROR_INVALIDDATA;
423             }
424
425             if (rf64) {
426                 next_tag_ofs = wav->data_end = avio_tell(pb) + data_size;
427             } else if (size != 0xFFFFFFFF) {
428                 data_size    = size;
429                 next_tag_ofs = wav->data_end = size ? next_tag_ofs : INT64_MAX;
430             } else {
431                 av_log(s, AV_LOG_WARNING, "Ignoring maximum wav data size, "
432                        "file may be invalid\n");
433                 data_size    = 0;
434                 next_tag_ofs = wav->data_end = INT64_MAX;
435             }
436
437             data_ofs = avio_tell(pb);
438
439             /* don't look for footer metadata if we can't seek or if we don't
440              * know where the data tag ends
441              */
442             if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) || (!rf64 && !size))
443                 goto break_loop;
444             break;
445         case MKTAG('f', 'a', 'c', 't'):
446             if (!sample_count)
447                 sample_count = (!wav->rifx ? avio_rl32(pb) : avio_rb32(pb));
448             break;
449         case MKTAG('b', 'e', 'x', 't'):
450             if ((ret = wav_parse_bext_tag(s, size)) < 0)
451                 return ret;
452             break;
453         case MKTAG('S','M','V','0'):
454             if (!got_fmt) {
455                 av_log(s, AV_LOG_ERROR, "found no 'fmt ' tag before the 'SMV0' tag\n");
456                 return AVERROR_INVALIDDATA;
457             }
458             // SMV file, a wav file with video appended.
459             if (size != MKTAG('0','2','0','0')) {
460                 av_log(s, AV_LOG_ERROR, "Unknown SMV version found\n");
461                 goto break_loop;
462             }
463             av_log(s, AV_LOG_DEBUG, "Found SMV data\n");
464             wav->smv_given_first = 0;
465             vst = avformat_new_stream(s, NULL);
466             if (!vst)
467                 return AVERROR(ENOMEM);
468             avio_r8(pb);
469             vst->id = 1;
470             vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
471             vst->codecpar->codec_id = AV_CODEC_ID_SMVJPEG;
472             vst->codecpar->width  = avio_rl24(pb);
473             vst->codecpar->height = avio_rl24(pb);
474             if (ff_alloc_extradata(vst->codecpar, 4)) {
475                 av_log(s, AV_LOG_ERROR, "Could not allocate extradata.\n");
476                 return AVERROR(ENOMEM);
477             }
478             size = avio_rl24(pb);
479             wav->smv_data_ofs = avio_tell(pb) + (size - 5) * 3;
480             avio_rl24(pb);
481             wav->smv_block_size = avio_rl24(pb);
482             avpriv_set_pts_info(vst, 32, 1, avio_rl24(pb));
483             vst->duration = avio_rl24(pb);
484             avio_rl24(pb);
485             avio_rl24(pb);
486             wav->smv_frames_per_jpeg = avio_rl24(pb);
487             if (wav->smv_frames_per_jpeg > 65536) {
488                 av_log(s, AV_LOG_ERROR, "too many frames per jpeg\n");
489                 return AVERROR_INVALIDDATA;
490             }
491             AV_WL32(vst->codecpar->extradata, wav->smv_frames_per_jpeg);
492             wav->smv_cur_pt = 0;
493             goto break_loop;
494         case MKTAG('L', 'I', 'S', 'T'):
495             if (size < 4) {
496                 av_log(s, AV_LOG_ERROR, "too short LIST tag\n");
497                 return AVERROR_INVALIDDATA;
498             }
499             switch (avio_rl32(pb)) {
500             case MKTAG('I', 'N', 'F', 'O'):
501                 ff_read_riff_info(s, size - 4);
502             }
503             break;
504         case MKTAG('I', 'D', '3', ' '):
505         case MKTAG('i', 'd', '3', ' '): {
506             ID3v2ExtraMeta *id3v2_extra_meta = NULL;
507             ff_id3v2_read_dict(pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
508             if (id3v2_extra_meta) {
509                 ff_id3v2_parse_apic(s, &id3v2_extra_meta);
510                 ff_id3v2_parse_chapters(s, &id3v2_extra_meta);
511                 ff_id3v2_parse_priv(s, &id3v2_extra_meta);
512             }
513             ff_id3v2_free_extra_meta(&id3v2_extra_meta);
514             }
515             break;
516         }
517
518         /* seek to next tag unless we know that we'll run into EOF */
519         if ((avio_size(pb) > 0 && next_tag_ofs >= avio_size(pb)) ||
520             wav_seek_tag(wav, pb, next_tag_ofs, SEEK_SET) < 0) {
521             break;
522         }
523     }
524
525 break_loop:
526     if (!got_fmt && !got_xma2) {
527         av_log(s, AV_LOG_ERROR, "no 'fmt ' or 'XMA2' tag found\n");
528         return AVERROR_INVALIDDATA;
529     }
530
531     if (data_ofs < 0) {
532         av_log(s, AV_LOG_ERROR, "no 'data' tag found\n");
533         return AVERROR_INVALIDDATA;
534     }
535
536     avio_seek(pb, data_ofs, SEEK_SET);
537
538     if (data_size > (INT64_MAX>>3)) {
539         av_log(s, AV_LOG_WARNING, "Data size %"PRId64" is too large\n", data_size);
540         data_size = 0;
541     }
542
543     if (   st->codecpar->bit_rate > 0 && data_size > 0
544         && st->codecpar->sample_rate > 0
545         && sample_count > 0 && st->codecpar->channels > 1
546         && sample_count % st->codecpar->channels == 0) {
547         if (fabs(8.0 * data_size * st->codecpar->channels * st->codecpar->sample_rate /
548             sample_count /st->codecpar->bit_rate - 1.0) < 0.3)
549             sample_count /= st->codecpar->channels;
550     }
551
552     if (   data_size > 0 && sample_count && st->codecpar->channels
553         && (data_size << 3) / sample_count / st->codecpar->channels > st->codecpar->bits_per_coded_sample  + 1) {
554         av_log(s, AV_LOG_WARNING, "ignoring wrong sample_count %"PRId64"\n", sample_count);
555         sample_count = 0;
556     }
557
558     /* G.729 hack (for Ticket4577)
559      * FIXME: Come up with cleaner, more general solution */
560     if (st->codecpar->codec_id == AV_CODEC_ID_G729 && sample_count && (data_size << 3) > sample_count) {
561         av_log(s, AV_LOG_WARNING, "ignoring wrong sample_count %"PRId64"\n", sample_count);
562         sample_count = 0;
563     }
564
565     if (!sample_count || av_get_exact_bits_per_sample(st->codecpar->codec_id) > 0)
566         if (   st->codecpar->channels
567             && data_size
568             && av_get_bits_per_sample(st->codecpar->codec_id)
569             && wav->data_end <= avio_size(pb))
570             sample_count = (data_size << 3)
571                                   /
572                 (st->codecpar->channels * (uint64_t)av_get_bits_per_sample(st->codecpar->codec_id));
573
574     if (sample_count)
575         st->duration = sample_count;
576
577     if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S32LE &&
578         st->codecpar->block_align == st->codecpar->channels * 4 &&
579         st->codecpar->bits_per_coded_sample == 32 &&
580         st->codecpar->extradata_size == 2 &&
581         AV_RL16(st->codecpar->extradata) == 1) {
582         st->codecpar->codec_id = AV_CODEC_ID_PCM_F16LE;
583         st->codecpar->bits_per_coded_sample = 16;
584     } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE &&
585                st->codecpar->block_align == st->codecpar->channels * 4 &&
586                st->codecpar->bits_per_coded_sample == 24) {
587         st->codecpar->codec_id = AV_CODEC_ID_PCM_F24LE;
588     } else if (st->codecpar->codec_id == AV_CODEC_ID_XMA1 ||
589                st->codecpar->codec_id == AV_CODEC_ID_XMA2) {
590         st->codecpar->block_align = 2048;
591     }
592
593     ff_metadata_conv_ctx(s, NULL, wav_metadata_conv);
594     ff_metadata_conv_ctx(s, NULL, ff_riff_info_conv);
595
596     set_spdif(s, wav);
597
598     return 0;
599 }
600
601 /**
602  * Find chunk with w64 GUID by skipping over other chunks.
603  * @return the size of the found chunk
604  */
605 static int64_t find_guid(AVIOContext *pb, const uint8_t guid1[16])
606 {
607     uint8_t guid[16];
608     int64_t size;
609
610     while (!avio_feof(pb)) {
611         avio_read(pb, guid, 16);
612         size = avio_rl64(pb);
613         if (size <= 24)
614             return AVERROR_INVALIDDATA;
615         if (!memcmp(guid, guid1, 16))
616             return size;
617         avio_skip(pb, FFALIGN(size, INT64_C(8)) - 24);
618     }
619     return AVERROR_EOF;
620 }
621
622 #define MAX_SIZE 4096
623
624 static int wav_read_packet(AVFormatContext *s, AVPacket *pkt)
625 {
626     int ret, size;
627     int64_t left;
628     AVStream *st;
629     WAVDemuxContext *wav = s->priv_data;
630
631     if (CONFIG_SPDIF_DEMUXER && wav->spdif == 1)
632         return ff_spdif_read_packet(s, pkt);
633
634     if (wav->smv_data_ofs > 0) {
635         int64_t audio_dts, video_dts;
636 smv_retry:
637         audio_dts = (int32_t)s->streams[0]->cur_dts;
638         video_dts = (int32_t)s->streams[1]->cur_dts;
639
640         if (audio_dts != AV_NOPTS_VALUE && video_dts != AV_NOPTS_VALUE) {
641             /*We always return a video frame first to get the pixel format first*/
642             wav->smv_last_stream = wav->smv_given_first ?
643                 av_compare_ts(video_dts, s->streams[1]->time_base,
644                               audio_dts, s->streams[0]->time_base) > 0 : 0;
645             wav->smv_given_first = 1;
646         }
647         wav->smv_last_stream = !wav->smv_last_stream;
648         wav->smv_last_stream |= wav->audio_eof;
649         wav->smv_last_stream &= !wav->smv_eof;
650         if (wav->smv_last_stream) {
651             uint64_t old_pos = avio_tell(s->pb);
652             uint64_t new_pos = wav->smv_data_ofs +
653                 wav->smv_block * wav->smv_block_size;
654             if (avio_seek(s->pb, new_pos, SEEK_SET) < 0) {
655                 ret = AVERROR_EOF;
656                 goto smv_out;
657             }
658             size = avio_rl24(s->pb);
659             ret  = av_get_packet(s->pb, pkt, size);
660             if (ret < 0)
661                 goto smv_out;
662             pkt->pos -= 3;
663             pkt->pts = wav->smv_block * wav->smv_frames_per_jpeg + wav->smv_cur_pt;
664             wav->smv_cur_pt++;
665             if (wav->smv_frames_per_jpeg > 0)
666                 wav->smv_cur_pt %= wav->smv_frames_per_jpeg;
667             if (!wav->smv_cur_pt)
668                 wav->smv_block++;
669
670             pkt->stream_index = 1;
671 smv_out:
672             avio_seek(s->pb, old_pos, SEEK_SET);
673             if (ret == AVERROR_EOF) {
674                 wav->smv_eof = 1;
675                 goto smv_retry;
676             }
677             return ret;
678         }
679     }
680
681     st = s->streams[0];
682
683     left = wav->data_end - avio_tell(s->pb);
684     if (wav->ignore_length)
685         left = INT_MAX;
686     if (left <= 0) {
687         if (CONFIG_W64_DEMUXER && wav->w64)
688             left = find_guid(s->pb, ff_w64_guid_data) - 24;
689         else
690             left = find_tag(wav, s->pb, MKTAG('d', 'a', 't', 'a'));
691         if (left < 0) {
692             wav->audio_eof = 1;
693             if (wav->smv_data_ofs > 0 && !wav->smv_eof)
694                 goto smv_retry;
695             return AVERROR_EOF;
696         }
697         wav->data_end = avio_tell(s->pb) + left;
698     }
699
700     size = MAX_SIZE;
701     if (st->codecpar->block_align > 1) {
702         if (size < st->codecpar->block_align)
703             size = st->codecpar->block_align;
704         size = (size / st->codecpar->block_align) * st->codecpar->block_align;
705     }
706     size = FFMIN(size, left);
707     ret  = av_get_packet(s->pb, pkt, size);
708     if (ret < 0)
709         return ret;
710     pkt->stream_index = 0;
711
712     return ret;
713 }
714
715 static int wav_read_seek(AVFormatContext *s,
716                          int stream_index, int64_t timestamp, int flags)
717 {
718     WAVDemuxContext *wav = s->priv_data;
719     AVStream *st;
720     wav->smv_eof = 0;
721     wav->audio_eof = 0;
722     if (wav->smv_data_ofs > 0) {
723         int64_t smv_timestamp = timestamp;
724         if (stream_index == 0)
725             smv_timestamp = av_rescale_q(timestamp, s->streams[0]->time_base, s->streams[1]->time_base);
726         else
727             timestamp = av_rescale_q(smv_timestamp, s->streams[1]->time_base, s->streams[0]->time_base);
728         if (wav->smv_frames_per_jpeg > 0) {
729             wav->smv_block = smv_timestamp / wav->smv_frames_per_jpeg;
730             wav->smv_cur_pt = smv_timestamp % wav->smv_frames_per_jpeg;
731         }
732     }
733
734     st = s->streams[0];
735     switch (st->codecpar->codec_id) {
736     case AV_CODEC_ID_MP2:
737     case AV_CODEC_ID_MP3:
738     case AV_CODEC_ID_AC3:
739     case AV_CODEC_ID_DTS:
740     case AV_CODEC_ID_XMA2:
741         /* use generic seeking with dynamically generated indexes */
742         return -1;
743     default:
744         break;
745     }
746     return ff_pcm_read_seek(s, stream_index, timestamp, flags);
747 }
748
749 #define OFFSET(x) offsetof(WAVDemuxContext, x)
750 #define DEC AV_OPT_FLAG_DECODING_PARAM
751 static const AVOption demux_options[] = {
752     { "ignore_length", "Ignore length", OFFSET(ignore_length), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, DEC },
753     { NULL },
754 };
755
756 static const AVClass wav_demuxer_class = {
757     .class_name = "WAV demuxer",
758     .item_name  = av_default_item_name,
759     .option     = demux_options,
760     .version    = LIBAVUTIL_VERSION_INT,
761 };
762 AVInputFormat ff_wav_demuxer = {
763     .name           = "wav",
764     .long_name      = NULL_IF_CONFIG_SMALL("WAV / WAVE (Waveform Audio)"),
765     .priv_data_size = sizeof(WAVDemuxContext),
766     .read_probe     = wav_probe,
767     .read_header    = wav_read_header,
768     .read_packet    = wav_read_packet,
769     .read_seek      = wav_read_seek,
770     .flags          = AVFMT_GENERIC_INDEX,
771     .codec_tag      = (const AVCodecTag * const []) { ff_codec_wav_tags,  0 },
772     .priv_class     = &wav_demuxer_class,
773 };
774 #endif /* CONFIG_WAV_DEMUXER */
775
776 #if CONFIG_W64_DEMUXER
777 static int w64_probe(const AVProbeData *p)
778 {
779     if (p->buf_size <= 40)
780         return 0;
781     if (!memcmp(p->buf,      ff_w64_guid_riff, 16) &&
782         !memcmp(p->buf + 24, ff_w64_guid_wave, 16))
783         return AVPROBE_SCORE_MAX;
784     else
785         return 0;
786 }
787
788 static int w64_read_header(AVFormatContext *s)
789 {
790     int64_t size, data_ofs = 0;
791     AVIOContext *pb      = s->pb;
792     WAVDemuxContext *wav = s->priv_data;
793     AVStream *st;
794     uint8_t guid[16];
795     int ret;
796
797     avio_read(pb, guid, 16);
798     if (memcmp(guid, ff_w64_guid_riff, 16))
799         return AVERROR_INVALIDDATA;
800
801     /* riff + wave + fmt + sizes */
802     if (avio_rl64(pb) < 16 + 8 + 16 + 8 + 16 + 8)
803         return AVERROR_INVALIDDATA;
804
805     avio_read(pb, guid, 16);
806     if (memcmp(guid, ff_w64_guid_wave, 16)) {
807         av_log(s, AV_LOG_ERROR, "could not find wave guid\n");
808         return AVERROR_INVALIDDATA;
809     }
810
811     wav->w64 = 1;
812
813     st = avformat_new_stream(s, NULL);
814     if (!st)
815         return AVERROR(ENOMEM);
816
817     while (!avio_feof(pb)) {
818         if (avio_read(pb, guid, 16) != 16)
819             break;
820         size = avio_rl64(pb);
821         if (size <= 24 || INT64_MAX - size < avio_tell(pb))
822             return AVERROR_INVALIDDATA;
823
824         if (!memcmp(guid, ff_w64_guid_fmt, 16)) {
825             /* subtract chunk header size - normal wav file doesn't count it */
826             ret = ff_get_wav_header(s, pb, st->codecpar, size - 24, 0);
827             if (ret < 0)
828                 return ret;
829             avio_skip(pb, FFALIGN(size, INT64_C(8)) - size);
830
831             avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
832         } else if (!memcmp(guid, ff_w64_guid_fact, 16)) {
833             int64_t samples;
834
835             samples = avio_rl64(pb);
836             if (samples > 0)
837                 st->duration = samples;
838             avio_skip(pb, FFALIGN(size, INT64_C(8)) - 32);
839         } else if (!memcmp(guid, ff_w64_guid_data, 16)) {
840             wav->data_end = avio_tell(pb) + size - 24;
841
842             data_ofs = avio_tell(pb);
843             if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
844                 break;
845
846             avio_skip(pb, size - 24);
847         } else if (!memcmp(guid, ff_w64_guid_summarylist, 16)) {
848             int64_t start, end, cur;
849             uint32_t count, chunk_size, i;
850
851             start = avio_tell(pb);
852             end = start + FFALIGN(size, INT64_C(8)) - 24;
853             count = avio_rl32(pb);
854
855             for (i = 0; i < count; i++) {
856                 char chunk_key[5], *value;
857
858                 if (avio_feof(pb) || (cur = avio_tell(pb)) < 0 || cur > end - 8 /* = tag + size */)
859                     break;
860
861                 chunk_key[4] = 0;
862                 avio_read(pb, chunk_key, 4);
863                 chunk_size = avio_rl32(pb);
864                 if (chunk_size == UINT32_MAX)
865                     return AVERROR_INVALIDDATA;
866
867                 value = av_mallocz(chunk_size + 1);
868                 if (!value)
869                     return AVERROR(ENOMEM);
870
871                 ret = avio_get_str16le(pb, chunk_size, value, chunk_size);
872                 avio_skip(pb, chunk_size - ret);
873
874                 av_dict_set(&s->metadata, chunk_key, value, AV_DICT_DONT_STRDUP_VAL);
875             }
876
877             avio_skip(pb, end - avio_tell(pb));
878         } else {
879             av_log(s, AV_LOG_DEBUG, "unknown guid: "FF_PRI_GUID"\n", FF_ARG_GUID(guid));
880             avio_skip(pb, FFALIGN(size, INT64_C(8)) - 24);
881         }
882     }
883
884     if (!data_ofs)
885         return AVERROR_EOF;
886
887     ff_metadata_conv_ctx(s, NULL, wav_metadata_conv);
888     ff_metadata_conv_ctx(s, NULL, ff_riff_info_conv);
889
890     handle_stream_probing(st);
891     st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
892
893     avio_seek(pb, data_ofs, SEEK_SET);
894
895     set_spdif(s, wav);
896
897     return 0;
898 }
899
900 AVInputFormat ff_w64_demuxer = {
901     .name           = "w64",
902     .long_name      = NULL_IF_CONFIG_SMALL("Sony Wave64"),
903     .priv_data_size = sizeof(WAVDemuxContext),
904     .read_probe     = w64_probe,
905     .read_header    = w64_read_header,
906     .read_packet    = wav_read_packet,
907     .read_seek      = wav_read_seek,
908     .flags          = AVFMT_GENERIC_INDEX,
909     .codec_tag      = (const AVCodecTag * const []) { ff_codec_wav_tags, 0 },
910 };
911 #endif /* CONFIG_W64_DEMUXER */