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