FFmpeg
wtvdec.c
Go to the documentation of this file.
1 /*
2  * Windows Television (WTV) demuxer
3  * Copyright (c) 2010-2011 Peter Ross <pross@xvid.org>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Windows Television (WTV) demuxer
25  * @author Peter Ross <pross@xvid.org>
26  */
27 
28 #include <inttypes.h>
29 
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/intfloat.h"
34 #include "avformat.h"
35 #include "internal.h"
36 #include "wtv.h"
37 #include "mpegts.h"
38 
39 /* Macros for formatting GUIDs */
40 #define PRI_PRETTY_GUID \
41  "%08"PRIx32"-%04"PRIx16"-%04"PRIx16"-%02x%02x%02x%02x%02x%02x%02x%02x"
42 #define ARG_PRETTY_GUID(g) \
43  AV_RL32(g),AV_RL16(g+4),AV_RL16(g+6),g[8],g[9],g[10],g[11],g[12],g[13],g[14],g[15]
44 #define LEN_PRETTY_GUID 34
45 
46 /*
47  * File system routines
48  */
49 
50 typedef struct WtvFile {
51  AVIOContext *pb_filesystem; /**< file system (AVFormatContext->pb) */
52 
53  int sector_bits; /**< sector shift bits; used to convert sector number into pb_filesystem offset */
54  uint32_t *sectors; /**< file allocation table */
55  int nb_sectors; /**< number of sectors */
56 
57  int error;
58  int64_t position;
59  int64_t length;
60 } WtvFile;
61 
62 static int64_t seek_by_sector(AVIOContext *pb, int64_t sector, int64_t offset)
63 {
64  return avio_seek(pb, (sector << WTV_SECTOR_BITS) + offset, SEEK_SET);
65 }
66 
67 /**
68  * @return bytes read, AVERROR_EOF on end of file, or <0 on error
69  */
70 static int wtvfile_read_packet(void *opaque, uint8_t *buf, int buf_size)
71 {
72  WtvFile *wf = opaque;
73  AVIOContext *pb = wf->pb_filesystem;
74  int nread = 0;
75 
76  if (wf->error || pb->error)
77  return -1;
78  if (wf->position >= wf->length || avio_feof(pb))
79  return AVERROR_EOF;
80 
81  buf_size = FFMIN(buf_size, wf->length - wf->position);
82  while(nread < buf_size) {
83  int n;
84  int remaining_in_sector = (1 << wf->sector_bits) - (wf->position & ((1 << wf->sector_bits) - 1));
85  int read_request = FFMIN(buf_size - nread, remaining_in_sector);
86 
87  n = avio_read(pb, buf, read_request);
88  if (n <= 0)
89  break;
90  nread += n;
91  buf += n;
92  wf->position += n;
93  if (n == remaining_in_sector) {
94  int i = wf->position >> wf->sector_bits;
95  if (i >= wf->nb_sectors ||
96  (wf->sectors[i] != wf->sectors[i - 1] + (1 << (wf->sector_bits - WTV_SECTOR_BITS)) &&
97  seek_by_sector(pb, wf->sectors[i], 0) < 0)) {
98  wf->error = 1;
99  break;
100  }
101  }
102  }
103  return nread;
104 }
105 
106 /**
107  * @return position (or file length)
108  */
109 static int64_t wtvfile_seek(void *opaque, int64_t offset, int whence)
110 {
111  WtvFile *wf = opaque;
112  AVIOContext *pb = wf->pb_filesystem;
113 
114  if (whence == AVSEEK_SIZE)
115  return wf->length;
116  else if (whence == SEEK_CUR)
117  offset = wf->position + offset;
118  else if (whence == SEEK_END)
119  offset = wf->length;
120 
121  wf->error = offset < 0 || offset >= wf->length ||
122  seek_by_sector(pb, wf->sectors[offset >> wf->sector_bits],
123  offset & ((1 << wf->sector_bits) - 1)) < 0;
124  wf->position = offset;
125  return offset;
126 }
127 
128 /**
129  * read non-zero integers (le32) from input stream
130  * @param pb
131  * @param[out] data destination
132  * @param count maximum number of integers to read
133  * @return total number of integers read
134  */
135 static int read_ints(AVIOContext *pb, uint32_t *data, int count)
136 {
137  int i, total = 0;
138  for (i = 0; i < count; i++) {
139  if ((data[total] = avio_rl32(pb)))
140  total++;
141  }
142  return total;
143 }
144 
145 /**
146  * Open file
147  * @param first_sector First sector
148  * @param length Length of file (bytes)
149  * @param depth File allocation table depth
150  * @return NULL on error
151  */
152 static AVIOContext * wtvfile_open_sector(unsigned first_sector, uint64_t length, int depth, AVFormatContext *s)
153 {
154  AVIOContext *pb;
155  WtvFile *wf;
156  uint8_t *buffer;
157  int64_t size;
158 
159  if (seek_by_sector(s->pb, first_sector, 0) < 0)
160  return NULL;
161 
162  wf = av_mallocz(sizeof(WtvFile));
163  if (!wf)
164  return NULL;
165 
166  if (depth == 0) {
167  wf->sectors = av_malloc(sizeof(uint32_t));
168  if (!wf->sectors) {
169  av_free(wf);
170  return NULL;
171  }
172  wf->sectors[0] = first_sector;
173  wf->nb_sectors = 1;
174  } else if (depth == 1) {
176  if (!wf->sectors) {
177  av_free(wf);
178  return NULL;
179  }
180  wf->nb_sectors = read_ints(s->pb, wf->sectors, WTV_SECTOR_SIZE / 4);
181  } else if (depth == 2) {
182  uint32_t sectors1[WTV_SECTOR_SIZE / 4];
183  int nb_sectors1 = read_ints(s->pb, sectors1, WTV_SECTOR_SIZE / 4);
184  int i;
185 
186  wf->sectors = av_malloc_array(nb_sectors1, 1 << WTV_SECTOR_BITS);
187  if (!wf->sectors) {
188  av_free(wf);
189  return NULL;
190  }
191  wf->nb_sectors = 0;
192  for (i = 0; i < nb_sectors1; i++) {
193  if (seek_by_sector(s->pb, sectors1[i], 0) < 0)
194  break;
195  wf->nb_sectors += read_ints(s->pb, wf->sectors + i * WTV_SECTOR_SIZE / 4, WTV_SECTOR_SIZE / 4);
196  }
197  } else {
198  av_log(s, AV_LOG_ERROR, "unsupported file allocation table depth (0x%x)\n", depth);
199  av_free(wf);
200  return NULL;
201  }
202  wf->sector_bits = length & (1ULL<<63) ? WTV_SECTOR_BITS : WTV_BIGSECTOR_BITS;
203 
204  if (!wf->nb_sectors) {
205  av_freep(&wf->sectors);
206  av_freep(&wf);
207  return NULL;
208  }
209 
210  size = avio_size(s->pb);
211  if (size >= 0 && (int64_t)wf->sectors[wf->nb_sectors - 1] << WTV_SECTOR_BITS > size)
212  av_log(s, AV_LOG_WARNING, "truncated file\n");
213 
214  /* check length */
215  length &= 0xFFFFFFFFFFFF;
216  if (length > ((int64_t)wf->nb_sectors << wf->sector_bits)) {
217  av_log(s, AV_LOG_WARNING, "reported file length (0x%"PRIx64") exceeds number of available sectors (0x%"PRIx64")\n", length, (int64_t)wf->nb_sectors << wf->sector_bits);
218  length = (int64_t)wf->nb_sectors << wf->sector_bits;
219  }
220  wf->length = length;
221 
222  /* seek to initial sector */
223  wf->position = 0;
224  if (seek_by_sector(s->pb, wf->sectors[0], 0) < 0) {
225  av_freep(&wf->sectors);
226  av_freep(&wf);
227  return NULL;
228  }
229 
230  wf->pb_filesystem = s->pb;
231  buffer = av_malloc(1 << wf->sector_bits);
232  if (!buffer) {
233  av_freep(&wf->sectors);
234  av_freep(&wf);
235  return NULL;
236  }
237 
238  pb = avio_alloc_context(buffer, 1 << wf->sector_bits, 0, wf,
240  if (!pb) {
241  av_freep(&buffer);
242  av_freep(&wf->sectors);
243  av_freep(&wf);
244  }
245  return pb;
246 }
247 
248 /**
249  * Open file using filename
250  * @param[in] buf directory buffer
251  * @param buf_size directory buffer size
252  * @param[in] filename
253  * @param filename_size size of filename
254  * @return NULL on error
255  */
256 static AVIOContext * wtvfile_open2(AVFormatContext *s, const uint8_t *buf, int buf_size, const uint8_t *filename, int filename_size)
257 {
258  const uint8_t *buf_end = buf + buf_size;
259 
260  while(buf + 48 <= buf_end) {
261  int dir_length, name_size, first_sector, depth;
262  uint64_t file_length;
263  const uint8_t *name;
265  av_log(s, AV_LOG_ERROR, "unknown guid "FF_PRI_GUID", expected dir_entry_guid; "
266  "remaining directory entries ignored\n", FF_ARG_GUID(buf));
267  break;
268  }
269  dir_length = AV_RL16(buf + 16);
270  file_length = AV_RL64(buf + 24);
271  name_size = 2 * AV_RL32(buf + 32);
272  if (name_size < 0) {
274  "bad filename length, remaining directory entries ignored\n");
275  break;
276  }
277  if (dir_length == 0) {
279  "bad dir length, remaining directory entries ignored\n");
280  break;
281  }
282  if (48 + (int64_t)name_size > buf_end - buf) {
283  av_log(s, AV_LOG_ERROR, "filename exceeds buffer size; remaining directory entries ignored\n");
284  break;
285  }
286  first_sector = AV_RL32(buf + 40 + name_size);
287  depth = AV_RL32(buf + 44 + name_size);
288 
289  /* compare file name; test optional null terminator */
290  name = buf + 40;
291  if (name_size >= filename_size &&
292  !memcmp(name, filename, filename_size) &&
293  (name_size < filename_size + 2 || !AV_RN16(name + filename_size)))
294  return wtvfile_open_sector(first_sector, file_length, depth, s);
295 
296  buf += dir_length;
297  }
298  return 0;
299 }
300 
301 #define wtvfile_open(s, buf, buf_size, filename) \
302  wtvfile_open2(s, buf, buf_size, filename, sizeof(filename))
303 
304 /**
305  * Close file opened with wtvfile_open_sector(), or wtv_open()
306  */
307 static void wtvfile_close(AVIOContext *pb)
308 {
309  WtvFile *wf = pb->opaque;
310  av_freep(&wf->sectors);
311  av_freep(&pb->opaque);
312  av_freep(&pb->buffer);
313  avio_context_free(&pb);
314 }
315 
316 /*
317  * Main demuxer
318  */
319 
320 typedef struct WtvStream {
322 } WtvStream;
323 
324 typedef struct WtvContext {
325  AVIOContext *pb; /**< timeline file */
326  int64_t epoch;
327  int64_t pts; /**< pts for next data chunk */
328  int64_t last_valid_pts; /**< latest valid pts, used for interactive seeking */
329 
330  /* maintain private seek index, as the AVIndexEntry->pos is relative to the
331  start of the 'timeline' file, not the file system (AVFormatContext->pb) */
335 } WtvContext;
336 
337 /* WTV GUIDs */
339  {0x48,0xC0,0xCE,0x5D,0xB9,0xD0,0x63,0x41,0x87,0x2C,0x4F,0x32,0x22,0x3B,0xE8,0x8A};
341  {0x6D,0x66,0x92,0xE2,0x02,0x9C,0x8D,0x44,0xAA,0x8D,0x78,0x1A,0x93,0xFD,0xC3,0x95};
343  {0x1C,0xD4,0x7B,0x10,0xDA,0xA6,0x91,0x46,0x83,0x69,0x11,0xB2,0xCD,0xAA,0x28,0x8E};
345  {0xE6,0xA2,0xB4,0x3A,0x47,0x42,0x34,0x4B,0x89,0x6C,0x30,0xAF,0xA5,0xD2,0x1C,0x24};
347  {0xD9,0x79,0xE7,0xEf,0xF0,0x97,0x86,0x47,0x80,0x0D,0x95,0xCF,0x50,0x5D,0xDC,0x66};
349  {0xC4,0xE1,0xD4,0x4B,0xA1,0x90,0x09,0x41,0x82,0x36,0x27,0xF0,0x0E,0x7D,0xCC,0x5B};
351  {0x68,0xAB,0xF1,0xCA,0x53,0xE1,0x41,0x4D,0xA6,0xB3,0xA7,0xC9,0x98,0xDB,0x75,0xEE};
353  {0x50,0xD9,0x99,0x95,0x33,0x5F,0x17,0x46,0xAF,0x7C,0x1E,0x54,0xB5,0x10,0xDA,0xA3};
355  {0xBE,0xBF,0x1C,0x50,0x49,0xB8,0xCE,0x42,0x9B,0xE9,0x3D,0xB8,0x69,0xFB,0x82,0xB3};
356 
357 /* Windows media GUIDs */
358 
359 /* Media types */
361  {0x81,0xEB,0x36,0xE4,0x4F,0x52,0xCE,0x11,0x9F,0x53,0x00,0x20,0xAF,0x0B,0xA7,0x70};
363  {0x6C,0x17,0x5F,0x45,0x06,0x4B,0xCE,0x47,0x9A,0xEF,0x8C,0xAE,0xF7,0x3D,0xF7,0xB5};
365  {0x20,0x80,0x6D,0xE0,0x46,0xDB,0xCF,0x11,0xB4,0xD1,0x00,0x80,0x5F,0x6C,0xBB,0xEA};
367  {0x89,0x8A,0x8B,0xB8,0x49,0xB0,0x80,0x4C,0xAD,0xCF,0x58,0x98,0x98,0x5E,0x22,0xC1};
368 
369 /* Media subtypes */
371  {0xC3,0xCB,0xFF,0x34,0xB3,0xD5,0x71,0x41,0x90,0x02,0xD4,0xC6,0x03,0x01,0x69,0x7F};
373  {0xE3,0x76,0x2A,0xF7,0x0A,0xEB,0xD0,0x11,0xAC,0xE4,0x00,0x00,0xC0,0xCC,0x16,0xBA};
375  {0xAA,0xDD,0x2A,0xF5,0xF0,0x36,0xF5,0x43,0x95,0xEA,0x6D,0x86,0x64,0x84,0x26,0x2A};
377  {0x79,0x85,0x9F,0x4A,0xF8,0x6B,0x92,0x43,0x8A,0x6D,0xD2,0xDD,0x09,0xFA,0x78,0x61};
378 
379 static int read_probe(const AVProbeData *p)
380 {
381  return ff_guidcmp(p->buf, ff_wtv_guid) ? 0 : AVPROBE_SCORE_MAX;
382 }
383 
384 /**
385  * Convert win32 FILETIME to ISO-8601 string
386  * @return <0 on error
387  */
388 static int filetime_to_iso8601(char *buf, int buf_size, int64_t value)
389 {
390  time_t t = (value / 10000000LL) - 11644473600LL;
391  struct tm tmbuf;
392  struct tm *tm = gmtime_r(&t, &tmbuf);
393  if (!tm)
394  return -1;
395  if (!strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", tm))
396  return -1;
397  return 0;
398 }
399 
400 /**
401  * Convert crazy time (100ns since 1 Jan 0001) to ISO-8601 string
402  * @return <0 on error
403  */
404 static int crazytime_to_iso8601(char *buf, int buf_size, int64_t value)
405 {
406  time_t t = (value / 10000000LL) - 719162LL*86400LL;
407  struct tm tmbuf;
408  struct tm *tm = gmtime_r(&t, &tmbuf);
409  if (!tm)
410  return -1;
411  if (!strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", tm))
412  return -1;
413  return 0;
414 }
415 
416 /**
417  * Convert OLE DATE to ISO-8601 string
418  * @return <0 on error
419  */
420 static int oledate_to_iso8601(char *buf, int buf_size, int64_t value)
421 {
422  time_t t = (av_int2double(value) - 25569.0) * 86400;
423  struct tm tmbuf;
424  struct tm *tm= gmtime_r(&t, &tmbuf);
425  if (!tm)
426  return -1;
427  if (!strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", tm))
428  return -1;
429  return 0;
430 }
431 
433 {
434  char mime[1024];
435  char description[1024];
436  unsigned int filesize;
437  AVStream *st;
438  int ret;
439  int64_t pos = avio_tell(pb);
440 
441  avio_get_str16le(pb, INT_MAX, mime, sizeof(mime));
442  if (strcmp(mime, "image/jpeg"))
443  goto done;
444 
445  avio_r8(pb);
446  avio_get_str16le(pb, INT_MAX, description, sizeof(description));
447  filesize = avio_rl32(pb);
448  if (!filesize)
449  goto done;
450 
451  st = avformat_new_stream(s, NULL);
452  if (!st)
453  goto done;
454  av_dict_set(&st->metadata, "title", description, 0);
457  st->id = -1;
458  ret = av_get_packet(pb, &st->attached_pic, filesize);
459  if (ret < 0)
460  goto done;
461  st->attached_pic.stream_index = st->index;
464 done:
465  avio_seek(pb, pos + length, SEEK_SET);
466 }
467 
468 static void get_tag(AVFormatContext *s, AVIOContext *pb, const char *key, int type, int length)
469 {
470  int buf_size;
471  char *buf;
472 
473  if (!strcmp(key, "WM/MediaThumbType")) {
474  avio_skip(pb, length);
475  return;
476  }
477 
478  buf_size = FFMAX(2*length, LEN_PRETTY_GUID) + 1;
479  buf = av_malloc(buf_size);
480  if (!buf)
481  return;
482 
483  if (type == 0 && length == 4) {
484  snprintf(buf, buf_size, "%u", avio_rl32(pb));
485  } else if (type == 1) {
486  avio_get_str16le(pb, length, buf, buf_size);
487  if (!strlen(buf)) {
488  av_free(buf);
489  return;
490  }
491  } else if (type == 3 && length == 4) {
492  strcpy(buf, avio_rl32(pb) ? "true" : "false");
493  } else if (type == 4 && length == 8) {
494  int64_t num = avio_rl64(pb);
495  if (!strcmp(key, "WM/EncodingTime") ||
496  !strcmp(key, "WM/MediaOriginalBroadcastDateTime")) {
497  if (filetime_to_iso8601(buf, buf_size, num) < 0) {
498  av_free(buf);
499  return;
500  }
501  } else if (!strcmp(key, "WM/WMRVEncodeTime") ||
502  !strcmp(key, "WM/WMRVEndTime")) {
503  if (crazytime_to_iso8601(buf, buf_size, num) < 0) {
504  av_free(buf);
505  return;
506  }
507  } else if (!strcmp(key, "WM/WMRVExpirationDate")) {
508  if (oledate_to_iso8601(buf, buf_size, num) < 0 ) {
509  av_free(buf);
510  return;
511  }
512  } else if (!strcmp(key, "WM/WMRVBitrate"))
513  snprintf(buf, buf_size, "%f", av_int2double(num));
514  else
515  snprintf(buf, buf_size, "%"PRIi64, num);
516  } else if (type == 5 && length == 2) {
517  snprintf(buf, buf_size, "%u", avio_rl16(pb));
518  } else if (type == 6 && length == 16) {
519  ff_asf_guid guid;
520  avio_read(pb, guid, 16);
521  snprintf(buf, buf_size, PRI_PRETTY_GUID, ARG_PRETTY_GUID(guid));
522  } else if (type == 2 && !strcmp(key, "WM/Picture")) {
523  get_attachment(s, pb, length);
524  av_freep(&buf);
525  return;
526  } else {
527  av_freep(&buf);
528  av_log(s, AV_LOG_WARNING, "unsupported metadata entry; key:%s, type:%d, length:0x%x\n", key, type, length);
529  avio_skip(pb, length);
530  return;
531  }
532 
533  av_dict_set(&s->metadata, key, buf, 0);
534  av_freep(&buf);
535 }
536 
537 /**
538  * Parse metadata entries
539  */
541 {
542  ff_asf_guid guid;
543  int length, type;
544  while(!avio_feof(pb)) {
545  char key[1024];
546  ff_get_guid(pb, &guid);
547  type = avio_rl32(pb);
548  length = avio_rl32(pb);
549  if (!length)
550  break;
551  if (ff_guidcmp(&guid, ff_metadata_guid)) {
552  av_log(s, AV_LOG_WARNING, "unknown guid "FF_PRI_GUID", expected metadata_guid; "
553  "remaining metadata entries ignored\n", FF_ARG_GUID(guid));
554  break;
555  }
556  avio_get_str16le(pb, INT_MAX, key, sizeof(key));
557  get_tag(s, pb, key, type, length);
558  }
559 
561 }
562 
563 /**
564  * parse VIDEOINFOHEADER2 structure
565  * @return bytes consumed
566  */
568 {
569  WtvContext *wtv = s->priv_data;
570  AVIOContext *pb = wtv->pb;
571 
572  avio_skip(pb, 72); // picture aspect ratio is unreliable
573  st->codecpar->codec_tag = ff_get_bmp_header(pb, st, NULL);
574 
575  return 72 + 40;
576 }
577 
578 /**
579  * Parse MPEG1WAVEFORMATEX extradata structure
580  */
582 {
583  /* fwHeadLayer */
584  switch (AV_RL16(st->codecpar->extradata)) {
585  case 0x0001 : st->codecpar->codec_id = AV_CODEC_ID_MP1; break;
586  case 0x0002 : st->codecpar->codec_id = AV_CODEC_ID_MP2; break;
587  case 0x0004 : st->codecpar->codec_id = AV_CODEC_ID_MP3; break;
588  }
589 
590  st->codecpar->bit_rate = AV_RL32(st->codecpar->extradata + 2); /* dwHeadBitrate */
591 
592  /* dwHeadMode */
593  switch (AV_RL16(st->codecpar->extradata + 6)) {
594  case 1 :
595  case 2 :
596  case 4 : st->codecpar->channels = 2;
598  break;
599  case 8 : st->codecpar->channels = 1;
601  break;
602  }
603 }
604 
605 /**
606  * Initialise stream
607  * @param st Stream to initialise, or NULL to create and initialise new stream
608  * @return NULL on error
609  */
611 {
612  if (st) {
613  if (st->codecpar->extradata) {
614  av_freep(&st->codecpar->extradata);
615  st->codecpar->extradata_size = 0;
616  }
617  } else {
618  WtvStream *wst = av_mallocz(sizeof(WtvStream));
619  if (!wst)
620  return NULL;
621  st = avformat_new_stream(s, NULL);
622  if (!st) {
623  av_free(wst);
624  return NULL;
625  }
626  st->id = sid;
627  st->priv_data = wst;
628  }
631  avpriv_set_pts_info(st, 64, 1, 10000000);
632  return st;
633 }
634 
635 /**
636  * parse Media Type structure and populate stream
637  * @param st Stream, or NULL to create new stream
638  * @param mediatype Mediatype GUID
639  * @param subtype Subtype GUID
640  * @param formattype Format GUID
641  * @param size Size of format buffer
642  * @return NULL on error
643  */
645  ff_asf_guid mediatype, ff_asf_guid subtype,
646  ff_asf_guid formattype, uint64_t size)
647 {
648  WtvContext *wtv = s->priv_data;
649  AVIOContext *pb = wtv->pb;
652  ff_asf_guid actual_subtype;
653  ff_asf_guid actual_formattype;
654 
655  if (size < 32) {
656  av_log(s, AV_LOG_WARNING, "format buffer size underflow\n");
657  avio_skip(pb, size);
658  return NULL;
659  }
660 
661  avio_skip(pb, size - 32);
662  ff_get_guid(pb, &actual_subtype);
663  ff_get_guid(pb, &actual_formattype);
664  if (avio_feof(pb))
665  return NULL;
666  avio_seek(pb, -size, SEEK_CUR);
667 
668  st = parse_media_type(s, st, sid, mediatype, actual_subtype, actual_formattype, size - 32);
669  avio_skip(pb, 32);
670  return st;
671  } else if (!ff_guidcmp(mediatype, ff_mediatype_audio)) {
672  st = new_stream(s, st, sid, AVMEDIA_TYPE_AUDIO);
673  if (!st)
674  return NULL;
675  if (!ff_guidcmp(formattype, ff_format_waveformatex)) {
676  int ret = ff_get_wav_header(s, pb, st->codecpar, size, 0);
677  if (ret < 0)
678  return NULL;
679  } else {
680  if (ff_guidcmp(formattype, ff_format_none))
681  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
682  avio_skip(pb, size);
683  }
684 
685  if (!memcmp(subtype + 4, (const uint8_t[]){FF_MEDIASUBTYPE_BASE_GUID}, 12)) {
687  } else if (!ff_guidcmp(subtype, mediasubtype_mpeg1payload)) {
688  if (st->codecpar->extradata && st->codecpar->extradata_size >= 22)
690  else
691  av_log(s, AV_LOG_WARNING, "MPEG1WAVEFORMATEX underflow\n");
692  } else {
694  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
695  av_log(s, AV_LOG_WARNING, "unknown subtype:"FF_PRI_GUID"\n", FF_ARG_GUID(subtype));
696  }
697  return st;
698  } else if (!ff_guidcmp(mediatype, ff_mediatype_video)) {
699  st = new_stream(s, st, sid, AVMEDIA_TYPE_VIDEO);
700  if (!st)
701  return NULL;
702  if (!ff_guidcmp(formattype, ff_format_videoinfo2)) {
703  int consumed = parse_videoinfoheader2(s, st);
704  avio_skip(pb, FFMAX(size - consumed, 0));
705  } else if (!ff_guidcmp(formattype, ff_format_mpeg2_video)) {
706  uint64_t consumed = parse_videoinfoheader2(s, st);
707  /* ignore extradata; files produced by windows media center contain meaningless mpeg1 sequence header */
708  avio_skip(pb, FFMAX(size - consumed, 0));
709  } else {
710  if (ff_guidcmp(formattype, ff_format_none))
711  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
712  avio_skip(pb, size);
713  }
714 
715  if (!memcmp(subtype + 4, (const uint8_t[]){FF_MEDIASUBTYPE_BASE_GUID}, 12)) {
717  } else {
719  }
720  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
721  av_log(s, AV_LOG_WARNING, "unknown subtype:"FF_PRI_GUID"\n", FF_ARG_GUID(subtype));
722  return st;
723  } else if (!ff_guidcmp(mediatype, mediatype_mpeg2_pes) &&
725  st = new_stream(s, st, sid, AVMEDIA_TYPE_SUBTITLE);
726  if (!st)
727  return NULL;
728  if (ff_guidcmp(formattype, ff_format_none))
729  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
730  avio_skip(pb, size);
732  return st;
733  } else if (!ff_guidcmp(mediatype, mediatype_mstvcaption) &&
735  st = new_stream(s, st, sid, AVMEDIA_TYPE_SUBTITLE);
736  if (!st)
737  return NULL;
738  if (ff_guidcmp(formattype, ff_format_none))
739  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
740  avio_skip(pb, size);
742  return st;
743  } else if (!ff_guidcmp(mediatype, mediatype_mpeg2_sections) &&
745  if (ff_guidcmp(formattype, ff_format_none))
746  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
747  avio_skip(pb, size);
748  return NULL;
749  }
750 
751  av_log(s, AV_LOG_WARNING, "unknown media type, mediatype:"FF_PRI_GUID
752  ", subtype:"FF_PRI_GUID", formattype:"FF_PRI_GUID"\n",
753  FF_ARG_GUID(mediatype), FF_ARG_GUID(subtype), FF_ARG_GUID(formattype));
754  avio_skip(pb, size);
755  return NULL;
756 }
757 
758 enum {
761 };
762 
763 /**
764  * Try to seek over a broken chunk
765  * @return <0 on error
766  */
767 static int recover(WtvContext *wtv, uint64_t broken_pos)
768 {
769  AVIOContext *pb = wtv->pb;
770  int i;
771  for (i = 0; i < wtv->nb_index_entries; i++) {
772  if (wtv->index_entries[i].pos > broken_pos) {
773  int64_t ret = avio_seek(pb, wtv->index_entries[i].pos, SEEK_SET);
774  if (ret < 0)
775  return ret;
776  wtv->pts = wtv->index_entries[i].timestamp;
777  return 0;
778  }
779  }
780  return AVERROR(EIO);
781 }
782 
783 /**
784  * Parse WTV chunks
785  * @param mode SEEK_TO_DATA or SEEK_TO_PTS
786  * @param seekts timestamp
787  * @param[out] len_ptr Length of data chunk
788  * @return stream index of data chunk, or <0 on error
789  */
790 static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_ptr)
791 {
792  WtvContext *wtv = s->priv_data;
793  AVIOContext *pb = wtv->pb;
794  while (!avio_feof(pb)) {
795  ff_asf_guid g;
796  int len, sid, consumed;
797 
798  ff_get_guid(pb, &g);
799  len = avio_rl32(pb);
800  if (len < 32 || len > INT_MAX - 7) {
801  int ret;
802  if (avio_feof(pb))
803  return AVERROR_EOF;
804  av_log(s, AV_LOG_WARNING, "encountered broken chunk\n");
805  if ((ret = recover(wtv, avio_tell(pb) - 20)) < 0)
806  return ret;
807  continue;
808  }
809  sid = avio_rl32(pb) & 0x7FFF;
810  avio_skip(pb, 8);
811  consumed = 32;
812 
814  if (ff_find_stream_index(s, sid) < 0) {
815  ff_asf_guid mediatype, subtype, formattype;
816  int size;
817  avio_skip(pb, 28);
818  ff_get_guid(pb, &mediatype);
819  ff_get_guid(pb, &subtype);
820  avio_skip(pb, 12);
821  ff_get_guid(pb, &formattype);
822  size = avio_rl32(pb);
823  if (size < 0 || size > INT_MAX - 92 - consumed)
824  return AVERROR_INVALIDDATA;
825  parse_media_type(s, 0, sid, mediatype, subtype, formattype, size);
826  consumed += 92 + size;
827  }
828  } else if (!ff_guidcmp(g, ff_stream2_guid)) {
829  int stream_index = ff_find_stream_index(s, sid);
830  if (stream_index >= 0 && s->streams[stream_index]->priv_data && !((WtvStream*)s->streams[stream_index]->priv_data)->seen_data) {
831  ff_asf_guid mediatype, subtype, formattype;
832  int size;
833  avio_skip(pb, 12);
834  ff_get_guid(pb, &mediatype);
835  ff_get_guid(pb, &subtype);
836  avio_skip(pb, 12);
837  ff_get_guid(pb, &formattype);
838  size = avio_rl32(pb);
839  if (size < 0 || size > INT_MAX - 76 - consumed)
840  return AVERROR_INVALIDDATA;
841  parse_media_type(s, s->streams[stream_index], sid, mediatype, subtype, formattype, size);
842  consumed += 76 + size;
843  }
850  int stream_index = ff_find_stream_index(s, sid);
851  if (stream_index >= 0) {
852  AVStream *st = s->streams[stream_index];
853  uint8_t buf[258];
854  const uint8_t *pbuf = buf;
855  int buf_size;
856 
857  avio_skip(pb, 8);
858  consumed += 8;
861  avio_skip(pb, 6);
862  consumed += 6;
863  }
864 
865  buf_size = FFMIN(len - consumed, sizeof(buf));
866  avio_read(pb, buf, buf_size);
867  consumed += buf_size;
868  ff_parse_mpeg2_descriptor(s, st, 0, &pbuf, buf + buf_size, NULL, 0, 0, NULL);
869  }
871  int stream_index = ff_find_stream_index(s, sid);
872  if (stream_index >= 0) {
873  AVStream *st = s->streams[stream_index];
874  int audio_type;
875  avio_skip(pb, 8);
876  audio_type = avio_r8(pb);
877  if (audio_type == 2)
879  else if (audio_type == 3)
881  consumed += 9;
882  }
884  int stream_index = ff_find_stream_index(s, sid);
885  if (stream_index >= 0) {
886  avio_skip(pb, 12);
887  if (avio_rl32(pb))
888  av_log(s, AV_LOG_WARNING, "DVB scrambled stream detected (st:%d), decoding will likely fail\n", stream_index);
889  consumed += 16;
890  }
892  int stream_index = ff_find_stream_index(s, sid);
893  if (stream_index >= 0) {
894  AVStream *st = s->streams[stream_index];
895  uint8_t language[4];
896  avio_skip(pb, 12);
897  avio_read(pb, language, 3);
898  if (language[0]) {
899  language[3] = 0;
900  av_dict_set(&st->metadata, "language", language, 0);
901  if (!strcmp(language, "nar") || !strcmp(language, "NAR"))
903  }
904  consumed += 15;
905  }
906  } else if (!ff_guidcmp(g, ff_timestamp_guid)) {
907  int stream_index = ff_find_stream_index(s, sid);
908  if (stream_index >= 0) {
909  avio_skip(pb, 8);
910  wtv->pts = avio_rl64(pb);
911  consumed += 16;
912  if (wtv->pts == -1)
913  wtv->pts = AV_NOPTS_VALUE;
914  else {
915  wtv->last_valid_pts = wtv->pts;
916  if (wtv->epoch == AV_NOPTS_VALUE || wtv->pts < wtv->epoch)
917  wtv->epoch = wtv->pts;
918  if (mode == SEEK_TO_PTS && wtv->pts >= seekts) {
919  avio_skip(pb, WTV_PAD8(len) - consumed);
920  return 0;
921  }
922  }
923  }
924  } else if (!ff_guidcmp(g, ff_data_guid)) {
925  int stream_index = ff_find_stream_index(s, sid);
926  if (mode == SEEK_TO_DATA && stream_index >= 0 && len > 32 && s->streams[stream_index]->priv_data) {
927  WtvStream *wst = s->streams[stream_index]->priv_data;
928  wst->seen_data = 1;
929  if (len_ptr) {
930  *len_ptr = len;
931  }
932  return stream_index;
933  }
934  } else if (!ff_guidcmp(g, /* DSATTRIB_WMDRMProtectionInfo */ (const ff_asf_guid){0x83,0x95,0x74,0x40,0x9D,0x6B,0xEC,0x4E,0xB4,0x3C,0x67,0xA1,0x80,0x1E,0x1A,0x9B})) {
935  int stream_index = ff_find_stream_index(s, sid);
936  if (stream_index >= 0)
937  av_log(s, AV_LOG_WARNING, "encrypted stream detected (st:%d), decoding will likely fail\n", stream_index);
938  } else if (
939  !ff_guidcmp(g, /* DSATTRIB_CAPTURE_STREAMTIME */ (const ff_asf_guid){0x14,0x56,0x1A,0x0C,0xCD,0x30,0x40,0x4F,0xBC,0xBF,0xD0,0x3E,0x52,0x30,0x62,0x07}) ||
940  !ff_guidcmp(g, /* DSATTRIB_PBDATAG_ATTRIBUTE */ (const ff_asf_guid){0x79,0x66,0xB5,0xE0,0xB9,0x12,0xCC,0x43,0xB7,0xDF,0x57,0x8C,0xAA,0x5A,0x7B,0x63}) ||
941  !ff_guidcmp(g, /* DSATTRIB_PicSampleSeq */ (const ff_asf_guid){0x02,0xAE,0x5B,0x2F,0x8F,0x7B,0x60,0x4F,0x82,0xD6,0xE4,0xEA,0x2F,0x1F,0x4C,0x99}) ||
942  !ff_guidcmp(g, /* DSATTRIB_TRANSPORT_PROPERTIES */ ff_DSATTRIB_TRANSPORT_PROPERTIES) ||
943  !ff_guidcmp(g, /* dvr_ms_vid_frame_rep_data */ (const ff_asf_guid){0xCC,0x32,0x64,0xDD,0x29,0xE2,0xDB,0x40,0x80,0xF6,0xD2,0x63,0x28,0xD2,0x76,0x1F}) ||
944  !ff_guidcmp(g, /* EVENTID_ChannelChangeSpanningEvent */ (const ff_asf_guid){0xE5,0xC5,0x67,0x90,0x5C,0x4C,0x05,0x42,0x86,0xC8,0x7A,0xFE,0x20,0xFE,0x1E,0xFA}) ||
945  !ff_guidcmp(g, /* EVENTID_ChannelInfoSpanningEvent */ (const ff_asf_guid){0x80,0x6D,0xF3,0x41,0x32,0x41,0xC2,0x4C,0xB1,0x21,0x01,0xA4,0x32,0x19,0xD8,0x1B}) ||
946  !ff_guidcmp(g, /* EVENTID_ChannelTypeSpanningEvent */ (const ff_asf_guid){0x51,0x1D,0xAB,0x72,0xD2,0x87,0x9B,0x48,0xBA,0x11,0x0E,0x08,0xDC,0x21,0x02,0x43}) ||
947  !ff_guidcmp(g, /* EVENTID_PIDListSpanningEvent */ (const ff_asf_guid){0x65,0x8F,0xFC,0x47,0xBB,0xE2,0x34,0x46,0x9C,0xEF,0xFD,0xBF,0xE6,0x26,0x1D,0x5C}) ||
948  !ff_guidcmp(g, /* EVENTID_SignalAndServiceStatusSpanningEvent */ (const ff_asf_guid){0xCB,0xC5,0x68,0x80,0x04,0x3C,0x2B,0x49,0xB4,0x7D,0x03,0x08,0x82,0x0D,0xCE,0x51}) ||
949  !ff_guidcmp(g, /* EVENTID_StreamTypeSpanningEvent */ (const ff_asf_guid){0xBC,0x2E,0xAF,0x82,0xA6,0x30,0x64,0x42,0xA8,0x0B,0xAD,0x2E,0x13,0x72,0xAC,0x60}) ||
950  !ff_guidcmp(g, (const ff_asf_guid){0x1E,0xBE,0xC3,0xC5,0x43,0x92,0xDC,0x11,0x85,0xE5,0x00,0x12,0x3F,0x6F,0x73,0xB9}) ||
951  !ff_guidcmp(g, (const ff_asf_guid){0x3B,0x86,0xA2,0xB1,0xEB,0x1E,0xC3,0x44,0x8C,0x88,0x1C,0xA3,0xFF,0xE3,0xE7,0x6A}) ||
952  !ff_guidcmp(g, (const ff_asf_guid){0x4E,0x7F,0x4C,0x5B,0xC4,0xD0,0x38,0x4B,0xA8,0x3E,0x21,0x7F,0x7B,0xBF,0x52,0xE7}) ||
953  !ff_guidcmp(g, (const ff_asf_guid){0x63,0x36,0xEB,0xFE,0xA1,0x7E,0xD9,0x11,0x83,0x08,0x00,0x07,0xE9,0x5E,0xAD,0x8D}) ||
954  !ff_guidcmp(g, (const ff_asf_guid){0x70,0xE9,0xF1,0xF8,0x89,0xA4,0x4C,0x4D,0x83,0x73,0xB8,0x12,0xE0,0xD5,0xF8,0x1E}) ||
958  !ff_guidcmp(g, (const ff_asf_guid){0xF7,0x10,0x02,0xB9,0xEE,0x7C,0xED,0x4E,0xBD,0x7F,0x05,0x40,0x35,0x86,0x18,0xA1})) {
959  //ignore known guids
960  } else
961  av_log(s, AV_LOG_WARNING, "unsupported chunk:"FF_PRI_GUID"\n", FF_ARG_GUID(g));
962 
963  avio_skip(pb, WTV_PAD8(len) - consumed);
964  }
965  return AVERROR_EOF;
966 }
967 
969 {
970  WtvContext *wtv = s->priv_data;
971  unsigned root_sector;
972  int root_size;
973  uint8_t root[WTV_SECTOR_SIZE];
974  AVIOContext *pb;
975  int64_t timeline_pos;
976  int64_t ret;
977 
978  wtv->epoch =
979  wtv->pts =
981 
982  /* read root directory sector */
983  avio_skip(s->pb, 0x30);
984  root_size = avio_rl32(s->pb);
985  if (root_size > sizeof(root)) {
986  av_log(s, AV_LOG_ERROR, "root directory size exceeds sector size\n");
987  return AVERROR_INVALIDDATA;
988  }
989  avio_skip(s->pb, 4);
990  root_sector = avio_rl32(s->pb);
991 
992  ret = seek_by_sector(s->pb, root_sector, 0);
993  if (ret < 0)
994  return ret;
995  root_size = avio_read(s->pb, root, root_size);
996  if (root_size < 0)
997  return AVERROR_INVALIDDATA;
998 
999  /* parse chunks up until first data chunk */
1000  wtv->pb = wtvfile_open(s, root, root_size, ff_timeline_le16);
1001  if (!wtv->pb) {
1002  av_log(s, AV_LOG_ERROR, "timeline data missing\n");
1003  return AVERROR_INVALIDDATA;
1004  }
1005 
1006  ret = parse_chunks(s, SEEK_TO_DATA, 0, 0);
1007  if (ret < 0) {
1008  wtvfile_close(wtv->pb);
1009  return ret;
1010  }
1011  avio_seek(wtv->pb, -32, SEEK_CUR);
1012 
1013  timeline_pos = avio_tell(s->pb); // save before opening another file
1014 
1015  /* read metadata */
1016  pb = wtvfile_open(s, root, root_size, ff_table_0_entries_legacy_attrib_le16);
1017  if (pb) {
1018  parse_legacy_attrib(s, pb);
1019  wtvfile_close(pb);
1020  }
1021 
1022  s->ctx_flags |= AVFMTCTX_NOHEADER; // Needed for noStreams.wtv
1023 
1024  /* read seek index */
1025  if (s->nb_streams) {
1026  AVStream *st = s->streams[0];
1027  pb = wtvfile_open(s, root, root_size, ff_table_0_entries_time_le16);
1028  if (pb) {
1029  while(1) {
1030  uint64_t timestamp = avio_rl64(pb);
1031  uint64_t frame_nb = avio_rl64(pb);
1032  if (avio_feof(pb))
1033  break;
1035  0, timestamp, frame_nb, 0, AVINDEX_KEYFRAME);
1036  }
1037  wtvfile_close(pb);
1038 
1039  if (wtv->nb_index_entries) {
1040  pb = wtvfile_open(s, root, root_size, ff_timeline_table_0_entries_Events_le16);
1041  if (pb) {
1042  AVIndexEntry *e = wtv->index_entries;
1043  AVIndexEntry *e_end = wtv->index_entries + wtv->nb_index_entries - 1;
1044  uint64_t last_position = 0;
1045  while (1) {
1046  uint64_t frame_nb = avio_rl64(pb);
1047  uint64_t position = avio_rl64(pb);
1048  while (e <= e_end && frame_nb > e->size) {
1049  e->pos = last_position;
1050  e++;
1051  }
1052  if (avio_feof(pb))
1053  break;
1054  last_position = position;
1055  }
1056  e_end->pos = last_position;
1057  wtvfile_close(pb);
1058  st->duration = e_end->timestamp;
1059  }
1060  }
1061  }
1062  }
1063 
1064  avio_seek(s->pb, timeline_pos, SEEK_SET);
1065  return 0;
1066 }
1067 
1069 {
1070  WtvContext *wtv = s->priv_data;
1071  AVIOContext *pb = wtv->pb;
1072  int stream_index, len, ret;
1073 
1074  stream_index = parse_chunks(s, SEEK_TO_DATA, 0, &len);
1075  if (stream_index < 0)
1076  return stream_index;
1077 
1078  ret = av_get_packet(pb, pkt, len - 32);
1079  if (ret < 0)
1080  return ret;
1081  pkt->stream_index = stream_index;
1082  pkt->pts = wtv->pts;
1083  avio_skip(pb, WTV_PAD8(len) - len);
1084  return 0;
1085 }
1086 
1087 static int read_seek(AVFormatContext *s, int stream_index,
1088  int64_t ts, int flags)
1089 {
1090  WtvContext *wtv = s->priv_data;
1091  AVIOContext *pb = wtv->pb;
1092  AVStream *st = s->streams[0];
1093  int64_t ts_relative;
1094  int i;
1095 
1097  return AVERROR(ENOSYS);
1098 
1099  /* timestamp adjustment is required because wtv->pts values are absolute,
1100  * whereas AVIndexEntry->timestamp values are relative to epoch. */
1101  ts_relative = ts;
1102  if (wtv->epoch != AV_NOPTS_VALUE)
1103  ts_relative -= wtv->epoch;
1104 
1105  i = ff_index_search_timestamp(wtv->index_entries, wtv->nb_index_entries, ts_relative, flags);
1106  if (i < 0) {
1107  if (wtv->last_valid_pts == AV_NOPTS_VALUE || ts < wtv->last_valid_pts) {
1108  if (avio_seek(pb, 0, SEEK_SET) < 0)
1109  return -1;
1110  } else if (st->duration != AV_NOPTS_VALUE && ts_relative > st->duration && wtv->nb_index_entries) {
1111  if (avio_seek(pb, wtv->index_entries[wtv->nb_index_entries - 1].pos, SEEK_SET) < 0)
1112  return -1;
1113  }
1114  if (parse_chunks(s, SEEK_TO_PTS, ts, 0) < 0)
1115  return AVERROR(ERANGE);
1116  return 0;
1117  }
1118  if (avio_seek(pb, wtv->index_entries[i].pos, SEEK_SET) < 0)
1119  return -1;
1120  wtv->pts = wtv->index_entries[i].timestamp;
1121  if (wtv->epoch != AV_NOPTS_VALUE)
1122  wtv->pts += wtv->epoch;
1123  wtv->last_valid_pts = wtv->pts;
1124  return 0;
1125 }
1126 
1128 {
1129  WtvContext *wtv = s->priv_data;
1130  av_freep(&wtv->index_entries);
1131  wtvfile_close(wtv->pb);
1132  return 0;
1133 }
1134 
1136  .name = "wtv",
1137  .long_name = NULL_IF_CONFIG_SMALL("Windows Television (WTV)"),
1138  .priv_data_size = sizeof(WtvContext),
1142  .read_seek = read_seek,
1144  .flags = AVFMT_SHOW_IDS,
1145 };
LEN_PRETTY_GUID
#define LEN_PRETTY_GUID
Definition: wtvdec.c:44
AV_CODEC_ID_EIA_608
@ AV_CODEC_ID_EIA_608
Definition: avcodec.h:669
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3971
crazytime_to_iso8601
static int crazytime_to_iso8601(char *buf, int buf_size, int64_t value)
Convert crazy time (100ns since 1 Jan 0001) to ISO-8601 string.
Definition: wtvdec.c:404
filetime_to_iso8601
static int filetime_to_iso8601(char *buf, int buf_size, int64_t value)
Convert win32 FILETIME to ISO-8601 string.
Definition: wtvdec.c:388
EVENTID_StreamIDSpanningEvent
static const ff_asf_guid EVENTID_StreamIDSpanningEvent
Definition: wtvdec.c:350
ff_mediasubtype_cpfilters_processed
const ff_asf_guid ff_mediasubtype_cpfilters_processed
Definition: wtv_common.c:68
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_get_guid
int ff_get_guid(AVIOContext *s, ff_asf_guid *g)
Definition: riffdec.c:32
EVENTID_CtxADescriptorSpanningEvent
static const ff_asf_guid EVENTID_CtxADescriptorSpanningEvent
Definition: wtvdec.c:344
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4480
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:465
mpegts.h
EVENTID_AudioTypeSpanningEvent
static const ff_asf_guid EVENTID_AudioTypeSpanningEvent
Definition: wtvdec.c:354
EVENTID_DVBScramblingControlSpanningEvent
static const ff_asf_guid EVENTID_DVBScramblingControlSpanningEvent
Definition: wtvdec.c:348
wtvfile_read_packet
static int wtvfile_read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: wtvdec.c:70
AVSEEK_FLAG_FRAME
#define AVSEEK_FLAG_FRAME
seeking based on frame number
Definition: avformat.h:2498
EVENTID_AudioDescriptorSpanningEvent
static const ff_asf_guid EVENTID_AudioDescriptorSpanningEvent
Definition: wtvdec.c:342
n
int n
Definition: avisynth_c.h:760
ff_mediatype_video
const ff_asf_guid ff_mediatype_video
Definition: wtv_common.c:43
WtvFile::position
int64_t position
Definition: wtvdec.c:58
mediasubtype_mpeg1payload
static const ff_asf_guid mediasubtype_mpeg1payload
Definition: wtvdec.c:360
AVStream::priv_data
void * priv_data
Definition: avformat.h:885
AV_RL64
uint64_t_TMPL AV_RL64
Definition: bytestream.h:87
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
WtvContext::pb
AVIOContext * pb
timeline file
Definition: wtvdec.c:325
AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:838
av_int2double
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
Definition: intfloat.h:60
avio_context_free
void avio_context_free(AVIOContext **s)
Free the supplied IO context and everything associated with it.
Definition: aviobuf.c:148
ff_timestamp_guid
const ff_asf_guid ff_timestamp_guid
Definition: wtv_common.c:29
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:85
WtvContext
Definition: wtvdec.c:324
count
void INT64 INT64 count
Definition: avisynth_c.h:767
parse_chunks
static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_ptr)
Parse WTV chunks.
Definition: wtvdec.c:790
parse_legacy_attrib
static void parse_legacy_attrib(AVFormatContext *s, AVIOContext *pb)
Parse metadata entries.
Definition: wtvdec.c:540
AV_RN16
#define AV_RN16(p)
Definition: intreadwrite.h:360
WtvFile::sectors
uint32_t * sectors
file allocation table
Definition: wtvdec.c:54
wtvfile_close
static void wtvfile_close(AVIOContext *pb)
Close file opened with wtvfile_open_sector(), or wtv_open()
Definition: wtvdec.c:307
ff_wav_codec_get_id
enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
Definition: riffdec.c:194
EVENTID_SubtitleSpanningEvent
static const ff_asf_guid EVENTID_SubtitleSpanningEvent
Definition: wtvdec.c:338
WtvContext::epoch
int64_t epoch
Definition: wtvdec.c:326
name
const char * name
Definition: avisynth_c.h:867
AV_CODEC_ID_DVB_TELETEXT
@ AV_CODEC_ID_DVB_TELETEXT
Definition: avcodec.h:665
ff_sync_guid
const ff_asf_guid ff_sync_guid
Definition: wtv_common.c:37
WtvFile::sector_bits
int sector_bits
sector shift bits; used to convert sector number into pb_filesystem offset
Definition: wtvdec.c:53
ff_add_index_entry
int ff_add_index_entry(AVIndexEntry **index_entries, int *nb_index_entries, unsigned int *index_entries_allocated_size, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Internal version of av_add_index_entry.
Definition: utils.c:1997
ff_format_waveformatex
const ff_asf_guid ff_format_waveformatex
Definition: wtv_common.c:74
AVSEEK_SIZE
#define AVSEEK_SIZE
ORing this as the "whence" parameter to a seek function causes it to return the filesize without seek...
Definition: avio.h:531
data
const char data[16]
Definition: mxf.c:91
AVSEEK_FLAG_BYTE
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:2496
AVIOContext::error
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3961
wtvfile_seek
static int64_t wtvfile_seek(void *opaque, int64_t offset, int whence)
Definition: wtvdec.c:109
intfloat.h
codec_type
enum AVMediaType codec_type
Definition: rtp.c:37
SEEK_TO_PTS
@ SEEK_TO_PTS
Definition: wtvdec.c:760
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:336
ff_timeline_table_0_entries_Events_le16
const uint8_t ff_timeline_table_0_entries_Events_le16[62]
Definition: wtv_common.c:52
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
AVIndexEntry
Definition: avformat.h:800
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
ff_stream1_guid
const ff_asf_guid ff_stream1_guid
Definition: wtv_common.c:35
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:808
ff_guidcmp
static av_always_inline int ff_guidcmp(const void *g1, const void *g2)
Definition: riff.h:118
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
mediasubtype_teletext
static const ff_asf_guid mediasubtype_teletext
Definition: wtvdec.c:372
AVCodecParameters::channels
int channels
Audio only.
Definition: avcodec.h:4063
ff_get_bmp_header
int ff_get_bmp_header(AVIOContext *pb, AVStream *st, uint32_t *size)
Read BITMAPINFOHEADER structure and set AVStream codec width, height and bits_per_encoded_sample fiel...
Definition: riffdec.c:211
ff_index_guid
const ff_asf_guid ff_index_guid
Definition: wtv_common.c:39
ff_data_guid
const ff_asf_guid ff_data_guid
Definition: wtv_common.c:31
parse_media_type
static AVStream * parse_media_type(AVFormatContext *s, AVStream *st, int sid, ff_asf_guid mediatype, ff_asf_guid subtype, ff_asf_guid formattype, uint64_t size)
parse Media Type structure and populate stream
Definition: wtvdec.c:644
gmtime_r
#define gmtime_r
Definition: time_internal.h:34
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
wtvfile_open_sector
static AVIOContext * wtvfile_open_sector(unsigned first_sector, uint64_t length, int depth, AVFormatContext *s)
Open file.
Definition: wtvdec.c:152
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
WtvContext::index_entries_allocated_size
unsigned int index_entries_allocated_size
Definition: wtvdec.c:334
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:565
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:919
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:753
ff_video_guids
const AVCodecGuid ff_video_guids[]
Definition: wtv_common.c:81
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:86
AVStream::attached_pic
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:952
WtvFile::error
int error
Definition: wtvdec.c:57
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: avcodec.h:659
ff_mediatype_audio
const ff_asf_guid ff_mediatype_audio
Definition: wtv_common.c:41
description
Tag description
Definition: snow.txt:206
read_seek
static int read_seek(AVFormatContext *s, int stream_index, int64_t ts, int flags)
Definition: wtvdec.c:1087
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
buf
void * buf
Definition: avisynth_c.h:766
AVInputFormat
Definition: avformat.h:640
ff_parse_mpeg2_descriptor
int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type, const uint8_t **pp, const uint8_t *desc_list_end, Mp4Descr *mp4_descr, int mp4_descr_count, int pid, MpegTSContext *ts)
Parse an MPEG-2 descriptor.
Definition: mpegts.c:1766
mediasubtype_dvb_subtitle
static const ff_asf_guid mediasubtype_dvb_subtitle
Definition: wtvdec.c:370
avio_get_str16le
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.
FF_ARG_GUID
#define FF_ARG_GUID(g)
Definition: riff.h:105
intreadwrite.h
parse_mpeg1waveformatex
static void parse_mpeg1waveformatex(AVStream *st)
Parse MPEG1WAVEFORMATEX extradata structure.
Definition: wtvdec.c:581
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_timeline_le16
const uint8_t ff_timeline_le16[16]
Definition: wtv_common.c:50
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
g
const char * g
Definition: vf_curves.c:115
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: avcodec.h:564
AVIndexEntry::size
int size
Definition: avformat.h:811
WtvStream::seen_data
int seen_data
Definition: wtvdec.c:321
AVIndexEntry::timestamp
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:802
WtvContext::index_entries
AVIndexEntry * index_entries
Definition: wtvdec.c:332
ff_format_none
const ff_asf_guid ff_format_none
Definition: wtv_common.c:45
AVStream::need_parsing
enum AVStreamParseType need_parsing
Definition: avformat.h:1088
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:90
mediasubtype_dtvccdata
static const ff_asf_guid mediasubtype_dtvccdata
Definition: wtvdec.c:374
key
const char * key
Definition: hwcontext_opencl.c:168
wtvfile_open2
static AVIOContext * wtvfile_open2(AVFormatContext *s, const uint8_t *buf, int buf_size, const uint8_t *filename, int filename_size)
Open file using filename.
Definition: wtvdec.c:256
EVENTID_LanguageSpanningEvent
static const ff_asf_guid EVENTID_LanguageSpanningEvent
Definition: wtvdec.c:340
time_internal.h
ARG_PRETTY_GUID
#define ARG_PRETTY_GUID(g)
Definition: wtvdec.c:42
AVFormatContext
Format I/O context.
Definition: avformat.h:1342
internal.h
WtvFile
Definition: wtvdec.c:50
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1017
WTV_BIGSECTOR_BITS
#define WTV_BIGSECTOR_BITS
Definition: wtv.h:30
NULL
#define NULL
Definition: coverity.c:32
ff_asf_guid
uint8_t ff_asf_guid[16]
Definition: riff.h:92
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1291
ff_asf_metadata_conv
const AVMetadataConv ff_asf_metadata_conv[]
Definition: asf.c:159
EVENTID_TeletextSpanningEvent
static const ff_asf_guid EVENTID_TeletextSpanningEvent
Definition: wtvdec.c:352
mediasubtype_mpeg2_sections
static const ff_asf_guid mediasubtype_mpeg2_sections
Definition: wtvdec.c:376
read_probe
static int read_probe(const AVProbeData *p)
Definition: wtvdec.c:379
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:446
ff_format_cpfilters_processed
const ff_asf_guid ff_format_cpfilters_processed
Definition: wtv_common.c:72
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:934
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3975
ff_wtv_guid
const ff_asf_guid ff_wtv_guid
Definition: wtv_common.c:27
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:769
mediatype_mstvcaption
static const ff_asf_guid mediatype_mstvcaption
Definition: wtvdec.c:366
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
recover
static int recover(WtvContext *wtv, uint64_t broken_pos)
Try to seek over a broken chunk.
Definition: wtvdec.c:767
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3146
WtvFile::nb_sectors
int nb_sectors
number of sectors
Definition: wtvdec.c:55
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
avpriv_set_pts_info
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:4910
size
int size
Definition: twinvq_data.h:11134
EVENTID_CSDescriptorSpanningEvent
static const ff_asf_guid EVENTID_CSDescriptorSpanningEvent
Definition: wtvdec.c:346
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
read_ints
static int read_ints(AVIOContext *pb, uint32_t *data, int count)
read non-zero integers (le32) from input stream
Definition: wtvdec.c:135
ff_format_mpeg2_video
const ff_asf_guid ff_format_mpeg2_video
Definition: wtv_common.c:76
ff_stream2_guid
const ff_asf_guid ff_stream2_guid
Definition: wtv_common.c:64
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:828
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:638
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
ff_codec_guid_get_id
enum AVCodecID ff_codec_guid_get_id(const AVCodecGuid *guids, ff_asf_guid guid)
Definition: riffdec.c:44
ff_DSATTRIB_TRANSPORT_PROPERTIES
const ff_asf_guid ff_DSATTRIB_TRANSPORT_PROPERTIES
Definition: wtv_common.c:60
mediatype_mpeg2_sections
static const ff_asf_guid mediatype_mpeg2_sections
Definition: wtvdec.c:362
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: avcodec.h:225
AVIOContext::opaque
void * opaque
A private pointer, passed to the read/write/seek/...
Definition: avio.h:233
parse_videoinfoheader2
static int parse_videoinfoheader2(AVFormatContext *s, AVStream *st)
parse VIDEOINFOHEADER2 structure
Definition: wtvdec.c:567
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: avcodec.h:216
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
WTV_SECTOR_SIZE
#define WTV_SECTOR_SIZE
Definition: wtv.h:29
WtvContext::pts
int64_t pts
pts for next data chunk
Definition: wtvdec.c:327
read_packet
static int read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: wtvdec.c:1068
read_header
static int read_header(AVFormatContext *s)
Definition: wtvdec.c:968
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
ff_metadata_conv
void ff_metadata_conv(AVDictionary **pm, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:26
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
avio_alloc_context
AVIOContext * avio_alloc_context(unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Allocate and initialize an AVIOContext for buffered I/O.
Definition: aviobuf.c:131
uint8_t
uint8_t
Definition: audio_convert.c:194
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
len
int len
Definition: vorbis_enc_data.h:452
ff_get_wav_header
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
Definition: riffdec.c:91
av_get_packet
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:313
language
Undefined Behavior In the C language
Definition: undefined.txt:3
WtvContext::nb_index_entries
int nb_index_entries
Definition: wtvdec.c:333
AVStream::disposition
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:923
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:829
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:877
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:870
WtvStream
Definition: wtvdec.c:320
PRI_PRETTY_GUID
#define PRI_PRETTY_GUID
Definition: wtvdec.c:40
WTV_SECTOR_BITS
#define WTV_SECTOR_BITS
Definition: wtv.h:28
oledate_to_iso8601
static int oledate_to_iso8601(char *buf, int buf_size, int64_t value)
Convert OLE DATE to ISO-8601 string.
Definition: wtvdec.c:420
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
WtvFile::pb_filesystem
AVIOContext * pb_filesystem
file system (AVFormatContext->pb)
Definition: wtvdec.c:51
SEEK_TO_DATA
@ SEEK_TO_DATA
Definition: wtvdec.c:759
WtvContext::last_valid_pts
int64_t last_valid_pts
latest valid pts, used for interactive seeking
Definition: wtvdec.c:328
avformat.h
ff_table_0_entries_time_le16
const uint8_t ff_table_0_entries_time_le16[40]
Definition: wtv_common.c:56
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:88
ff_SBE2_STREAM_DESC_EVENT
const ff_asf_guid ff_SBE2_STREAM_DESC_EVENT
Definition: wtv_common.c:33
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:871
ff_codec_bmp_tags
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
channel_layout.h
ff_format_videoinfo2
const ff_asf_guid ff_format_videoinfo2
Definition: wtv_common.c:78
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
mode
mode
Definition: ebur128.h:83
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:647
ff_wtv_demuxer
AVInputFormat ff_wtv_demuxer
Definition: wtvdec.c:1135
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:801
ff_index_search_timestamp
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries, int64_t wanted_timestamp, int flags)
Internal version of av_index_search_timestamp.
Definition: utils.c:2065
ff_dir_entry_guid
const ff_asf_guid ff_dir_entry_guid
Definition: wtv_common.c:25
AVPacket::stream_index
int stream_index
Definition: avcodec.h:1479
FF_MEDIASUBTYPE_BASE_GUID
#define FF_MEDIASUBTYPE_BASE_GUID
Definition: riff.h:111
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:331
get_tag
static void get_tag(AVFormatContext *s, AVIOContext *pb, const char *key, int type, int length)
Definition: wtvdec.c:468
seek_by_sector
static int64_t seek_by_sector(AVIOContext *pb, int64_t sector, int64_t offset)
Definition: wtvdec.c:62
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:3999
WTV_PAD8
#define WTV_PAD8(x)
Definition: wtv.h:31
AVIOContext::buffer
unsigned char * buffer
Start of the buffer.
Definition: avio.h:226
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
ff_find_stream_index
int ff_find_stream_index(AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:4994
read_close
static int read_close(AVFormatContext *s)
Definition: wtvdec.c:1127
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
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
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4059
avio_rl64
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:777
ff_codec_wav_guids
const AVCodecGuid ff_codec_wav_guids[]
Definition: riff.c:610
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:791
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
ff_table_0_entries_legacy_attrib_le16
const uint8_t ff_table_0_entries_legacy_attrib_le16[58]
Definition: wtv_common.c:54
new_stream
static AVStream * new_stream(AVFormatContext *s, AVStream *st, int sid, int codec_type)
Initialise stream.
Definition: wtvdec.c:610
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3986
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
wtvfile_open
#define wtvfile_open(s, buf, buf_size, filename)
Definition: wtvdec.c:301
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
length
const char int length
Definition: avisynth_c.h:860
WtvFile::length
int64_t length
Definition: wtvdec.c:59
ff_metadata_guid
const ff_asf_guid ff_metadata_guid
Definition: wtv_common.c:62
wtv.h
mediatype_mpeg2_pes
static const ff_asf_guid mediatype_mpeg2_pes
Definition: wtvdec.c:364
snprintf
#define snprintf
Definition: snprintf.h:34
AV_CODEC_ID_MP1
@ AV_CODEC_ID_MP1
Definition: avcodec.h:606
get_attachment
static void get_attachment(AVFormatContext *s, AVIOContext *pb, int length)
Definition: wtvdec.c:432
FF_PRI_GUID
#define FF_PRI_GUID
Definition: riff.h:101
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:358