FFmpeg coverage

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