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