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