FFmpeg  4.4
wavdec.c
Go to the documentation of this file.
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.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/opt.h"
37 #include "avformat.h"
38 #include "avio.h"
39 #include "avio_internal.h"
40 #include "id3v2.h"
41 #include "internal.h"
42 #include "metadata.h"
43 #include "pcm.h"
44 #include "riff.h"
45 #include "w64.h"
46 #include "spdif.h"
47 
48 typedef struct WAVDemuxContext {
49  const AVClass *class;
50  int64_t data_end;
51  int w64;
52  int64_t smv_data_ofs;
55  int smv_block;
57  int smv_eof;
58  int audio_eof;
60  int max_size;
61  int spdif;
63  int unaligned; // e.g. if an odd number of bytes ID3 tag was prepended
64  int rifx; // RIFX: integer byte order for parameters is big endian
66 
67 #define OFFSET(x) offsetof(WAVDemuxContext, x)
68 #define DEC AV_OPT_FLAG_DECODING_PARAM
69 static const AVOption demux_options[] = {
70 #define W64_DEMUXER_OPTIONS_OFFSET (1 * CONFIG_WAV_DEMUXER)
71 #if CONFIG_WAV_DEMUXER
72  { "ignore_length", "Ignore length", OFFSET(ignore_length), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, DEC },
73 #endif
74  { "max_size", "max size of single packet", OFFSET(max_size), AV_OPT_TYPE_INT, { .i64 = 4096 }, 1024, 1 << 22, DEC },
75  { NULL },
76 };
77 
79 {
80  if (CONFIG_SPDIF_DEMUXER && s->streams[0]->codecpar->codec_tag == 1) {
81  enum AVCodecID codec;
82  int len = 1<<16;
83  int ret = ffio_ensure_seekback(s->pb, len);
84 
85  if (ret >= 0) {
87  if (!buf) {
88  ret = AVERROR(ENOMEM);
89  } else {
90  int64_t pos = avio_tell(s->pb);
91  len = ret = avio_read(s->pb, buf, len);
92  if (len >= 0) {
93  ret = ff_spdif_probe(buf, len, &codec);
94  if (ret > AVPROBE_SCORE_EXTENSION) {
95  s->streams[0]->codecpar->codec_id = codec;
96  wav->spdif = 1;
97  }
98  }
99  avio_seek(s->pb, pos, SEEK_SET);
100  av_free(buf);
101  }
102  }
103 
104  if (ret < 0)
105  av_log(s, AV_LOG_WARNING, "Cannot check for SPDIF\n");
106  }
107 }
108 
109 #if CONFIG_WAV_DEMUXER
110 
111 static int64_t next_tag(AVIOContext *pb, uint32_t *tag, int big_endian)
112 {
113  *tag = avio_rl32(pb);
114  if (!big_endian) {
115  return avio_rl32(pb);
116  } else {
117  return avio_rb32(pb);
118  }
119 }
120 
121 /* RIFF chunks are always at even offsets relative to where they start. */
122 static int64_t wav_seek_tag(WAVDemuxContext * wav, AVIOContext *s, int64_t offset, int whence)
123 {
124  offset += offset < INT64_MAX && offset + wav->unaligned & 1;
125 
126  return avio_seek(s, offset, whence);
127 }
128 
129 /* return the size of the found tag */
130 static int64_t find_tag(WAVDemuxContext * wav, AVIOContext *pb, uint32_t tag1)
131 {
132  unsigned int tag;
133  int64_t size;
134 
135  for (;;) {
136  if (avio_feof(pb))
137  return AVERROR_EOF;
138  size = next_tag(pb, &tag, wav->rifx);
139  if (tag == tag1)
140  break;
141  wav_seek_tag(wav, pb, size, SEEK_CUR);
142  }
143  return size;
144 }
145 
146 static int wav_probe(const AVProbeData *p)
147 {
148  /* check file header */
149  if (p->buf_size <= 32)
150  return 0;
151  if (!memcmp(p->buf + 8, "WAVE", 4)) {
152  if (!memcmp(p->buf, "RIFF", 4) || !memcmp(p->buf, "RIFX", 4))
153  /* Since the ACT demuxer has a standard WAV header at the top of
154  * its own, the returned score is decreased to avoid a probe
155  * conflict between ACT and WAV. */
156  return AVPROBE_SCORE_MAX - 1;
157  else if ((!memcmp(p->buf, "RF64", 4) ||
158  !memcmp(p->buf, "BW64", 4)) &&
159  !memcmp(p->buf + 12, "ds64", 4))
160  return AVPROBE_SCORE_MAX;
161  }
162  return 0;
163 }
164 
165 static void handle_stream_probing(AVStream *st)
166 {
169  st->probe_packets = FFMIN(st->probe_packets, 32);
170  }
171 }
172 
173 static int wav_parse_fmt_tag(AVFormatContext *s, int64_t size, AVStream **st)
174 {
175  AVIOContext *pb = s->pb;
176  WAVDemuxContext *wav = s->priv_data;
177  int ret;
178 
179  /* parse fmt header */
180  *st = avformat_new_stream(s, NULL);
181  if (!*st)
182  return AVERROR(ENOMEM);
183 
184  ret = ff_get_wav_header(s, pb, (*st)->codecpar, size, wav->rifx);
185  if (ret < 0)
186  return ret;
187  handle_stream_probing(*st);
188 
189  (*st)->need_parsing = AVSTREAM_PARSE_FULL_RAW;
190 
191  avpriv_set_pts_info(*st, 64, 1, (*st)->codecpar->sample_rate);
192 
193  return 0;
194 }
195 
196 static int wav_parse_xma2_tag(AVFormatContext *s, int64_t size, AVStream **st)
197 {
198  AVIOContext *pb = s->pb;
199  int version, num_streams, i, channels = 0, ret;
200 
201  if (size < 36)
202  return AVERROR_INVALIDDATA;
203 
204  *st = avformat_new_stream(s, NULL);
205  if (!*st)
206  return AVERROR(ENOMEM);
207 
208  (*st)->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
209  (*st)->codecpar->codec_id = AV_CODEC_ID_XMA2;
210  (*st)->need_parsing = AVSTREAM_PARSE_FULL_RAW;
211 
212  version = avio_r8(pb);
213  if (version != 3 && version != 4)
214  return AVERROR_INVALIDDATA;
215  num_streams = avio_r8(pb);
216  if (size != (32 + ((version==3)?0:8) + 4*num_streams))
217  return AVERROR_INVALIDDATA;
218  avio_skip(pb, 10);
219  (*st)->codecpar->sample_rate = avio_rb32(pb);
220  if (version == 4)
221  avio_skip(pb, 8);
222  avio_skip(pb, 4);
223  (*st)->duration = avio_rb32(pb);
224  avio_skip(pb, 8);
225 
226  for (i = 0; i < num_streams; i++) {
227  channels += avio_r8(pb);
228  avio_skip(pb, 3);
229  }
230  (*st)->codecpar->channels = channels;
231 
232  if ((*st)->codecpar->channels <= 0 || (*st)->codecpar->sample_rate <= 0)
233  return AVERROR_INVALIDDATA;
234 
235  avpriv_set_pts_info(*st, 64, 1, (*st)->codecpar->sample_rate);
236 
237  avio_seek(pb, -size, SEEK_CUR);
238  if ((ret = ff_get_extradata(s, (*st)->codecpar, pb, size)) < 0)
239  return ret;
240 
241  return 0;
242 }
243 
244 static inline int wav_parse_bext_string(AVFormatContext *s, const char *key,
245  int length)
246 {
247  char temp[257];
248  int ret;
249 
250  av_assert0(length < sizeof(temp));
251  if ((ret = avio_read(s->pb, temp, length)) != length)
252  return ret < 0 ? ret : AVERROR_INVALIDDATA;
253 
254  temp[length] = 0;
255 
256  if (strlen(temp))
257  return av_dict_set(&s->metadata, key, temp, 0);
258 
259  return 0;
260 }
261 
262 static int wav_parse_bext_tag(AVFormatContext *s, int64_t size)
263 {
264  char temp[131], *coding_history;
265  int ret, x;
266  uint64_t time_reference;
267  int64_t umid_parts[8], umid_mask = 0;
268 
269  if ((ret = wav_parse_bext_string(s, "description", 256)) < 0 ||
270  (ret = wav_parse_bext_string(s, "originator", 32)) < 0 ||
271  (ret = wav_parse_bext_string(s, "originator_reference", 32)) < 0 ||
272  (ret = wav_parse_bext_string(s, "origination_date", 10)) < 0 ||
273  (ret = wav_parse_bext_string(s, "origination_time", 8)) < 0)
274  return ret;
275 
276  time_reference = avio_rl64(s->pb);
277  snprintf(temp, sizeof(temp), "%"PRIu64, time_reference);
278  if ((ret = av_dict_set(&s->metadata, "time_reference", temp, 0)) < 0)
279  return ret;
280 
281  /* check if version is >= 1, in which case an UMID may be present */
282  if (avio_rl16(s->pb) >= 1) {
283  for (x = 0; x < 8; x++)
284  umid_mask |= umid_parts[x] = avio_rb64(s->pb);
285 
286  if (umid_mask) {
287  /* the string formatting below is per SMPTE 330M-2004 Annex C */
288  if (umid_parts[4] == 0 && umid_parts[5] == 0 &&
289  umid_parts[6] == 0 && umid_parts[7] == 0) {
290  /* basic UMID */
291  snprintf(temp, sizeof(temp),
292  "0x%016"PRIX64"%016"PRIX64"%016"PRIX64"%016"PRIX64,
293  umid_parts[0], umid_parts[1],
294  umid_parts[2], umid_parts[3]);
295  } else {
296  /* extended UMID */
297  snprintf(temp, sizeof(temp),
298  "0x%016"PRIX64"%016"PRIX64"%016"PRIX64"%016"PRIX64
299  "%016"PRIX64"%016"PRIX64"%016"PRIX64"%016"PRIX64,
300  umid_parts[0], umid_parts[1],
301  umid_parts[2], umid_parts[3],
302  umid_parts[4], umid_parts[5],
303  umid_parts[6], umid_parts[7]);
304  }
305 
306  if ((ret = av_dict_set(&s->metadata, "umid", temp, 0)) < 0)
307  return ret;
308  }
309 
310  avio_skip(s->pb, 190);
311  } else
312  avio_skip(s->pb, 254);
313 
314  if (size > 602) {
315  /* CodingHistory present */
316  size -= 602;
317 
318  if (!(coding_history = av_malloc(size + 1)))
319  return AVERROR(ENOMEM);
320 
321  if ((ret = avio_read(s->pb, coding_history, size)) != size) {
322  av_free(coding_history);
323  return ret < 0 ? ret : AVERROR_INVALIDDATA;
324  }
325 
326  coding_history[size] = 0;
327  if ((ret = av_dict_set(&s->metadata, "coding_history", coding_history,
329  return ret;
330  }
331 
332  return 0;
333 }
334 
335 static const AVMetadataConv wav_metadata_conv[] = {
336  { "description", "comment" },
337  { "originator", "encoded_by" },
338  { "origination_date", "date" },
339  { "origination_time", "creation_time" },
340  { 0 },
341 };
342 
343 /* wav input */
344 static int wav_read_header(AVFormatContext *s)
345 {
346  int64_t size, av_uninit(data_size);
347  int64_t sample_count = 0;
348  int rf64 = 0, bw64 = 0;
349  uint32_t tag;
350  AVIOContext *pb = s->pb;
351  AVStream *st = NULL;
352  WAVDemuxContext *wav = s->priv_data;
353  int ret, got_fmt = 0, got_xma2 = 0;
354  int64_t next_tag_ofs, data_ofs = -1;
355 
356  wav->unaligned = avio_tell(s->pb) & 1;
357 
358  wav->smv_data_ofs = -1;
359 
360  /* read chunk ID */
361  tag = avio_rl32(pb);
362  switch (tag) {
363  case MKTAG('R', 'I', 'F', 'F'):
364  break;
365  case MKTAG('R', 'I', 'F', 'X'):
366  wav->rifx = 1;
367  break;
368  case MKTAG('R', 'F', '6', '4'):
369  rf64 = 1;
370  break;
371  case MKTAG('B', 'W', '6', '4'):
372  bw64 = 1;
373  break;
374  default:
375  av_log(s, AV_LOG_ERROR, "invalid start code %s in RIFF header\n",
376  av_fourcc2str(tag));
377  return AVERROR_INVALIDDATA;
378  }
379 
380  /* read chunk size */
381  avio_rl32(pb);
382 
383  /* read format */
384  if (avio_rl32(pb) != MKTAG('W', 'A', 'V', 'E')) {
385  av_log(s, AV_LOG_ERROR, "invalid format in RIFF header\n");
386  return AVERROR_INVALIDDATA;
387  }
388 
389  if (rf64 || bw64) {
390  if (avio_rl32(pb) != MKTAG('d', 's', '6', '4'))
391  return AVERROR_INVALIDDATA;
392  size = avio_rl32(pb);
393  if (size < 24)
394  return AVERROR_INVALIDDATA;
395  avio_rl64(pb); /* RIFF size */
396 
397  data_size = avio_rl64(pb);
398  sample_count = avio_rl64(pb);
399 
400  if (data_size < 0 || sample_count < 0) {
401  av_log(s, AV_LOG_ERROR, "negative data_size and/or sample_count in "
402  "ds64: data_size = %"PRId64", sample_count = %"PRId64"\n",
403  data_size, sample_count);
404  return AVERROR_INVALIDDATA;
405  }
406  avio_skip(pb, size - 24); /* skip rest of ds64 chunk */
407 
408  }
409 
410  for (;;) {
411  AVStream *vst;
412  size = next_tag(pb, &tag, wav->rifx);
413  next_tag_ofs = avio_tell(pb) + size;
414 
415  if (avio_feof(pb))
416  break;
417 
418  switch (tag) {
419  case MKTAG('f', 'm', 't', ' '):
420  /* only parse the first 'fmt ' tag found */
421  if (!got_xma2 && !got_fmt && (ret = wav_parse_fmt_tag(s, size, &st)) < 0) {
422  return ret;
423  } else if (got_fmt)
424  av_log(s, AV_LOG_WARNING, "found more than one 'fmt ' tag\n");
425 
426  got_fmt = 1;
427  break;
428  case MKTAG('X', 'M', 'A', '2'):
429  /* only parse the first 'XMA2' tag found */
430  if (!got_fmt && !got_xma2 && (ret = wav_parse_xma2_tag(s, size, &st)) < 0) {
431  return ret;
432  } else if (got_xma2)
433  av_log(s, AV_LOG_WARNING, "found more than one 'XMA2' tag\n");
434 
435  got_xma2 = 1;
436  break;
437  case MKTAG('d', 'a', 't', 'a'):
438  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) && !got_fmt && !got_xma2) {
440  "found no 'fmt ' tag before the 'data' tag\n");
441  return AVERROR_INVALIDDATA;
442  }
443 
444  if (rf64 || bw64) {
445  next_tag_ofs = wav->data_end = avio_tell(pb) + data_size;
446  } else if (size != 0xFFFFFFFF) {
447  data_size = size;
448  next_tag_ofs = wav->data_end = size ? next_tag_ofs : INT64_MAX;
449  } else {
450  av_log(s, AV_LOG_WARNING, "Ignoring maximum wav data size, "
451  "file may be invalid\n");
452  data_size = 0;
453  next_tag_ofs = wav->data_end = INT64_MAX;
454  }
455 
456  data_ofs = avio_tell(pb);
457 
458  /* don't look for footer metadata if we can't seek or if we don't
459  * know where the data tag ends
460  */
461  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) || (!(rf64 && !bw64) && !size))
462  goto break_loop;
463  break;
464  case MKTAG('f', 'a', 'c', 't'):
465  if (!sample_count)
466  sample_count = (!wav->rifx ? avio_rl32(pb) : avio_rb32(pb));
467  break;
468  case MKTAG('b', 'e', 'x', 't'):
469  if ((ret = wav_parse_bext_tag(s, size)) < 0)
470  return ret;
471  break;
472  case MKTAG('S','M','V','0'):
473  if (!got_fmt) {
474  av_log(s, AV_LOG_ERROR, "found no 'fmt ' tag before the 'SMV0' tag\n");
475  return AVERROR_INVALIDDATA;
476  }
477  // SMV file, a wav file with video appended.
478  if (size != MKTAG('0','2','0','0')) {
479  av_log(s, AV_LOG_ERROR, "Unknown SMV version found\n");
480  goto break_loop;
481  }
482  av_log(s, AV_LOG_DEBUG, "Found SMV data\n");
483  wav->smv_given_first = 0;
484  vst = avformat_new_stream(s, NULL);
485  if (!vst)
486  return AVERROR(ENOMEM);
487  avio_r8(pb);
488  vst->id = 1;
491  vst->codecpar->width = avio_rl24(pb);
492  vst->codecpar->height = avio_rl24(pb);
493  if ((ret = ff_alloc_extradata(vst->codecpar, 4)) < 0) {
494  av_log(s, AV_LOG_ERROR, "Could not allocate extradata.\n");
495  return ret;
496  }
497  size = avio_rl24(pb);
498  wav->smv_data_ofs = avio_tell(pb) + (size - 5) * 3;
499  avio_rl24(pb);
500  wav->smv_block_size = avio_rl24(pb);
501  avpriv_set_pts_info(vst, 32, 1, avio_rl24(pb));
502  vst->duration = avio_rl24(pb);
503  avio_rl24(pb);
504  avio_rl24(pb);
505  wav->smv_frames_per_jpeg = avio_rl24(pb);
506  if (wav->smv_frames_per_jpeg > 65536) {
507  av_log(s, AV_LOG_ERROR, "too many frames per jpeg\n");
508  return AVERROR_INVALIDDATA;
509  }
511  goto break_loop;
512  case MKTAG('L', 'I', 'S', 'T'):
513  case MKTAG('l', 'i', 's', 't'):
514  if (size < 4) {
515  av_log(s, AV_LOG_ERROR, "too short LIST tag\n");
516  return AVERROR_INVALIDDATA;
517  }
518  switch (avio_rl32(pb)) {
519  case MKTAG('I', 'N', 'F', 'O'):
520  ff_read_riff_info(s, size - 4);
521  break;
522  case MKTAG('a', 'd', 't', 'l'):
523  if (s->nb_chapters > 0) {
524  while (avio_tell(pb) < next_tag_ofs &&
525  !avio_feof(pb)) {
526  char cue_label[512];
527  unsigned id, sub_size;
528 
529  if (avio_rl32(pb) != MKTAG('l', 'a', 'b', 'l'))
530  break;
531 
532  sub_size = avio_rl32(pb);
533  if (sub_size < 5)
534  break;
535  id = avio_rl32(pb);
536  avio_get_str(pb, sub_size - 4, cue_label, sizeof(cue_label));
537  avio_skip(pb, avio_tell(pb) & 1);
538 
539  for (int i = 0; i < s->nb_chapters; i++) {
540  if (s->chapters[i]->id == id) {
541  av_dict_set(&s->chapters[i]->metadata, "title", cue_label, 0);
542  break;
543  }
544  }
545  }
546  }
547  break;
548  }
549  break;
550  case MKTAG('I', 'D', '3', ' '):
551  case MKTAG('i', 'd', '3', ' '): {
552  ID3v2ExtraMeta *id3v2_extra_meta = NULL;
553  ff_id3v2_read_dict(pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
554  if (id3v2_extra_meta) {
555  ff_id3v2_parse_apic(s, id3v2_extra_meta);
556  ff_id3v2_parse_chapters(s, id3v2_extra_meta);
557  ff_id3v2_parse_priv(s, id3v2_extra_meta);
558  }
559  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
560  }
561  break;
562  case MKTAG('c', 'u', 'e', ' '):
563  if (size >= 4 && got_fmt && st->codecpar->sample_rate > 0) {
564  AVRational tb = {1, st->codecpar->sample_rate};
565  unsigned nb_cues = avio_rl32(pb);
566 
567  if (size >= nb_cues * 24LL + 4LL) {
568  for (int i = 0; i < nb_cues; i++) {
569  unsigned offset, id = avio_rl32(pb);
570 
571  if (avio_feof(pb))
572  return AVERROR_INVALIDDATA;
573 
574  avio_skip(pb, 16);
575  offset = avio_rl32(pb);
576 
578  return AVERROR(ENOMEM);
579  }
580  }
581  }
582  break;
583  }
584 
585  /* seek to next tag unless we know that we'll run into EOF */
586  if ((avio_size(pb) > 0 && next_tag_ofs >= avio_size(pb)) ||
587  wav_seek_tag(wav, pb, next_tag_ofs, SEEK_SET) < 0) {
588  break;
589  }
590  }
591 
592 break_loop:
593  if (!got_fmt && !got_xma2) {
594  av_log(s, AV_LOG_ERROR, "no 'fmt ' or 'XMA2' tag found\n");
595  return AVERROR_INVALIDDATA;
596  }
597 
598  if (data_ofs < 0) {
599  av_log(s, AV_LOG_ERROR, "no 'data' tag found\n");
600  return AVERROR_INVALIDDATA;
601  }
602 
603  avio_seek(pb, data_ofs, SEEK_SET);
604 
605  if (data_size > (INT64_MAX>>3)) {
606  av_log(s, AV_LOG_WARNING, "Data size %"PRId64" is too large\n", data_size);
607  data_size = 0;
608  }
609 
610  if ( st->codecpar->bit_rate > 0 && data_size > 0
611  && st->codecpar->sample_rate > 0
612  && sample_count > 0 && st->codecpar->channels > 1
613  && sample_count % st->codecpar->channels == 0) {
614  if (fabs(8.0 * data_size * st->codecpar->channels * st->codecpar->sample_rate /
615  sample_count /st->codecpar->bit_rate - 1.0) < 0.3)
616  sample_count /= st->codecpar->channels;
617  }
618 
619  if ( data_size > 0 && sample_count && st->codecpar->channels
620  && (data_size << 3) / sample_count / st->codecpar->channels > st->codecpar->bits_per_coded_sample + 1) {
621  av_log(s, AV_LOG_WARNING, "ignoring wrong sample_count %"PRId64"\n", sample_count);
622  sample_count = 0;
623  }
624 
625  /* G.729 hack (for Ticket4577)
626  * FIXME: Come up with cleaner, more general solution */
627  if (st->codecpar->codec_id == AV_CODEC_ID_G729 && sample_count && (data_size << 3) > sample_count) {
628  av_log(s, AV_LOG_WARNING, "ignoring wrong sample_count %"PRId64"\n", sample_count);
629  sample_count = 0;
630  }
631 
632  if (!sample_count || av_get_exact_bits_per_sample(st->codecpar->codec_id) > 0)
633  if ( st->codecpar->channels
634  && data_size
636  && wav->data_end <= avio_size(pb))
637  sample_count = (data_size << 3)
638  /
639  (st->codecpar->channels * (uint64_t)av_get_bits_per_sample(st->codecpar->codec_id));
640 
641  if (sample_count)
642  st->duration = sample_count;
643 
645  st->codecpar->block_align == st->codecpar->channels * 4 &&
646  st->codecpar->bits_per_coded_sample == 32 &&
647  st->codecpar->extradata_size == 2 &&
648  AV_RL16(st->codecpar->extradata) == 1) {
651  } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE &&
652  st->codecpar->block_align == st->codecpar->channels * 4 &&
653  st->codecpar->bits_per_coded_sample == 24) {
655  } else if (st->codecpar->codec_id == AV_CODEC_ID_XMA1 ||
657  st->codecpar->block_align = 2048;
658  } else if (st->codecpar->codec_id == AV_CODEC_ID_ADPCM_MS && st->codecpar->channels > 2 &&
659  st->codecpar->block_align < INT_MAX / st->codecpar->channels) {
660  st->codecpar->block_align *= st->codecpar->channels;
661  }
662 
663  ff_metadata_conv_ctx(s, NULL, wav_metadata_conv);
665 
666  set_spdif(s, wav);
667 
668  return 0;
669 }
670 
671 /**
672  * Find chunk with w64 GUID by skipping over other chunks.
673  * @return the size of the found chunk
674  */
675 static int64_t find_guid(AVIOContext *pb, const uint8_t guid1[16])
676 {
677  uint8_t guid[16];
678  int64_t size;
679 
680  while (!avio_feof(pb)) {
681  avio_read(pb, guid, 16);
682  size = avio_rl64(pb);
683  if (size <= 24 || size > INT64_MAX - 8)
684  return AVERROR_INVALIDDATA;
685  if (!memcmp(guid, guid1, 16))
686  return size;
687  avio_skip(pb, FFALIGN(size, INT64_C(8)) - 24);
688  }
689  return AVERROR_EOF;
690 }
691 
692 static int wav_read_packet(AVFormatContext *s, AVPacket *pkt)
693 {
694  int ret, size;
695  int64_t left;
696  AVStream *st;
697  WAVDemuxContext *wav = s->priv_data;
698 
699  if (CONFIG_SPDIF_DEMUXER && wav->spdif == 1)
700  return ff_spdif_read_packet(s, pkt);
701 
702  if (wav->smv_data_ofs > 0) {
703  int64_t audio_dts, video_dts;
704 smv_retry:
705  audio_dts = (int32_t)s->streams[0]->cur_dts;
706  video_dts = (int32_t)s->streams[1]->cur_dts;
707 
709  /*We always return a video frame first to get the pixel format first*/
710  wav->smv_last_stream = wav->smv_given_first ?
711  av_compare_ts(video_dts, s->streams[1]->time_base,
712  audio_dts, s->streams[0]->time_base) > 0 : 0;
713  wav->smv_given_first = 1;
714  }
715  wav->smv_last_stream = !wav->smv_last_stream;
716  wav->smv_last_stream |= wav->audio_eof;
717  wav->smv_last_stream &= !wav->smv_eof;
718  if (wav->smv_last_stream) {
719  uint64_t old_pos = avio_tell(s->pb);
720  uint64_t new_pos = wav->smv_data_ofs +
721  wav->smv_block * wav->smv_block_size;
722  if (avio_seek(s->pb, new_pos, SEEK_SET) < 0) {
723  ret = AVERROR_EOF;
724  goto smv_out;
725  }
726  size = avio_rl24(s->pb);
727  ret = av_get_packet(s->pb, pkt, size);
728  if (ret < 0)
729  goto smv_out;
730  pkt->pos -= 3;
731  pkt->pts = wav->smv_block * wav->smv_frames_per_jpeg;
733  wav->smv_block++;
734 
735  pkt->stream_index = 1;
736 smv_out:
737  avio_seek(s->pb, old_pos, SEEK_SET);
738  if (ret == AVERROR_EOF) {
739  wav->smv_eof = 1;
740  goto smv_retry;
741  }
742  return ret;
743  }
744  }
745 
746  st = s->streams[0];
747 
748  left = wav->data_end - avio_tell(s->pb);
749  if (wav->ignore_length)
750  left = INT_MAX;
751  if (left <= 0) {
752  if (CONFIG_W64_DEMUXER && wav->w64)
753  left = find_guid(s->pb, ff_w64_guid_data) - 24;
754  else
755  left = find_tag(wav, s->pb, MKTAG('d', 'a', 't', 'a'));
756  if (left < 0) {
757  wav->audio_eof = 1;
758  if (wav->smv_data_ofs > 0 && !wav->smv_eof)
759  goto smv_retry;
760  return AVERROR_EOF;
761  }
762  wav->data_end = avio_tell(s->pb) + left;
763  }
764 
765  size = wav->max_size;
766  if (st->codecpar->block_align > 1) {
767  if (size < st->codecpar->block_align)
768  size = st->codecpar->block_align;
769  size = (size / st->codecpar->block_align) * st->codecpar->block_align;
770  }
771  size = FFMIN(size, left);
772  ret = av_get_packet(s->pb, pkt, size);
773  if (ret < 0)
774  return ret;
775  pkt->stream_index = 0;
776 
777  return ret;
778 }
779 
780 static int wav_read_seek(AVFormatContext *s,
781  int stream_index, int64_t timestamp, int flags)
782 {
783  WAVDemuxContext *wav = s->priv_data;
784  AVStream *st;
785  wav->smv_eof = 0;
786  wav->audio_eof = 0;
787  if (wav->smv_data_ofs > 0) {
788  int64_t smv_timestamp = timestamp;
789  if (stream_index == 0)
790  smv_timestamp = av_rescale_q(timestamp, s->streams[0]->time_base, s->streams[1]->time_base);
791  else
792  timestamp = av_rescale_q(smv_timestamp, s->streams[1]->time_base, s->streams[0]->time_base);
793  if (wav->smv_frames_per_jpeg > 0) {
794  wav->smv_block = smv_timestamp / wav->smv_frames_per_jpeg;
795  }
796  }
797 
798  st = s->streams[0];
799  switch (st->codecpar->codec_id) {
800  case AV_CODEC_ID_MP2:
801  case AV_CODEC_ID_MP3:
802  case AV_CODEC_ID_AC3:
803  case AV_CODEC_ID_DTS:
804  case AV_CODEC_ID_XMA2:
805  /* use generic seeking with dynamically generated indexes */
806  return -1;
807  default:
808  break;
809  }
810  return ff_pcm_read_seek(s, stream_index, timestamp, flags);
811 }
812 
813 static const AVClass wav_demuxer_class = {
814  .class_name = "WAV demuxer",
815  .item_name = av_default_item_name,
816  .option = demux_options,
817  .version = LIBAVUTIL_VERSION_INT,
818 };
820  .name = "wav",
821  .long_name = NULL_IF_CONFIG_SMALL("WAV / WAVE (Waveform Audio)"),
822  .priv_data_size = sizeof(WAVDemuxContext),
823  .read_probe = wav_probe,
824  .read_header = wav_read_header,
825  .read_packet = wav_read_packet,
826  .read_seek = wav_read_seek,
828  .codec_tag = ff_wav_codec_tags_list,
829  .priv_class = &wav_demuxer_class,
830 };
831 #endif /* CONFIG_WAV_DEMUXER */
832 
833 #if CONFIG_W64_DEMUXER
834 static int w64_probe(const AVProbeData *p)
835 {
836  if (p->buf_size <= 40)
837  return 0;
838  if (!memcmp(p->buf, ff_w64_guid_riff, 16) &&
839  !memcmp(p->buf + 24, ff_w64_guid_wave, 16))
840  return AVPROBE_SCORE_MAX;
841  else
842  return 0;
843 }
844 
845 static int w64_read_header(AVFormatContext *s)
846 {
847  int64_t size, data_ofs = 0;
848  AVIOContext *pb = s->pb;
849  WAVDemuxContext *wav = s->priv_data;
850  AVStream *st;
851  uint8_t guid[16];
852  int ret;
853 
854  avio_read(pb, guid, 16);
855  if (memcmp(guid, ff_w64_guid_riff, 16))
856  return AVERROR_INVALIDDATA;
857 
858  /* riff + wave + fmt + sizes */
859  if (avio_rl64(pb) < 16 + 8 + 16 + 8 + 16 + 8)
860  return AVERROR_INVALIDDATA;
861 
862  avio_read(pb, guid, 16);
863  if (memcmp(guid, ff_w64_guid_wave, 16)) {
864  av_log(s, AV_LOG_ERROR, "could not find wave guid\n");
865  return AVERROR_INVALIDDATA;
866  }
867 
868  wav->w64 = 1;
869 
870  st = avformat_new_stream(s, NULL);
871  if (!st)
872  return AVERROR(ENOMEM);
873 
874  while (!avio_feof(pb)) {
875  if (avio_read(pb, guid, 16) != 16)
876  break;
877  size = avio_rl64(pb);
878  if (size <= 24 || INT64_MAX - size < avio_tell(pb))
879  return AVERROR_INVALIDDATA;
880 
881  if (!memcmp(guid, ff_w64_guid_fmt, 16)) {
882  /* subtract chunk header size - normal wav file doesn't count it */
883  ret = ff_get_wav_header(s, pb, st->codecpar, size - 24, 0);
884  if (ret < 0)
885  return ret;
886  avio_skip(pb, FFALIGN(size, INT64_C(8)) - size);
887 
888  avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
889  } else if (!memcmp(guid, ff_w64_guid_fact, 16)) {
890  int64_t samples;
891 
892  samples = avio_rl64(pb);
893  if (samples > 0)
894  st->duration = samples;
895  avio_skip(pb, FFALIGN(size, INT64_C(8)) - 32);
896  } else if (!memcmp(guid, ff_w64_guid_data, 16)) {
897  wav->data_end = avio_tell(pb) + size - 24;
898 
899  data_ofs = avio_tell(pb);
900  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
901  break;
902 
903  avio_skip(pb, size - 24);
904  } else if (!memcmp(guid, ff_w64_guid_summarylist, 16)) {
905  int64_t start, end, cur;
906  uint32_t count, chunk_size, i;
907  int64_t filesize = avio_size(s->pb);
908 
909  start = avio_tell(pb);
910  end = start + FFALIGN(size, INT64_C(8)) - 24;
911  count = avio_rl32(pb);
912 
913  for (i = 0; i < count; i++) {
914  char chunk_key[5], *value;
915 
916  if (avio_feof(pb) || (cur = avio_tell(pb)) < 0 || cur > end - 8 /* = tag + size */)
917  break;
918 
919  chunk_key[4] = 0;
920  avio_read(pb, chunk_key, 4);
921  chunk_size = avio_rl32(pb);
922  if (chunk_size == UINT32_MAX || (filesize >= 0 && chunk_size > filesize))
923  return AVERROR_INVALIDDATA;
924 
925  value = av_malloc(chunk_size + 1);
926  if (!value)
927  return AVERROR(ENOMEM);
928 
929  ret = avio_get_str16le(pb, chunk_size, value, chunk_size);
930  if (ret < 0) {
931  av_free(value);
932  return ret;
933  }
934  avio_skip(pb, chunk_size - ret);
935 
936  av_dict_set(&s->metadata, chunk_key, value, AV_DICT_DONT_STRDUP_VAL);
937  }
938 
939  avio_skip(pb, end - avio_tell(pb));
940  } else {
941  av_log(s, AV_LOG_DEBUG, "unknown guid: "FF_PRI_GUID"\n", FF_ARG_GUID(guid));
942  avio_skip(pb, FFALIGN(size, INT64_C(8)) - 24);
943  }
944  }
945 
946  if (!data_ofs)
947  return AVERROR_EOF;
948 
949  ff_metadata_conv_ctx(s, NULL, wav_metadata_conv);
951 
952  handle_stream_probing(st);
954 
955  avio_seek(pb, data_ofs, SEEK_SET);
956 
957  set_spdif(s, wav);
958 
959  return 0;
960 }
961 
962 static const AVClass w64_demuxer_class = {
963  .class_name = "W64 demuxer",
964  .item_name = av_default_item_name,
966  .version = LIBAVUTIL_VERSION_INT,
967 };
968 
970  .name = "w64",
971  .long_name = NULL_IF_CONFIG_SMALL("Sony Wave64"),
972  .priv_data_size = sizeof(WAVDemuxContext),
973  .read_probe = w64_probe,
974  .read_header = w64_read_header,
975  .read_packet = wav_read_packet,
976  .read_seek = wav_read_seek,
978  .codec_tag = ff_wav_codec_tags_list,
979  .priv_class = &w64_demuxer_class,
980 };
981 #endif /* CONFIG_W64_DEMUXER */
AVInputFormat ff_w64_demuxer
AVInputFormat ff_wav_demuxer
channels
Definition: aptx.h:33
static const GUIDParseTable * find_guid(ff_asf_guid guid)
Definition: asfdec_o.c:1654
#define av_uninit(x)
Definition: attributes.h:154
return
uint8_t
int32_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Main libavformat public API header.
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:310
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:463
@ AVSTREAM_PARSE_FULL_RAW
full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...
Definition: avformat.h:798
Buffered I/O operations.
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:902
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:342
int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a UTF-16 string from pb and convert it to UTF-8.
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:364
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:734
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:337
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:633
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:750
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
Definition: aviobuf.c:860
unsigned int avio_rl24(AVIOContext *s)
Definition: aviobuf.c:742
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:781
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:624
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:758
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:998
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
#define AV_RL16
Definition: intreadwrite.h:42
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define s(width, name)
Definition: cbs_vp9.c:257
#define FFMIN(a, b)
Definition: common.h:105
#define MKTAG(a, b, c, d)
Definition: common.h:478
#define CONFIG_W64_DEMUXER
Definition: config.h:2436
#define CONFIG_SPDIF_DEMUXER
Definition: config.h:2402
#define NULL
Definition: coverity.c:32
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
Public dictionary API.
double value
Definition: eval.c:98
enum AVCodecID id
sample_rate
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
@ AV_OPT_TYPE_INT
Definition: opt.h:225
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
@ AV_CODEC_ID_PCM_F24LE
Definition: codec_id.h:348
@ AV_CODEC_ID_G729
Definition: codec_id.h:477
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:313
@ AV_CODEC_ID_XMA1
Definition: codec_id.h:504
@ AV_CODEC_ID_PCM_F16LE
Definition: codec_id.h:347
@ AV_CODEC_ID_XMA2
Definition: codec_id.h:505
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:325
@ AV_CODEC_ID_PCM_S32LE
Definition: codec_id.h:321
@ AV_CODEC_ID_ADPCM_MS
Definition: codec_id.h:359
@ AV_CODEC_ID_MP2
Definition: codec_id.h:424
@ AV_CODEC_ID_DTS
Definition: codec_id.h:428
@ AV_CODEC_ID_SMVJPEG
Definition: codec_id.h:263
@ AV_CODEC_ID_AC3
Definition: codec_id.h:427
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:425
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
Definition: avcodec.h:215
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:613
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:524
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4505
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:74
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:147
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
const char * key
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
Definition: id3v2.c:1122
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header.
Definition: id3v2.c:1138
int ff_id3v2_parse_priv(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Add metadata for all PRIV tags in the ID3v2 header.
Definition: id3v2.c:1269
int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create chapters for all CHAP tags found in the ID3v2 header.
Definition: id3v2.c:1178
void ff_id3v2_read_dict(AVIOContext *pb, AVDictionary **metadata, const char *magic, ID3v2ExtraMeta **extra_meta)
Read an ID3v2 tag into specified dictionary and retrieve supported extra metadata.
Definition: id3v2.c:1110
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
Definition: id3v2.h:35
int i
Definition: input.c:407
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4941
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:3312
AVChapter * avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: utils.c:4635
int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: utils.c:3330
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
void ff_metadata_conv_ctx(AVFormatContext *ctx, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:59
int ff_pcm_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: pcm.c:56
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
version
Definition: libkvazaar.c:320
#define FFALIGN(x, a)
Definition: macros.h:48
internal metadata API header see avformat.h or the public API!
uint32_t tag
Definition: movenc.c:1600
AVOptions.
#define tb
Definition: regdef.h:68
const AVMetadataConv ff_riff_info_conv[]
Definition: riff.c:603
internal header for RIFF based (de)muxers do NOT include this in end user applications
#define FF_PRI_GUID
Definition: riff.h:105
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
Definition: riffdec.c:91
#define FF_ARG_GUID(g)
Definition: riff.h:109
int ff_read_riff_info(AVFormatContext *s, int64_t size)
Definition: riffdec.c:228
const AVCodecTag *const ff_wav_codec_tags_list[]
#define snprintf
Definition: snprintf.h:34
int ff_spdif_probe(const uint8_t *p_buf, int buf_size, enum AVCodecID *codec)
Definition: spdifdec.c:116
int ff_spdif_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: spdifdec.c:173
unsigned int pos
Definition: spdifenc.c:412
Describe the class of an AVClass context structure.
Definition: log.h:67
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
int channels
Audio only.
Definition: codec_par.h:166
int width
Video only.
Definition: codec_par.h:126
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
int block_align
Audio only.
Definition: codec_par.h:177
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int sample_rate
Audio only.
Definition: codec_par.h:170
Format I/O context.
Definition: avformat.h:1232
Bytestream IO Context.
Definition: avio.h:161
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
AVOption.
Definition: opt.h:248
This structure stores compressed data.
Definition: packet.h:346
int stream_index
Definition: packet.h:371
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:389
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: internal.h:248
Stream structure.
Definition: avformat.h:873
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
int probe_packets
Number of packets to buffer for codec probing.
Definition: avformat.h:1073
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:922
int id
Format-specific stream ID.
Definition: avformat.h:880
enum AVStreamParseType need_parsing
Definition: avformat.h:1081
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1113
int ignore_length
Definition: wavdec.c:59
int smv_block_size
Definition: wavdec.c:53
int smv_frames_per_jpeg
Definition: wavdec.c:54
int smv_block
Definition: wavdec.c:55
int smv_given_first
Definition: wavdec.c:62
int64_t data_end
Definition: wavdec.c:50
int max_size
Definition: wavdec.c:60
int unaligned
Definition: wavdec.c:63
int64_t smv_data_ofs
Definition: wavdec.c:52
int audio_eof
Definition: wavdec.c:58
int smv_last_stream
Definition: wavdec.c:56
#define av_free(p)
#define av_malloc(s)
#define av_log(a,...)
int64_t audio_dts
Definition: movenc.c:61
AVPacket * pkt
Definition: movenc.c:59
int64_t video_dts
Definition: movenc.c:61
int size
else temp
Definition: vf_mcdeint.c:259
if(ret< 0)
Definition: vf_mcdeint.c:282
static const uint8_t offset[127][2]
Definition: vf_spp.c:107
int len
const uint8_t ff_w64_guid_wave[16]
Definition: w64.c:28
const uint8_t ff_w64_guid_summarylist[16]
Definition: w64.c:47
const uint8_t ff_w64_guid_riff[16]
Definition: w64.c:23
const uint8_t ff_w64_guid_data[16]
Definition: w64.c:42
const uint8_t ff_w64_guid_fact[16]
Definition: w64.c:38
const uint8_t ff_w64_guid_fmt[16]
Definition: w64.c:33
static void set_spdif(AVFormatContext *s, WAVDemuxContext *wav)
Definition: wavdec.c:78
static const AVOption demux_options[]
Definition: wavdec.c:69
#define W64_DEMUXER_OPTIONS_OFFSET
#define OFFSET(x)
Definition: wavdec.c:67
#define DEC
Definition: wavdec.c:68