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 (48 + (int64_t)name_size > buf_end - buf) {
277  av_log(s, AV_LOG_ERROR, "filename exceeds buffer size; remaining directory entries ignored\n");
278  break;
279  }
280  first_sector = AV_RL32(buf + 40 + name_size);
281  depth = AV_RL32(buf + 44 + name_size);
282 
283  /* compare file name; test optional null terminator */
284  name = buf + 40;
285  if (name_size >= filename_size &&
286  !memcmp(name, filename, filename_size) &&
287  (name_size < filename_size + 2 || !AV_RN16(name + filename_size)))
288  return wtvfile_open_sector(first_sector, file_length, depth, s);
289 
290  buf += dir_length;
291  }
292  return NULL;
293 }
294 
295 #define wtvfile_open(s, buf, buf_size, filename) \
296  wtvfile_open2(s, buf, buf_size, filename, sizeof(filename))
297 
298 /**
299  * Close file opened with wtvfile_open_sector(), or wtv_open()
300  */
301 static void wtvfile_close(AVIOContext *pb)
302 {
303  WtvFile *wf = pb->opaque;
304  av_freep(&wf->sectors);
305  av_freep(&pb->opaque);
306  av_freep(&pb->buffer);
307  avio_context_free(&pb);
308 }
309 
310 /*
311  * Main demuxer
312  */
313 
314 typedef struct WtvStream {
316 } WtvStream;
317 
318 typedef struct WtvContext {
319  AVIOContext *pb; /**< timeline file */
320  int64_t epoch;
321  int64_t pts; /**< pts for next data chunk */
322  int64_t last_valid_pts; /**< latest valid pts, used for interactive seeking */
323 
324  /* maintain private seek index, as the AVIndexEntry->pos is relative to the
325  start of the 'timeline' file, not the file system (AVFormatContext->pb) */
329 } WtvContext;
330 
331 /* WTV GUIDs */
333  {0x48,0xC0,0xCE,0x5D,0xB9,0xD0,0x63,0x41,0x87,0x2C,0x4F,0x32,0x22,0x3B,0xE8,0x8A};
335  {0x6D,0x66,0x92,0xE2,0x02,0x9C,0x8D,0x44,0xAA,0x8D,0x78,0x1A,0x93,0xFD,0xC3,0x95};
337  {0x1C,0xD4,0x7B,0x10,0xDA,0xA6,0x91,0x46,0x83,0x69,0x11,0xB2,0xCD,0xAA,0x28,0x8E};
339  {0xE6,0xA2,0xB4,0x3A,0x47,0x42,0x34,0x4B,0x89,0x6C,0x30,0xAF,0xA5,0xD2,0x1C,0x24};
341  {0xD9,0x79,0xE7,0xEf,0xF0,0x97,0x86,0x47,0x80,0x0D,0x95,0xCF,0x50,0x5D,0xDC,0x66};
343  {0xC4,0xE1,0xD4,0x4B,0xA1,0x90,0x09,0x41,0x82,0x36,0x27,0xF0,0x0E,0x7D,0xCC,0x5B};
345  {0x68,0xAB,0xF1,0xCA,0x53,0xE1,0x41,0x4D,0xA6,0xB3,0xA7,0xC9,0x98,0xDB,0x75,0xEE};
347  {0x50,0xD9,0x99,0x95,0x33,0x5F,0x17,0x46,0xAF,0x7C,0x1E,0x54,0xB5,0x10,0xDA,0xA3};
349  {0xBE,0xBF,0x1C,0x50,0x49,0xB8,0xCE,0x42,0x9B,0xE9,0x3D,0xB8,0x69,0xFB,0x82,0xB3};
350 
351 /* Windows media GUIDs */
352 
353 /* Media types */
355  {0x81,0xEB,0x36,0xE4,0x4F,0x52,0xCE,0x11,0x9F,0x53,0x00,0x20,0xAF,0x0B,0xA7,0x70};
357  {0x6C,0x17,0x5F,0x45,0x06,0x4B,0xCE,0x47,0x9A,0xEF,0x8C,0xAE,0xF7,0x3D,0xF7,0xB5};
359  {0x20,0x80,0x6D,0xE0,0x46,0xDB,0xCF,0x11,0xB4,0xD1,0x00,0x80,0x5F,0x6C,0xBB,0xEA};
361  {0x89,0x8A,0x8B,0xB8,0x49,0xB0,0x80,0x4C,0xAD,0xCF,0x58,0x98,0x98,0x5E,0x22,0xC1};
362 
363 /* Media subtypes */
365  {0xC3,0xCB,0xFF,0x34,0xB3,0xD5,0x71,0x41,0x90,0x02,0xD4,0xC6,0x03,0x01,0x69,0x7F};
367  {0xE3,0x76,0x2A,0xF7,0x0A,0xEB,0xD0,0x11,0xAC,0xE4,0x00,0x00,0xC0,0xCC,0x16,0xBA};
369  {0xAA,0xDD,0x2A,0xF5,0xF0,0x36,0xF5,0x43,0x95,0xEA,0x6D,0x86,0x64,0x84,0x26,0x2A};
371  {0x79,0x85,0x9F,0x4A,0xF8,0x6B,0x92,0x43,0x8A,0x6D,0xD2,0xDD,0x09,0xFA,0x78,0x61};
372 
373 static int read_probe(const AVProbeData *p)
374 {
375  return ff_guidcmp(p->buf, ff_wtv_guid) ? 0 : AVPROBE_SCORE_MAX;
376 }
377 
378 /**
379  * Convert win32 FILETIME to ISO-8601 string
380  * @return <0 on error
381  */
382 static int filetime_to_iso8601(char *buf, int buf_size, int64_t value)
383 {
384  time_t t = (value / 10000000LL) - 11644473600LL;
385  struct tm tmbuf;
386  struct tm *tm = gmtime_r(&t, &tmbuf);
387  if (!tm)
388  return -1;
389  if (!strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", tm))
390  return -1;
391  return 0;
392 }
393 
394 /**
395  * Convert crazy time (100ns since 1 Jan 0001) to ISO-8601 string
396  * @return <0 on error
397  */
398 static int crazytime_to_iso8601(char *buf, int buf_size, int64_t value)
399 {
400  time_t t = (value / 10000000LL) - 719162LL*86400LL;
401  struct tm tmbuf;
402  struct tm *tm = gmtime_r(&t, &tmbuf);
403  if (!tm)
404  return -1;
405  if (!strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", tm))
406  return -1;
407  return 0;
408 }
409 
410 /**
411  * Convert OLE DATE to ISO-8601 string
412  * @return <0 on error
413  */
414 static int oledate_to_iso8601(char *buf, int buf_size, int64_t value)
415 {
416  time_t t = (av_int2double(value) - 25569.0) * 86400;
417  struct tm tmbuf;
418  struct tm *tm= gmtime_r(&t, &tmbuf);
419  if (!tm)
420  return -1;
421  if (!strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", tm))
422  return -1;
423  return 0;
424 }
425 
427 {
428  char mime[1024];
429  char description[1024];
430  unsigned int filesize;
431  AVStream *st;
432  int ret;
433  int64_t pos = avio_tell(pb);
434 
435  avio_get_str16le(pb, INT_MAX, mime, sizeof(mime));
436  if (strcmp(mime, "image/jpeg"))
437  goto done;
438 
439  avio_r8(pb);
440  avio_get_str16le(pb, INT_MAX, description, sizeof(description));
441  filesize = avio_rl32(pb);
442  if (!filesize)
443  goto done;
444 
445  st = avformat_new_stream(s, NULL);
446  if (!st)
447  goto done;
448  av_dict_set(&st->metadata, "title", description, 0);
451  st->id = -1;
452  ret = av_get_packet(pb, &st->attached_pic, filesize);
453  if (ret < 0)
454  goto done;
455  st->attached_pic.stream_index = st->index;
458 done:
459  avio_seek(pb, pos + length, SEEK_SET);
460 }
461 
462 static void get_tag(AVFormatContext *s, AVIOContext *pb, const char *key, int type, int length)
463 {
464  int buf_size;
465  char *buf;
466 
467  if (!strcmp(key, "WM/MediaThumbType")) {
468  avio_skip(pb, length);
469  return;
470  }
471 
472  buf_size = FFMAX(2*length, LEN_PRETTY_GUID) + 1;
473  buf = av_malloc(buf_size);
474  if (!buf)
475  return;
476 
477  if (type == 0 && length == 4) {
478  snprintf(buf, buf_size, "%u", avio_rl32(pb));
479  } else if (type == 1) {
480  avio_get_str16le(pb, length, buf, buf_size);
481  if (!strlen(buf)) {
482  av_free(buf);
483  return;
484  }
485  } else if (type == 3 && length == 4) {
486  strcpy(buf, avio_rl32(pb) ? "true" : "false");
487  } else if (type == 4 && length == 8) {
488  int64_t num = avio_rl64(pb);
489  if (!strcmp(key, "WM/EncodingTime") ||
490  !strcmp(key, "WM/MediaOriginalBroadcastDateTime")) {
491  if (filetime_to_iso8601(buf, buf_size, num) < 0) {
492  av_free(buf);
493  return;
494  }
495  } else if (!strcmp(key, "WM/WMRVEncodeTime") ||
496  !strcmp(key, "WM/WMRVEndTime")) {
497  if (crazytime_to_iso8601(buf, buf_size, num) < 0) {
498  av_free(buf);
499  return;
500  }
501  } else if (!strcmp(key, "WM/WMRVExpirationDate")) {
502  if (oledate_to_iso8601(buf, buf_size, num) < 0 ) {
503  av_free(buf);
504  return;
505  }
506  } else if (!strcmp(key, "WM/WMRVBitrate"))
507  snprintf(buf, buf_size, "%f", av_int2double(num));
508  else
509  snprintf(buf, buf_size, "%"PRIi64, num);
510  } else if (type == 5 && length == 2) {
511  snprintf(buf, buf_size, "%u", avio_rl16(pb));
512  } else if (type == 6 && length == 16) {
513  ff_asf_guid guid;
514  avio_read(pb, guid, 16);
515  snprintf(buf, buf_size, PRI_PRETTY_GUID, ARG_PRETTY_GUID(guid));
516  } else if (type == 2 && !strcmp(key, "WM/Picture")) {
517  get_attachment(s, pb, length);
518  av_freep(&buf);
519  return;
520  } else {
521  av_freep(&buf);
522  av_log(s, AV_LOG_WARNING, "unsupported metadata entry; key:%s, type:%d, length:0x%x\n", key, type, length);
523  avio_skip(pb, length);
524  return;
525  }
526 
527  av_dict_set(&s->metadata, key, buf, 0);
528  av_freep(&buf);
529 }
530 
531 /**
532  * Parse metadata entries
533  */
535 {
536  ff_asf_guid guid;
537  int length, type;
538  while(!avio_feof(pb)) {
539  char key[1024];
540  ff_get_guid(pb, &guid);
541  type = avio_rl32(pb);
542  length = avio_rl32(pb);
543  if (!length)
544  break;
545  if (ff_guidcmp(&guid, ff_metadata_guid)) {
546  av_log(s, AV_LOG_WARNING, "unknown guid "FF_PRI_GUID", expected metadata_guid; "
547  "remaining metadata entries ignored\n", FF_ARG_GUID(guid));
548  break;
549  }
550  avio_get_str16le(pb, INT_MAX, key, sizeof(key));
551  get_tag(s, pb, key, type, length);
552  }
553 
555 }
556 
557 /**
558  * parse VIDEOINFOHEADER2 structure
559  * @return bytes consumed
560  */
562 {
563  WtvContext *wtv = s->priv_data;
564  AVIOContext *pb = wtv->pb;
565 
566  avio_skip(pb, 72); // picture aspect ratio is unreliable
567  st->codecpar->codec_tag = ff_get_bmp_header(pb, st, NULL);
568 
569  return 72 + 40;
570 }
571 
572 /**
573  * Parse MPEG1WAVEFORMATEX extradata structure
574  */
576 {
577  /* fwHeadLayer */
578  switch (AV_RL16(st->codecpar->extradata)) {
579  case 0x0001 : st->codecpar->codec_id = AV_CODEC_ID_MP1; break;
580  case 0x0002 : st->codecpar->codec_id = AV_CODEC_ID_MP2; break;
581  case 0x0004 : st->codecpar->codec_id = AV_CODEC_ID_MP3; break;
582  }
583 
584  st->codecpar->bit_rate = AV_RL32(st->codecpar->extradata + 2); /* dwHeadBitrate */
585 
586  /* dwHeadMode */
587  switch (AV_RL16(st->codecpar->extradata + 6)) {
588  case 1 :
589  case 2 :
590  case 4 : st->codecpar->channels = 2;
592  break;
593  case 8 : st->codecpar->channels = 1;
595  break;
596  }
597 }
598 
599 /**
600  * Initialise stream
601  * @param st Stream to initialise, or NULL to create and initialise new stream
602  * @return NULL on error
603  */
605 {
606  if (st) {
607  if (st->codecpar->extradata) {
608  av_freep(&st->codecpar->extradata);
609  st->codecpar->extradata_size = 0;
610  }
611  } else {
612  WtvStream *wst = av_mallocz(sizeof(WtvStream));
613  if (!wst)
614  return NULL;
615  st = avformat_new_stream(s, NULL);
616  if (!st) {
617  av_free(wst);
618  return NULL;
619  }
620  st->id = sid;
621  st->priv_data = wst;
622  }
625  avpriv_set_pts_info(st, 64, 1, 10000000);
626  return st;
627 }
628 
629 /**
630  * parse Media Type structure and populate stream
631  * @param st Stream, or NULL to create new stream
632  * @param mediatype Mediatype GUID
633  * @param subtype Subtype GUID
634  * @param formattype Format GUID
635  * @param size Size of format buffer
636  * @return NULL on error
637  */
639  ff_asf_guid mediatype, ff_asf_guid subtype,
640  ff_asf_guid formattype, uint64_t size)
641 {
642  WtvContext *wtv = s->priv_data;
643  AVIOContext *pb = wtv->pb;
646  ff_asf_guid actual_subtype;
647  ff_asf_guid actual_formattype;
648 
649  if (size < 32) {
650  av_log(s, AV_LOG_WARNING, "format buffer size underflow\n");
651  avio_skip(pb, size);
652  return NULL;
653  }
654 
655  avio_skip(pb, size - 32);
656  ff_get_guid(pb, &actual_subtype);
657  ff_get_guid(pb, &actual_formattype);
658  avio_seek(pb, -size, SEEK_CUR);
659 
660  st = parse_media_type(s, st, sid, mediatype, actual_subtype, actual_formattype, size - 32);
661  avio_skip(pb, 32);
662  return st;
663  } else if (!ff_guidcmp(mediatype, ff_mediatype_audio)) {
664  st = new_stream(s, st, sid, AVMEDIA_TYPE_AUDIO);
665  if (!st)
666  return NULL;
667  if (!ff_guidcmp(formattype, ff_format_waveformatex)) {
668  int ret = ff_get_wav_header(s, pb, st->codecpar, size, 0);
669  if (ret < 0)
670  return NULL;
671  } else {
672  if (ff_guidcmp(formattype, ff_format_none))
673  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
674  avio_skip(pb, size);
675  }
676 
677  if (!memcmp(subtype + 4, (const uint8_t[]){FF_MEDIASUBTYPE_BASE_GUID}, 12)) {
679  } else if (!ff_guidcmp(subtype, mediasubtype_mpeg1payload)) {
680  if (st->codecpar->extradata && st->codecpar->extradata_size >= 22)
682  else
683  av_log(s, AV_LOG_WARNING, "MPEG1WAVEFORMATEX underflow\n");
684  } else {
686  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
687  av_log(s, AV_LOG_WARNING, "unknown subtype:"FF_PRI_GUID"\n", FF_ARG_GUID(subtype));
688  }
689  return st;
690  } else if (!ff_guidcmp(mediatype, ff_mediatype_video)) {
691  st = new_stream(s, st, sid, AVMEDIA_TYPE_VIDEO);
692  if (!st)
693  return NULL;
694  if (!ff_guidcmp(formattype, ff_format_videoinfo2)) {
695  int consumed = parse_videoinfoheader2(s, st);
696  avio_skip(pb, FFMAX(size - consumed, 0));
697  } else if (!ff_guidcmp(formattype, ff_format_mpeg2_video)) {
698  uint64_t consumed = parse_videoinfoheader2(s, st);
699  /* ignore extradata; files produced by windows media center contain meaningless mpeg1 sequence header */
700  avio_skip(pb, FFMAX(size - consumed, 0));
701  } else {
702  if (ff_guidcmp(formattype, ff_format_none))
703  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
704  avio_skip(pb, size);
705  }
706 
707  if (!memcmp(subtype + 4, (const uint8_t[]){FF_MEDIASUBTYPE_BASE_GUID}, 12)) {
709  } else {
711  }
712  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
713  av_log(s, AV_LOG_WARNING, "unknown subtype:"FF_PRI_GUID"\n", FF_ARG_GUID(subtype));
714  return st;
715  } else if (!ff_guidcmp(mediatype, mediatype_mpeg2_pes) &&
717  st = new_stream(s, st, sid, AVMEDIA_TYPE_SUBTITLE);
718  if (!st)
719  return NULL;
720  if (ff_guidcmp(formattype, ff_format_none))
721  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
722  avio_skip(pb, size);
724  return st;
725  } else if (!ff_guidcmp(mediatype, mediatype_mstvcaption) &&
727  st = new_stream(s, st, sid, AVMEDIA_TYPE_SUBTITLE);
728  if (!st)
729  return NULL;
730  if (ff_guidcmp(formattype, ff_format_none))
731  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
732  avio_skip(pb, size);
734  return st;
735  } else if (!ff_guidcmp(mediatype, mediatype_mpeg2_sections) &&
737  if (ff_guidcmp(formattype, ff_format_none))
738  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
739  avio_skip(pb, size);
740  return NULL;
741  }
742 
743  av_log(s, AV_LOG_WARNING, "unknown media type, mediatype:"FF_PRI_GUID
744  ", subtype:"FF_PRI_GUID", formattype:"FF_PRI_GUID"\n",
745  FF_ARG_GUID(mediatype), FF_ARG_GUID(subtype), FF_ARG_GUID(formattype));
746  avio_skip(pb, size);
747  return NULL;
748 }
749 
750 enum {
753 };
754 
755 /**
756  * Try to seek over a broken chunk
757  * @return <0 on error
758  */
759 static int recover(WtvContext *wtv, uint64_t broken_pos)
760 {
761  AVIOContext *pb = wtv->pb;
762  int i;
763  for (i = 0; i < wtv->nb_index_entries; i++) {
764  if (wtv->index_entries[i].pos > broken_pos) {
765  int64_t ret = avio_seek(pb, wtv->index_entries[i].pos, SEEK_SET);
766  if (ret < 0)
767  return ret;
768  wtv->pts = wtv->index_entries[i].timestamp;
769  return 0;
770  }
771  }
772  return AVERROR(EIO);
773 }
774 
775 /**
776  * Parse WTV chunks
777  * @param mode SEEK_TO_DATA or SEEK_TO_PTS
778  * @param seekts timestamp
779  * @param[out] len_ptr Length of data chunk
780  * @return stream index of data chunk, or <0 on error
781  */
782 static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_ptr)
783 {
784  WtvContext *wtv = s->priv_data;
785  AVIOContext *pb = wtv->pb;
786  while (!avio_feof(pb)) {
787  ff_asf_guid g;
788  int len, sid, consumed;
789 
790  ff_get_guid(pb, &g);
791  len = avio_rl32(pb);
792  if (len < 32) {
793  int ret;
794  if (avio_feof(pb))
795  return AVERROR_EOF;
796  av_log(s, AV_LOG_WARNING, "encountered broken chunk\n");
797  if ((ret = recover(wtv, avio_tell(pb) - 20)) < 0)
798  return ret;
799  continue;
800  }
801  sid = avio_rl32(pb) & 0x7FFF;
802  avio_skip(pb, 8);
803  consumed = 32;
804 
806  if (ff_find_stream_index(s, sid) < 0) {
807  ff_asf_guid mediatype, subtype, formattype;
808  int size;
809  avio_skip(pb, 28);
810  ff_get_guid(pb, &mediatype);
811  ff_get_guid(pb, &subtype);
812  avio_skip(pb, 12);
813  ff_get_guid(pb, &formattype);
814  size = avio_rl32(pb);
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  parse_media_type(s, s->streams[stream_index], sid, mediatype, subtype, formattype, size);
830  consumed += 76 + size;
831  }
838  int stream_index = ff_find_stream_index(s, sid);
839  if (stream_index >= 0) {
840  AVStream *st = s->streams[stream_index];
841  uint8_t buf[258];
842  const uint8_t *pbuf = buf;
843  int buf_size;
844 
845  avio_skip(pb, 8);
846  consumed += 8;
849  avio_skip(pb, 6);
850  consumed += 6;
851  }
852 
853  buf_size = FFMIN(len - consumed, sizeof(buf));
854  avio_read(pb, buf, buf_size);
855  consumed += buf_size;
856  ff_parse_mpeg2_descriptor(s, st, 0, &pbuf, buf + buf_size, NULL, 0, 0, NULL);
857  }
858  } else if (!ff_guidcmp(g, EVENTID_AudioTypeSpanningEvent)) {
859  int stream_index = ff_find_stream_index(s, sid);
860  if (stream_index >= 0) {
861  AVStream *st = s->streams[stream_index];
862  int audio_type;
863  avio_skip(pb, 8);
864  audio_type = avio_r8(pb);
865  if (audio_type == 2)
867  else if (audio_type == 3)
869  consumed += 9;
870  }
872  int stream_index = ff_find_stream_index(s, sid);
873  if (stream_index >= 0) {
874  avio_skip(pb, 12);
875  if (avio_rl32(pb))
876  av_log(s, AV_LOG_WARNING, "DVB scrambled stream detected (st:%d), decoding will likely fail\n", stream_index);
877  consumed += 16;
878  }
879  } else if (!ff_guidcmp(g, EVENTID_LanguageSpanningEvent)) {
880  int stream_index = ff_find_stream_index(s, sid);
881  if (stream_index >= 0) {
882  AVStream *st = s->streams[stream_index];
883  uint8_t language[4];
884  avio_skip(pb, 12);
885  avio_read(pb, language, 3);
886  if (language[0]) {
887  language[3] = 0;
888  av_dict_set(&st->metadata, "language", language, 0);
889  if (!strcmp(language, "nar") || !strcmp(language, "NAR"))
891  }
892  consumed += 15;
893  }
894  } else if (!ff_guidcmp(g, ff_timestamp_guid)) {
895  int stream_index = ff_find_stream_index(s, sid);
896  if (stream_index >= 0) {
897  avio_skip(pb, 8);
898  wtv->pts = avio_rl64(pb);
899  consumed += 16;
900  if (wtv->pts == -1)
901  wtv->pts = AV_NOPTS_VALUE;
902  else {
903  wtv->last_valid_pts = wtv->pts;
904  if (wtv->epoch == AV_NOPTS_VALUE || wtv->pts < wtv->epoch)
905  wtv->epoch = wtv->pts;
906  if (mode == SEEK_TO_PTS && wtv->pts >= seekts) {
907  avio_skip(pb, WTV_PAD8(len) - consumed);
908  return 0;
909  }
910  }
911  }
912  } else if (!ff_guidcmp(g, ff_data_guid)) {
913  int stream_index = ff_find_stream_index(s, sid);
914  if (mode == SEEK_TO_DATA && stream_index >= 0 && len > 32 && s->streams[stream_index]->priv_data) {
915  WtvStream *wst = s->streams[stream_index]->priv_data;
916  wst->seen_data = 1;
917  if (len_ptr) {
918  *len_ptr = len;
919  }
920  return stream_index;
921  }
922  } 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})) {
923  int stream_index = ff_find_stream_index(s, sid);
924  if (stream_index >= 0)
925  av_log(s, AV_LOG_WARNING, "encrypted stream detected (st:%d), decoding will likely fail\n", stream_index);
926  } else if (
927  !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}) ||
928  !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}) ||
929  !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}) ||
930  !ff_guidcmp(g, /* DSATTRIB_TRANSPORT_PROPERTIES */ ff_DSATTRIB_TRANSPORT_PROPERTIES) ||
931  !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}) ||
932  !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}) ||
933  !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}) ||
934  !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}) ||
935  !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}) ||
936  !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}) ||
937  !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}) ||
938  !ff_guidcmp(g, (const ff_asf_guid){0x1E,0xBE,0xC3,0xC5,0x43,0x92,0xDC,0x11,0x85,0xE5,0x00,0x12,0x3F,0x6F,0x73,0xB9}) ||
939  !ff_guidcmp(g, (const ff_asf_guid){0x3B,0x86,0xA2,0xB1,0xEB,0x1E,0xC3,0x44,0x8C,0x88,0x1C,0xA3,0xFF,0xE3,0xE7,0x6A}) ||
940  !ff_guidcmp(g, (const ff_asf_guid){0x4E,0x7F,0x4C,0x5B,0xC4,0xD0,0x38,0x4B,0xA8,0x3E,0x21,0x7F,0x7B,0xBF,0x52,0xE7}) ||
941  !ff_guidcmp(g, (const ff_asf_guid){0x63,0x36,0xEB,0xFE,0xA1,0x7E,0xD9,0x11,0x83,0x08,0x00,0x07,0xE9,0x5E,0xAD,0x8D}) ||
942  !ff_guidcmp(g, (const ff_asf_guid){0x70,0xE9,0xF1,0xF8,0x89,0xA4,0x4C,0x4D,0x83,0x73,0xB8,0x12,0xE0,0xD5,0xF8,0x1E}) ||
943  !ff_guidcmp(g, ff_index_guid) ||
944  !ff_guidcmp(g, ff_sync_guid) ||
946  !ff_guidcmp(g, (const ff_asf_guid){0xF7,0x10,0x02,0xB9,0xEE,0x7C,0xED,0x4E,0xBD,0x7F,0x05,0x40,0x35,0x86,0x18,0xA1})) {
947  //ignore known guids
948  } else
949  av_log(s, AV_LOG_WARNING, "unsupported chunk:"FF_PRI_GUID"\n", FF_ARG_GUID(g));
950 
951  avio_skip(pb, WTV_PAD8(len) - consumed);
952  }
953  return AVERROR_EOF;
954 }
955 
957 {
958  WtvContext *wtv = s->priv_data;
959  unsigned root_sector;
960  int root_size;
961  uint8_t root[WTV_SECTOR_SIZE];
962  AVIOContext *pb;
963  int64_t timeline_pos;
964  int64_t ret;
965 
966  wtv->epoch =
967  wtv->pts =
969 
970  /* read root directory sector */
971  avio_skip(s->pb, 0x30);
972  root_size = avio_rl32(s->pb);
973  if (root_size > sizeof(root)) {
974  av_log(s, AV_LOG_ERROR, "root directory size exceeds sector size\n");
975  return AVERROR_INVALIDDATA;
976  }
977  avio_skip(s->pb, 4);
978  root_sector = avio_rl32(s->pb);
979 
980  ret = seek_by_sector(s->pb, root_sector, 0);
981  if (ret < 0)
982  return ret;
983  root_size = avio_read(s->pb, root, root_size);
984  if (root_size < 0)
985  return AVERROR_INVALIDDATA;
986 
987  /* parse chunks up until first data chunk */
988  wtv->pb = wtvfile_open(s, root, root_size, ff_timeline_le16);
989  if (!wtv->pb) {
990  av_log(s, AV_LOG_ERROR, "timeline data missing\n");
991  return AVERROR_INVALIDDATA;
992  }
993 
994  ret = parse_chunks(s, SEEK_TO_DATA, 0, 0);
995  if (ret < 0) {
996  wtvfile_close(wtv->pb);
997  return ret;
998  }
999  avio_seek(wtv->pb, -32, SEEK_CUR);
1000 
1001  timeline_pos = avio_tell(s->pb); // save before opening another file
1002 
1003  /* read metadata */
1004  pb = wtvfile_open(s, root, root_size, ff_table_0_entries_legacy_attrib_le16);
1005  if (pb) {
1006  parse_legacy_attrib(s, pb);
1007  wtvfile_close(pb);
1008  }
1009 
1010  s->ctx_flags |= AVFMTCTX_NOHEADER; // Needed for noStreams.wtv
1011 
1012  /* read seek index */
1013  if (s->nb_streams) {
1014  AVStream *st = s->streams[0];
1015  pb = wtvfile_open(s, root, root_size, ff_table_0_entries_time_le16);
1016  if (pb) {
1017  while(1) {
1018  uint64_t timestamp = avio_rl64(pb);
1019  uint64_t frame_nb = avio_rl64(pb);
1020  if (avio_feof(pb))
1021  break;
1023  0, timestamp, frame_nb, 0, AVINDEX_KEYFRAME);
1024  }
1025  wtvfile_close(pb);
1026 
1027  if (wtv->nb_index_entries) {
1028  pb = wtvfile_open(s, root, root_size, ff_timeline_table_0_entries_Events_le16);
1029  if (pb) {
1030  AVIndexEntry *e = wtv->index_entries;
1031  AVIndexEntry *e_end = wtv->index_entries + wtv->nb_index_entries - 1;
1032  uint64_t last_position = 0;
1033  while (1) {
1034  uint64_t frame_nb = avio_rl64(pb);
1035  uint64_t position = avio_rl64(pb);
1036  while (e <= e_end && frame_nb > e->size) {
1037  e->pos = last_position;
1038  e++;
1039  }
1040  if (avio_feof(pb))
1041  break;
1042  last_position = position;
1043  }
1044  e_end->pos = last_position;
1045  wtvfile_close(pb);
1046  st->duration = e_end->timestamp;
1047  }
1048  }
1049  }
1050  }
1051 
1052  avio_seek(s->pb, timeline_pos, SEEK_SET);
1053  return 0;
1054 }
1055 
1057 {
1058  WtvContext *wtv = s->priv_data;
1059  AVIOContext *pb = wtv->pb;
1060  int stream_index, len, ret;
1061 
1062  stream_index = parse_chunks(s, SEEK_TO_DATA, 0, &len);
1063  if (stream_index < 0)
1064  return stream_index;
1065 
1066  ret = av_get_packet(pb, pkt, len - 32);
1067  if (ret < 0)
1068  return ret;
1069  pkt->stream_index = stream_index;
1070  pkt->pts = wtv->pts;
1071  avio_skip(pb, WTV_PAD8(len) - len);
1072  return 0;
1073 }
1074 
1075 static int read_seek(AVFormatContext *s, int stream_index,
1076  int64_t ts, int flags)
1077 {
1078  WtvContext *wtv = s->priv_data;
1079  AVIOContext *pb = wtv->pb;
1080  AVStream *st = s->streams[0];
1081  int64_t ts_relative;
1082  int i;
1083 
1084  if ((flags & AVSEEK_FLAG_FRAME) || (flags & AVSEEK_FLAG_BYTE))
1085  return AVERROR(ENOSYS);
1086 
1087  /* timestamp adjustment is required because wtv->pts values are absolute,
1088  * whereas AVIndexEntry->timestamp values are relative to epoch. */
1089  ts_relative = ts;
1090  if (wtv->epoch != AV_NOPTS_VALUE)
1091  ts_relative -= wtv->epoch;
1092 
1093  i = ff_index_search_timestamp(wtv->index_entries, wtv->nb_index_entries, ts_relative, flags);
1094  if (i < 0) {
1095  if (wtv->last_valid_pts == AV_NOPTS_VALUE || ts < wtv->last_valid_pts) {
1096  if (avio_seek(pb, 0, SEEK_SET) < 0)
1097  return -1;
1098  } else if (st->duration != AV_NOPTS_VALUE && ts_relative > st->duration && wtv->nb_index_entries) {
1099  if (avio_seek(pb, wtv->index_entries[wtv->nb_index_entries - 1].pos, SEEK_SET) < 0)
1100  return -1;
1101  }
1102  if (parse_chunks(s, SEEK_TO_PTS, ts, 0) < 0)
1103  return AVERROR(ERANGE);
1104  return 0;
1105  }
1106  if (avio_seek(pb, wtv->index_entries[i].pos, SEEK_SET) < 0)
1107  return -1;
1108  wtv->pts = wtv->index_entries[i].timestamp;
1109  if (wtv->epoch != AV_NOPTS_VALUE)
1110  wtv->pts += wtv->epoch;
1111  wtv->last_valid_pts = wtv->pts;
1112  return 0;
1113 }
1114 
1116 {
1117  WtvContext *wtv = s->priv_data;
1118  av_freep(&wtv->index_entries);
1119  wtvfile_close(wtv->pb);
1120  return 0;
1121 }
1122 
1124  .name = "wtv",
1125  .long_name = NULL_IF_CONFIG_SMALL("Windows Television (WTV)"),
1126  .priv_data_size = sizeof(WtvContext),
1130  .read_seek = read_seek,
1132  .flags = AVFMT_SHOW_IDS,
1133 };
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:759
#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:370
#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:340
int64_t pts
pts for next data chunk
Definition: wtvdec.c:321
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:3158
int64_t epoch
Definition: wtvdec.c:320
#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:4938
const char * g
Definition: vf_curves.c:115
int64_t position
Definition: wtvdec.c:58
int64_t pos
Definition: avformat.h:805
static const ff_asf_guid mediatype_mstvcaption
Definition: wtvdec.c:360
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:877
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:561
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:834
int error
Definition: wtvdec.c:57
void * priv_data
Definition: avformat.h:891
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:87
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:2054
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1400
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
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:315
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:460
const AVCodecGuid ff_codec_wav_guids[]
Definition: riff.c:618
Format I/O context.
Definition: avformat.h:1351
#define gmtime_r
Definition: time_internal.h:34
static const ff_asf_guid mediatype_mpeg2_sections
Definition: wtvdec.c:356
#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:1056
#define av_malloc(s)
#define FF_MEDIASUBTYPE_BASE_GUID
Definition: riff.h:111
static int read_header(AVFormatContext *s)
Definition: wtvdec.c:956
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1295
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:1094
int id
Format-specific stream ID.
Definition: avformat.h:883
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:4519
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:1419
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:462
static int oledate_to_iso8601(char *buf, int buf_size, int64_t value)
Convert OLE DATE to ISO-8601 string.
Definition: wtvdec.c:414
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:304
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:388
static int read_close(AVFormatContext *s)
Definition: wtvdec.c:1115
#define AVINDEX_KEYFRAME
Definition: avformat.h:812
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:1591
static AVStream * new_stream(AVFormatContext *s, AVStream *st, int sid, int codec_type)
Initialise stream.
Definition: wtvdec.c:604
AVInputFormat ff_wtv_demuxer
Definition: wtvdec.c:1123
AVIOContext * pb_filesystem
file system (AVFormatContext->pb)
Definition: wtvdec.c:51
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:759
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:806
#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:412
static void get_attachment(AVFormatContext *s, AVIOContext *pb, int length)
Definition: wtvdec.c:426
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:361
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:319
#define wtvfile_open(s, buf, buf_size, filename)
Definition: wtvdec.c:295
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:1407
static int filetime_to_iso8601(char *buf, int buf_size, int64_t value)
Convert win32 FILETIME to ISO-8601 string.
Definition: wtvdec.c:382
int ff_find_stream_index(AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:5022
audio channel layout utility functions
static const ff_asf_guid EVENTID_DVBScramblingControlSpanningEvent
Definition: wtvdec.c:342
#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:358
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:354
#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:782
static void parse_legacy_attrib(AVFormatContext *s, AVIOContext *pb)
Parse metadata entries.
Definition: wtvdec.c:534
static void wtvfile_close(AVIOContext *pb)
Close file opened with wtvfile_open_sector(), or wtv_open()
Definition: wtvdec.c:301
AVDictionary * metadata
Definition: avformat.h:940
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:398
static const ff_asf_guid EVENTID_StreamIDSpanningEvent
Definition: wtvdec.c:344
static const ff_asf_guid EVENTID_CtxADescriptorSpanningEvent
Definition: wtvdec.c:338
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:844
static const ff_asf_guid EVENTID_AudioTypeSpanningEvent
Definition: wtvdec.c:348
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:835
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:876
const ff_asf_guid ff_DSATTRIB_TRANSPORT_PROPERTIES
Definition: wtv_common.c:60
static const ff_asf_guid EVENTID_AudioDescriptorSpanningEvent
Definition: wtvdec.c:336
#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:1986
AVIOContext * pb
I/O context.
Definition: avformat.h:1393
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:332
int nb_index_entries
Definition: wtvdec.c:327
static const ff_asf_guid mediasubtype_teletext
Definition: wtvdec.c:366
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:638
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:2514
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:328
static int read_seek(AVFormatContext *s, int stream_index, int64_t ts, int flags)
Definition: wtvdec.c:1075
#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:1777
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:925
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
full parsing and repack
Definition: avformat.h:795
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:743
Main libavformat public API header.
static void parse_mpeg1waveformatex(AVStream *st)
Parse MPEG1WAVEFORMATEX extradata structure.
Definition: wtvdec.c:575
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:929
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:368
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:322
#define av_free(p)
uint32_t * sectors
file allocation table
Definition: wtvdec.c:54
static const ff_asf_guid EVENTID_LanguageSpanningEvent
Definition: wtvdec.c:334
int len
static const ff_asf_guid mediasubtype_dvb_subtitle
Definition: wtvdec.c:364
void * priv_data
Format private data.
Definition: avformat.h:1379
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:2516
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:346
#define av_freep(p)
static int read_probe(const AVProbeData *p)
Definition: wtvdec.c:373
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:650
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
#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:357
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:87
This structure stores compressed data.
Definition: packet.h:332
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:767
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:348
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:958
int i
Definition: input.c:406
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
GLuint buffer
Definition: opengl_enc.c:101
AVIndexEntry * index_entries
Definition: wtvdec.c:326
const char * name
Definition: opengl_enc.c:102