FFmpeg: libavformat/wtvdec.c Source File

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 
30 #include "libavutil/channel_layout.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/intfloat.h"
33 #include "libavutil/time_internal.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  */
151  static AVIOContext * wtvfile_open_sector(unsigned first_sector, uint64_t length, int depth, AVFormatContext *s)
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) {
174  wf->sectors = av_malloc(WTV_SECTOR_SIZE);
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,
238  wtvfile_read_packet, NULL, wtvfile_seek);
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 {
320   int seen_data;
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) */
331   AVIndexEntry *index_entries;
332   int nb_index_entries;
333   unsigned int index_entries_allocated_size;
334 } WtvContext;
335 
336 /* WTV GUIDs */
337  static const ff_asf_guid EVENTID_SubtitleSpanningEvent =
338  {0x48,0xC0,0xCE,0x5D,0xB9,0xD0,0x63,0x41,0x87,0x2C,0x4F,0x32,0x22,0x3B,0xE8,0x8A};
339  static const ff_asf_guid EVENTID_LanguageSpanningEvent =
340  {0x6D,0x66,0x92,0xE2,0x02,0x9C,0x8D,0x44,0xAA,0x8D,0x78,0x1A,0x93,0xFD,0xC3,0x95};
341  static const ff_asf_guid EVENTID_AudioDescriptorSpanningEvent =
342  {0x1C,0xD4,0x7B,0x10,0xDA,0xA6,0x91,0x46,0x83,0x69,0x11,0xB2,0xCD,0xAA,0x28,0x8E};
343  static const ff_asf_guid EVENTID_CtxADescriptorSpanningEvent =
344  {0xE6,0xA2,0xB4,0x3A,0x47,0x42,0x34,0x4B,0x89,0x6C,0x30,0xAF,0xA5,0xD2,0x1C,0x24};
345  static const ff_asf_guid EVENTID_CSDescriptorSpanningEvent =
346  {0xD9,0x79,0xE7,0xEf,0xF0,0x97,0x86,0x47,0x80,0x0D,0x95,0xCF,0x50,0x5D,0xDC,0x66};
347  static const ff_asf_guid EVENTID_DVBScramblingControlSpanningEvent =
348  {0xC4,0xE1,0xD4,0x4B,0xA1,0x90,0x09,0x41,0x82,0x36,0x27,0xF0,0x0E,0x7D,0xCC,0x5B};
349  static const ff_asf_guid EVENTID_StreamIDSpanningEvent =
350  {0x68,0xAB,0xF1,0xCA,0x53,0xE1,0x41,0x4D,0xA6,0xB3,0xA7,0xC9,0x98,0xDB,0x75,0xEE};
351  static const ff_asf_guid EVENTID_TeletextSpanningEvent =
352  {0x50,0xD9,0x99,0x95,0x33,0x5F,0x17,0x46,0xAF,0x7C,0x1E,0x54,0xB5,0x10,0xDA,0xA3};
353  static const ff_asf_guid EVENTID_AudioTypeSpanningEvent =
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 */
359  static const ff_asf_guid mediasubtype_mpeg1payload =
360  {0x81,0xEB,0x36,0xE4,0x4F,0x52,0xCE,0x11,0x9F,0x53,0x00,0x20,0xAF,0x0B,0xA7,0x70};
361  static const ff_asf_guid mediatype_mpeg2_sections =
362  {0x6C,0x17,0x5F,0x45,0x06,0x4B,0xCE,0x47,0x9A,0xEF,0x8C,0xAE,0xF7,0x3D,0xF7,0xB5};
363  static const ff_asf_guid mediatype_mpeg2_pes =
364  {0x20,0x80,0x6D,0xE0,0x46,0xDB,0xCF,0x11,0xB4,0xD1,0x00,0x80,0x5F,0x6C,0xBB,0xEA};
365  static const ff_asf_guid mediatype_mstvcaption =
366  {0x89,0x8A,0x8B,0xB8,0x49,0xB0,0x80,0x4C,0xAD,0xCF,0x58,0x98,0x98,0x5E,0x22,0xC1};
367 
368 /* Media subtypes */
369  static const ff_asf_guid mediasubtype_dvb_subtitle =
370  {0xC3,0xCB,0xFF,0x34,0xB3,0xD5,0x71,0x41,0x90,0x02,0xD4,0xC6,0x03,0x01,0x69,0x7F};
371  static const ff_asf_guid mediasubtype_teletext =
372  {0xE3,0x76,0x2A,0xF7,0x0A,0xEB,0xD0,0x11,0xAC,0xE4,0x00,0x00,0xC0,0xCC,0x16,0xBA};
373  static const ff_asf_guid mediasubtype_dtvccdata =
374  {0xAA,0xDD,0x2A,0xF5,0xF0,0x36,0xF5,0x43,0x95,0xEA,0x6D,0x86,0x64,0x84,0x26,0x2A};
375  static const ff_asf_guid mediasubtype_mpeg2_sections =
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 
431  static void get_attachment(AVFormatContext *s, AVIOContext *pb, int length)
432 {
433  char mime[1024];
434  char description[1024];
435  unsigned int filesize;
436  AVStream *st;
437  int64_t pos = avio_tell(pb);
438 
439  avio_get_str16le(pb, INT_MAX, mime, sizeof(mime));
440  if (strcmp(mime, "image/jpeg"))
441  goto done;
442 
443  avio_r8(pb);
444  avio_get_str16le(pb, INT_MAX, description, sizeof(description));
445  filesize = avio_rl32(pb);
446  if (!filesize)
447  goto done;
448 
449  if (ff_add_attached_pic(s, NULL, pb, NULL, filesize) < 0)
450  goto done;
451  st = s->streams[s->nb_streams - 1];
452  av_dict_set(&st->metadata, "title", description, 0);
453  st->codecpar->codec_id = AV_CODEC_ID_MJPEG;
454  st->id = -1;
455 done:
456  avio_seek(pb, pos + length, SEEK_SET);
457 }
458 
459  static void get_tag(AVFormatContext *s, AVIOContext *pb, const char *key, int type, int length)
460 {
461  int buf_size;
462  char *buf;
463 
464  if (!strcmp(key, "WM/MediaThumbType")) {
465  avio_skip(pb, length);
466  return;
467  }
468 
469  buf_size = FFMAX(2*length, LEN_PRETTY_GUID) + 1;
470  buf = av_malloc(buf_size);
471  if (!buf)
472  return;
473 
474  if (type == 0 && length == 4) {
475  snprintf(buf, buf_size, "%u", avio_rl32(pb));
476  } else if (type == 1) {
477  avio_get_str16le(pb, length, buf, buf_size);
478  if (!strlen(buf)) {
479  av_free(buf);
480  return;
481  }
482  } else if (type == 3 && length == 4) {
483  strcpy(buf, avio_rl32(pb) ? "true" : "false");
484  } else if (type == 4 && length == 8) {
485  int64_t num = avio_rl64(pb);
486  if (!strcmp(key, "WM/EncodingTime") ||
487  !strcmp(key, "WM/MediaOriginalBroadcastDateTime")) {
488  if (filetime_to_iso8601(buf, buf_size, num) < 0) {
489  av_free(buf);
490  return;
491  }
492  } else if (!strcmp(key, "WM/WMRVEncodeTime") ||
493  !strcmp(key, "WM/WMRVEndTime")) {
494  if (crazytime_to_iso8601(buf, buf_size, num) < 0) {
495  av_free(buf);
496  return;
497  }
498  } else if (!strcmp(key, "WM/WMRVExpirationDate")) {
499  if (oledate_to_iso8601(buf, buf_size, num) < 0 ) {
500  av_free(buf);
501  return;
502  }
503  } else if (!strcmp(key, "WM/WMRVBitrate"))
504  snprintf(buf, buf_size, "%f", av_int2double(num));
505  else
506  snprintf(buf, buf_size, "%"PRIi64, num);
507  } else if (type == 5 && length == 2) {
508  snprintf(buf, buf_size, "%u", avio_rl16(pb));
509  } else if (type == 6 && length == 16) {
510  ff_asf_guid guid;
511  avio_read(pb, guid, 16);
512  snprintf(buf, buf_size, PRI_PRETTY_GUID, ARG_PRETTY_GUID(guid));
513  } else if (type == 2 && !strcmp(key, "WM/Picture")) {
514  get_attachment(s, pb, length);
515  av_freep(&buf);
516  return;
517  } else {
518  av_freep(&buf);
519  av_log(s, AV_LOG_WARNING, "unsupported metadata entry; key:%s, type:%d, length:0x%x\n", key, type, length);
520  avio_skip(pb, length);
521  return;
522  }
523 
524  av_dict_set(&s->metadata, key, buf, 0);
525  av_freep(&buf);
526 }
527 
528 /**
529  * Parse metadata entries
530  */
531  static void parse_legacy_attrib(AVFormatContext *s, AVIOContext *pb)
532 {
533  ff_asf_guid guid;
534  int length, type;
535  while(!avio_feof(pb)) {
536  char key[1024];
537  ff_get_guid(pb, &guid);
538  type = avio_rl32(pb);
539  length = avio_rl32(pb);
540  if (!length)
541  break;
542  if (ff_guidcmp(&guid, ff_metadata_guid)) {
543  av_log(s, AV_LOG_WARNING, "unknown guid "FF_PRI_GUID ", expected metadata_guid; "
544  "remaining metadata entries ignored\n", FF_ARG_GUID(guid));
545  break;
546  }
547  avio_get_str16le(pb, INT_MAX, key, sizeof(key));
548  get_tag(s, pb, key, type, length);
549  }
550 
551  ff_metadata_conv(&s->metadata, NULL, ff_asf_metadata_conv);
552 }
553 
554 /**
555  * parse VIDEOINFOHEADER2 structure
556  * @return bytes consumed
557  */
558  static int parse_videoinfoheader2(AVFormatContext *s, AVStream *st)
559 {
560  WtvContext *wtv = s->priv_data;
561  AVIOContext *pb = wtv->pb;
562 
563  avio_skip(pb, 72); // picture aspect ratio is unreliable
564  st->codecpar->codec_tag = ff_get_bmp_header(pb, st, NULL);
565 
566  return 72 + 40;
567 }
568 
569 /**
570  * Parse MPEG1WAVEFORMATEX extradata structure
571  */
572  static void parse_mpeg1waveformatex(AVStream *st)
573 {
574  /* fwHeadLayer */
575  switch (AV_RL16(st->codecpar->extradata)) {
576  case 0x0001 : st->codecpar->codec_id = AV_CODEC_ID_MP1; break;
577  case 0x0002 : st->codecpar->codec_id = AV_CODEC_ID_MP2; break;
578  case 0x0004 : st->codecpar->codec_id = AV_CODEC_ID_MP3; break;
579  }
580 
581  st->codecpar->bit_rate = AV_RL32(st->codecpar->extradata + 2); /* dwHeadBitrate */
582 
583  /* dwHeadMode */
584  switch (AV_RL16(st->codecpar->extradata + 6)) {
585  case 1 :
586  case 2 :
587  case 4 : st->codecpar->channels = 2;
588  st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
589  break;
590  case 8 : st->codecpar->channels = 1;
591  st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
592  break;
593  }
594 }
595 
596 /**
597  * Initialise stream
598  * @param st Stream to initialise, or NULL to create and initialise new stream
599  * @return NULL on error
600  */
601  static AVStream * new_stream(AVFormatContext *s, AVStream *st, int sid, int codec_type)
602 {
603  if (st) {
604  if (st->codecpar->extradata) {
605  av_freep(&st->codecpar->extradata);
606  st->codecpar->extradata_size = 0;
607  }
608  } else {
609  WtvStream *wst = av_mallocz(sizeof(WtvStream));
610  if (!wst)
611  return NULL;
612  st = avformat_new_stream(s, NULL);
613  if (!st) {
614  av_free(wst);
615  return NULL;
616  }
617  st->id = sid;
618  st->priv_data = wst;
619  }
620  st->codecpar->codec_type = codec_type;
621  ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL;
622  avpriv_set_pts_info(st, 64, 1, 10000000);
623  return st;
624 }
625 
626 /**
627  * parse Media Type structure and populate stream
628  * @param st Stream, or NULL to create new stream
629  * @param mediatype Mediatype GUID
630  * @param subtype Subtype GUID
631  * @param formattype Format GUID
632  * @param size Size of format buffer
633  * @return NULL on error
634  */
635  static AVStream * parse_media_type(AVFormatContext *s, AVStream *st, int sid,
636  ff_asf_guid mediatype, ff_asf_guid subtype,
637  ff_asf_guid formattype, uint64_t size)
638 {
639  WtvContext *wtv = s->priv_data;
640  AVIOContext *pb = wtv->pb;
641  if (!ff_guidcmp(subtype, ff_mediasubtype_cpfilters_processed) &&
642  !ff_guidcmp(formattype, ff_format_cpfilters_processed)) {
643  ff_asf_guid actual_subtype;
644  ff_asf_guid actual_formattype;
645 
646  if (size < 32) {
647  av_log(s, AV_LOG_WARNING, "format buffer size underflow\n");
648  avio_skip(pb, size);
649  return NULL;
650  }
651 
652  avio_skip(pb, size - 32);
653  ff_get_guid(pb, &actual_subtype);
654  ff_get_guid(pb, &actual_formattype);
655  if (avio_feof(pb))
656  return NULL;
657  avio_seek(pb, -size, SEEK_CUR);
658 
659  st = parse_media_type(s, st, sid, mediatype, actual_subtype, actual_formattype, size - 32);
660  avio_skip(pb, 32);
661  return st;
662  } else if (!ff_guidcmp(mediatype, ff_mediatype_audio)) {
663  st = new_stream(s, st, sid, AVMEDIA_TYPE_AUDIO);
664  if (!st)
665  return NULL;
666  if (!ff_guidcmp(formattype, ff_format_waveformatex)) {
667  int ret = ff_get_wav_header(s, pb, st->codecpar, size, 0);
668  if (ret < 0)
669  return NULL;
670  } else {
671  if (ff_guidcmp(formattype, ff_format_none))
672  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID "\n", FF_ARG_GUID(formattype));
673  avio_skip(pb, size);
674  }
675 
676  if (!memcmp(subtype + 4, (const uint8_t[]){FF_MEDIASUBTYPE_BASE_GUID}, 12)) {
677  st->codecpar->codec_id = ff_wav_codec_get_id(AV_RL32(subtype), st->codecpar->bits_per_coded_sample);
678  } else if (!ff_guidcmp(subtype, mediasubtype_mpeg1payload)) {
679  if (st->codecpar->extradata && st->codecpar->extradata_size >= 22)
680  parse_mpeg1waveformatex(st);
681  else
682  av_log(s, AV_LOG_WARNING, "MPEG1WAVEFORMATEX underflow\n");
683  } else {
684  st->codecpar->codec_id = ff_codec_guid_get_id(ff_codec_wav_guids, subtype);
685  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
686  av_log(s, AV_LOG_WARNING, "unknown subtype:"FF_PRI_GUID "\n", FF_ARG_GUID(subtype));
687  }
688  return st;
689  } else if (!ff_guidcmp(mediatype, ff_mediatype_video)) {
690  st = new_stream(s, st, sid, AVMEDIA_TYPE_VIDEO);
691  if (!st)
692  return NULL;
693  if (!ff_guidcmp(formattype, ff_format_videoinfo2)) {
694  int consumed = parse_videoinfoheader2(s, st);
695  avio_skip(pb, FFMAX(size - consumed, 0));
696  } else if (!ff_guidcmp(formattype, ff_format_mpeg2_video)) {
697  uint64_t consumed = parse_videoinfoheader2(s, st);
698  /* ignore extradata; files produced by windows media center contain meaningless mpeg1 sequence header */
699  avio_skip(pb, FFMAX(size - consumed, 0));
700  } else {
701  if (ff_guidcmp(formattype, ff_format_none))
702  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID "\n", FF_ARG_GUID(formattype));
703  avio_skip(pb, size);
704  }
705 
706  if (!memcmp(subtype + 4, (const uint8_t[]){FF_MEDIASUBTYPE_BASE_GUID}, 12)) {
707  st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags, AV_RL32(subtype));
708  } else {
709  st->codecpar->codec_id = ff_codec_guid_get_id(ff_video_guids, subtype);
710  }
711  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
712  av_log(s, AV_LOG_WARNING, "unknown subtype:"FF_PRI_GUID "\n", FF_ARG_GUID(subtype));
713  return st;
714  } else if (!ff_guidcmp(mediatype, mediatype_mpeg2_pes) &&
715  !ff_guidcmp(subtype, mediasubtype_dvb_subtitle)) {
716  st = new_stream(s, st, sid, AVMEDIA_TYPE_SUBTITLE);
717  if (!st)
718  return NULL;
719  if (ff_guidcmp(formattype, ff_format_none))
720  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID "\n", FF_ARG_GUID(formattype));
721  avio_skip(pb, size);
722  st->codecpar->codec_id = AV_CODEC_ID_DVB_SUBTITLE;
723  return st;
724  } else if (!ff_guidcmp(mediatype, mediatype_mstvcaption) &&
725  (!ff_guidcmp(subtype, mediasubtype_teletext) || !ff_guidcmp(subtype, mediasubtype_dtvccdata))) {
726  st = new_stream(s, st, sid, AVMEDIA_TYPE_SUBTITLE);
727  if (!st)
728  return NULL;
729  if (ff_guidcmp(formattype, ff_format_none))
730  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID "\n", FF_ARG_GUID(formattype));
731  avio_skip(pb, size);
732  st->codecpar->codec_id = !ff_guidcmp(subtype, mediasubtype_teletext) ? AV_CODEC_ID_DVB_TELETEXT : AV_CODEC_ID_EIA_608;
733  return st;
734  } else if (!ff_guidcmp(mediatype, mediatype_mpeg2_sections) &&
735  !ff_guidcmp(subtype, mediasubtype_mpeg2_sections)) {
736  if (ff_guidcmp(formattype, ff_format_none))
737  av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID "\n", FF_ARG_GUID(formattype));
738  avio_skip(pb, size);
739  return NULL;
740  }
741 
742  av_log(s, AV_LOG_WARNING, "unknown media type, mediatype:"FF_PRI_GUID
743  ", subtype:"FF_PRI_GUID ", formattype:"FF_PRI_GUID "\n",
744  FF_ARG_GUID(mediatype), FF_ARG_GUID(subtype), FF_ARG_GUID(formattype));
745  avio_skip(pb, size);
746  return NULL;
747 }
748 
749 enum {
750   SEEK_TO_DATA = 0,
751   SEEK_TO_PTS,
752 };
753 
754 /**
755  * Try to seek over a broken chunk
756  * @return <0 on error
757  */
758  static int recover(WtvContext *wtv, uint64_t broken_pos)
759 {
760  AVIOContext *pb = wtv->pb;
761  int i;
762  for (i = 0; i < wtv->nb_index_entries; i++) {
763  if (wtv->index_entries[i].pos > broken_pos) {
764  int64_t ret = avio_seek(pb, wtv->index_entries[i].pos, SEEK_SET);
765  if (ret < 0)
766  return ret;
767  wtv->pts = wtv->index_entries[i].timestamp;
768  return 0;
769  }
770  }
771  return AVERROR(EIO);
772 }
773 
774 /**
775  * Parse WTV chunks
776  * @param mode SEEK_TO_DATA or SEEK_TO_PTS
777  * @param seekts timestamp
778  * @param[out] len_ptr Length of data chunk
779  * @return stream index of data chunk, or <0 on error
780  */
781  static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_ptr)
782 {
783  WtvContext *wtv = s->priv_data;
784  AVIOContext *pb = wtv->pb;
785  while (!avio_feof(pb)) {
786  ff_asf_guid g;
787  int len, sid, consumed;
788 
789  ff_get_guid(pb, &g);
790  len = avio_rl32(pb);
791  if (len < 32 || len > INT_MAX - 7) {
792  int ret;
793  if (avio_feof(pb))
794  return AVERROR_EOF;
795  av_log(s, AV_LOG_WARNING, "encountered broken chunk\n");
796  if ((ret = recover(wtv, avio_tell(pb) - 20)) < 0)
797  return ret;
798  continue;
799  }
800  sid = avio_rl32(pb) & 0x7FFF;
801  avio_skip(pb, 8);
802  consumed = 32;
803 
804  if (!ff_guidcmp(g, ff_SBE2_STREAM_DESC_EVENT)) {
805  if (ff_find_stream_index(s, sid) < 0) {
806  ff_asf_guid mediatype, subtype, formattype;
807  int size;
808  avio_skip(pb, 28);
809  ff_get_guid(pb, &mediatype);
810  ff_get_guid(pb, &subtype);
811  avio_skip(pb, 12);
812  ff_get_guid(pb, &formattype);
813  size = avio_rl32(pb);
814  if (size < 0 || size > INT_MAX - 92 - consumed)
815  return AVERROR_INVALIDDATA;
816  parse_media_type(s, 0, sid, mediatype, subtype, formattype, size);
817  consumed += 92 + size;
818  }
819  } else if (!ff_guidcmp(g, ff_stream2_guid)) {
820  int stream_index = ff_find_stream_index(s, sid);
821  if (stream_index >= 0 && s->streams[stream_index]->priv_data && !((WtvStream*)s->streams[stream_index]->priv_data)->seen_data) {
822  ff_asf_guid mediatype, subtype, formattype;
823  int size;
824  avio_skip(pb, 12);
825  ff_get_guid(pb, &mediatype);
826  ff_get_guid(pb, &subtype);
827  avio_skip(pb, 12);
828  ff_get_guid(pb, &formattype);
829  size = avio_rl32(pb);
830  if (size < 0 || size > INT_MAX - 76 - consumed)
831  return AVERROR_INVALIDDATA;
832  parse_media_type(s, s->streams[stream_index], sid, mediatype, subtype, formattype, size);
833  consumed += 76 + size;
834  }
835  } else if (!ff_guidcmp(g, EVENTID_AudioDescriptorSpanningEvent) ||
836  !ff_guidcmp(g, EVENTID_CtxADescriptorSpanningEvent) ||
837  !ff_guidcmp(g, EVENTID_CSDescriptorSpanningEvent) ||
838  !ff_guidcmp(g, EVENTID_StreamIDSpanningEvent) ||
839  !ff_guidcmp(g, EVENTID_SubtitleSpanningEvent) ||
840  !ff_guidcmp(g, EVENTID_TeletextSpanningEvent)) {
841  int stream_index = ff_find_stream_index(s, sid);
842  if (stream_index >= 0) {
843  AVStream *st = s->streams[stream_index];
844  uint8_t buf[258];
845  const uint8_t *pbuf = buf;
846  int buf_size;
847 
848  avio_skip(pb, 8);
849  consumed += 8;
850  if (!ff_guidcmp(g, EVENTID_CtxADescriptorSpanningEvent) ||
851  !ff_guidcmp(g, EVENTID_CSDescriptorSpanningEvent)) {
852  avio_skip(pb, 6);
853  consumed += 6;
854  }
855 
856  buf_size = FFMIN(len - consumed, sizeof(buf));
857  avio_read(pb, buf, buf_size);
858  consumed += buf_size;
859  ff_parse_mpeg2_descriptor(s, st, 0, &pbuf, buf + buf_size, NULL, 0, 0, NULL);
860  }
861  } else if (!ff_guidcmp(g, EVENTID_AudioTypeSpanningEvent)) {
862  int stream_index = ff_find_stream_index(s, sid);
863  if (stream_index >= 0) {
864  AVStream *st = s->streams[stream_index];
865  int audio_type;
866  avio_skip(pb, 8);
867  audio_type = avio_r8(pb);
868  if (audio_type == 2)
869  st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED;
870  else if (audio_type == 3)
871  st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED;
872  consumed += 9;
873  }
874  } else if (!ff_guidcmp(g, EVENTID_DVBScramblingControlSpanningEvent)) {
875  int stream_index = ff_find_stream_index(s, sid);
876  if (stream_index >= 0) {
877  avio_skip(pb, 12);
878  if (avio_rl32(pb))
879  av_log(s, AV_LOG_WARNING, "DVB scrambled stream detected (st:%d), decoding will likely fail\n", stream_index);
880  consumed += 16;
881  }
882  } else if (!ff_guidcmp(g, EVENTID_LanguageSpanningEvent)) {
883  int stream_index = ff_find_stream_index(s, sid);
884  if (stream_index >= 0) {
885  AVStream *st = s->streams[stream_index];
886  uint8_t language[4];
887  avio_skip(pb, 12);
888  avio_read(pb, language, 3);
889  if (language[0]) {
890  language[3] = 0;
891  av_dict_set(&st->metadata, "language", language, 0);
892  if (!strcmp(language, "nar") || !strcmp(language, "NAR"))
893  st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED;
894  }
895  consumed += 15;
896  }
897  } else if (!ff_guidcmp(g, ff_timestamp_guid)) {
898  int stream_index = ff_find_stream_index(s, sid);
899  if (stream_index >= 0) {
900  avio_skip(pb, 8);
901  wtv->pts = avio_rl64(pb);
902  consumed += 16;
903  if (wtv->pts == -1)
904  wtv->pts = AV_NOPTS_VALUE;
905  else {
906  wtv->last_valid_pts = wtv->pts;
907  if (wtv->epoch == AV_NOPTS_VALUE || wtv->pts < wtv->epoch)
908  wtv->epoch = wtv->pts;
909  if (mode == SEEK_TO_PTS && wtv->pts >= seekts) {
910  avio_skip(pb, WTV_PAD8(len) - consumed);
911  return 0;
912  }
913  }
914  }
915  } else if (!ff_guidcmp(g, ff_data_guid)) {
916  int stream_index = ff_find_stream_index(s, sid);
917  if (mode == SEEK_TO_DATA && stream_index >= 0 && len > 32 && s->streams[stream_index]->priv_data) {
918  WtvStream *wst = s->streams[stream_index]->priv_data;
919  wst->seen_data = 1;
920  if (len_ptr) {
921  *len_ptr = len;
922  }
923  return stream_index;
924  }
925  } 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})) {
926  int stream_index = ff_find_stream_index(s, sid);
927  if (stream_index >= 0)
928  av_log(s, AV_LOG_WARNING, "encrypted stream detected (st:%d), decoding will likely fail\n", stream_index);
929  } else if (
930  !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}) ||
931  !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}) ||
932  !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}) ||
933  !ff_guidcmp(g, /* DSATTRIB_TRANSPORT_PROPERTIES */ ff_DSATTRIB_TRANSPORT_PROPERTIES) ||
934  !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}) ||
935  !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}) ||
936  !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}) ||
937  !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}) ||
938  !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}) ||
939  !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}) ||
940  !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}) ||
941  !ff_guidcmp(g, (const ff_asf_guid){0x1E,0xBE,0xC3,0xC5,0x43,0x92,0xDC,0x11,0x85,0xE5,0x00,0x12,0x3F,0x6F,0x73,0xB9}) ||
942  !ff_guidcmp(g, (const ff_asf_guid){0x3B,0x86,0xA2,0xB1,0xEB,0x1E,0xC3,0x44,0x8C,0x88,0x1C,0xA3,0xFF,0xE3,0xE7,0x6A}) ||
943  !ff_guidcmp(g, (const ff_asf_guid){0x4E,0x7F,0x4C,0x5B,0xC4,0xD0,0x38,0x4B,0xA8,0x3E,0x21,0x7F,0x7B,0xBF,0x52,0xE7}) ||
944  !ff_guidcmp(g, (const ff_asf_guid){0x63,0x36,0xEB,0xFE,0xA1,0x7E,0xD9,0x11,0x83,0x08,0x00,0x07,0xE9,0x5E,0xAD,0x8D}) ||
945  !ff_guidcmp(g, (const ff_asf_guid){0x70,0xE9,0xF1,0xF8,0x89,0xA4,0x4C,0x4D,0x83,0x73,0xB8,0x12,0xE0,0xD5,0xF8,0x1E}) ||
946  !ff_guidcmp(g, ff_index_guid) ||
947  !ff_guidcmp(g, ff_sync_guid) ||
948  !ff_guidcmp(g, ff_stream1_guid) ||
949  !ff_guidcmp(g, (const ff_asf_guid){0xF7,0x10,0x02,0xB9,0xEE,0x7C,0xED,0x4E,0xBD,0x7F,0x05,0x40,0x35,0x86,0x18,0xA1})) {
950  //ignore known guids
951  } else
952  av_log(s, AV_LOG_WARNING, "unsupported chunk:"FF_PRI_GUID "\n", FF_ARG_GUID(g));
953 
954  if (avio_feof(pb))
955  break;
956 
957  avio_skip(pb, WTV_PAD8(len) - consumed);
958  }
959  return AVERROR_EOF;
960 }
961 
962  static int read_header(AVFormatContext *s)
963 {
964  WtvContext *wtv = s->priv_data;
965  unsigned root_sector;
966  int root_size;
967  uint8_t root[WTV_SECTOR_SIZE];
968  AVIOContext *pb;
969  int64_t timeline_pos;
970  int64_t ret;
971 
972  wtv->epoch =
973  wtv->pts =
974  wtv->last_valid_pts = AV_NOPTS_VALUE;
975 
976  /* read root directory sector */
977  avio_skip(s->pb, 0x30);
978  root_size = avio_rl32(s->pb);
979  if (root_size > sizeof(root)) {
980  av_log(s, AV_LOG_ERROR, "root directory size exceeds sector size\n");
981  return AVERROR_INVALIDDATA;
982  }
983  avio_skip(s->pb, 4);
984  root_sector = avio_rl32(s->pb);
985 
986  ret = seek_by_sector(s->pb, root_sector, 0);
987  if (ret < 0)
988  return ret;
989  root_size = avio_read(s->pb, root, root_size);
990  if (root_size < 0)
991  return AVERROR_INVALIDDATA;
992 
993  /* parse chunks up until first data chunk */
994  wtv->pb = wtvfile_open(s, root, root_size, ff_timeline_le16);
995  if (!wtv->pb) {
996  av_log(s, AV_LOG_ERROR, "timeline data missing\n");
997  return AVERROR_INVALIDDATA;
998  }
999 
1000  ret = parse_chunks(s, SEEK_TO_DATA, 0, 0);
1001  if (ret < 0) {
1002  wtvfile_close(wtv->pb);
1003  return ret;
1004  }
1005  avio_seek(wtv->pb, -32, SEEK_CUR);
1006 
1007  timeline_pos = avio_tell(s->pb); // save before opening another file
1008 
1009  /* read metadata */
1010  pb = wtvfile_open(s, root, root_size, ff_table_0_entries_legacy_attrib_le16);
1011  if (pb) {
1012  parse_legacy_attrib(s, pb);
1013  wtvfile_close(pb);
1014  }
1015 
1016  s->ctx_flags |= AVFMTCTX_NOHEADER; // Needed for noStreams.wtv
1017 
1018  /* read seek index */
1019  if (s->nb_streams) {
1020  AVStream *st = s->streams[0];
1021  pb = wtvfile_open(s, root, root_size, ff_table_0_entries_time_le16);
1022  if (pb) {
1023  while(1) {
1024  uint64_t timestamp = avio_rl64(pb);
1025  uint64_t frame_nb = avio_rl64(pb);
1026  if (avio_feof(pb))
1027  break;
1028  ff_add_index_entry(&wtv->index_entries, &wtv->nb_index_entries, &wtv->index_entries_allocated_size,
1029  0, timestamp, frame_nb, 0, AVINDEX_KEYFRAME);
1030  }
1031  wtvfile_close(pb);
1032 
1033  if (wtv->nb_index_entries) {
1034  pb = wtvfile_open(s, root, root_size, ff_timeline_table_0_entries_Events_le16);
1035  if (pb) {
1036  AVIndexEntry *e = wtv->index_entries;
1037  AVIndexEntry *e_end = wtv->index_entries + wtv->nb_index_entries - 1;
1038  uint64_t last_position = 0;
1039  while (1) {
1040  uint64_t frame_nb = avio_rl64(pb);
1041  uint64_t position = avio_rl64(pb);
1042  while (e <= e_end && frame_nb > e->size) {
1043  e->pos = last_position;
1044  e++;
1045  }
1046  if (avio_feof(pb))
1047  break;
1048  last_position = position;
1049  }
1050  e_end->pos = last_position;
1051  wtvfile_close(pb);
1052  st->duration = e_end->timestamp;
1053  }
1054  }
1055  }
1056  }
1057 
1058  avio_seek(s->pb, timeline_pos, SEEK_SET);
1059  return 0;
1060 }
1061 
1062  static int read_packet(AVFormatContext *s, AVPacket *pkt)
1063 {
1064  WtvContext *wtv = s->priv_data;
1065  AVIOContext *pb = wtv->pb;
1066  int stream_index, len, ret;
1067 
1068  stream_index = parse_chunks(s, SEEK_TO_DATA, 0, &len);
1069  if (stream_index < 0)
1070  return stream_index;
1071 
1072  ret = av_get_packet(pb, pkt, len - 32);
1073  if (ret < 0)
1074  return ret;
1075  pkt->stream_index = stream_index;
1076  pkt->pts = wtv->pts;
1077  avio_skip(pb, WTV_PAD8(len) - len);
1078  return 0;
1079 }
1080 
1081  static int read_seek(AVFormatContext *s, int stream_index,
1082  int64_t ts, int flags)
1083 {
1084  WtvContext *wtv = s->priv_data;
1085  AVIOContext *pb = wtv->pb;
1086  AVStream *st = s->streams[0];
1087  int64_t ts_relative;
1088  int i;
1089 
1090  if ((flags & AVSEEK_FLAG_FRAME) || (flags & AVSEEK_FLAG_BYTE))
1091  return AVERROR(ENOSYS);
1092 
1093  /* timestamp adjustment is required because wtv->pts values are absolute,
1094  * whereas AVIndexEntry->timestamp values are relative to epoch. */
1095  ts_relative = ts;
1096  if (wtv->epoch != AV_NOPTS_VALUE)
1097  ts_relative -= wtv->epoch;
1098 
1099  i = ff_index_search_timestamp(wtv->index_entries, wtv->nb_index_entries, ts_relative, flags);
1100  if (i < 0) {
1101  if (wtv->last_valid_pts == AV_NOPTS_VALUE || ts < wtv->last_valid_pts) {
1102  if (avio_seek(pb, 0, SEEK_SET) < 0)
1103  return -1;
1104  } else if (st->duration != AV_NOPTS_VALUE && ts_relative > st->duration && wtv->nb_index_entries) {
1105  if (avio_seek(pb, wtv->index_entries[wtv->nb_index_entries - 1].pos, SEEK_SET) < 0)
1106  return -1;
1107  }
1108  if (parse_chunks(s, SEEK_TO_PTS, ts, 0) < 0)
1109  return AVERROR(ERANGE);
1110  return 0;
1111  }
1112  if (avio_seek(pb, wtv->index_entries[i].pos, SEEK_SET) < 0)
1113  return -1;
1114  wtv->pts = wtv->index_entries[i].timestamp;
1115  if (wtv->epoch != AV_NOPTS_VALUE)
1116  wtv->pts += wtv->epoch;
1117  wtv->last_valid_pts = wtv->pts;
1118  return 0;
1119 }
1120 
1121  static int read_close(AVFormatContext *s)
1122 {
1123  WtvContext *wtv = s->priv_data;
1124  av_freep(&wtv->index_entries);
1125  wtvfile_close(wtv->pb);
1126  return 0;
1127 }
1128 
1129  const AVInputFormat ff_wtv_demuxer = {
1130  .name = "wtv",
1131  .long_name = NULL_IF_CONFIG_SMALL("Windows Television (WTV)"),
1132  .priv_data_size = sizeof(WtvContext),
1133  .read_probe = read_probe,
1134  .read_header = read_header,
1135  .read_packet = read_packet,
1136  .read_seek = read_seek,
1137  .read_close = read_close,
1138  .flags = AVFMT_SHOW_IDS,
1139 };
LEN_PRETTY_GUID
#define LEN_PRETTY_GUID
Definition: wtvdec.c:44
AV_CODEC_ID_EIA_608
@ AV_CODEC_ID_EIA_608
Definition: codec_id.h:532
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
crazytime_to_iso8601
static int crazytime_to_iso8601(char *buf, int buf_size, int64_t value)
Convert crazy time (100ns since 1 Jan 0001) to ISO-8601 string.
Definition: wtvdec.c:403
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
filetime_to_iso8601
static int filetime_to_iso8601(char *buf, int buf_size, int64_t value)
Convert win32 FILETIME to ISO-8601 string.
Definition: wtvdec.c:387
EVENTID_StreamIDSpanningEvent
static const ff_asf_guid EVENTID_StreamIDSpanningEvent
Definition: wtvdec.c:349
ff_mediasubtype_cpfilters_processed
const ff_asf_guid ff_mediasubtype_cpfilters_processed
Definition: wtv_common.c:68
AVERROR
Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_get_guid
int ff_get_guid(AVIOContext *s, ff_asf_guid *g)
Definition: riffdec.c:31
EVENTID_CtxADescriptorSpanningEvent
static const ff_asf_guid EVENTID_CtxADescriptorSpanningEvent
Definition: wtvdec.c:343
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:768
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:473
mpegts.h
EVENTID_AudioTypeSpanningEvent
static const ff_asf_guid EVENTID_AudioTypeSpanningEvent
Definition: wtvdec.c:353
EVENTID_DVBScramblingControlSpanningEvent
static const ff_asf_guid EVENTID_DVBScramblingControlSpanningEvent
Definition: wtvdec.c:347
wtvfile_read_packet
static int wtvfile_read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: wtvdec.c:70
AVSEEK_FLAG_FRAME
#define AVSEEK_FLAG_FRAME
seeking based on frame number
Definition: avformat.h:2278
EVENTID_AudioDescriptorSpanningEvent
static const ff_asf_guid EVENTID_AudioDescriptorSpanningEvent
Definition: wtvdec.c:341
ff_mediatype_video
const ff_asf_guid ff_mediatype_video
Definition: wtv_common.c:43
WtvFile::position
int64_t position
Definition: wtvdec.c:58
mediasubtype_mpeg1payload
static const ff_asf_guid mediasubtype_mpeg1payload
Definition: wtvdec.c:359
AVStream::priv_data
void * priv_data
Definition: avformat.h:951
AV_RL64
uint64_t_TMPL AV_RL64
Definition: bytestream.h:91
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
WtvContext::pb
AVIOContext * pb
timeline file
Definition: wtvdec.c:324
av_int2double
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
Definition: intfloat.h:60
avio_context_free
void avio_context_free(AVIOContext **s)
Free the supplied IO context and everything associated with it.
Definition: aviobuf.c:152
ff_timestamp_guid
const ff_asf_guid ff_timestamp_guid
Definition: wtv_common.c:29
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
WtvContext
Definition: wtvdec.c:323
parse_chunks
static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_ptr)
Parse WTV chunks.
Definition: wtvdec.c:781
parse_legacy_attrib
static void parse_legacy_attrib(AVFormatContext *s, AVIOContext *pb)
Parse metadata entries.
Definition: wtvdec.c:531
AV_RN16
#define AV_RN16(p)
Definition: intreadwrite.h:360
WtvFile::sectors
uint32_t * sectors
file allocation table
Definition: wtvdec.c:54
wtvfile_close
static void wtvfile_close(AVIOContext *pb)
Close file opened with wtvfile_open_sector(), or wtv_open()
Definition: wtvdec.c:306
ff_wav_codec_get_id
enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
Definition: riffdec.c:191
EVENTID_SubtitleSpanningEvent
static const ff_asf_guid EVENTID_SubtitleSpanningEvent
Definition: wtvdec.c:337
WtvContext::epoch
int64_t epoch
Definition: wtvdec.c:325
AV_CODEC_ID_DVB_TELETEXT
@ AV_CODEC_ID_DVB_TELETEXT
Definition: codec_id.h:529
ff_sync_guid
const ff_asf_guid ff_sync_guid
Definition: wtv_common.c:37
WtvFile::sector_bits
int sector_bits
sector shift bits; used to convert sector number into pb_filesystem offset
Definition: wtvdec.c:53
ff_add_index_entry
int ff_add_index_entry(AVIndexEntry **index_entries, int *nb_index_entries, unsigned int *index_entries_allocated_size, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Internal version of av_add_index_entry.
Definition: seek.c:59
ff_format_waveformatex
const ff_asf_guid ff_format_waveformatex
Definition: wtv_common.c:74
AVSEEK_SIZE
#define AVSEEK_SIZE
ORing this as the "whence" parameter to a seek function causes it to return the filesize without seek...
Definition: avio.h:478
data
const char data[16]
Definition: mxf.c:143
AVSEEK_FLAG_BYTE
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:2276
AVIOContext::error
int error
contains the error code or 0 if no error happened
Definition: avio.h:240
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
wtvfile_seek
static int64_t wtvfile_seek(void *opaque, int64_t offset, int whence)
Definition: wtvdec.c:108
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
intfloat.h
codec_type
enum AVMediaType codec_type
Definition: rtp.c:37
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:352
ff_timeline_table_0_entries_Events_le16
const uint8_t ff_timeline_table_0_entries_Events_le16[62]
Definition: wtv_common.c:52
AVIndexEntry
Definition: avformat.h:801
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
ff_stream1_guid
const ff_asf_guid ff_stream1_guid
Definition: wtv_common.c:35
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:809
ff_guidcmp
static av_always_inline int ff_guidcmp(const void *g1, const void *g2)
Definition: riff.h:121
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:459
mediasubtype_teletext
static const ff_asf_guid mediasubtype_teletext
Definition: wtvdec.c:371
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
ff_get_bmp_header
int ff_get_bmp_header(AVIOContext *pb, AVStream *st, uint32_t *size)
Read BITMAPINFOHEADER structure and set AVStream codec width, height and bits_per_encoded_sample fiel...
Definition: riffdec.c:208
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:432
ff_index_guid
const ff_asf_guid ff_index_guid
Definition: wtv_common.c:39
ff_data_guid
const ff_asf_guid ff_data_guid
Definition: wtv_common.c:31
parse_media_type
static AVStream * parse_media_type(AVFormatContext *s, AVStream *st, int sid, ff_asf_guid mediatype, ff_asf_guid subtype, ff_asf_guid formattype, uint64_t size)
parse Media Type structure and populate stream
Definition: wtvdec.c:635
gmtime_r
#define gmtime_r
Definition: time_internal.h:34
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:504
wtvfile_open_sector
static AVIOContext * wtvfile_open_sector(unsigned first_sector, uint64_t length, int depth, AVFormatContext *s)
Open file.
Definition: wtvdec.c:151
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
WtvContext::index_entries_allocated_size
unsigned int index_entries_allocated_size
Definition: wtvdec.c:333
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:424
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:985
SEEK_TO_PTS
@ SEEK_TO_PTS
Definition: wtvdec.c:751
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:743
SEEK_TO_DATA
@ SEEK_TO_DATA
Definition: wtvdec.c:750
ff_video_guids
const AVCodecGuid ff_video_guids[]
Definition: wtv_common.c:81
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
WtvFile::error
int error
Definition: wtvdec.c:57
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: codec_id.h:523
ff_mediatype_audio
const ff_asf_guid ff_mediatype_audio
Definition: wtv_common.c:41
description
Tag description
Definition: snow.txt:206
read_seek
static int read_seek(AVFormatContext *s, int stream_index, int64_t ts, int flags)
Definition: wtvdec.c:1081
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:650
ff_parse_mpeg2_descriptor
int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type, const uint8_t **pp, const uint8_t *desc_list_end, Mp4Descr *mp4_descr, int mp4_descr_count, int pid, MpegTSContext *ts)
Parse an MPEG-2 descriptor.
Definition: mpegts.c:1803
mediasubtype_dvb_subtitle
static const ff_asf_guid mediasubtype_dvb_subtitle
Definition: wtvdec.c:369
avio_get_str16le
int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a UTF-16 string from pb and convert it to UTF-8.
FF_ARG_GUID
#define FF_ARG_GUID(g)
Definition: riff.h:108
intreadwrite.h
parse_mpeg1waveformatex
static void parse_mpeg1waveformatex(AVStream *st)
Parse MPEG1WAVEFORMATEX extradata structure.
Definition: wtvdec.c:572
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_timeline_le16
const uint8_t ff_timeline_le16[16]
Definition: wtv_common.c:50
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:655
g
const char * g
Definition: vf_curves.c:117
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:449
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:423
AVIndexEntry::size
int size
Definition: avformat.h:812
WtvStream::seen_data
int seen_data
Definition: wtvdec.c:320
AVIndexEntry::timestamp
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:803
WtvContext::index_entries
AVIndexEntry * index_entries
Definition: wtvdec.c:331
ff_format_none
const ff_asf_guid ff_format_none
Definition: wtv_common.c:45
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
mediasubtype_dtvccdata
static const ff_asf_guid mediasubtype_dtvccdata
Definition: wtvdec.c:373
key
const char * key
Definition: hwcontext_opencl.c:168
wtvfile_open2
static AVIOContext * wtvfile_open2(AVFormatContext *s, const uint8_t *buf, int buf_size, const uint8_t *filename, int filename_size)
Open file using filename.
Definition: wtvdec.c:255
EVENTID_LanguageSpanningEvent
static const ff_asf_guid EVENTID_LanguageSpanningEvent
Definition: wtvdec.c:339
time_internal.h
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:405
ARG_PRETTY_GUID
#define ARG_PRETTY_GUID(g)
Definition: wtvdec.c:42
AVFormatContext
Format I/O context.
Definition: avformat.h:1200
internal.h
WtvFile
Definition: wtvdec.c:50
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1095
WTV_BIGSECTOR_BITS
#define WTV_BIGSECTOR_BITS
Definition: wtv.h:30
NULL
#define NULL
Definition: coverity.c:32
ff_asf_guid
uint8_t ff_asf_guid[16]
Definition: riff.h:95
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1151
ff_asf_metadata_conv
const AVMetadataConv ff_asf_metadata_conv[]
Definition: asf.c:155
EVENTID_TeletextSpanningEvent
static const ff_asf_guid EVENTID_TeletextSpanningEvent
Definition: wtvdec.c:351
mediasubtype_mpeg2_sections
static const ff_asf_guid mediasubtype_mpeg2_sections
Definition: wtvdec.c:375
read_probe
static int read_probe(const AVProbeData *p)
Definition: wtvdec.c:378
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:447
ff_format_cpfilters_processed
const ff_asf_guid ff_format_cpfilters_processed
Definition: wtv_common.c:72
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:1006
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
ff_wtv_guid
const ff_asf_guid ff_wtv_guid
Definition: wtv_common.c:27
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:759
mediatype_mstvcaption
static const ff_asf_guid mediatype_mstvcaption
Definition: wtvdec.c:365
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
ff_wtv_demuxer
const AVInputFormat ff_wtv_demuxer
Definition: wtvdec.c:1129
recover
static int recover(WtvContext *wtv, uint64_t broken_pos)
Try to seek over a broken chunk.
Definition: wtvdec.c:758
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:357
WtvFile::nb_sectors
int nb_sectors
number of sectors
Definition: wtvdec.c:55
size
int size
Definition: twinvq_data.h:10344
EVENTID_CSDescriptorSpanningEvent
static const ff_asf_guid EVENTID_CSDescriptorSpanningEvent
Definition: wtvdec.c:345
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
read_ints
static int read_ints(AVIOContext *pb, uint32_t *data, int count)
read non-zero integers (le32) from input stream
Definition: wtvdec.c:134
ff_format_mpeg2_video
const ff_asf_guid ff_format_mpeg2_video
Definition: wtv_common.c:76
ff_stream2_guid
const ff_asf_guid ff_stream2_guid
Definition: wtv_common.c:64
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
The stream is intended for hearing impaired audiences.
Definition: avformat.h:857
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:632
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
ff_codec_guid_get_id
enum AVCodecID ff_codec_guid_get_id(const AVCodecGuid *guids, ff_asf_guid guid)
Definition: riffdec.c:43
ff_DSATTRIB_TRANSPORT_PROPERTIES
const ff_asf_guid ff_DSATTRIB_TRANSPORT_PROPERTIES
Definition: wtv_common.c:60
mediatype_mpeg2_sections
static const ff_asf_guid mediatype_mpeg2_sections
Definition: wtvdec.c:361
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:57
AVIOContext::opaque
void * opaque
A private pointer, passed to the read/write/seek/...
Definition: avio.h:233
parse_videoinfoheader2
static int parse_videoinfoheader2(AVFormatContext *s, AVStream *st)
parse VIDEOINFOHEADER2 structure
Definition: wtvdec.c:558
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
WTV_SECTOR_SIZE
#define WTV_SECTOR_SIZE
Definition: wtv.h:29
WtvContext::pts
int64_t pts
pts for next data chunk
Definition: wtvdec.c:326
read_packet
static int read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: wtvdec.c:1062
read_header
static int read_header(AVFormatContext *s)
Definition: wtvdec.c:962
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
ff_metadata_conv
void ff_metadata_conv(AVDictionary **pm, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:26
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
avio_alloc_context
AVIOContext * avio_alloc_context(unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Allocate and initialize an AVIOContext for buffered I/O.
Definition: aviobuf.c:135
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:263
len
int len
Definition: vorbis_enc_data.h:426
ff_get_wav_header
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
Definition: riffdec.c:90
av_get_packet
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:197
language
Undefined Behavior In the C language
Definition: undefined.txt:3
WtvContext::nb_index_entries
int nb_index_entries
Definition: wtvdec.c:332
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:995
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
The stream is intended for visually impaired audiences.
Definition: avformat.h:861
ff_find_stream_index
int ff_find_stream_index(const AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:1276
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:949
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:935
WtvStream
Definition: wtvdec.c:319
PRI_PRETTY_GUID
#define PRI_PRETTY_GUID
Definition: wtvdec.c:40
WTV_SECTOR_BITS
#define WTV_SECTOR_BITS
Definition: wtv.h:28
oledate_to_iso8601
static int oledate_to_iso8601(char *buf, int buf_size, int64_t value)
Convert OLE DATE to ISO-8601 string.
Definition: wtvdec.c:419
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:260
WtvFile::pb_filesystem
AVIOContext * pb_filesystem
file system (AVFormatContext->pb)
Definition: wtvdec.c:51
WtvContext::last_valid_pts
int64_t last_valid_pts
latest valid pts, used for interactive seeking
Definition: wtvdec.c:327
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
ff_table_0_entries_time_le16
const uint8_t ff_table_0_entries_time_le16[40]
Definition: wtv_common.c:56
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
ff_SBE2_STREAM_DESC_EVENT
const ff_asf_guid ff_SBE2_STREAM_DESC_EVENT
Definition: wtv_common.c:33
ff_codec_bmp_tags
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:34
channel_layout.h
ff_format_videoinfo2
const ff_asf_guid ff_format_videoinfo2
Definition: wtv_common.c:78
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
mode
mode
Definition: ebur128.h:83
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:641
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:802
ff_index_search_timestamp
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries, int64_t wanted_timestamp, int flags)
Internal version of av_index_search_timestamp.
Definition: seek.c:127
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:1196
ff_dir_entry_guid
const ff_asf_guid ff_dir_entry_guid
Definition: wtv_common.c:25
AVPacket::stream_index
int stream_index
Definition: packet.h:375
FF_MEDIASUBTYPE_BASE_GUID
#define FF_MEDIASUBTYPE_BASE_GUID
Definition: riff.h:114
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:347
get_tag
static void get_tag(AVFormatContext *s, AVIOContext *pb, const char *key, int type, int length)
Definition: wtvdec.c:459
seek_by_sector
static int64_t seek_by_sector(AVIOContext *pb, int64_t sector, int64_t offset)
Definition: wtvdec.c:62
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
WTV_PAD8
#define WTV_PAD8(x)
Definition: wtv.h:31
AVIOContext::buffer
unsigned char * buffer
Start of the buffer.
Definition: avio.h:226
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
read_close
static int read_close(AVFormatContext *s)
Definition: wtvdec.c:1121
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
avio_rl64
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:767
ff_codec_wav_guids
const AVCodecGuid ff_codec_wav_guids[]
Definition: riff.c:632
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:792
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
ff_table_0_entries_legacy_attrib_le16
const uint8_t ff_table_0_entries_legacy_attrib_le16[58]
Definition: wtv_common.c:54
new_stream
static AVStream * new_stream(AVFormatContext *s, AVStream *st, int sid, int codec_type)
Initialise stream.
Definition: wtvdec.c:601
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
wtvfile_open
#define wtvfile_open(s, buf, buf_size, filename)
Definition: wtvdec.c:300
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
WtvFile::length
int64_t length
Definition: wtvdec.c:59
ff_metadata_guid
const ff_asf_guid ff_metadata_guid
Definition: wtv_common.c:62
wtv.h
mediatype_mpeg2_pes
static const ff_asf_guid mediatype_mpeg2_pes
Definition: wtvdec.c:363
snprintf
#define snprintf
Definition: snprintf.h:34
AV_CODEC_ID_MP1
@ AV_CODEC_ID_MP1
Definition: codec_id.h:465
get_attachment
static void get_attachment(AVFormatContext *s, AVIOContext *pb, int length)
Definition: wtvdec.c:431
FF_PRI_GUID
#define FF_PRI_GUID
Definition: riff.h:104
ff_add_attached_pic
int ff_add_attached_pic(AVFormatContext *s, AVStream *st, AVIOContext *pb, AVBufferRef **buf, int size)
Add an attached pic to an AVStream.
Definition: utils.c:250
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:375
Generated on Wed Aug 24 2022 21:38:28 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /