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