FFmpeg  4.4.6
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;
51  int w64;
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 = av_sat_add64(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  if (!wav->smv_block_size)
502  return AVERROR_INVALIDDATA;
503  avpriv_set_pts_info(vst, 32, 1, avio_rl24(pb));
504  vst->duration = avio_rl24(pb);
505  avio_rl24(pb);
506  avio_rl24(pb);
507  wav->smv_frames_per_jpeg = avio_rl24(pb);
508  if (wav->smv_frames_per_jpeg > 65536) {
509  av_log(s, AV_LOG_ERROR, "too many frames per jpeg\n");
510  return AVERROR_INVALIDDATA;
511  }
513  goto break_loop;
514  case MKTAG('L', 'I', 'S', 'T'):
515  case MKTAG('l', 'i', 's', 't'):
516  if (size < 4) {
517  av_log(s, AV_LOG_ERROR, "too short LIST tag\n");
518  return AVERROR_INVALIDDATA;
519  }
520  switch (avio_rl32(pb)) {
521  case MKTAG('I', 'N', 'F', 'O'):
522  ff_read_riff_info(s, size - 4);
523  break;
524  case MKTAG('a', 'd', 't', 'l'):
525  if (s->nb_chapters > 0) {
526  while (avio_tell(pb) < next_tag_ofs &&
527  !avio_feof(pb)) {
528  char cue_label[512];
529  unsigned id, sub_size;
530 
531  if (avio_rl32(pb) != MKTAG('l', 'a', 'b', 'l'))
532  break;
533 
534  sub_size = avio_rl32(pb);
535  if (sub_size < 5)
536  break;
537  id = avio_rl32(pb);
538  avio_get_str(pb, sub_size - 4, cue_label, sizeof(cue_label));
539  avio_skip(pb, avio_tell(pb) & 1);
540 
541  for (int i = 0; i < s->nb_chapters; i++) {
542  if (s->chapters[i]->id == id) {
543  av_dict_set(&s->chapters[i]->metadata, "title", cue_label, 0);
544  break;
545  }
546  }
547  }
548  }
549  break;
550  }
551  break;
552  case MKTAG('I', 'D', '3', ' '):
553  case MKTAG('i', 'd', '3', ' '): {
554  ID3v2ExtraMeta *id3v2_extra_meta = NULL;
555  ff_id3v2_read_dict(pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
556  if (id3v2_extra_meta) {
557  ff_id3v2_parse_apic(s, id3v2_extra_meta);
558  ff_id3v2_parse_chapters(s, id3v2_extra_meta);
559  ff_id3v2_parse_priv(s, id3v2_extra_meta);
560  }
561  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
562  }
563  break;
564  case MKTAG('c', 'u', 'e', ' '):
565  if (size >= 4 && got_fmt && st->codecpar->sample_rate > 0) {
566  AVRational tb = {1, st->codecpar->sample_rate};
567  unsigned nb_cues = avio_rl32(pb);
568 
569  if (size >= nb_cues * 24LL + 4LL) {
570  for (int i = 0; i < nb_cues; i++) {
571  unsigned offset, id = avio_rl32(pb);
572 
573  if (avio_feof(pb))
574  return AVERROR_INVALIDDATA;
575 
576  avio_skip(pb, 16);
577  offset = avio_rl32(pb);
578 
580  return AVERROR(ENOMEM);
581  }
582  }
583  }
584  break;
585  }
586 
587  /* seek to next tag unless we know that we'll run into EOF */
588  if ((avio_size(pb) > 0 && next_tag_ofs >= avio_size(pb)) ||
589  wav_seek_tag(wav, pb, next_tag_ofs, SEEK_SET) < 0) {
590  break;
591  }
592  }
593 
594 break_loop:
595  if (!got_fmt && !got_xma2) {
596  av_log(s, AV_LOG_ERROR, "no 'fmt ' or 'XMA2' tag found\n");
597  return AVERROR_INVALIDDATA;
598  }
599 
600  if (data_ofs < 0) {
601  av_log(s, AV_LOG_ERROR, "no 'data' tag found\n");
602  return AVERROR_INVALIDDATA;
603  }
604 
605  avio_seek(pb, data_ofs, SEEK_SET);
606 
607  if (data_size > (INT64_MAX>>3)) {
608  av_log(s, AV_LOG_WARNING, "Data size %"PRId64" is too large\n", data_size);
609  data_size = 0;
610  }
611 
612  if ( st->codecpar->bit_rate > 0 && data_size > 0
613  && st->codecpar->sample_rate > 0
614  && sample_count > 0 && st->codecpar->channels > 1
615  && sample_count % st->codecpar->channels == 0) {
616  if (fabs(8.0 * data_size * st->codecpar->channels * st->codecpar->sample_rate /
617  sample_count /st->codecpar->bit_rate - 1.0) < 0.3)
618  sample_count /= st->codecpar->channels;
619  }
620 
621  if ( data_size > 0 && sample_count && st->codecpar->channels
622  && (data_size << 3) / sample_count / st->codecpar->channels > st->codecpar->bits_per_coded_sample + 1) {
623  av_log(s, AV_LOG_WARNING, "ignoring wrong sample_count %"PRId64"\n", sample_count);
624  sample_count = 0;
625  }
626 
627  /* G.729 hack (for Ticket4577)
628  * FIXME: Come up with cleaner, more general solution */
629  if (st->codecpar->codec_id == AV_CODEC_ID_G729 && sample_count && (data_size << 3) > sample_count) {
630  av_log(s, AV_LOG_WARNING, "ignoring wrong sample_count %"PRId64"\n", sample_count);
631  sample_count = 0;
632  }
633 
634  if (!sample_count || av_get_exact_bits_per_sample(st->codecpar->codec_id) > 0)
635  if ( st->codecpar->channels
636  && data_size
638  && wav->data_end <= avio_size(pb))
639  sample_count = (data_size << 3)
640  /
641  (st->codecpar->channels * (uint64_t)av_get_bits_per_sample(st->codecpar->codec_id));
642 
643  if (sample_count)
644  st->duration = sample_count;
645 
647  st->codecpar->block_align == st->codecpar->channels * 4 &&
648  st->codecpar->bits_per_coded_sample == 32 &&
649  st->codecpar->extradata_size == 2 &&
650  AV_RL16(st->codecpar->extradata) == 1) {
653  } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE &&
654  st->codecpar->block_align == st->codecpar->channels * 4 &&
655  st->codecpar->bits_per_coded_sample == 24) {
657  } else if (st->codecpar->codec_id == AV_CODEC_ID_XMA1 ||
659  st->codecpar->block_align = 2048;
660  } else if (st->codecpar->codec_id == AV_CODEC_ID_ADPCM_MS && st->codecpar->channels > 2 &&
661  st->codecpar->block_align < INT_MAX / st->codecpar->channels) {
662  st->codecpar->block_align *= st->codecpar->channels;
663  }
664 
665  ff_metadata_conv_ctx(s, NULL, wav_metadata_conv);
667 
668  set_spdif(s, wav);
669 
670  return 0;
671 }
672 
673 /**
674  * Find chunk with w64 GUID by skipping over other chunks.
675  * @return the size of the found chunk
676  */
677 static int64_t find_guid(AVIOContext *pb, const uint8_t guid1[16])
678 {
679  uint8_t guid[16];
680  int64_t size;
681 
682  while (!avio_feof(pb)) {
683  avio_read(pb, guid, 16);
684  size = avio_rl64(pb);
685  if (size <= 24 || size > INT64_MAX - 8)
686  return AVERROR_INVALIDDATA;
687  if (!memcmp(guid, guid1, 16))
688  return size;
689  avio_skip(pb, FFALIGN(size, INT64_C(8)) - 24);
690  }
691  return AVERROR_EOF;
692 }
693 
694 static int wav_read_packet(AVFormatContext *s, AVPacket *pkt)
695 {
696  int ret, size;
697  int64_t left;
698  AVStream *st;
699  WAVDemuxContext *wav = s->priv_data;
700 
701  if (CONFIG_SPDIF_DEMUXER && wav->spdif == 1)
702  return ff_spdif_read_packet(s, pkt);
703 
704  if (wav->smv_data_ofs > 0) {
706 smv_retry:
707  audio_dts = (int32_t)s->streams[0]->cur_dts;
708  video_dts = (int32_t)s->streams[1]->cur_dts;
709 
711  /*We always return a video frame first to get the pixel format first*/
712  wav->smv_last_stream = wav->smv_given_first ?
713  av_compare_ts(video_dts, s->streams[1]->time_base,
714  audio_dts, s->streams[0]->time_base) > 0 : 0;
715  wav->smv_given_first = 1;
716  }
717  wav->smv_last_stream = !wav->smv_last_stream;
718  wav->smv_last_stream |= wav->audio_eof;
719  wav->smv_last_stream &= !wav->smv_eof;
720  if (wav->smv_last_stream) {
721  uint64_t old_pos = avio_tell(s->pb);
722  uint64_t new_pos = wav->smv_data_ofs +
723  wav->smv_block * (int64_t)wav->smv_block_size;
724  if (avio_seek(s->pb, new_pos, SEEK_SET) < 0) {
725  ret = AVERROR_EOF;
726  goto smv_out;
727  }
728  size = avio_rl24(s->pb);
729  if (size > wav->smv_block_size) {
730  ret = AVERROR_EOF;
731  goto smv_out;
732  }
733  ret = av_get_packet(s->pb, pkt, size);
734  if (ret < 0)
735  goto smv_out;
736  pkt->pos -= 3;
737  pkt->pts = wav->smv_block * wav->smv_frames_per_jpeg;
739  wav->smv_block++;
740 
741  pkt->stream_index = 1;
742 smv_out:
743  avio_seek(s->pb, old_pos, SEEK_SET);
744  if (ret == AVERROR_EOF) {
745  wav->smv_eof = 1;
746  goto smv_retry;
747  }
748  return ret;
749  }
750  }
751 
752  st = s->streams[0];
753 
754  left = wav->data_end - avio_tell(s->pb);
755  if (wav->ignore_length)
756  left = INT_MAX;
757  if (left <= 0) {
758  if (CONFIG_W64_DEMUXER && wav->w64)
759  left = find_guid(s->pb, ff_w64_guid_data) - 24;
760  else
761  left = find_tag(wav, s->pb, MKTAG('d', 'a', 't', 'a'));
762  if (left < 0) {
763  wav->audio_eof = 1;
764  if (wav->smv_data_ofs > 0 && !wav->smv_eof)
765  goto smv_retry;
766  return AVERROR_EOF;
767  }
768  if (INT64_MAX - left < avio_tell(s->pb))
769  return AVERROR_INVALIDDATA;
770  wav->data_end = avio_tell(s->pb) + left;
771  }
772 
773  size = wav->max_size;
774  if (st->codecpar->block_align > 1) {
775  if (size < st->codecpar->block_align)
776  size = st->codecpar->block_align;
777  size = (size / st->codecpar->block_align) * st->codecpar->block_align;
778  }
779  size = FFMIN(size, left);
780  ret = av_get_packet(s->pb, pkt, size);
781  if (ret < 0)
782  return ret;
783  pkt->stream_index = 0;
784 
785  return ret;
786 }
787 
788 static int wav_read_seek(AVFormatContext *s,
789  int stream_index, int64_t timestamp, int flags)
790 {
791  WAVDemuxContext *wav = s->priv_data;
792  AVStream *st;
793  wav->smv_eof = 0;
794  wav->audio_eof = 0;
795  if (wav->smv_data_ofs > 0) {
796  int64_t smv_timestamp = timestamp;
797  if (stream_index == 0)
798  smv_timestamp = av_rescale_q(timestamp, s->streams[0]->time_base, s->streams[1]->time_base);
799  else
800  timestamp = av_rescale_q(smv_timestamp, s->streams[1]->time_base, s->streams[0]->time_base);
801  if (wav->smv_frames_per_jpeg > 0) {
802  wav->smv_block = smv_timestamp / wav->smv_frames_per_jpeg;
803  }
804  }
805 
806  st = s->streams[0];
807  switch (st->codecpar->codec_id) {
808  case AV_CODEC_ID_MP2:
809  case AV_CODEC_ID_MP3:
810  case AV_CODEC_ID_AC3:
811  case AV_CODEC_ID_DTS:
812  case AV_CODEC_ID_XMA2:
813  /* use generic seeking with dynamically generated indexes */
814  return -1;
815  default:
816  break;
817  }
818  return ff_pcm_read_seek(s, stream_index, timestamp, flags);
819 }
820 
821 static const AVClass wav_demuxer_class = {
822  .class_name = "WAV demuxer",
823  .item_name = av_default_item_name,
824  .option = demux_options,
825  .version = LIBAVUTIL_VERSION_INT,
826 };
828  .name = "wav",
829  .long_name = NULL_IF_CONFIG_SMALL("WAV / WAVE (Waveform Audio)"),
830  .priv_data_size = sizeof(WAVDemuxContext),
831  .read_probe = wav_probe,
832  .read_header = wav_read_header,
833  .read_packet = wav_read_packet,
834  .read_seek = wav_read_seek,
836  .codec_tag = ff_wav_codec_tags_list,
837  .priv_class = &wav_demuxer_class,
838 };
839 #endif /* CONFIG_WAV_DEMUXER */
840 
841 #if CONFIG_W64_DEMUXER
842 static int w64_probe(const AVProbeData *p)
843 {
844  if (p->buf_size <= 40)
845  return 0;
846  if (!memcmp(p->buf, ff_w64_guid_riff, 16) &&
847  !memcmp(p->buf + 24, ff_w64_guid_wave, 16))
848  return AVPROBE_SCORE_MAX;
849  else
850  return 0;
851 }
852 
853 static int w64_read_header(AVFormatContext *s)
854 {
855  int64_t size, data_ofs = 0;
856  AVIOContext *pb = s->pb;
857  WAVDemuxContext *wav = s->priv_data;
858  AVStream *st;
859  uint8_t guid[16];
860  int ret;
861 
862  if (avio_read(pb, guid, 16) != 16 || memcmp(guid, ff_w64_guid_riff, 16))
863  return AVERROR_INVALIDDATA;
864 
865  /* riff + wave + fmt + sizes */
866  if (avio_rl64(pb) < 16 + 8 + 16 + 8 + 16 + 8)
867  return AVERROR_INVALIDDATA;
868 
869  avio_read(pb, guid, 16);
870  if (memcmp(guid, ff_w64_guid_wave, 16)) {
871  av_log(s, AV_LOG_ERROR, "could not find wave guid\n");
872  return AVERROR_INVALIDDATA;
873  }
874 
875  wav->w64 = 1;
876 
877  st = avformat_new_stream(s, NULL);
878  if (!st)
879  return AVERROR(ENOMEM);
880 
881  while (!avio_feof(pb)) {
882  if (avio_read(pb, guid, 16) != 16)
883  break;
884  size = avio_rl64(pb);
885  if (size <= 24 || INT64_MAX - size < avio_tell(pb))
886  return AVERROR_INVALIDDATA;
887 
888  if (!memcmp(guid, ff_w64_guid_fmt, 16)) {
889  /* subtract chunk header size - normal wav file doesn't count it */
890  ret = ff_get_wav_header(s, pb, st->codecpar, size - 24, 0);
891  if (ret < 0)
892  return ret;
893  avio_skip(pb, FFALIGN(size, INT64_C(8)) - size);
894 
895  avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
896  } else if (!memcmp(guid, ff_w64_guid_fact, 16)) {
897  int64_t samples;
898 
899  samples = avio_rl64(pb);
900  if (samples > 0)
901  st->duration = samples;
902  avio_skip(pb, FFALIGN(size, INT64_C(8)) - 32);
903  } else if (!memcmp(guid, ff_w64_guid_data, 16)) {
904  wav->data_end = avio_tell(pb) + size - 24;
905 
906  data_ofs = avio_tell(pb);
907  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
908  break;
909 
910  avio_skip(pb, size - 24);
911  } else if (!memcmp(guid, ff_w64_guid_summarylist, 16)) {
912  int64_t start, end, cur;
913  uint32_t count, chunk_size, i;
914  int64_t filesize = avio_size(s->pb);
915 
916  start = avio_tell(pb);
917  end = start + FFALIGN(size, INT64_C(8)) - 24;
918  count = avio_rl32(pb);
919 
920  for (i = 0; i < count; i++) {
921  char chunk_key[5], *value;
922 
923  if (avio_feof(pb) || (cur = avio_tell(pb)) < 0 || cur > end - 8 /* = tag + size */)
924  break;
925 
926  chunk_key[4] = 0;
927  avio_read(pb, chunk_key, 4);
928  chunk_size = avio_rl32(pb);
929  if (chunk_size == UINT32_MAX || (filesize >= 0 && chunk_size > filesize))
930  return AVERROR_INVALIDDATA;
931 
932  value = av_malloc(chunk_size + 1);
933  if (!value)
934  return AVERROR(ENOMEM);
935 
936  ret = avio_get_str16le(pb, chunk_size, value, chunk_size);
937  if (ret < 0) {
938  av_free(value);
939  return ret;
940  }
941  avio_skip(pb, chunk_size - ret);
942 
943  av_dict_set(&s->metadata, chunk_key, value, AV_DICT_DONT_STRDUP_VAL);
944  }
945 
946  avio_skip(pb, end - avio_tell(pb));
947  } else {
948  av_log(s, AV_LOG_DEBUG, "unknown guid: "FF_PRI_GUID"\n", FF_ARG_GUID(guid));
949  avio_skip(pb, FFALIGN(size, INT64_C(8)) - 24);
950  }
951  }
952 
953  if (!data_ofs)
954  return AVERROR_EOF;
955 
956  ff_metadata_conv_ctx(s, NULL, wav_metadata_conv);
958 
959  handle_stream_probing(st);
961 
962  avio_seek(pb, data_ofs, SEEK_SET);
963 
964  set_spdif(s, wav);
965 
966  return 0;
967 }
968 
969 static const AVClass w64_demuxer_class = {
970  .class_name = "W64 demuxer",
971  .item_name = av_default_item_name,
973  .version = LIBAVUTIL_VERSION_INT,
974 };
975 
977  .name = "w64",
978  .long_name = NULL_IF_CONFIG_SMALL("Sony Wave64"),
979  .priv_data_size = sizeof(WAVDemuxContext),
980  .read_probe = w64_probe,
981  .read_header = w64_read_header,
982  .read_packet = wav_read_packet,
983  .read_seek = wav_read_seek,
985  .codec_tag = ff_wav_codec_tags_list,
986  .priv_class = &w64_demuxer_class,
987 };
988 #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:572
#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 av_sat_add64
Definition: common.h:164
#define CONFIG_W64_DEMUXER
Definition: config.h:2440
#define CONFIG_SPDIF_DEMUXER
Definition: config.h:2406
#define NULL
Definition: coverity.c:32
long long int64_t
Definition: coverity.c:34
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:545
@ 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:639
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:550
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4509
#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:1126
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:1142
int ff_id3v2_parse_priv(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Add metadata for all PRIV tags in the ID3v2 header.
Definition: id3v2.c:1273
int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create chapters for all CHAP tags found in the ID3v2 header.
Definition: id3v2.c:1182
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:1114
#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:4945
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:3314
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:4639
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:3332
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:326
#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:1611
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