FFmpeg
wtvdec.c
Go to the documentation of this file.
1 /*
2  * Windows Television (WTV) demuxer
3  * Copyright (c) 2010-2011 Peter Ross <pross@xvid.org>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Windows Television (WTV) demuxer
25  * @author Peter Ross <pross@xvid.org>
26  */
27 
28 #include <inttypes.h>
29 
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/intfloat.h"
34 #include "avformat.h"
35 #include "internal.h"
36 #include "wtv.h"
37 #include "mpegts.h"
38 
39 /* Macros for formatting GUIDs */
40 #define PRI_PRETTY_GUID \
41  "%08"PRIx32"-%04"PRIx16"-%04"PRIx16"-%02x%02x%02x%02x%02x%02x%02x%02x"
42 #define ARG_PRETTY_GUID(g) \
43  AV_RL32(g),AV_RL16(g+4),AV_RL16(g+6),g[8],g[9],g[10],g[11],g[12],g[13],g[14],g[15]
44 #define LEN_PRETTY_GUID 34
45 
46 /*
47  * File system routines
48  */
49 
50 typedef struct WtvFile {
51  AVIOContext *pb_filesystem; /**< file system (AVFormatContext->pb) */
52 
53  int sector_bits; /**< sector shift bits; used to convert sector number into pb_filesystem offset */
54  uint32_t *sectors; /**< file allocation table */
55  int nb_sectors; /**< number of sectors */
56 
57  int error;
58  int64_t position;
59  int64_t length;
60 } WtvFile;
61 
62 static int64_t seek_by_sector(AVIOContext *pb, int64_t sector, int64_t offset)
63 {
64  return avio_seek(pb, (sector << WTV_SECTOR_BITS) + offset, SEEK_SET);
65 }
66 
67 /**
68  * @return bytes read, AVERROR_EOF on end of file, or <0 on error
69  */
70 static int wtvfile_read_packet(void *opaque, uint8_t *buf, int buf_size)
71 {
72  WtvFile *wf = opaque;
73  AVIOContext *pb = wf->pb_filesystem;
74  int nread = 0, n = 0;
75 
76  if (wf->error || pb->error)
77  return -1;
78  if (wf->position >= wf->length || avio_feof(pb))
79  return AVERROR_EOF;
80 
81  buf_size = FFMIN(buf_size, wf->length - wf->position);
82  while(nread < buf_size) {
83  int remaining_in_sector = (1 << wf->sector_bits) - (wf->position & ((1 << wf->sector_bits) - 1));
84  int read_request = FFMIN(buf_size - nread, remaining_in_sector);
85 
86  n = avio_read(pb, buf, read_request);
87  if (n <= 0)
88  break;
89  nread += n;
90  buf += n;
91  wf->position += n;
92  if (n == remaining_in_sector) {
93  int i = wf->position >> wf->sector_bits;
94  if (i >= wf->nb_sectors ||
95  (wf->sectors[i] != wf->sectors[i - 1] + (1 << (wf->sector_bits - WTV_SECTOR_BITS)) &&
96  seek_by_sector(pb, wf->sectors[i], 0) < 0)) {
97  wf->error = 1;
98  break;
99  }
100  }
101  }
102  return nread ? nread : n;
103 }
104 
105 /**
106  * @return position (or file length)
107  */
108 static int64_t wtvfile_seek(void *opaque, int64_t offset, int whence)
109 {
110  WtvFile *wf = opaque;
111  AVIOContext *pb = wf->pb_filesystem;
112 
113  if (whence == AVSEEK_SIZE)
114  return wf->length;
115  else if (whence == SEEK_CUR)
116  offset = wf->position + offset;
117  else if (whence == SEEK_END)
118  offset = wf->length;
119 
120  wf->error = offset < 0 || offset >= wf->length ||
121  seek_by_sector(pb, wf->sectors[offset >> wf->sector_bits],
122  offset & ((1 << wf->sector_bits) - 1)) < 0;
123  wf->position = offset;
124  return offset;
125 }
126 
127 /**
128  * read non-zero integers (le32) from input stream
129  * @param pb
130  * @param[out] data destination
131  * @param count maximum number of integers to read
132  * @return total number of integers read
133  */
134 static int read_ints(AVIOContext *pb, uint32_t *data, int count)
135 {
136  int i, total = 0;
137  for (i = 0; i < count; i++) {
138  if ((data[total] = avio_rl32(pb)))
139  total++;
140  }
141  return total;
142 }
143 
144 /**
145  * Open file
146  * @param first_sector First sector
147  * @param length Length of file (bytes)
148  * @param depth File allocation table depth
149  * @return NULL on error
150  */
152 {
153  AVIOContext *pb;
154  WtvFile *wf;
155  uint8_t *buffer;
156  int64_t size;
157 
158  if (seek_by_sector(s->pb, first_sector, 0) < 0)
159  return NULL;
160 
161  wf = av_mallocz(sizeof(WtvFile));
162  if (!wf)
163  return NULL;
164 
165  if (depth == 0) {
166  wf->sectors = av_malloc(sizeof(uint32_t));
167  if (!wf->sectors) {
168  av_free(wf);
169  return NULL;
170  }
171  wf->sectors[0] = first_sector;
172  wf->nb_sectors = 1;
173  } else if (depth == 1) {
175  if (!wf->sectors) {
176  av_free(wf);
177  return NULL;
178  }
179  wf->nb_sectors = read_ints(s->pb, wf->sectors, WTV_SECTOR_SIZE / 4);
180  } else if (depth == 2) {
181  uint32_t sectors1[WTV_SECTOR_SIZE / 4];
182  int nb_sectors1 = read_ints(s->pb, sectors1, WTV_SECTOR_SIZE / 4);
183  int i;
184 
185  wf->sectors = av_malloc_array(nb_sectors1, 1 << WTV_SECTOR_BITS);
186  if (!wf->sectors) {
187  av_free(wf);
188  return NULL;
189  }
190  wf->nb_sectors = 0;
191  for (i = 0; i < nb_sectors1; i++) {
192  if (seek_by_sector(s->pb, sectors1[i], 0) < 0)
193  break;
194  wf->nb_sectors += read_ints(s->pb, wf->sectors + i * WTV_SECTOR_SIZE / 4, WTV_SECTOR_SIZE / 4);
195  }
196  } else {
197  av_log(s, AV_LOG_ERROR, "unsupported file allocation table depth (0x%x)\n", depth);
198  av_free(wf);
199  return NULL;
200  }
201  wf->sector_bits = length & (1ULL<<63) ? WTV_SECTOR_BITS : WTV_BIGSECTOR_BITS;
202 
203  if (!wf->nb_sectors) {
204  av_freep(&wf->sectors);
205  av_freep(&wf);
206  return NULL;
207  }
208 
209  size = avio_size(s->pb);
210  if (size >= 0 && (int64_t)wf->sectors[wf->nb_sectors - 1] << WTV_SECTOR_BITS > size)
211  av_log(s, AV_LOG_WARNING, "truncated file\n");
212 
213  /* check length */
214  length &= 0xFFFFFFFFFFFF;
215  if (length > ((int64_t)wf->nb_sectors << wf->sector_bits)) {
216  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);
217  length = (int64_t)wf->nb_sectors << wf->sector_bits;
218  }
219  wf->length = length;
220 
221  /* seek to initial sector */
222  wf->position = 0;
223  if (seek_by_sector(s->pb, wf->sectors[0], 0) < 0) {
224  av_freep(&wf->sectors);
225  av_freep(&wf);
226  return NULL;
227  }
228 
229  wf->pb_filesystem = s->pb;
230  buffer = av_malloc(1 << wf->sector_bits);
231  if (!buffer) {
232  av_freep(&wf->sectors);
233  av_freep(&wf);
234  return NULL;
235  }
236 
237  pb = avio_alloc_context(buffer, 1 << wf->sector_bits, 0, wf,
239  if (!pb) {
240  av_freep(&buffer);
241  av_freep(&wf->sectors);
242  av_freep(&wf);
243  }
244  return pb;
245 }
246 
247 /**
248  * Open file using filename
249  * @param[in] buf directory buffer
250  * @param buf_size directory buffer size
251  * @param[in] filename
252  * @param filename_size size of filename
253  * @return NULL on error
254  */
255 static AVIOContext * wtvfile_open2(AVFormatContext *s, const uint8_t *buf, int buf_size, const uint8_t *filename, int filename_size)
256 {
257  const uint8_t *buf_end = buf + buf_size;
258 
259  while(buf + 48 <= buf_end) {
260  int dir_length, name_size, first_sector, depth;
261  uint64_t file_length;
262  const uint8_t *name;
263  if (ff_guidcmp(buf, ff_dir_entry_guid)) {
264  av_log(s, AV_LOG_ERROR, "unknown guid "FF_PRI_GUID", expected dir_entry_guid; "
265  "remaining directory entries ignored\n", FF_ARG_GUID(buf));
266  break;
267  }
268  dir_length = AV_RL16(buf + 16);
269  file_length = AV_RL64(buf + 24);
270  name_size = 2 * AV_RL32(buf + 32);
271  if (name_size < 0) {
272  av_log(s, AV_LOG_ERROR,
273  "bad filename length, remaining directory entries ignored\n");
274  break;
275  }
276  if (dir_length == 0) {
277  av_log(s, AV_LOG_ERROR,
278  "bad dir length, remaining directory entries ignored\n");
279  break;
280  }
281  if (48 + (int64_t)name_size > buf_end - buf) {
282  av_log(s, AV_LOG_ERROR, "filename exceeds buffer size; remaining directory entries ignored\n");
283  break;
284  }
285  first_sector = AV_RL32(buf + 40 + name_size);
286  depth = AV_RL32(buf + 44 + name_size);
287 
288  /* compare file name; test optional null terminator */
289  name = buf + 40;
290  if (name_size >= filename_size &&
291  !memcmp(name, filename, filename_size) &&
292  (name_size < filename_size + 2 || !AV_RN16(name + filename_size)))
293  return wtvfile_open_sector(first_sector, file_length, depth, s);
294 
295  buf += dir_length;
296  }
297  return NULL;
298 }
299 
300 #define wtvfile_open(s, buf, buf_size, filename) \
301  wtvfile_open2(s, buf, buf_size, filename, sizeof(filename))
302 
303 /**
304  * Close file opened with wtvfile_open_sector(), or wtv_open()
305  */
306 static void wtvfile_close(AVIOContext *pb)
307 {
308  WtvFile *wf = pb->opaque;
309  av_freep(&wf->sectors);
310  av_freep(&pb->opaque);
311  av_freep(&pb->buffer);
312  avio_context_free(&pb);
313 }
314 
315 /*
316  * Main demuxer
317  */
318 
319 typedef struct WtvStream {
321 } WtvStream;
322 
323 typedef struct WtvContext {
324  AVIOContext *pb; /**< timeline file */
325  int64_t epoch;
326  int64_t pts; /**< pts for next data chunk */
327  int64_t last_valid_pts; /**< latest valid pts, used for interactive seeking */
328 
329  /* maintain private seek index, as the AVIndexEntry->pos is relative to the
330  start of the 'timeline' file, not the file system (AVFormatContext->pb) */
334 } WtvContext;
335 
336 /* WTV GUIDs */
338  {0x48,0xC0,0xCE,0x5D,0xB9,0xD0,0x63,0x41,0x87,0x2C,0x4F,0x32,0x22,0x3B,0xE8,0x8A};
340  {0x6D,0x66,0x92,0xE2,0x02,0x9C,0x8D,0x44,0xAA,0x8D,0x78,0x1A,0x93,0xFD,0xC3,0x95};
342  {0x1C,0xD4,0x7B,0x10,0xDA,0xA6,0x91,0x46,0x83,0x69,0x11,0xB2,0xCD,0xAA,0x28,0x8E};
344  {0xE6,0xA2,0xB4,0x3A,0x47,0x42,0x34,0x4B,0x89,0x6C,0x30,0xAF,0xA5,0xD2,0x1C,0x24};
346  {0xD9,0x79,0xE7,0xEf,0xF0,0x97,0x86,0x47,0x80,0x0D,0x95,0xCF,0x50,0x5D,0xDC,0x66};
348  {0xC4,0xE1,0xD4,0x4B,0xA1,0x90,0x09,0x41,0x82,0x36,0x27,0xF0,0x0E,0x7D,0xCC,0x5B};
350  {0x68,0xAB,0xF1,0xCA,0x53,0xE1,0x41,0x4D,0xA6,0xB3,0xA7,0xC9,0x98,0xDB,0x75,0xEE};
352  {0x50,0xD9,0x99,0x95,0x33,0x5F,0x17,0x46,0xAF,0x7C,0x1E,0x54,0xB5,0x10,0xDA,0xA3};
354  {0xBE,0xBF,0x1C,0x50,0x49,0xB8,0xCE,0x42,0x9B,0xE9,0x3D,0xB8,0x69,0xFB,0x82,0xB3};
355 
356 /* Windows media GUIDs */
357 
358 /* Media types */
360  {0x81,0xEB,0x36,0xE4,0x4F,0x52,0xCE,0x11,0x9F,0x53,0x00,0x20,0xAF,0x0B,0xA7,0x70};
362  {0x6C,0x17,0x5F,0x45,0x06,0x4B,0xCE,0x47,0x9A,0xEF,0x8C,0xAE,0xF7,0x3D,0xF7,0xB5};
364  {0x20,0x80,0x6D,0xE0,0x46,0xDB,0xCF,0x11,0xB4,0xD1,0x00,0x80,0x5F,0x6C,0xBB,0xEA};
366  {0x89,0x8A,0x8B,0xB8,0x49,0xB0,0x80,0x4C,0xAD,0xCF,0x58,0x98,0x98,0x5E,0x22,0xC1};
367 
368 /* Media subtypes */
370  {0xC3,0xCB,0xFF,0x34,0xB3,0xD5,0x71,0x41,0x90,0x02,0xD4,0xC6,0x03,0x01,0x69,0x7F};
372  {0xE3,0x76,0x2A,0xF7,0x0A,0xEB,0xD0,0x11,0xAC,0xE4,0x00,0x00,0xC0,0xCC,0x16,0xBA};
374  {0xAA,0xDD,0x2A,0xF5,0xF0,0x36,0xF5,0x43,0x95,0xEA,0x6D,0x86,0x64,0x84,0x26,0x2A};
376  {0x79,0x85,0x9F,0x4A,0xF8,0x6B,0x92,0x43,0x8A,0x6D,0xD2,0xDD,0x09,0xFA,0x78,0x61};
377 
378 static int read_probe(const AVProbeData *p)
379 {
380  return ff_guidcmp(p->buf, ff_wtv_guid) ? 0 : AVPROBE_SCORE_MAX;
381 }
382 
383 /**
384  * Convert win32 FILETIME to ISO-8601 string
385  * @return <0 on error
386  */
387 static int filetime_to_iso8601(char *buf, int buf_size, int64_t value)
388 {
389  time_t t = (value / 10000000LL) - 11644473600LL;
390  struct tm tmbuf;
391  struct tm *tm = gmtime_r(&t, &tmbuf);
392  if (!tm)
393  return -1;
394  if (!strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", tm))
395  return -1;
396  return 0;
397 }
398 
399 /**
400  * Convert crazy time (100ns since 1 Jan 0001) to ISO-8601 string
401  * @return <0 on error
402  */
403 static int crazytime_to_iso8601(char *buf, int buf_size, int64_t value)
404 {
405  time_t t = (value / 10000000LL) - 719162LL*86400LL;
406  struct tm tmbuf;
407  struct tm *tm = gmtime_r(&t, &tmbuf);
408  if (!tm)
409  return -1;
410  if (!strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", tm))
411  return -1;
412  return 0;
413 }
414 
415 /**
416  * Convert OLE DATE to ISO-8601 string
417  * @return <0 on error
418  */
419 static int oledate_to_iso8601(char *buf, int buf_size, int64_t value)
420 {
421  time_t t = (av_int2double(value) - 25569.0) * 86400;
422  struct tm tmbuf;
423  struct tm *tm= gmtime_r(&t, &tmbuf);
424  if (!tm)
425  return -1;
426  if (!strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", tm))
427  return -1;
428  return 0;
429 }
430 
432 {
433  char mime[1024];
434  char description[1024];
435  unsigned int filesize;
436  AVStream *st;
437  int ret;
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  st = avformat_new_stream(s, NULL);
451  if (!st)
452  goto done;
453  av_dict_set(&st->metadata, "title", description, 0);
456  st->id = -1;
457  ret = av_get_packet(pb, &st->attached_pic, filesize);
458  if (ret < 0)
459  goto done;
460  st->attached_pic.stream_index = st->index;
463 done:
464  avio_seek(pb, pos + length, SEEK_SET);
465 }
466 
467 static void get_tag(AVFormatContext *s, AVIOContext *pb, const char *key, int type, int length)
468 {
469  int buf_size;
470  char *buf;
471 
472  if (!strcmp(key, "WM/MediaThumbType")) {
473  avio_skip(pb, length);
474  return;
475  }
476 
477  buf_size = FFMAX(2*length, LEN_PRETTY_GUID) + 1;
478  buf = av_malloc(buf_size);
479  if (!buf)
480  return;
481 
482  if (type == 0 && length == 4) {
483  snprintf(buf, buf_size, "%u", avio_rl32(pb));
484  } else if (type == 1) {
485  avio_get_str16le(pb, length, buf, buf_size);
486  if (!strlen(buf)) {
487  av_free(buf);
488  return;
489  }
490  } else if (type == 3 && length == 4) {
491  strcpy(buf, avio_rl32(pb) ? "true" : "false");
492  } else if (type == 4 && length == 8) {
493  int64_t num = avio_rl64(pb);
494  if (!strcmp(key, "WM/EncodingTime") ||
495  !strcmp(key, "WM/MediaOriginalBroadcastDateTime")) {
496  if (filetime_to_iso8601(buf, buf_size, num) < 0) {
497  av_free(buf);
498  return;
499  }
500  } else if (!strcmp(key, "WM/WMRVEncodeTime") ||
501  !strcmp(key, "WM/WMRVEndTime")) {
502  if (crazytime_to_iso8601(buf, buf_size, num) < 0) {
503  av_free(buf);
504  return;
505  }
506  } else if (!strcmp(key, "WM/WMRVExpirationDate")) {
507  if (oledate_to_iso8601(buf, buf_size, num) < 0 ) {
508  av_free(buf);
509  return;
510  }
511  } else if (!strcmp(key, "WM/WMRVBitrate"))
512  snprintf(buf, buf_size, "%f", av_int2double(num));
513  else
514  snprintf(buf, buf_size, "%"PRIi64, num);
515  } else if (type == 5 && length == 2) {
516  snprintf(buf, buf_size, "%u", avio_rl16(pb));
517  } else if (type == 6 && length == 16) {
518  ff_asf_guid guid;
519  avio_read(pb, guid, 16);
520  snprintf(buf, buf_size, PRI_PRETTY_GUID, ARG_PRETTY_GUID(guid));
521  } else if (type == 2 && !strcmp(key, "WM/Picture")) {
522  get_attachment(s, pb, length);
523  av_freep(&buf);
524  return;
525  } else {
526  av_freep(&buf);
527  av_log(s, AV_LOG_WARNING, "unsupported metadata entry; key:%s, type:%d, length:0x%x\n", key, type, length);
528  avio_skip(pb, length);
529  return;
530  }
531 
532  av_dict_set(&s->metadata, key, buf, 0);
533  av_freep(&buf);
534 }
535 
536 /**
537  * Parse metadata entries
538  */
540 {
541  ff_asf_guid guid;
542  int length, type;
543  while(!avio_feof(pb)) {
544  char key[1024];
545  ff_get_guid(pb, &guid);
546  type = avio_rl32(pb);
547  length = avio_rl32(pb);
548  if (!length)
549  break;
550  if (ff_guidcmp(&guid, ff_metadata_guid)) {
551  av_log(s, AV_LOG_WARNING, "unknown guid "FF_PRI_GUID", expected metadata_guid; "
552  "remaining metadata entries ignored\n", FF_ARG_GUID(guid));
553  break;
554  }
555  avio_get_str16le(pb, INT_MAX, key, sizeof(key));
556  get_tag(s, pb, key, type, length);
557  }
558 
560 }
561 
562 /**
563  * parse VIDEOINFOHEADER2 structure
564  * @return bytes consumed
565  */
567 {
568  WtvContext *wtv = s->priv_data;
569  AVIOContext *pb = wtv->pb;
570 
571  avio_skip(pb, 72); // picture aspect ratio is unreliable
572  st->codecpar->codec_tag = ff_get_bmp_header(pb, st, NULL);
573 
574  return 72 + 40;
575 }
576 
577 /**
578  * Parse MPEG1WAVEFORMATEX extradata structure
579  */
581 {
582  /* fwHeadLayer */
583  switch (AV_RL16(st->codecpar->extradata)) {
584  case 0x0001 : st->codecpar->codec_id = AV_CODEC_ID_MP1; break;
585  case 0x0002 : st->codecpar->codec_id = AV_CODEC_ID_MP2; break;
586  case 0x0004 : st->codecpar->codec_id = AV_CODEC_ID_MP3; break;
587  }
588 
589  st->codecpar->bit_rate = AV_RL32(st->codecpar->extradata + 2); /* dwHeadBitrate */
590 
591  /* dwHeadMode */
592  switch (AV_RL16(st->codecpar->extradata + 6)) {
593  case 1 :
594  case 2 :
595  case 4 : st->codecpar->channels = 2;
597  break;
598  case 8 : st->codecpar->channels = 1;
600  break;
601  }
602 }
603 
604 /**
605  * Initialise stream
606  * @param st Stream to initialise, or NULL to create and initialise new stream
607  * @return NULL on error
608  */
610 {
611  if (st) {
612  if (st->codecpar->extradata) {
613  av_freep(&st->codecpar->extradata);
614  st->codecpar->extradata_size = 0;
615  }
616  } else {
617  WtvStream *wst = av_mallocz(sizeof(WtvStream));
618  if (!wst)
619  return NULL;
620  st = avformat_new_stream(s, NULL);
621  if (!st) {
622  av_free(wst);
623  return NULL;
624  }
625  st->id = sid;
626  st->priv_data = wst;
627  }
630  avpriv_set_pts_info(st, 64, 1, 10000000);
631  return st;
632 }
633 
634 /**
635  * parse Media Type structure and populate stream
636  * @param st Stream, or NULL to create new stream
637  * @param mediatype Mediatype GUID
638  * @param subtype Subtype GUID
639  * @param formattype Format GUID
640  * @param size Size of format buffer
641  * @return NULL on error
642  */
644  ff_asf_guid mediatype, ff_asf_guid subtype,
645  ff_asf_guid formattype, uint64_t size)
646 {
647  WtvContext *wtv = s->priv_data;
648  AVIOContext *pb = wtv->pb;
651  ff_asf_guid actual_subtype;
652  ff_asf_guid actual_formattype;
653 
654  if (size < 32) {
655  av_log(s, AV_LOG_WARNING, "format buffer size underflow\n");
656  avio_skip(pb, size);
657  return NULL;
658  }
659 
660  avio_skip(pb, size - 32);
661  ff_get_guid(pb, &actual_subtype);
662  ff_get_guid(pb, &actual_formattype);
663  avio_seek(pb, -size, SEEK_CUR);
664 
665  st = parse_media_type(s, st, sid, mediatype, actual_subtype, actual_formattype, size - 32);
666  avio_skip(pb, 32);
667  return st;
668  } else if (!ff_guidcmp(mediatype, ff_mediatype_audio)) {
669  st = new_stream(s, st, sid, AVMEDIA_TYPE_AUDIO);
670  if (!st)
671  return NULL;
672  if (!ff_guidcmp(formattype, ff_format_waveformatex)) {
673  int ret = ff_get_wav_header(s, pb, st->codecpar, size, 0);
674  if (ret < 0)
675  return NULL;
676  } else {
677  if (ff_guidcmp(formattype, ff_format_none))
678  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
679  avio_skip(pb, size);
680  }
681 
682  if (!memcmp(subtype + 4, (const uint8_t[]){FF_MEDIASUBTYPE_BASE_GUID}, 12)) {
684  } else if (!ff_guidcmp(subtype, mediasubtype_mpeg1payload)) {
685  if (st->codecpar->extradata && st->codecpar->extradata_size >= 22)
687  else
688  av_log(s, AV_LOG_WARNING, "MPEG1WAVEFORMATEX underflow\n");
689  } else {
691  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
692  av_log(s, AV_LOG_WARNING, "unknown subtype:"FF_PRI_GUID"\n", FF_ARG_GUID(subtype));
693  }
694  return st;
695  } else if (!ff_guidcmp(mediatype, ff_mediatype_video)) {
696  st = new_stream(s, st, sid, AVMEDIA_TYPE_VIDEO);
697  if (!st)
698  return NULL;
699  if (!ff_guidcmp(formattype, ff_format_videoinfo2)) {
700  int consumed = parse_videoinfoheader2(s, st);
701  avio_skip(pb, FFMAX(size - consumed, 0));
702  } else if (!ff_guidcmp(formattype, ff_format_mpeg2_video)) {
703  uint64_t consumed = parse_videoinfoheader2(s, st);
704  /* ignore extradata; files produced by windows media center contain meaningless mpeg1 sequence header */
705  avio_skip(pb, FFMAX(size - consumed, 0));
706  } else {
707  if (ff_guidcmp(formattype, ff_format_none))
708  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
709  avio_skip(pb, size);
710  }
711 
712  if (!memcmp(subtype + 4, (const uint8_t[]){FF_MEDIASUBTYPE_BASE_GUID}, 12)) {
714  } else {
716  }
717  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
718  av_log(s, AV_LOG_WARNING, "unknown subtype:"FF_PRI_GUID"\n", FF_ARG_GUID(subtype));
719  return st;
720  } else if (!ff_guidcmp(mediatype, mediatype_mpeg2_pes) &&
722  st = new_stream(s, st, sid, AVMEDIA_TYPE_SUBTITLE);
723  if (!st)
724  return NULL;
725  if (ff_guidcmp(formattype, ff_format_none))
726  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
727  avio_skip(pb, size);
729  return st;
730  } else if (!ff_guidcmp(mediatype, mediatype_mstvcaption) &&
732  st = new_stream(s, st, sid, AVMEDIA_TYPE_SUBTITLE);
733  if (!st)
734  return NULL;
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);
739  return st;
740  } else if (!ff_guidcmp(mediatype, mediatype_mpeg2_sections) &&
742  if (ff_guidcmp(formattype, ff_format_none))
743  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
744  avio_skip(pb, size);
745  return NULL;
746  }
747 
748  av_log(s, AV_LOG_WARNING, "unknown media type, mediatype:"FF_PRI_GUID
749  ", subtype:"FF_PRI_GUID", formattype:"FF_PRI_GUID"\n",
750  FF_ARG_GUID(mediatype), FF_ARG_GUID(subtype), FF_ARG_GUID(formattype));
751  avio_skip(pb, size);
752  return NULL;
753 }
754 
755 enum {
758 };
759 
760 /**
761  * Try to seek over a broken chunk
762  * @return <0 on error
763  */
764 static int recover(WtvContext *wtv, uint64_t broken_pos)
765 {
766  AVIOContext *pb = wtv->pb;
767  int i;
768  for (i = 0; i < wtv->nb_index_entries; i++) {
769  if (wtv->index_entries[i].pos > broken_pos) {
770  int64_t ret = avio_seek(pb, wtv->index_entries[i].pos, SEEK_SET);
771  if (ret < 0)
772  return ret;
773  wtv->pts = wtv->index_entries[i].timestamp;
774  return 0;
775  }
776  }
777  return AVERROR(EIO);
778 }
779 
780 /**
781  * Parse WTV chunks
782  * @param mode SEEK_TO_DATA or SEEK_TO_PTS
783  * @param seekts timestamp
784  * @param[out] len_ptr Length of data chunk
785  * @return stream index of data chunk, or <0 on error
786  */
787 static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_ptr)
788 {
789  WtvContext *wtv = s->priv_data;
790  AVIOContext *pb = wtv->pb;
791  while (!avio_feof(pb)) {
792  ff_asf_guid g;
793  int len, sid, consumed;
794 
795  ff_get_guid(pb, &g);
796  len = avio_rl32(pb);
797  if (len < 32) {
798  int ret;
799  if (avio_feof(pb))
800  return AVERROR_EOF;
801  av_log(s, AV_LOG_WARNING, "encountered broken chunk\n");
802  if ((ret = recover(wtv, avio_tell(pb) - 20)) < 0)
803  return ret;
804  continue;
805  }
806  sid = avio_rl32(pb) & 0x7FFF;
807  avio_skip(pb, 8);
808  consumed = 32;
809 
811  if (ff_find_stream_index(s, sid) < 0) {
812  ff_asf_guid mediatype, subtype, formattype;
813  int size;
814  avio_skip(pb, 28);
815  ff_get_guid(pb, &mediatype);
816  ff_get_guid(pb, &subtype);
817  avio_skip(pb, 12);
818  ff_get_guid(pb, &formattype);
819  size = avio_rl32(pb);
820  parse_media_type(s, 0, sid, mediatype, subtype, formattype, size);
821  consumed += 92 + size;
822  }
823  } else if (!ff_guidcmp(g, ff_stream2_guid)) {
824  int stream_index = ff_find_stream_index(s, sid);
825  if (stream_index >= 0 && s->streams[stream_index]->priv_data && !((WtvStream*)s->streams[stream_index]->priv_data)->seen_data) {
826  ff_asf_guid mediatype, subtype, formattype;
827  int size;
828  avio_skip(pb, 12);
829  ff_get_guid(pb, &mediatype);
830  ff_get_guid(pb, &subtype);
831  avio_skip(pb, 12);
832  ff_get_guid(pb, &formattype);
833  size = avio_rl32(pb);
834  parse_media_type(s, s->streams[stream_index], sid, mediatype, subtype, formattype, size);
835  consumed += 76 + size;
836  }
843  int stream_index = ff_find_stream_index(s, sid);
844  if (stream_index >= 0) {
845  AVStream *st = s->streams[stream_index];
846  uint8_t buf[258];
847  const uint8_t *pbuf = buf;
848  int buf_size;
849 
850  avio_skip(pb, 8);
851  consumed += 8;
854  avio_skip(pb, 6);
855  consumed += 6;
856  }
857 
858  buf_size = FFMIN(len - consumed, sizeof(buf));
859  avio_read(pb, buf, buf_size);
860  consumed += buf_size;
861  ff_parse_mpeg2_descriptor(s, st, 0, &pbuf, buf + buf_size, NULL, 0, 0, NULL);
862  }
863  } else if (!ff_guidcmp(g, EVENTID_AudioTypeSpanningEvent)) {
864  int stream_index = ff_find_stream_index(s, sid);
865  if (stream_index >= 0) {
866  AVStream *st = s->streams[stream_index];
867  int audio_type;
868  avio_skip(pb, 8);
869  audio_type = avio_r8(pb);
870  if (audio_type == 2)
872  else if (audio_type == 3)
874  consumed += 9;
875  }
877  int stream_index = ff_find_stream_index(s, sid);
878  if (stream_index >= 0) {
879  avio_skip(pb, 12);
880  if (avio_rl32(pb))
881  av_log(s, AV_LOG_WARNING, "DVB scrambled stream detected (st:%d), decoding will likely fail\n", stream_index);
882  consumed += 16;
883  }
884  } else if (!ff_guidcmp(g, EVENTID_LanguageSpanningEvent)) {
885  int stream_index = ff_find_stream_index(s, sid);
886  if (stream_index >= 0) {
887  AVStream *st = s->streams[stream_index];
888  uint8_t language[4];
889  avio_skip(pb, 12);
890  avio_read(pb, language, 3);
891  if (language[0]) {
892  language[3] = 0;
893  av_dict_set(&st->metadata, "language", language, 0);
894  if (!strcmp(language, "nar") || !strcmp(language, "NAR"))
896  }
897  consumed += 15;
898  }
899  } else if (!ff_guidcmp(g, ff_timestamp_guid)) {
900  int stream_index = ff_find_stream_index(s, sid);
901  if (stream_index >= 0) {
902  avio_skip(pb, 8);
903  wtv->pts = avio_rl64(pb);
904  consumed += 16;
905  if (wtv->pts == -1)
906  wtv->pts = AV_NOPTS_VALUE;
907  else {
908  wtv->last_valid_pts = wtv->pts;
909  if (wtv->epoch == AV_NOPTS_VALUE || wtv->pts < wtv->epoch)
910  wtv->epoch = wtv->pts;
911  if (mode == SEEK_TO_PTS && wtv->pts >= seekts) {
912  avio_skip(pb, WTV_PAD8(len) - consumed);
913  return 0;
914  }
915  }
916  }
917  } else if (!ff_guidcmp(g, ff_data_guid)) {
918  int stream_index = ff_find_stream_index(s, sid);
919  if (mode == SEEK_TO_DATA && stream_index >= 0 && len > 32 && s->streams[stream_index]->priv_data) {
920  WtvStream *wst = s->streams[stream_index]->priv_data;
921  wst->seen_data = 1;
922  if (len_ptr) {
923  *len_ptr = len;
924  }
925  return stream_index;
926  }
927  } 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})) {
928  int stream_index = ff_find_stream_index(s, sid);
929  if (stream_index >= 0)
930  av_log(s, AV_LOG_WARNING, "encrypted stream detected (st:%d), decoding will likely fail\n", stream_index);
931  } else if (
932  !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}) ||
933  !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}) ||
934  !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}) ||
935  !ff_guidcmp(g, /* DSATTRIB_TRANSPORT_PROPERTIES */ ff_DSATTRIB_TRANSPORT_PROPERTIES) ||
936  !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}) ||
937  !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}) ||
938  !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}) ||
939  !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}) ||
940  !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}) ||
941  !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}) ||
942  !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}) ||
943  !ff_guidcmp(g, (const ff_asf_guid){0x1E,0xBE,0xC3,0xC5,0x43,0x92,0xDC,0x11,0x85,0xE5,0x00,0x12,0x3F,0x6F,0x73,0xB9}) ||
944  !ff_guidcmp(g, (const ff_asf_guid){0x3B,0x86,0xA2,0xB1,0xEB,0x1E,0xC3,0x44,0x8C,0x88,0x1C,0xA3,0xFF,0xE3,0xE7,0x6A}) ||
945  !ff_guidcmp(g, (const ff_asf_guid){0x4E,0x7F,0x4C,0x5B,0xC4,0xD0,0x38,0x4B,0xA8,0x3E,0x21,0x7F,0x7B,0xBF,0x52,0xE7}) ||
946  !ff_guidcmp(g, (const ff_asf_guid){0x63,0x36,0xEB,0xFE,0xA1,0x7E,0xD9,0x11,0x83,0x08,0x00,0x07,0xE9,0x5E,0xAD,0x8D}) ||
947  !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, ff_index_guid) ||
949  !ff_guidcmp(g, ff_sync_guid) ||
951  !ff_guidcmp(g, (const ff_asf_guid){0xF7,0x10,0x02,0xB9,0xEE,0x7C,0xED,0x4E,0xBD,0x7F,0x05,0x40,0x35,0x86,0x18,0xA1})) {
952  //ignore known guids
953  } else
954  av_log(s, AV_LOG_WARNING, "unsupported chunk:"FF_PRI_GUID"\n", FF_ARG_GUID(g));
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 
1089  if ((flags & AVSEEK_FLAG_FRAME) || (flags & AVSEEK_FLAG_BYTE))
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 };
const uint8_t ff_table_0_entries_time_le16[40]
Definition: wtv_common.c:56
static int recover(WtvContext *wtv, uint64_t broken_pos)
Try to seek over a broken chunk.
Definition: wtvdec.c:764
#define WTV_SECTOR_BITS
Definition: wtv.h:28
const ff_asf_guid ff_metadata_guid
Definition: wtv_common.c:62
static const ff_asf_guid mediasubtype_mpeg2_sections
Definition: wtvdec.c:375
#define NULL
Definition: coverity.c:32
const ff_asf_guid ff_SBE2_STREAM_DESC_EVENT
Definition: wtv_common.c:33
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:346
#define WTV_BIGSECTOR_BITS
Definition: wtv.h:30
static const ff_asf_guid EVENTID_CSDescriptorSpanningEvent
Definition: wtvdec.c:345
int64_t pts
pts for next data chunk
Definition: wtvdec.c:326
static int read_ints(AVIOContext *pb, uint32_t *data, int count)
read non-zero integers (le32) from input stream
Definition: wtvdec.c:134
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3097
int64_t epoch
Definition: wtvdec.c:325
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define FF_ARG_GUID(g)
Definition: riff.h:105
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4871
const char * g
Definition: vf_curves.c:115
int64_t position
Definition: wtvdec.c:58
int64_t pos
Definition: avformat.h:809
static const ff_asf_guid mediatype_mstvcaption
Definition: wtvdec.c:365
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int sector_bits
sector shift bits; used to convert sector number into pb_filesystem offset
Definition: wtvdec.c:53
int index
stream index in AVFormatContext
Definition: avformat.h:881
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
unsigned char * buffer
Start of the buffer.
Definition: avio.h:226
enum AVMediaType codec_type
Definition: rtp.c:37
static int parse_videoinfoheader2(AVFormatContext *s, AVStream *st)
parse VIDEOINFOHEADER2 structure
Definition: wtvdec.c:566
const ff_asf_guid ff_mediatype_video
Definition: wtv_common.c:43
GLint GLenum type
Definition: opengl_enc.c:104
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:838
int error
Definition: wtvdec.c:57
void * priv_data
Definition: avformat.h:895
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:341
void * opaque
A private pointer, passed to the read/write/seek/...
Definition: avio.h:233
const char * key
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
uint64_t_TMPL AV_RL64
Definition: bytestream.h:91
static AVPacket pkt
#define AV_CH_LAYOUT_STEREO
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries, int64_t wanted_timestamp, int flags)
Internal version of av_index_search_timestamp.
Definition: utils.c:1993
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1288
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:91
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.
const ff_asf_guid ff_format_waveformatex
Definition: wtv_common.c:74
int seen_data
Definition: wtvdec.c:320
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:460
const AVCodecGuid ff_codec_wav_guids[]
Definition: riff.c:619
Format I/O context.
Definition: avformat.h:1239
#define gmtime_r
Definition: time_internal.h:34
static const ff_asf_guid mediatype_mpeg2_sections
Definition: wtvdec.c:361
#define PRI_PRETTY_GUID
Definition: wtvdec.c:40
const ff_asf_guid ff_data_guid
Definition: wtv_common.c:31
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
Definition: intfloat.h:60
uint8_t
static int read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: wtvdec.c:1061
#define av_malloc(s)
#define FF_MEDIASUBTYPE_BASE_GUID
Definition: riff.h:111
static int read_header(AVFormatContext *s)
Definition: wtvdec.c:961
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1183
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
enum AVStreamParseType need_parsing
Definition: avformat.h:1088
int id
Format-specific stream ID.
Definition: avformat.h:887
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int64_t length
Definition: wtvdec.c:59
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4453
const ff_asf_guid ff_mediatype_audio
Definition: wtv_common.c:41
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1307
const ff_asf_guid ff_mediasubtype_cpfilters_processed
Definition: wtv_common.c:68
#define AVERROR_EOF
End of file.
Definition: error.h:55
static void get_tag(AVFormatContext *s, AVIOContext *pb, const char *key, int type, int length)
Definition: wtvdec.c:467
static int oledate_to_iso8601(char *buf, int buf_size, int64_t value)
Convert OLE DATE to ISO-8601 string.
Definition: wtvdec.c:419
static int64_t seek_by_sector(AVIOContext *pb, int64_t sector, int64_t offset)
Definition: wtvdec.c:62
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:305
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
const ff_asf_guid ff_sync_guid
Definition: wtv_common.c:37
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:637
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
Definition: riffdec.c:91
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
static int read_close(AVFormatContext *s)
Definition: wtvdec.c:1120
#define AVINDEX_KEYFRAME
Definition: avformat.h:816
const uint8_t ff_table_0_entries_legacy_attrib_le16[58]
Definition: wtv_common.c:54
Definition: wtvdec.c:50
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:138
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1479
static AVStream * new_stream(AVFormatContext *s, AVStream *st, int sid, int codec_type)
Initialise stream.
Definition: wtvdec.c:609
AVInputFormat ff_wtv_demuxer
Definition: wtvdec.c:1128
AVIOContext * pb_filesystem
file system (AVFormatContext->pb)
Definition: wtvdec.c:51
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:754
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:810
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
unsigned int pos
Definition: spdifenc.c:410
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:419
static void get_attachment(AVFormatContext *s, AVIOContext *pb, int length)
Definition: wtvdec.c:431
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
Tag description
Definition: snow.txt:206
GLsizei GLsizei * length
Definition: opengl_enc.c:114
int ff_get_guid(AVIOContext *s, ff_asf_guid *g)
Definition: riffdec.c:32
GLsizei count
Definition: opengl_enc.c:108
#define FFMAX(a, b)
Definition: common.h:94
const uint8_t ff_timeline_table_0_entries_Events_le16[62]
Definition: wtv_common.c:52
#define LEN_PRETTY_GUID
Definition: wtvdec.c:44
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:628
AVIOContext * pb
timeline file
Definition: wtvdec.c:324
#define wtvfile_open(s, buf, buf_size, filename)
Definition: wtvdec.c:300
const ff_asf_guid ff_format_cpfilters_processed
Definition: wtv_common.c:72
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1295
static int filetime_to_iso8601(char *buf, int buf_size, int64_t value)
Convert win32 FILETIME to ISO-8601 string.
Definition: wtvdec.c:387
int ff_find_stream_index(AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:4955
audio channel layout utility functions
static const ff_asf_guid EVENTID_DVBScramblingControlSpanningEvent
Definition: wtvdec.c:347
#define FFMIN(a, b)
Definition: common.h:96
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
static const ff_asf_guid mediatype_mpeg2_pes
Definition: wtvdec.c:363
int depth
Definition: wtvenc.c:72
const uint8_t ff_timeline_le16[16]
Definition: wtv_common.c:50
static const ff_asf_guid mediasubtype_mpeg1payload
Definition: wtvdec.c:359
#define WTV_PAD8(x)
Definition: wtv.h:31
const ff_asf_guid ff_timestamp_guid
Definition: wtv_common.c:29
#define s(width, name)
Definition: cbs_vp9.c:257
static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_ptr)
Parse WTV chunks.
Definition: wtvdec.c:787
static void parse_legacy_attrib(AVFormatContext *s, AVIOContext *pb)
Parse metadata entries.
Definition: wtvdec.c:539
static void wtvfile_close(AVIOContext *pb)
Close file opened with wtvfile_open_sector(), or wtv_open()
Definition: wtvdec.c:306
AVDictionary * metadata
Definition: avformat.h:944
const ff_asf_guid ff_format_mpeg2_video
Definition: wtv_common.c:76
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:403
static const ff_asf_guid EVENTID_StreamIDSpanningEvent
Definition: wtvdec.c:349
static const ff_asf_guid EVENTID_CtxADescriptorSpanningEvent
Definition: wtvdec.c:343
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:848
static const ff_asf_guid EVENTID_AudioTypeSpanningEvent
Definition: wtvdec.c:353
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:839
static int wtvfile_read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: wtvdec.c:70
uint8_t ff_asf_guid[16]
Definition: riff.h:92
Stream structure.
Definition: avformat.h:880
const ff_asf_guid ff_DSATTRIB_TRANSPORT_PROPERTIES
Definition: wtv_common.c:60
static const ff_asf_guid EVENTID_AudioDescriptorSpanningEvent
Definition: wtvdec.c:341
#define WTV_SECTOR_SIZE
Definition: wtv.h:29
int ff_add_index_entry(AVIndexEntry **index_entries, int *nb_index_entries, unsigned int *index_entries_allocated_size, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Internal version of av_add_index_entry.
Definition: utils.c:1925
AVIOContext * pb
I/O context.
Definition: avformat.h:1281
int first_sector
Definition: wtvenc.c:73
#define AV_RN16(p)
Definition: intreadwrite.h:360
static const ff_asf_guid EVENTID_SubtitleSpanningEvent
Definition: wtvdec.c:337
int nb_index_entries
Definition: wtvdec.c:332
static const ff_asf_guid mediasubtype_teletext
Definition: wtvdec.c:371
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
const ff_asf_guid ff_index_guid
Definition: wtv_common.c:39
Undefined Behavior In the C language
Definition: undefined.txt:3
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:643
const AVCodecGuid ff_video_guids[]
Definition: wtv_common.c:81
static int64_t wtvfile_seek(void *opaque, int64_t offset, int whence)
Definition: wtvdec.c:108
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:2408
const AVMetadataConv ff_asf_metadata_conv[]
Definition: asf.c:159
#define snprintf
Definition: snprintf.h:34
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
unsigned int index_entries_allocated_size
Definition: wtvdec.c:333
static int read_seek(AVFormatContext *s, int stream_index, int64_t ts, int flags)
Definition: wtvdec.c:1080
#define flags(name, subs,...)
Definition: cbs_av1.c:560
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:1780
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:929
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
full parsing and repack
Definition: avformat.h:799
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:738
Main libavformat public API header.
static void parse_mpeg1waveformatex(AVStream *st)
Parse MPEG1WAVEFORMATEX extradata structure.
Definition: wtvdec.c:580
const ff_asf_guid ff_stream2_guid
Definition: wtv_common.c:64
enum AVCodecID ff_codec_guid_get_id(const AVCodecGuid *guids, ff_asf_guid guid)
Definition: riffdec.c:44
const ff_asf_guid ff_dir_entry_guid
Definition: wtv_common.c:25
enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
Definition: riffdec.c:192
static AVIOContext * wtvfile_open_sector(unsigned first_sector, uint64_t length, int depth, AVFormatContext *s)
Open file.
Definition: wtvdec.c:151
#define FF_PRI_GUID
Definition: riff.h:101
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:933
void avio_context_free(AVIOContext **s)
Free the supplied IO context and everything associated with it.
Definition: aviobuf.c:155
#define AVSEEK_SIZE
ORing this as the "whence" parameter to a seek function causes it to return the filesize without seek...
Definition: avio.h:531
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:209
void ff_metadata_conv(AVDictionary **pm, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:26
static const ff_asf_guid mediasubtype_dtvccdata
Definition: wtvdec.c:373
const ff_asf_guid ff_format_videoinfo2
Definition: wtv_common.c:78
const ff_asf_guid ff_wtv_guid
Definition: wtv_common.c:27
int64_t last_valid_pts
latest valid pts, used for interactive seeking
Definition: wtvdec.c:327
#define av_free(p)
uint32_t * sectors
file allocation table
Definition: wtvdec.c:54
static const ff_asf_guid EVENTID_LanguageSpanningEvent
Definition: wtvdec.c:339
int len
static const ff_asf_guid mediasubtype_dvb_subtitle
Definition: wtvdec.c:369
void * priv_data
Format private data.
Definition: avformat.h:1267
const ff_asf_guid ff_format_none
Definition: wtv_common.c:45
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
#define AVSEEK_FLAG_FRAME
seeking based on frame number
Definition: avformat.h:2410
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
int channels
Audio only.
Definition: codec_par.h:166
static const ff_asf_guid EVENTID_TeletextSpanningEvent
Definition: wtvdec.c:351
#define av_freep(p)
static int read_probe(const AVProbeData *p)
Definition: wtvdec.c:378
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:652
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1045
#define av_malloc_array(a, b)
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:368
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
const ff_asf_guid ff_stream1_guid
Definition: wtv_common.c:35
int stream_index
Definition: packet.h:365
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
int nb_sectors
number of sectors
Definition: wtvdec.c:55
#define AV_CH_LAYOUT_MONO
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:255
static av_always_inline int ff_guidcmp(const void *g1, const void *g2)
Definition: riff.h:118
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
This structure stores compressed data.
Definition: packet.h:340
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:762
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
#define ARG_PRETTY_GUID(g)
Definition: wtvdec.c:42
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:962
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
GLuint buffer
Definition: opengl_enc.c:101
AVIndexEntry * index_entries
Definition: wtvdec.c:331
const char * name
Definition: opengl_enc.c:102