FFmpeg  2.8.17
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 #include <stdint.h>
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/log.h"
32 #include "libavutil/mathematics.h"
33 #include "libavutil/opt.h"
34 #include "avformat.h"
35 #include "avio.h"
36 #include "avio_internal.h"
37 #include "internal.h"
38 #include "metadata.h"
39 #include "pcm.h"
40 #include "riff.h"
41 #include "w64.h"
42 #include "spdif.h"
43 
44 typedef struct WAVDemuxContext {
45  const AVClass *class;
46  int64_t data_end;
47  int w64;
48  int64_t smv_data_ofs;
51  int smv_block;
53  int smv_eof;
54  int audio_eof;
56  int spdif;
59  int unaligned; // e.g. if an odd number of bytes ID3 tag was prepended
60  int rifx; // RIFX: integer byte order for parameters is big endian
62 
63 #if CONFIG_WAV_DEMUXER
64 
65 static int64_t next_tag(AVIOContext *pb, uint32_t *tag, int big_endian)
66 {
67  *tag = avio_rl32(pb);
68  if (!big_endian) {
69  return avio_rl32(pb);
70  } else {
71  return avio_rb32(pb);
72  }
73 }
74 
75 /* RIFF chunks are always at even offsets relative to where they start. */
76 static int64_t wav_seek_tag(WAVDemuxContext * wav, AVIOContext *s, int64_t offset, int whence)
77 {
78  offset += offset < INT64_MAX && offset + wav->unaligned & 1;
79 
80  return avio_seek(s, offset, whence);
81 }
82 
83 /* return the size of the found tag */
84 static int64_t find_tag(WAVDemuxContext * wav, AVIOContext *pb, uint32_t tag1)
85 {
86  unsigned int tag;
87  int64_t size;
88 
89  for (;;) {
90  if (avio_feof(pb))
91  return AVERROR_EOF;
92  size = next_tag(pb, &tag, wav->rifx);
93  if (tag == tag1)
94  break;
95  wav_seek_tag(wav, pb, size, SEEK_CUR);
96  }
97  return size;
98 }
99 
100 static int wav_probe(AVProbeData *p)
101 {
102  /* check file header */
103  if (p->buf_size <= 32)
104  return 0;
105  if (!memcmp(p->buf + 8, "WAVE", 4)) {
106  if (!memcmp(p->buf, "RIFF", 4) || !memcmp(p->buf, "RIFX", 4))
107  /* Since the ACT demuxer has a standard WAV header at the top of
108  * its own, the returned score is decreased to avoid a probe
109  * conflict between ACT and WAV. */
110  return AVPROBE_SCORE_MAX - 1;
111  else if (!memcmp(p->buf, "RF64", 4) &&
112  !memcmp(p->buf + 12, "ds64", 4))
113  return AVPROBE_SCORE_MAX;
114  }
115  return 0;
116 }
117 
118 static void handle_stream_probing(AVStream *st)
119 {
120  if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
122  st->probe_packets = FFMIN(st->probe_packets, 32);
123  }
124 }
125 
126 static int wav_parse_fmt_tag(AVFormatContext *s, int64_t size, AVStream **st)
127 {
128  AVIOContext *pb = s->pb;
129  WAVDemuxContext *wav = s->priv_data;
130  int ret;
131 
132  /* parse fmt header */
133  *st = avformat_new_stream(s, NULL);
134  if (!*st)
135  return AVERROR(ENOMEM);
136 
137  ret = ff_get_wav_header(s, pb, (*st)->codec, size, wav->rifx);
138  if (ret < 0)
139  return ret;
140  handle_stream_probing(*st);
141 
142  (*st)->need_parsing = AVSTREAM_PARSE_FULL_RAW;
143 
144  avpriv_set_pts_info(*st, 64, 1, (*st)->codec->sample_rate);
145 
146  return 0;
147 }
148 
149 static inline int wav_parse_bext_string(AVFormatContext *s, const char *key,
150  int length)
151 {
152  char temp[257];
153  int ret;
154 
155  av_assert0(length < sizeof(temp));
156  if ((ret = avio_read(s->pb, temp, length)) != length)
157  return ret < 0 ? ret : AVERROR_INVALIDDATA;
158 
159  temp[length] = 0;
160 
161  if (strlen(temp))
162  return av_dict_set(&s->metadata, key, temp, 0);
163 
164  return 0;
165 }
166 
167 static int wav_parse_bext_tag(AVFormatContext *s, int64_t size)
168 {
169  char temp[131], *coding_history;
170  int ret, x;
171  uint64_t time_reference;
172  int64_t umid_parts[8], umid_mask = 0;
173 
174  if ((ret = wav_parse_bext_string(s, "description", 256)) < 0 ||
175  (ret = wav_parse_bext_string(s, "originator", 32)) < 0 ||
176  (ret = wav_parse_bext_string(s, "originator_reference", 32)) < 0 ||
177  (ret = wav_parse_bext_string(s, "origination_date", 10)) < 0 ||
178  (ret = wav_parse_bext_string(s, "origination_time", 8)) < 0)
179  return ret;
180 
181  time_reference = avio_rl64(s->pb);
182  snprintf(temp, sizeof(temp), "%"PRIu64, time_reference);
183  if ((ret = av_dict_set(&s->metadata, "time_reference", temp, 0)) < 0)
184  return ret;
185 
186  /* check if version is >= 1, in which case an UMID may be present */
187  if (avio_rl16(s->pb) >= 1) {
188  for (x = 0; x < 8; x++)
189  umid_mask |= umid_parts[x] = avio_rb64(s->pb);
190 
191  if (umid_mask) {
192  /* the string formatting below is per SMPTE 330M-2004 Annex C */
193  if (umid_parts[4] == 0 && umid_parts[5] == 0 &&
194  umid_parts[6] == 0 && umid_parts[7] == 0) {
195  /* basic UMID */
196  snprintf(temp, sizeof(temp),
197  "0x%016"PRIX64"%016"PRIX64"%016"PRIX64"%016"PRIX64,
198  umid_parts[0], umid_parts[1],
199  umid_parts[2], umid_parts[3]);
200  } else {
201  /* extended UMID */
202  snprintf(temp, sizeof(temp),
203  "0x%016"PRIX64"%016"PRIX64"%016"PRIX64"%016"PRIX64
204  "%016"PRIX64"%016"PRIX64"%016"PRIX64"%016"PRIX64,
205  umid_parts[0], umid_parts[1],
206  umid_parts[2], umid_parts[3],
207  umid_parts[4], umid_parts[5],
208  umid_parts[6], umid_parts[7]);
209  }
210 
211  if ((ret = av_dict_set(&s->metadata, "umid", temp, 0)) < 0)
212  return ret;
213  }
214 
215  avio_skip(s->pb, 190);
216  } else
217  avio_skip(s->pb, 254);
218 
219  if (size > 602) {
220  /* CodingHistory present */
221  size -= 602;
222 
223  if (!(coding_history = av_malloc(size + 1)))
224  return AVERROR(ENOMEM);
225 
226  if ((ret = avio_read(s->pb, coding_history, size)) != size) {
227  av_free(coding_history);
228  return ret < 0 ? ret : AVERROR_INVALIDDATA;
229  }
230 
231  coding_history[size] = 0;
232  if ((ret = av_dict_set(&s->metadata, "coding_history", coding_history,
234  return ret;
235  }
236 
237  return 0;
238 }
239 
240 static const AVMetadataConv wav_metadata_conv[] = {
241  { "description", "comment" },
242  { "originator", "encoded_by" },
243  { "origination_date", "date" },
244  { "origination_time", "creation_time" },
245  { 0 },
246 };
247 
248 /* wav input */
249 static int wav_read_header(AVFormatContext *s)
250 {
251  int64_t size, av_uninit(data_size);
252  int64_t sample_count = 0;
253  int rf64 = 0;
254  char start_code[32];
255  uint32_t tag;
256  AVIOContext *pb = s->pb;
257  AVStream *st = NULL;
258  WAVDemuxContext *wav = s->priv_data;
259  int ret, got_fmt = 0;
260  int64_t next_tag_ofs, data_ofs = -1;
261 
262  wav->unaligned = avio_tell(s->pb) & 1;
263 
264  wav->smv_data_ofs = -1;
265 
266  /* read chunk ID */
267  tag = avio_rl32(pb);
268  switch (tag) {
269  case MKTAG('R', 'I', 'F', 'F'):
270  break;
271  case MKTAG('R', 'I', 'F', 'X'):
272  wav->rifx = 1;
273  break;
274  case MKTAG('R', 'F', '6', '4'):
275  rf64 = 1;
276  break;
277  default:
278  av_get_codec_tag_string(start_code, sizeof(start_code), tag);
279  av_log(s, AV_LOG_ERROR, "invalid start code %s in RIFF header\n", start_code);
280  return AVERROR_INVALIDDATA;
281  }
282 
283  /* read chunk size */
284  avio_rl32(pb);
285 
286  /* read format */
287  if (avio_rl32(pb) != MKTAG('W', 'A', 'V', 'E')) {
288  av_log(s, AV_LOG_ERROR, "invalid format in RIFF header\n");
289  return AVERROR_INVALIDDATA;
290  }
291 
292  if (rf64) {
293  if (avio_rl32(pb) != MKTAG('d', 's', '6', '4'))
294  return AVERROR_INVALIDDATA;
295  size = avio_rl32(pb);
296  if (size < 24)
297  return AVERROR_INVALIDDATA;
298  avio_rl64(pb); /* RIFF size */
299 
300  data_size = avio_rl64(pb);
301  sample_count = avio_rl64(pb);
302 
303  if (data_size < 0 || sample_count < 0) {
304  av_log(s, AV_LOG_ERROR, "negative data_size and/or sample_count in "
305  "ds64: data_size = %"PRId64", sample_count = %"PRId64"\n",
306  data_size, sample_count);
307  return AVERROR_INVALIDDATA;
308  }
309  avio_skip(pb, size - 24); /* skip rest of ds64 chunk */
310 
311  }
312 
313  for (;;) {
314  AVStream *vst;
315  size = next_tag(pb, &tag, wav->rifx);
316  next_tag_ofs = avio_tell(pb) + size;
317 
318  if (avio_feof(pb))
319  break;
320 
321  switch (tag) {
322  case MKTAG('f', 'm', 't', ' '):
323  /* only parse the first 'fmt ' tag found */
324  if (!got_fmt && (ret = wav_parse_fmt_tag(s, size, &st)) < 0) {
325  return ret;
326  } else if (got_fmt)
327  av_log(s, AV_LOG_WARNING, "found more than one 'fmt ' tag\n");
328 
329  got_fmt = 1;
330  break;
331  case MKTAG('d', 'a', 't', 'a'):
332  if (!got_fmt) {
333  av_log(s, AV_LOG_ERROR,
334  "found no 'fmt ' tag before the 'data' tag\n");
335  return AVERROR_INVALIDDATA;
336  }
337 
338  if (rf64) {
339  next_tag_ofs = wav->data_end = avio_tell(pb) + data_size;
340  } else if (size != 0xFFFFFFFF) {
341  data_size = size;
342  next_tag_ofs = wav->data_end = size ? next_tag_ofs : INT64_MAX;
343  } else {
344  av_log(s, AV_LOG_WARNING, "Ignoring maximum wav data size, "
345  "file may be invalid\n");
346  data_size = 0;
347  next_tag_ofs = wav->data_end = INT64_MAX;
348  }
349 
350  data_ofs = avio_tell(pb);
351 
352  /* don't look for footer metadata if we can't seek or if we don't
353  * know where the data tag ends
354  */
355  if (!pb->seekable || (!rf64 && !size))
356  goto break_loop;
357  break;
358  case MKTAG('f', 'a', 'c', 't'):
359  if (!sample_count)
360  sample_count = (!wav->rifx ? avio_rl32(pb) : avio_rb32(pb));
361  break;
362  case MKTAG('b', 'e', 'x', 't'):
363  if ((ret = wav_parse_bext_tag(s, size)) < 0)
364  return ret;
365  break;
366  case MKTAG('S','M','V','0'):
367  if (!got_fmt) {
368  av_log(s, AV_LOG_ERROR, "found no 'fmt ' tag before the 'SMV0' tag\n");
369  return AVERROR_INVALIDDATA;
370  }
371  // SMV file, a wav file with video appended.
372  if (size != MKTAG('0','2','0','0')) {
373  av_log(s, AV_LOG_ERROR, "Unknown SMV version found\n");
374  goto break_loop;
375  }
376  av_log(s, AV_LOG_DEBUG, "Found SMV data\n");
377  wav->smv_given_first = 0;
378  vst = avformat_new_stream(s, NULL);
379  if (!vst)
380  return AVERROR(ENOMEM);
381  avio_r8(pb);
382  vst->id = 1;
385  vst->codec->width = avio_rl24(pb);
386  vst->codec->height = avio_rl24(pb);
387  if (ff_alloc_extradata(vst->codec, 4)) {
388  av_log(s, AV_LOG_ERROR, "Could not allocate extradata.\n");
389  return AVERROR(ENOMEM);
390  }
391  size = avio_rl24(pb);
392  wav->smv_data_ofs = avio_tell(pb) + (size - 5) * 3;
393  avio_rl24(pb);
394  wav->smv_block_size = avio_rl24(pb);
395  avpriv_set_pts_info(vst, 32, 1, avio_rl24(pb));
396  vst->duration = avio_rl24(pb);
397  avio_rl24(pb);
398  avio_rl24(pb);
399  wav->smv_frames_per_jpeg = avio_rl24(pb);
400  if (wav->smv_frames_per_jpeg > 65536) {
401  av_log(s, AV_LOG_ERROR, "too many frames per jpeg\n");
402  return AVERROR_INVALIDDATA;
403  }
405  wav->smv_cur_pt = 0;
406  goto break_loop;
407  case MKTAG('L', 'I', 'S', 'T'):
408  if (size < 4) {
409  av_log(s, AV_LOG_ERROR, "too short LIST tag\n");
410  return AVERROR_INVALIDDATA;
411  }
412  switch (avio_rl32(pb)) {
413  case MKTAG('I', 'N', 'F', 'O'):
414  ff_read_riff_info(s, size - 4);
415  }
416  break;
417  }
418 
419  /* seek to next tag unless we know that we'll run into EOF */
420  if ((avio_size(pb) > 0 && next_tag_ofs >= avio_size(pb)) ||
421  wav_seek_tag(wav, pb, next_tag_ofs, SEEK_SET) < 0) {
422  break;
423  }
424  }
425 
426 break_loop:
427  if (data_ofs < 0) {
428  av_log(s, AV_LOG_ERROR, "no 'data' tag found\n");
429  return AVERROR_INVALIDDATA;
430  }
431 
432  avio_seek(pb, data_ofs, SEEK_SET);
433 
434  if (data_size > (INT64_MAX>>3)) {
435  av_log(s, AV_LOG_WARNING, "Data size %"PRId64" is too large\n", data_size);
436  data_size = 0;
437  }
438 
439  if ( st->codec->bit_rate > 0 && data_size > 0
440  && st->codec->sample_rate > 0
441  && sample_count > 0 && st->codec->channels > 1
442  && sample_count % st->codec->channels == 0) {
443  if (fabs(8.0 * data_size * st->codec->channels * st->codec->sample_rate /
444  sample_count /st->codec->bit_rate - 1.0) < 0.3)
445  sample_count /= st->codec->channels;
446  }
447 
448  if ( data_size > 0 && sample_count && st->codec->channels
449  && (data_size << 3) / sample_count / st->codec->channels > st->codec->bits_per_coded_sample + 1) {
450  av_log(s, AV_LOG_WARNING, "ignoring wrong sample_count %"PRId64"\n", sample_count);
451  sample_count = 0;
452  }
453 
454  /* G.729 hack (for Ticket4577)
455  * FIXME: Come up with cleaner, more general solution */
456  if (st->codec->codec_id == AV_CODEC_ID_G729 && sample_count && (data_size << 3) > sample_count) {
457  av_log(s, AV_LOG_WARNING, "ignoring wrong sample_count %"PRId64"\n", sample_count);
458  sample_count = 0;
459  }
460 
461  if (!sample_count || av_get_exact_bits_per_sample(st->codec->codec_id) > 0)
462  if ( st->codec->channels
463  && data_size
465  && wav->data_end <= avio_size(pb))
466  sample_count = (data_size << 3)
467  /
468  (st->codec->channels * (uint64_t)av_get_bits_per_sample(st->codec->codec_id));
469 
470  if (sample_count)
471  st->duration = sample_count;
472 
473  ff_metadata_conv_ctx(s, NULL, wav_metadata_conv);
475 
476  return 0;
477 }
478 
479 /**
480  * Find chunk with w64 GUID by skipping over other chunks.
481  * @return the size of the found chunk
482  */
483 static int64_t find_guid(AVIOContext *pb, const uint8_t guid1[16])
484 {
485  uint8_t guid[16];
486  int64_t size;
487 
488  while (!avio_feof(pb)) {
489  avio_read(pb, guid, 16);
490  size = avio_rl64(pb);
491  if (size <= 24)
492  return AVERROR_INVALIDDATA;
493  if (!memcmp(guid, guid1, 16))
494  return size;
495  avio_skip(pb, FFALIGN(size, INT64_C(8)) - 24);
496  }
497  return AVERROR_EOF;
498 }
499 
500 #define MAX_SIZE 4096
501 
502 static int wav_read_packet(AVFormatContext *s, AVPacket *pkt)
503 {
504  int ret, size;
505  int64_t left;
506  AVStream *st;
507  WAVDemuxContext *wav = s->priv_data;
508 
509  if (CONFIG_SPDIF_DEMUXER && wav->spdif == 0 &&
510  s->streams[0]->codec->codec_tag == 1) {
511  enum AVCodecID codec;
512  ret = ff_spdif_probe(s->pb->buffer, s->pb->buf_end - s->pb->buffer,
513  &codec);
514  if (ret > AVPROBE_SCORE_EXTENSION) {
515  s->streams[0]->codec->codec_id = codec;
516  wav->spdif = 1;
517  } else {
518  wav->spdif = -1;
519  }
520  }
521  if (CONFIG_SPDIF_DEMUXER && wav->spdif == 1)
522  return ff_spdif_read_packet(s, pkt);
523 
524  if (wav->smv_data_ofs > 0) {
525  int64_t audio_dts, video_dts;
526 smv_retry:
527  audio_dts = (int32_t)s->streams[0]->cur_dts;
528  video_dts = (int32_t)s->streams[1]->cur_dts;
529 
530  if (audio_dts != AV_NOPTS_VALUE && video_dts != AV_NOPTS_VALUE) {
531  /*We always return a video frame first to get the pixel format first*/
532  wav->smv_last_stream = wav->smv_given_first ?
533  av_compare_ts(video_dts, s->streams[1]->time_base,
534  audio_dts, s->streams[0]->time_base) > 0 : 0;
535  wav->smv_given_first = 1;
536  }
537  wav->smv_last_stream = !wav->smv_last_stream;
538  wav->smv_last_stream |= wav->audio_eof;
539  wav->smv_last_stream &= !wav->smv_eof;
540  if (wav->smv_last_stream) {
541  uint64_t old_pos = avio_tell(s->pb);
542  uint64_t new_pos = wav->smv_data_ofs +
543  wav->smv_block * wav->smv_block_size;
544  if (avio_seek(s->pb, new_pos, SEEK_SET) < 0) {
545  ret = AVERROR_EOF;
546  goto smv_out;
547  }
548  size = avio_rl24(s->pb);
549  ret = av_get_packet(s->pb, pkt, size);
550  if (ret < 0)
551  goto smv_out;
552  pkt->pos -= 3;
553  pkt->pts = wav->smv_block * wav->smv_frames_per_jpeg + wav->smv_cur_pt;
554  wav->smv_cur_pt++;
555  if (wav->smv_frames_per_jpeg > 0)
556  wav->smv_cur_pt %= wav->smv_frames_per_jpeg;
557  if (!wav->smv_cur_pt)
558  wav->smv_block++;
559 
560  pkt->stream_index = 1;
561 smv_out:
562  avio_seek(s->pb, old_pos, SEEK_SET);
563  if (ret == AVERROR_EOF) {
564  wav->smv_eof = 1;
565  goto smv_retry;
566  }
567  return ret;
568  }
569  }
570 
571  st = s->streams[0];
572 
573  left = wav->data_end - avio_tell(s->pb);
574  if (wav->ignore_length)
575  left = INT_MAX;
576  if (left <= 0) {
577  if (CONFIG_W64_DEMUXER && wav->w64)
578  left = find_guid(s->pb, ff_w64_guid_data) - 24;
579  else
580  left = find_tag(wav, s->pb, MKTAG('d', 'a', 't', 'a'));
581  if (left < 0) {
582  wav->audio_eof = 1;
583  if (wav->smv_data_ofs > 0 && !wav->smv_eof)
584  goto smv_retry;
585  return AVERROR_EOF;
586  }
587  wav->data_end = avio_tell(s->pb) + left;
588  }
589 
590  size = MAX_SIZE;
591  if (st->codec->block_align > 1) {
592  if (size < st->codec->block_align)
593  size = st->codec->block_align;
594  size = (size / st->codec->block_align) * st->codec->block_align;
595  }
596  size = FFMIN(size, left);
597  ret = av_get_packet(s->pb, pkt, size);
598  if (ret < 0)
599  return ret;
600  pkt->stream_index = 0;
601 
602  return ret;
603 }
604 
605 static int wav_read_seek(AVFormatContext *s,
606  int stream_index, int64_t timestamp, int flags)
607 {
608  WAVDemuxContext *wav = s->priv_data;
609  AVStream *st;
610  wav->smv_eof = 0;
611  wav->audio_eof = 0;
612  if (wav->smv_data_ofs > 0) {
613  int64_t smv_timestamp = timestamp;
614  if (stream_index == 0)
615  smv_timestamp = av_rescale_q(timestamp, s->streams[0]->time_base, s->streams[1]->time_base);
616  else
617  timestamp = av_rescale_q(smv_timestamp, s->streams[1]->time_base, s->streams[0]->time_base);
618  if (wav->smv_frames_per_jpeg > 0) {
619  wav->smv_block = smv_timestamp / wav->smv_frames_per_jpeg;
620  wav->smv_cur_pt = smv_timestamp % wav->smv_frames_per_jpeg;
621  }
622  }
623 
624  st = s->streams[0];
625  switch (st->codec->codec_id) {
626  case AV_CODEC_ID_MP2:
627  case AV_CODEC_ID_MP3:
628  case AV_CODEC_ID_AC3:
629  case AV_CODEC_ID_DTS:
630  /* use generic seeking with dynamically generated indexes */
631  return -1;
632  default:
633  break;
634  }
635  return ff_pcm_read_seek(s, stream_index, timestamp, flags);
636 }
637 
638 #define OFFSET(x) offsetof(WAVDemuxContext, x)
639 #define DEC AV_OPT_FLAG_DECODING_PARAM
640 static const AVOption demux_options[] = {
641  { "ignore_length", "Ignore length", OFFSET(ignore_length), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, DEC },
642  { NULL },
643 };
644 
645 static const AVClass wav_demuxer_class = {
646  .class_name = "WAV demuxer",
647  .item_name = av_default_item_name,
648  .option = demux_options,
649  .version = LIBAVUTIL_VERSION_INT,
650 };
651 AVInputFormat ff_wav_demuxer = {
652  .name = "wav",
653  .long_name = NULL_IF_CONFIG_SMALL("WAV / WAVE (Waveform Audio)"),
654  .priv_data_size = sizeof(WAVDemuxContext),
655  .read_probe = wav_probe,
656  .read_header = wav_read_header,
657  .read_packet = wav_read_packet,
658  .read_seek = wav_read_seek,
659  .flags = AVFMT_GENERIC_INDEX,
660  .codec_tag = (const AVCodecTag * const []) { ff_codec_wav_tags, 0 },
661  .priv_class = &wav_demuxer_class,
662 };
663 #endif /* CONFIG_WAV_DEMUXER */
664 
665 #if CONFIG_W64_DEMUXER
666 static int w64_probe(AVProbeData *p)
667 {
668  if (p->buf_size <= 40)
669  return 0;
670  if (!memcmp(p->buf, ff_w64_guid_riff, 16) &&
671  !memcmp(p->buf + 24, ff_w64_guid_wave, 16))
672  return AVPROBE_SCORE_MAX;
673  else
674  return 0;
675 }
676 
677 static int w64_read_header(AVFormatContext *s)
678 {
679  int64_t size, data_ofs = 0;
680  AVIOContext *pb = s->pb;
681  WAVDemuxContext *wav = s->priv_data;
682  AVStream *st;
683  uint8_t guid[16];
684  int ret;
685 
686  avio_read(pb, guid, 16);
687  if (memcmp(guid, ff_w64_guid_riff, 16))
688  return AVERROR_INVALIDDATA;
689 
690  /* riff + wave + fmt + sizes */
691  if (avio_rl64(pb) < 16 + 8 + 16 + 8 + 16 + 8)
692  return AVERROR_INVALIDDATA;
693 
694  avio_read(pb, guid, 16);
695  if (memcmp(guid, ff_w64_guid_wave, 16)) {
696  av_log(s, AV_LOG_ERROR, "could not find wave guid\n");
697  return AVERROR_INVALIDDATA;
698  }
699 
700  wav->w64 = 1;
701 
702  st = avformat_new_stream(s, NULL);
703  if (!st)
704  return AVERROR(ENOMEM);
705 
706  while (!avio_feof(pb)) {
707  if (avio_read(pb, guid, 16) != 16)
708  break;
709  size = avio_rl64(pb);
710  if (size <= 24 || INT64_MAX - size < avio_tell(pb))
711  return AVERROR_INVALIDDATA;
712 
713  if (!memcmp(guid, ff_w64_guid_fmt, 16)) {
714  /* subtract chunk header size - normal wav file doesn't count it */
715  ret = ff_get_wav_header(s, pb, st->codec, size - 24, 0);
716  if (ret < 0)
717  return ret;
718  avio_skip(pb, FFALIGN(size, INT64_C(8)) - size);
719 
720  avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
721  } else if (!memcmp(guid, ff_w64_guid_fact, 16)) {
722  int64_t samples;
723 
724  samples = avio_rl64(pb);
725  if (samples > 0)
726  st->duration = samples;
727  } else if (!memcmp(guid, ff_w64_guid_data, 16)) {
728  wav->data_end = avio_tell(pb) + size - 24;
729 
730  data_ofs = avio_tell(pb);
731  if (!pb->seekable)
732  break;
733 
734  avio_skip(pb, size - 24);
735  } else if (!memcmp(guid, ff_w64_guid_summarylist, 16)) {
736  int64_t start, end, cur;
737  uint32_t count, chunk_size, i;
738 
739  start = avio_tell(pb);
740  end = start + FFALIGN(size, INT64_C(8)) - 24;
741  count = avio_rl32(pb);
742 
743  for (i = 0; i < count; i++) {
744  char chunk_key[5], *value;
745 
746  if (avio_feof(pb) || (cur = avio_tell(pb)) < 0 || cur > end - 8 /* = tag + size */)
747  break;
748 
749  chunk_key[4] = 0;
750  avio_read(pb, chunk_key, 4);
751  chunk_size = avio_rl32(pb);
752  if (chunk_size == UINT32_MAX)
753  return AVERROR_INVALIDDATA;
754 
755  value = av_mallocz(chunk_size + 1);
756  if (!value)
757  return AVERROR(ENOMEM);
758 
759  ret = avio_get_str16le(pb, chunk_size, value, chunk_size);
760  avio_skip(pb, chunk_size - ret);
761 
762  av_dict_set(&s->metadata, chunk_key, value, AV_DICT_DONT_STRDUP_VAL);
763  }
764 
765  avio_skip(pb, end - avio_tell(pb));
766  } else {
767  av_log(s, AV_LOG_DEBUG, "unknown guid: "FF_PRI_GUID"\n", FF_ARG_GUID(guid));
768  avio_skip(pb, FFALIGN(size, INT64_C(8)) - 24);
769  }
770  }
771 
772  if (!data_ofs)
773  return AVERROR_EOF;
774 
775  ff_metadata_conv_ctx(s, NULL, wav_metadata_conv);
777 
778  handle_stream_probing(st);
780 
781  avio_seek(pb, data_ofs, SEEK_SET);
782 
783  return 0;
784 }
785 
786 AVInputFormat ff_w64_demuxer = {
787  .name = "w64",
788  .long_name = NULL_IF_CONFIG_SMALL("Sony Wave64"),
789  .priv_data_size = sizeof(WAVDemuxContext),
790  .read_probe = w64_probe,
791  .read_header = w64_read_header,
792  .read_packet = wav_read_packet,
793  .read_seek = wav_read_seek,
794  .flags = AVFMT_GENERIC_INDEX,
795  .codec_tag = (const AVCodecTag * const []) { ff_codec_wav_tags, 0 },
796 };
797 #endif /* CONFIG_W64_DEMUXER */
int ff_read_riff_info(AVFormatContext *s, int64_t size)
Definition: riffdec.c:221
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:631
Bytestream IO Context.
Definition: avio.h:111
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void ff_metadata_conv_ctx(AVFormatContext *ctx, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:59
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:284
const uint8_t ff_w64_guid_wave[16]
Definition: w64.c:28
Buffered I/O operations.
int ff_spdif_probe(const uint8_t *p_buf, int buf_size, enum AVCodecID *codec)
Definition: spdifdec.c:112
AVOption.
Definition: opt.h:255
const uint8_t ff_w64_guid_fact[16]
Definition: w64.c:38
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:62
unsigned char * buf_end
End of the data, may be less than buffer+buffer_size if the read function returned less data than req...
Definition: avio.h:128
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1458
else temp
Definition: vf_mcdeint.c:257
#define FF_ARG_GUID(g)
Definition: riff.h:97
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:4098
int probe_packets
Number of packets to buffer for codec probing.
Definition: avformat.h:1038
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:204
int smv_frames_per_jpeg
Definition: wavdec.c:50
unsigned char * buffer
Start of the buffer.
Definition: avio.h:125
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:279
size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
Put a string representing the codec tag codec_tag in buf.
Definition: utils.c:3077
static AVPacket pkt
#define MAX_SIZE
Definition: vf_unsharp.c:265
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 block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2309
int ignore_length
Definition: wavdec.c:55
#define FFALIGN(x, a)
Definition: common.h:97
Format I/O context.
Definition: avformat.h:1285
static const GUIDParseTable * find_guid(ff_asf_guid guid)
Definition: asfdec_o.c:1651
int64_t cur_dts
Definition: avformat.h:1031
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
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
internal metadata API header see avformat.h or the public API!
Public dictionary API.
uint8_t
#define av_malloc(s)
AVOptions.
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:694
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
enum AVStreamParseType need_parsing
Definition: avformat.h:1046
int id
Format-specific stream ID.
Definition: avformat.h:861
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1627
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:3761
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1353
uint32_t tag
Definition: movenc.c:1339
#define AVERROR_EOF
End of file.
Definition: error.h:55
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:244
ptrdiff_t size
Definition: opengl_enc.c:101
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:761
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:390
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:3006
full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...
Definition: avformat.h:790
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:542
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:147
int ff_spdif_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: spdifdec.c:169
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:102
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:3414
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1497
av_default_item_name
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:663
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:178
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:425
simple assert() macros that are a bit more flexible than ISO C assert().
GLsizei GLsizei * length
Definition: opengl_enc.c:115
int smv_block_size
Definition: wavdec.c:49
int smv_cur_pt
Definition: wavdec.c:57
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
GLsizei count
Definition: opengl_enc.c:109
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:378
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare 2 timestamps each in its own timebases.
Definition: mathematics.c:152
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:533
return
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:873
#define CONFIG_W64_DEMUXER
Definition: config.h:1253
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:463
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:462
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:160
int bit_rate
the average bitrate
Definition: avcodec.h:1577
#define FFMIN(a, b)
Definition: common.h:92
int smv_last_stream
Definition: wavdec.c:52
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:3339
#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:78
static int read_probe(AVProbeData *pd)
Definition: jvdec.c:55
int width
picture width / height.
Definition: avcodec.h:1691
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
const uint8_t ff_w64_guid_data[16]
Definition: w64.c:42
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
int32_t
const uint8_t ff_w64_guid_riff[16]
Definition: w64.c:23
int audio_eof
Definition: wavdec.c:54
int ff_pcm_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: pcm.c:45
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:634
Stream structure.
Definition: avformat.h:854
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
enum AVMediaType codec_type
Definition: avcodec.h:1520
enum AVCodecID codec_id
Definition: avcodec.h:1529
int sample_rate
samples per second
Definition: avcodec.h:2272
AVIOContext * pb
I/O context.
Definition: avformat.h:1327
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1544
int ff_alloc_extradata(AVCodecContext *avctx, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c:2941
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:69
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:485
#define DEC
Definition: tta.c:409
int64_t smv_data_ofs
Definition: wavdec.c:48
#define snprintf
Definition: snprintf.h:34
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:470
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecContext *codec, int size, int big_endian)
Definition: riffdec.c:86
This structure contains the data a format has to probe a file.
Definition: avformat.h:460
static const uint8_t start_code[]
Definition: h264.c:1289
const AVMetadataConv ff_riff_info_conv[]
Definition: riff.c:455
static int flags
Definition: cpu.c:47
const uint8_t ff_w64_guid_fmt[16]
Definition: w64.c:33
#define OFFSET(x)
Definition: ffmpeg_opt.c:3000
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:913
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:472
int smv_given_first
Definition: wavdec.c:58
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:647
Main libavformat public API header.
if(ret< 0)
Definition: vf_mcdeint.c:280
#define FF_PRI_GUID
Definition: riff.h:93
int64_t data_end
Definition: wavdec.c:46
#define av_free(p)
int smv_block
Definition: wavdec.c:51
int channels
number of audio channels
Definition: avcodec.h:2273
void * priv_data
Format private data.
Definition: avformat.h:1313
const uint8_t ff_w64_guid_summarylist[16]
Definition: w64.c:47
#define av_uninit(x)
Definition: attributes.h:141
#define CONFIG_SPDIF_DEMUXER
Definition: config.h:1228
void INT64 start
Definition: avisynth_c.h:553
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:640
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
Definition: aviobuf.c:303
unsigned int avio_rl24(AVIOContext *s)
Definition: aviobuf.c:655
int stream_index
Definition: avcodec.h:1435
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:896
#define MKTAG(a, b, c, d)
Definition: common.h:341
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: avformat.h:1092
This structure stores compressed data.
Definition: avcodec.h:1410
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:671
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:252
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1426
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:240
int unaligned
Definition: wavdec.c:59
#define AV_WL32(p, v)
Definition: intreadwrite.h:426