wtvdec.c 38 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050
  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. * @file
  23. * Windows Television (WTV) demuxer
  24. * @author Peter Ross <pross@xvid.org>
  25. */
  26. #include "libavutil/intreadwrite.h"
  27. #include "libavutil/intfloat.h"
  28. #include "avformat.h"
  29. #include "internal.h"
  30. #include "wtv.h"
  31. #include "mpegts.h"
  32. #include <strings.h>
  33. /* Macros for formating GUIDs */
  34. #define PRI_PRETTY_GUID \
  35. "%08x-%04x-%04x-%02x%02x%02x%02x%02x%02x%02x%02x"
  36. #define ARG_PRETTY_GUID(g) \
  37. 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]
  38. #define LEN_PRETTY_GUID 34
  39. /*
  40. *
  41. * File system routines
  42. *
  43. */
  44. typedef struct {
  45. AVIOContext *pb_filesystem; /** file system (AVFormatContext->pb) */
  46. int sector_bits; /** sector shift bits; used to convert sector number into pb_filesystem offset */
  47. uint32_t *sectors; /** file allocation table */
  48. int nb_sectors; /** number of sectors */
  49. int error;
  50. int64_t position;
  51. int64_t length;
  52. } WtvFile;
  53. /**
  54. * @return bytes read, 0 on end of file, or <0 on error
  55. */
  56. static int wtvfile_read_packet(void *opaque, uint8_t *buf, int buf_size)
  57. {
  58. WtvFile *wf = opaque;
  59. AVIOContext *pb = wf->pb_filesystem;
  60. int nread = 0;
  61. if (wf->error || pb->error)
  62. return -1;
  63. if (wf->position >= wf->length || url_feof(pb))
  64. return 0;
  65. buf_size = FFMIN(buf_size, wf->length - wf->position);
  66. while(nread < buf_size) {
  67. int n;
  68. int remaining_in_sector = (1 << wf->sector_bits) - (wf->position & ((1 << wf->sector_bits) - 1));
  69. int read_request = FFMIN(buf_size - nread, remaining_in_sector);
  70. n = avio_read(pb, buf, read_request);
  71. if (n <= 0)
  72. break;
  73. nread += n;
  74. buf += n;
  75. wf->position += n;
  76. if (n == remaining_in_sector) {
  77. int i = wf->position >> wf->sector_bits;
  78. if (i >= wf->nb_sectors ||
  79. (wf->sectors[i] != wf->sectors[i - 1] + (1 << (wf->sector_bits - WTV_SECTOR_BITS)) &&
  80. avio_seek(pb, (int64_t)wf->sectors[i] << WTV_SECTOR_BITS, SEEK_SET) < 0)) {
  81. wf->error = 1;
  82. break;
  83. }
  84. }
  85. }
  86. return nread;
  87. }
  88. /**
  89. * @return position (or file length)
  90. */
  91. static int64_t wtvfile_seek(void *opaque, int64_t offset, int whence)
  92. {
  93. WtvFile *wf = opaque;
  94. AVIOContext *pb = wf->pb_filesystem;
  95. if (whence == AVSEEK_SIZE)
  96. return wf->length;
  97. else if (whence == SEEK_CUR)
  98. offset = wf->position + offset;
  99. else if (whence == SEEK_END)
  100. offset = wf->length;
  101. wf->error = offset < 0 || offset >= wf->length ||
  102. avio_seek(pb, ((int64_t)wf->sectors[offset >> wf->sector_bits] << WTV_SECTOR_BITS)
  103. + (offset & ((1 << wf->sector_bits) - 1)), SEEK_SET) < 0;
  104. wf->position = offset;
  105. return offset;
  106. }
  107. /**
  108. * read non-zero integers (le32) from input stream
  109. * @param pb
  110. * @param[out] data destination
  111. * @param count maximum number of integers to read
  112. * @return total number of integers read
  113. */
  114. static int read_ints(AVIOContext *pb, uint32_t *data, int count)
  115. {
  116. int i, total = 0;
  117. for (i = 0; i < count; i++) {
  118. if ((data[total] = avio_rl32(pb)))
  119. total++;
  120. }
  121. return total;
  122. }
  123. /**
  124. * Open file
  125. * @param first_sector First sector
  126. * @param length Length of file (bytes)
  127. * @param depth File allocation table depth
  128. * @return NULL on error
  129. */
  130. static AVIOContext * wtvfile_open_sector(int first_sector, uint64_t length, int depth, AVFormatContext *s)
  131. {
  132. AVIOContext *pb;
  133. WtvFile *wf;
  134. uint8_t *buffer;
  135. if (avio_seek(s->pb, first_sector << WTV_SECTOR_BITS, SEEK_SET) < 0)
  136. return NULL;
  137. wf = av_mallocz(sizeof(WtvFile));
  138. if (!wf)
  139. return NULL;
  140. if (depth == 0) {
  141. wf->sectors = av_malloc(sizeof(uint32_t));
  142. if (!wf->sectors) {
  143. av_free(wf);
  144. return NULL;
  145. }
  146. wf->sectors[0] = first_sector;
  147. wf->nb_sectors = 1;
  148. } else if (depth == 1) {
  149. wf->sectors = av_malloc(WTV_SECTOR_SIZE);
  150. if (!wf->sectors) {
  151. av_free(wf);
  152. return NULL;
  153. }
  154. wf->nb_sectors = read_ints(s->pb, wf->sectors, WTV_SECTOR_SIZE / 4);
  155. } else if (depth == 2) {
  156. uint32_t sectors1[WTV_SECTOR_SIZE / 4];
  157. int nb_sectors1 = read_ints(s->pb, sectors1, WTV_SECTOR_SIZE / 4);
  158. int i;
  159. wf->sectors = av_malloc(nb_sectors1 << WTV_SECTOR_BITS);
  160. if (!wf->sectors) {
  161. av_free(wf);
  162. return NULL;
  163. }
  164. wf->nb_sectors = 0;
  165. for (i = 0; i < nb_sectors1; i++) {
  166. if (avio_seek(s->pb, (int64_t)sectors1[i] << WTV_SECTOR_BITS, SEEK_SET) < 0)
  167. break;
  168. wf->nb_sectors += read_ints(s->pb, wf->sectors + i * WTV_SECTOR_SIZE / 4, WTV_SECTOR_SIZE / 4);
  169. }
  170. } else {
  171. av_log(s, AV_LOG_ERROR, "unsupported file allocation table depth (0x%x)\n", depth);
  172. av_free(wf);
  173. return NULL;
  174. }
  175. wf->sector_bits = length & (1ULL<<63) ? WTV_SECTOR_BITS : WTV_BIGSECTOR_BITS;
  176. if (!wf->nb_sectors) {
  177. av_free(wf->sectors);
  178. av_free(wf);
  179. return NULL;
  180. }
  181. /* check length */
  182. length &= 0xFFFFFFFFFFFF;
  183. if (length > ((int64_t)wf->nb_sectors << wf->sector_bits)) {
  184. 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);
  185. length = (int64_t)wf->nb_sectors << wf->sector_bits;
  186. }
  187. wf->length = length;
  188. /* seek to intial sector */
  189. wf->position = 0;
  190. if (avio_seek(s->pb, (int64_t)wf->sectors[0] << WTV_SECTOR_BITS, SEEK_SET) < 0) {
  191. av_free(wf->sectors);
  192. av_free(wf);
  193. return NULL;
  194. }
  195. wf->pb_filesystem = s->pb;
  196. buffer = av_malloc(1 << wf->sector_bits);
  197. if (!buffer) {
  198. av_free(wf->sectors);
  199. av_free(wf);
  200. return NULL;
  201. }
  202. pb = avio_alloc_context(buffer, 1 << wf->sector_bits, 0, wf,
  203. wtvfile_read_packet, NULL, wtvfile_seek);
  204. if (!pb) {
  205. av_free(buffer);
  206. av_free(wf->sectors);
  207. av_free(wf);
  208. }
  209. return pb;
  210. }
  211. /**
  212. * Open file using filename
  213. * @param[in] buf directory buffer
  214. * @param buf_size directory buffer size
  215. * @param[in] filename
  216. * @param filename_size size of filename
  217. * @return NULL on error
  218. */
  219. static AVIOContext * wtvfile_open2(AVFormatContext *s, const uint8_t *buf, int buf_size, const uint8_t *filename, int filename_size)
  220. {
  221. const uint8_t *buf_end = buf + buf_size;
  222. while(buf + 48 <= buf_end) {
  223. int dir_length, name_size, first_sector, depth;
  224. uint64_t file_length;
  225. const uint8_t *name;
  226. if (ff_guidcmp(buf, ff_dir_entry_guid)) {
  227. av_log(s, AV_LOG_ERROR, "unknown guid "FF_PRI_GUID", expected dir_entry_guid; "
  228. "remaining directory entries ignored\n", FF_ARG_GUID(buf));
  229. break;
  230. }
  231. dir_length = AV_RL16(buf + 16);
  232. file_length = AV_RL64(buf + 24);
  233. name_size = 2 * AV_RL32(buf + 32);
  234. if (name_size < 0) {
  235. av_log(s, AV_LOG_ERROR,
  236. "bad filename length, remaining directory entries ignored\n");
  237. break;
  238. }
  239. if (48 + name_size > buf_end - buf) {
  240. av_log(s, AV_LOG_ERROR, "filename exceeds buffer size; remaining directory entries ignored\n");
  241. break;
  242. }
  243. first_sector = AV_RL32(buf + 40 + name_size);
  244. depth = AV_RL32(buf + 44 + name_size);
  245. /* compare file name; test optional null terminator */
  246. name = buf + 40;
  247. if (name_size >= filename_size &&
  248. !memcmp(name, filename, filename_size) &&
  249. (name_size < filename_size + 2 || !AV_RN16(name + filename_size)))
  250. return wtvfile_open_sector(first_sector, file_length, depth, s);
  251. buf += dir_length;
  252. }
  253. return 0;
  254. }
  255. #define wtvfile_open(s, buf, buf_size, filename) \
  256. wtvfile_open2(s, buf, buf_size, filename, sizeof(filename))
  257. /**
  258. * Close file opened with wtvfile_open_sector(), or wtv_open()
  259. */
  260. static void wtvfile_close(AVIOContext *pb)
  261. {
  262. WtvFile *wf = pb->opaque;
  263. av_free(wf->sectors);
  264. av_freep(&pb->opaque);
  265. av_freep(&pb->buffer);
  266. av_free(pb);
  267. }
  268. /*
  269. *
  270. * Main demuxer
  271. *
  272. */
  273. typedef struct {
  274. int seen_data;
  275. } WtvStream;
  276. typedef struct {
  277. AVIOContext *pb; /** timeline file */
  278. int64_t epoch;
  279. int64_t pts; /** pts for next data chunk */
  280. int64_t last_valid_pts; /** latest valid pts, used for interative seeking */
  281. /* maintain private seek index, as the AVIndexEntry->pos is relative to the
  282. start of the 'timeline' file, not the file system (AVFormatContext->pb) */
  283. AVIndexEntry *index_entries;
  284. int nb_index_entries;
  285. unsigned int index_entries_allocated_size;
  286. } WtvContext;
  287. /* WTV GUIDs */
  288. static const ff_asf_guid EVENTID_SubtitleSpanningEvent =
  289. {0x48,0xC0,0xCE,0x5D,0xB9,0xD0,0x63,0x41,0x87,0x2C,0x4F,0x32,0x22,0x3B,0xE8,0x8A};
  290. static const ff_asf_guid EVENTID_LanguageSpanningEvent =
  291. {0x6D,0x66,0x92,0xE2,0x02,0x9C,0x8D,0x44,0xAA,0x8D,0x78,0x1A,0x93,0xFD,0xC3,0x95};
  292. static const ff_asf_guid EVENTID_AudioDescriptorSpanningEvent =
  293. {0x1C,0xD4,0x7B,0x10,0xDA,0xA6,0x91,0x46,0x83,0x69,0x11,0xB2,0xCD,0xAA,0x28,0x8E};
  294. static const ff_asf_guid EVENTID_CtxADescriptorSpanningEvent =
  295. {0xE6,0xA2,0xB4,0x3A,0x47,0x42,0x34,0x4B,0x89,0x6C,0x30,0xAF,0xA5,0xD2,0x1C,0x24};
  296. static const ff_asf_guid EVENTID_CSDescriptorSpanningEvent =
  297. {0xD9,0x79,0xE7,0xEf,0xF0,0x97,0x86,0x47,0x80,0x0D,0x95,0xCF,0x50,0x5D,0xDC,0x66};
  298. static const ff_asf_guid EVENTID_DVBScramblingControlSpanningEvent =
  299. {0xC4,0xE1,0xD4,0x4B,0xA1,0x90,0x09,0x41,0x82,0x36,0x27,0xF0,0x0E,0x7D,0xCC,0x5B};
  300. static const ff_asf_guid EVENTID_StreamIDSpanningEvent =
  301. {0x68,0xAB,0xF1,0xCA,0x53,0xE1,0x41,0x4D,0xA6,0xB3,0xA7,0xC9,0x98,0xDB,0x75,0xEE};
  302. static const ff_asf_guid EVENTID_TeletextSpanningEvent =
  303. {0x50,0xD9,0x99,0x95,0x33,0x5F,0x17,0x46,0xAF,0x7C,0x1E,0x54,0xB5,0x10,0xDA,0xA3};
  304. static const ff_asf_guid EVENTID_AudioTypeSpanningEvent =
  305. {0xBE,0xBF,0x1C,0x50,0x49,0xB8,0xCE,0x42,0x9B,0xE9,0x3D,0xB8,0x69,0xFB,0x82,0xB3};
  306. /* Windows media GUIDs */
  307. /* Media types */
  308. static const ff_asf_guid mediasubtype_mpeg1payload =
  309. {0x81,0xEB,0x36,0xE4,0x4F,0x52,0xCE,0x11,0x9F,0x53,0x00,0x20,0xAF,0x0B,0xA7,0x70};
  310. static const ff_asf_guid mediatype_mpeg2_sections =
  311. {0x6C,0x17,0x5F,0x45,0x06,0x4B,0xCE,0x47,0x9A,0xEF,0x8C,0xAE,0xF7,0x3D,0xF7,0xB5};
  312. static const ff_asf_guid mediatype_mpeg2_pes =
  313. {0x20,0x80,0x6D,0xE0,0x46,0xDB,0xCF,0x11,0xB4,0xD1,0x00,0x80,0x5F,0x6C,0xBB,0xEA};
  314. static const ff_asf_guid mediatype_mstvcaption =
  315. {0x89,0x8A,0x8B,0xB8,0x49,0xB0,0x80,0x4C,0xAD,0xCF,0x58,0x98,0x98,0x5E,0x22,0xC1};
  316. /* Media subtypes */
  317. static const ff_asf_guid mediasubtype_dvb_subtitle =
  318. {0xC3,0xCB,0xFF,0x34,0xB3,0xD5,0x71,0x41,0x90,0x02,0xD4,0xC6,0x03,0x01,0x69,0x7F};
  319. static const ff_asf_guid mediasubtype_teletext =
  320. {0xE3,0x76,0x2A,0xF7,0x0A,0xEB,0xD0,0x11,0xAC,0xE4,0x00,0x00,0xC0,0xCC,0x16,0xBA};
  321. static const ff_asf_guid mediasubtype_dtvccdata =
  322. {0xAA,0xDD,0x2A,0xF5,0xF0,0x36,0xF5,0x43,0x95,0xEA,0x6D,0x86,0x64,0x84,0x26,0x2A};
  323. static const ff_asf_guid mediasubtype_mpeg2_sections =
  324. {0x79,0x85,0x9F,0x4A,0xF8,0x6B,0x92,0x43,0x8A,0x6D,0xD2,0xDD,0x09,0xFA,0x78,0x61};
  325. /* Formats */
  326. static const ff_asf_guid format_videoinfo2 =
  327. {0xA0,0x76,0x2A,0xF7,0x0A,0xEB,0xD0,0x11,0xAC,0xE4,0x00,0x00,0xC0,0xCC,0x16,0xBA};
  328. static int read_probe(AVProbeData *p)
  329. {
  330. return ff_guidcmp(p->buf, ff_wtv_guid) ? 0 : AVPROBE_SCORE_MAX;
  331. }
  332. /**
  333. * Convert win32 FILETIME to ISO-8601 string
  334. */
  335. static void filetime_to_iso8601(char *buf, int buf_size, int64_t value)
  336. {
  337. time_t t = (value / 10000000LL) - 11644473600LL;
  338. strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", gmtime(&t));
  339. }
  340. /**
  341. * Convert crazy time (100ns since 1 Jan 0001) to ISO-8601 string
  342. */
  343. static void crazytime_to_iso8601(char *buf, int buf_size, int64_t value)
  344. {
  345. time_t t = (value / 10000000LL) - 719162LL*86400LL;
  346. strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", gmtime(&t));
  347. }
  348. /**
  349. * Convert OLE DATE to ISO-8601 string
  350. * @return <0 on error
  351. */
  352. static int oledate_to_iso8601(char *buf, int buf_size, int64_t value)
  353. {
  354. time_t t = (av_int2double(value) - 25569.0) * 86400;
  355. struct tm *result= gmtime(&t);
  356. if (!result)
  357. return -1;
  358. strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", result);
  359. return 0;
  360. }
  361. static void get_attachment(AVFormatContext *s, AVIOContext *pb, int length)
  362. {
  363. char mime[1024];
  364. char description[1024];
  365. unsigned int filesize;
  366. AVStream *st;
  367. int64_t pos = avio_tell(pb);
  368. avio_get_str16le(pb, INT_MAX, mime, sizeof(mime));
  369. if (strcmp(mime, "image/jpeg"))
  370. goto done;
  371. avio_r8(pb);
  372. avio_get_str16le(pb, INT_MAX, description, sizeof(description));
  373. filesize = avio_rl32(pb);
  374. if (!filesize)
  375. goto done;
  376. st = avformat_new_stream(s, NULL);
  377. if (!st)
  378. goto done;
  379. av_dict_set(&st->metadata, "title", description, 0);
  380. st->codec->codec_id = CODEC_ID_MJPEG;
  381. st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT;
  382. st->codec->extradata = av_mallocz(filesize);
  383. st->id = -1;
  384. if (!st->codec->extradata)
  385. goto done;
  386. st->codec->extradata_size = filesize;
  387. avio_read(pb, st->codec->extradata, filesize);
  388. done:
  389. avio_seek(pb, pos + length, SEEK_SET);
  390. }
  391. static void get_tag(AVFormatContext *s, AVIOContext *pb, const char *key, int type, int length)
  392. {
  393. int buf_size = FFMAX(2*length, LEN_PRETTY_GUID) + 1;
  394. char *buf = av_malloc(buf_size);
  395. if (!buf)
  396. return;
  397. if (type == 0 && length == 4) {
  398. snprintf(buf, buf_size, "%"PRIi32, avio_rl32(pb));
  399. } else if (type == 1) {
  400. avio_get_str16le(pb, length, buf, buf_size);
  401. if (!strlen(buf)) {
  402. av_free(buf);
  403. return;
  404. }
  405. } else if (type == 3 && length == 4) {
  406. strcpy(buf, avio_rl32(pb) ? "true" : "false");
  407. } else if (type == 4 && length == 8) {
  408. int64_t num = avio_rl64(pb);
  409. if (!strcmp(key, "WM/EncodingTime") ||
  410. !strcmp(key, "WM/MediaOriginalBroadcastDateTime"))
  411. filetime_to_iso8601(buf, buf_size, num);
  412. else if (!strcmp(key, "WM/WMRVEncodeTime") ||
  413. !strcmp(key, "WM/WMRVEndTime"))
  414. crazytime_to_iso8601(buf, buf_size, num);
  415. else if (!strcmp(key, "WM/WMRVExpirationDate")) {
  416. if (oledate_to_iso8601(buf, buf_size, num) < 0 ) {
  417. av_free(buf);
  418. return;
  419. }
  420. } else if (!strcmp(key, "WM/WMRVBitrate"))
  421. snprintf(buf, buf_size, "%f", av_int2double(num));
  422. else
  423. snprintf(buf, buf_size, "%"PRIi64, num);
  424. } else if (type == 5 && length == 2) {
  425. snprintf(buf, buf_size, "%"PRIi16, avio_rl16(pb));
  426. } else if (type == 6 && length == 16) {
  427. ff_asf_guid guid;
  428. avio_read(pb, guid, 16);
  429. snprintf(buf, buf_size, PRI_PRETTY_GUID, ARG_PRETTY_GUID(guid));
  430. } else if (type == 2 && !strcmp(key, "WM/Picture")) {
  431. get_attachment(s, pb, length);
  432. av_freep(&buf);
  433. return;
  434. } else {
  435. av_freep(&buf);
  436. av_log(s, AV_LOG_WARNING, "unsupported metadata entry; key:%s, type:%d, length:0x%x\n", key, type, length);
  437. avio_skip(pb, length);
  438. return;
  439. }
  440. av_dict_set(&s->metadata, key, buf, 0);
  441. av_freep(&buf);
  442. }
  443. /**
  444. * Parse metadata entries
  445. */
  446. static void parse_legacy_attrib(AVFormatContext *s, AVIOContext *pb)
  447. {
  448. ff_asf_guid guid;
  449. int length, type;
  450. while(!url_feof(pb)) {
  451. char key[1024];
  452. ff_get_guid(pb, &guid);
  453. type = avio_rl32(pb);
  454. length = avio_rl32(pb);
  455. if (!length)
  456. break;
  457. if (ff_guidcmp(&guid, ff_metadata_guid)) {
  458. av_log(s, AV_LOG_WARNING, "unknown guid "FF_PRI_GUID", expected metadata_guid; "
  459. "remaining metadata entries ignored\n", FF_ARG_GUID(guid));
  460. break;
  461. }
  462. avio_get_str16le(pb, INT_MAX, key, sizeof(key));
  463. get_tag(s, pb, key, type, length);
  464. }
  465. ff_metadata_conv(&s->metadata, NULL, ff_asf_metadata_conv);
  466. }
  467. /**
  468. * parse VIDEOINFOHEADER2 structure
  469. * @return bytes consumed
  470. */
  471. static int parse_videoinfoheader2(AVFormatContext *s, AVStream *st)
  472. {
  473. WtvContext *wtv = s->priv_data;
  474. AVIOContext *pb = wtv->pb;
  475. avio_skip(pb, 72); // picture aspect ratio is unreliable
  476. ff_get_bmp_header(pb, st);
  477. return 72 + 40;
  478. }
  479. /**
  480. * Parse MPEG1WAVEFORMATEX extradata structure
  481. */
  482. static void parse_mpeg1waveformatex(AVStream *st)
  483. {
  484. /* fwHeadLayer */
  485. switch (AV_RL16(st->codec->extradata)) {
  486. case 0x0001 : st->codec->codec_id = CODEC_ID_MP1; break;
  487. case 0x0002 : st->codec->codec_id = CODEC_ID_MP2; break;
  488. case 0x0004 : st->codec->codec_id = CODEC_ID_MP3; break;
  489. }
  490. st->codec->bit_rate = AV_RL32(st->codec->extradata + 2); /* dwHeadBitrate */
  491. /* dwHeadMode */
  492. switch (AV_RL16(st->codec->extradata + 6)) {
  493. case 1 : case 2 : case 4 : st->codec->channels = 2; break;
  494. case 8 : st->codec->channels = 1; break;
  495. }
  496. }
  497. /**
  498. * Initialise stream
  499. * @param st Stream to initialise, or NULL to create and initialise new stream
  500. * @return NULL on error
  501. */
  502. static AVStream * new_stream(AVFormatContext *s, AVStream *st, int sid, int codec_type)
  503. {
  504. if (st) {
  505. if (st->codec->extradata) {
  506. av_freep(&st->codec->extradata);
  507. st->codec->extradata_size = 0;
  508. }
  509. } else {
  510. WtvStream *wst = av_mallocz(sizeof(WtvStream));
  511. if (!wst)
  512. return NULL;
  513. st = avformat_new_stream(s, NULL);
  514. if (!st) {
  515. av_free(wst);
  516. return NULL;
  517. }
  518. st->id = sid;
  519. st->priv_data = wst;
  520. }
  521. st->codec->codec_type = codec_type;
  522. st->need_parsing = AVSTREAM_PARSE_FULL;
  523. avpriv_set_pts_info(st, 64, 1, 10000000);
  524. return st;
  525. }
  526. /**
  527. * parse Media Type structure and populate stream
  528. * @param st Stream, or NULL to create new stream
  529. * @param mediatype Mediatype GUID
  530. * @param subtype Subtype GUID
  531. * @param formattype Format GUID
  532. * @param size Size of format buffer
  533. * @return NULL on error
  534. */
  535. static AVStream * parse_media_type(AVFormatContext *s, AVStream *st, int sid,
  536. ff_asf_guid mediatype, ff_asf_guid subtype,
  537. ff_asf_guid formattype, int size)
  538. {
  539. WtvContext *wtv = s->priv_data;
  540. AVIOContext *pb = wtv->pb;
  541. if (!ff_guidcmp(subtype, ff_mediasubtype_cpfilters_processed) &&
  542. !ff_guidcmp(formattype, ff_format_cpfilters_processed)) {
  543. ff_asf_guid actual_subtype;
  544. ff_asf_guid actual_formattype;
  545. if (size < 32) {
  546. av_log(s, AV_LOG_WARNING, "format buffer size underflow\n");
  547. avio_skip(pb, size);
  548. return NULL;
  549. }
  550. avio_skip(pb, size - 32);
  551. ff_get_guid(pb, &actual_subtype);
  552. ff_get_guid(pb, &actual_formattype);
  553. avio_seek(pb, -size, SEEK_CUR);
  554. st = parse_media_type(s, st, sid, mediatype, actual_subtype, actual_formattype, size - 32);
  555. avio_skip(pb, 32);
  556. return st;
  557. } else if (!ff_guidcmp(mediatype, ff_mediatype_audio)) {
  558. st = new_stream(s, st, sid, AVMEDIA_TYPE_AUDIO);
  559. if (!st)
  560. return NULL;
  561. if (!ff_guidcmp(formattype, ff_format_waveformatex)) {
  562. int ret = ff_get_wav_header(pb, st->codec, size);
  563. if (ret < 0)
  564. return NULL;
  565. } else {
  566. if (ff_guidcmp(formattype, ff_format_none))
  567. av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
  568. avio_skip(pb, size);
  569. }
  570. if (!memcmp(subtype + 4, (const uint8_t[]){FF_MEDIASUBTYPE_BASE_GUID}, 12)) {
  571. st->codec->codec_id = ff_wav_codec_get_id(AV_RL32(subtype), st->codec->bits_per_coded_sample);
  572. } else if (!ff_guidcmp(subtype, mediasubtype_mpeg1payload)) {
  573. if (st->codec->extradata && st->codec->extradata_size >= 22)
  574. parse_mpeg1waveformatex(st);
  575. else
  576. av_log(s, AV_LOG_WARNING, "MPEG1WAVEFORMATEX underflow\n");
  577. } else {
  578. st->codec->codec_id = ff_codec_guid_get_id(ff_codec_wav_guids, subtype);
  579. if (st->codec->codec_id == CODEC_ID_NONE)
  580. av_log(s, AV_LOG_WARNING, "unknown subtype:"FF_PRI_GUID"\n", FF_ARG_GUID(subtype));
  581. }
  582. return st;
  583. } else if (!ff_guidcmp(mediatype, ff_mediatype_video)) {
  584. st = new_stream(s, st, sid, AVMEDIA_TYPE_VIDEO);
  585. if (!st)
  586. return NULL;
  587. if (!ff_guidcmp(formattype, format_videoinfo2)) {
  588. int consumed = parse_videoinfoheader2(s, st);
  589. avio_skip(pb, FFMAX(size - consumed, 0));
  590. } else if (!ff_guidcmp(formattype, ff_format_mpeg2_video)) {
  591. int consumed = parse_videoinfoheader2(s, st);
  592. avio_skip(pb, FFMAX(size - consumed, 0));
  593. } else {
  594. if (ff_guidcmp(formattype, ff_format_none))
  595. av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
  596. avio_skip(pb, size);
  597. }
  598. if (!memcmp(subtype + 4, (const uint8_t[]){FF_MEDIASUBTYPE_BASE_GUID}, 12)) {
  599. st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, AV_RL32(subtype));
  600. } else {
  601. st->codec->codec_id = ff_codec_guid_get_id(ff_video_guids, subtype);
  602. }
  603. if (st->codec->codec_id == CODEC_ID_NONE)
  604. av_log(s, AV_LOG_WARNING, "unknown subtype:"FF_PRI_GUID"\n", FF_ARG_GUID(subtype));
  605. return st;
  606. } else if (!ff_guidcmp(mediatype, mediatype_mpeg2_pes) &&
  607. !ff_guidcmp(subtype, mediasubtype_dvb_subtitle)) {
  608. st = new_stream(s, st, sid, AVMEDIA_TYPE_SUBTITLE);
  609. if (!st)
  610. return NULL;
  611. if (ff_guidcmp(formattype, ff_format_none))
  612. av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
  613. avio_skip(pb, size);
  614. st->codec->codec_id = CODEC_ID_DVB_SUBTITLE;
  615. return st;
  616. } else if (!ff_guidcmp(mediatype, mediatype_mstvcaption) &&
  617. (!ff_guidcmp(subtype, mediasubtype_teletext) || !ff_guidcmp(subtype, mediasubtype_dtvccdata))) {
  618. st = new_stream(s, st, sid, AVMEDIA_TYPE_SUBTITLE);
  619. if (!st)
  620. return NULL;
  621. if (ff_guidcmp(formattype, ff_format_none))
  622. av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
  623. avio_skip(pb, size);
  624. st->codec->codec_id = CODEC_ID_DVB_TELETEXT;
  625. return st;
  626. } else if (!ff_guidcmp(mediatype, mediatype_mpeg2_sections) &&
  627. !ff_guidcmp(subtype, mediasubtype_mpeg2_sections)) {
  628. if (ff_guidcmp(formattype, ff_format_none))
  629. av_log(s, AV_LOG_WARNING, "unknown formattype:"FF_PRI_GUID"\n", FF_ARG_GUID(formattype));
  630. avio_skip(pb, size);
  631. return NULL;
  632. }
  633. av_log(s, AV_LOG_WARNING, "unknown media type, mediatype:"FF_PRI_GUID
  634. ", subtype:"FF_PRI_GUID", formattype:"FF_PRI_GUID"\n",
  635. FF_ARG_GUID(mediatype), FF_ARG_GUID(subtype), FF_ARG_GUID(formattype));
  636. avio_skip(pb, size);
  637. return NULL;
  638. }
  639. enum {
  640. SEEK_TO_DATA = 0,
  641. SEEK_TO_PTS,
  642. };
  643. /**
  644. * Parse WTV chunks
  645. * @param mode SEEK_TO_DATA or SEEK_TO_PTS
  646. * @param seekts timestamp
  647. * @param[out] len_ptr Length of data chunk
  648. * @return stream index of data chunk, or <0 on error
  649. */
  650. static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_ptr)
  651. {
  652. WtvContext *wtv = s->priv_data;
  653. AVIOContext *pb = wtv->pb;
  654. while (!url_feof(pb)) {
  655. ff_asf_guid g;
  656. int len, sid, consumed;
  657. ff_get_guid(pb, &g);
  658. len = avio_rl32(pb);
  659. if (len < 32)
  660. break;
  661. sid = avio_rl32(pb) & 0x7FFF;
  662. avio_skip(pb, 8);
  663. consumed = 32;
  664. if (!ff_guidcmp(g, ff_stream_guid)) {
  665. if (ff_find_stream_index(s, sid) < 0) {
  666. ff_asf_guid mediatype, subtype, formattype;
  667. int size;
  668. avio_skip(pb, 28);
  669. ff_get_guid(pb, &mediatype);
  670. ff_get_guid(pb, &subtype);
  671. avio_skip(pb, 12);
  672. ff_get_guid(pb, &formattype);
  673. size = avio_rl32(pb);
  674. parse_media_type(s, 0, sid, mediatype, subtype, formattype, size);
  675. consumed += 92 + size;
  676. }
  677. } else if (!ff_guidcmp(g, ff_stream2_guid)) {
  678. int stream_index = ff_find_stream_index(s, sid);
  679. if (stream_index >= 0 && !((WtvStream*)s->streams[stream_index]->priv_data)->seen_data) {
  680. ff_asf_guid mediatype, subtype, formattype;
  681. int size;
  682. avio_skip(pb, 12);
  683. ff_get_guid(pb, &mediatype);
  684. ff_get_guid(pb, &subtype);
  685. avio_skip(pb, 12);
  686. ff_get_guid(pb, &formattype);
  687. size = avio_rl32(pb);
  688. parse_media_type(s, s->streams[stream_index], sid, mediatype, subtype, formattype, size);
  689. consumed += 76 + size;
  690. }
  691. } else if (!ff_guidcmp(g, EVENTID_AudioDescriptorSpanningEvent) ||
  692. !ff_guidcmp(g, EVENTID_CtxADescriptorSpanningEvent) ||
  693. !ff_guidcmp(g, EVENTID_CSDescriptorSpanningEvent) ||
  694. !ff_guidcmp(g, EVENTID_StreamIDSpanningEvent) ||
  695. !ff_guidcmp(g, EVENTID_SubtitleSpanningEvent) ||
  696. !ff_guidcmp(g, EVENTID_TeletextSpanningEvent)) {
  697. int stream_index = ff_find_stream_index(s, sid);
  698. if (stream_index >= 0) {
  699. AVStream *st = s->streams[stream_index];
  700. uint8_t buf[258];
  701. const uint8_t *pbuf = buf;
  702. int buf_size;
  703. avio_skip(pb, 8);
  704. consumed += 8;
  705. if (!ff_guidcmp(g, EVENTID_CtxADescriptorSpanningEvent) ||
  706. !ff_guidcmp(g, EVENTID_CSDescriptorSpanningEvent)) {
  707. avio_skip(pb, 6);
  708. consumed += 6;
  709. }
  710. buf_size = FFMIN(len - consumed, sizeof(buf));
  711. avio_read(pb, buf, buf_size);
  712. consumed += buf_size;
  713. ff_parse_mpeg2_descriptor(s, st, 0, &pbuf, buf + buf_size, NULL, 0, 0, NULL);
  714. }
  715. } else if (!ff_guidcmp(g, EVENTID_AudioTypeSpanningEvent)) {
  716. int stream_index = ff_find_stream_index(s, sid);
  717. if (stream_index >= 0) {
  718. AVStream *st = s->streams[stream_index];
  719. int audio_type;
  720. avio_skip(pb, 8);
  721. audio_type = avio_r8(pb);
  722. if (audio_type == 2)
  723. st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED;
  724. else if (audio_type == 3)
  725. st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED;
  726. consumed += 9;
  727. }
  728. } else if (!ff_guidcmp(g, EVENTID_DVBScramblingControlSpanningEvent)) {
  729. int stream_index = ff_find_stream_index(s, sid);
  730. if (stream_index >= 0) {
  731. avio_skip(pb, 12);
  732. if (avio_rl32(pb))
  733. av_log(s, AV_LOG_WARNING, "DVB scrambled stream detected (st:%d), decoding will likely fail\n", stream_index);
  734. consumed += 16;
  735. }
  736. } else if (!ff_guidcmp(g, EVENTID_LanguageSpanningEvent)) {
  737. int stream_index = ff_find_stream_index(s, sid);
  738. if (stream_index >= 0) {
  739. AVStream *st = s->streams[stream_index];
  740. uint8_t language[4];
  741. avio_skip(pb, 12);
  742. avio_read(pb, language, 3);
  743. if (language[0]) {
  744. language[3] = 0;
  745. av_dict_set(&st->metadata, "language", language, 0);
  746. if (!strcmp(language, "nar") || !strcmp(language, "NAR"))
  747. st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED;
  748. }
  749. consumed += 15;
  750. }
  751. } else if (!ff_guidcmp(g, ff_timestamp_guid)) {
  752. int stream_index = ff_find_stream_index(s, sid);
  753. if (stream_index >= 0) {
  754. avio_skip(pb, 8);
  755. wtv->pts = avio_rl64(pb);
  756. consumed += 16;
  757. if (wtv->pts == -1)
  758. wtv->pts = AV_NOPTS_VALUE;
  759. else {
  760. wtv->last_valid_pts = wtv->pts;
  761. if (wtv->epoch == AV_NOPTS_VALUE || wtv->pts < wtv->epoch)
  762. wtv->epoch = wtv->pts;
  763. if (mode == SEEK_TO_PTS && wtv->pts >= seekts) {
  764. avio_skip(pb, WTV_PAD8(len) - consumed);
  765. return 0;
  766. }
  767. }
  768. }
  769. } else if (!ff_guidcmp(g, ff_data_guid)) {
  770. int stream_index = ff_find_stream_index(s, sid);
  771. if (mode == SEEK_TO_DATA && stream_index >= 0 && len > 32) {
  772. WtvStream *wst = s->streams[stream_index]->priv_data;
  773. wst->seen_data = 1;
  774. if (len_ptr) {
  775. *len_ptr = len;
  776. }
  777. return stream_index;
  778. }
  779. } else if (
  780. !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}) ||
  781. !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}) ||
  782. !ff_guidcmp(g, /* DSATTRIB_TRANSPORT_PROPERTIES */ ff_DSATTRIB_TRANSPORT_PROPERTIES) ||
  783. !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}) ||
  784. !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}) ||
  785. !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}) ||
  786. !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}) ||
  787. !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}) ||
  788. !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}) ||
  789. !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}) ||
  790. !ff_guidcmp(g, (const ff_asf_guid){0x1E,0xBE,0xC3,0xC5,0x43,0x92,0xDC,0x11,0x85,0xE5,0x00,0x12,0x3F,0x6F,0x73,0xB9}) ||
  791. !ff_guidcmp(g, (const ff_asf_guid){0x3B,0x86,0xA2,0xB1,0xEB,0x1E,0xC3,0x44,0x8C,0x88,0x1C,0xA3,0xFF,0xE3,0xE7,0x6A}) ||
  792. !ff_guidcmp(g, (const ff_asf_guid){0x4E,0x7F,0x4C,0x5B,0xC4,0xD0,0x38,0x4B,0xA8,0x3E,0x21,0x7F,0x7B,0xBF,0x52,0xE7}) ||
  793. !ff_guidcmp(g, (const ff_asf_guid){0x63,0x36,0xEB,0xFE,0xA1,0x7E,0xD9,0x11,0x83,0x08,0x00,0x07,0xE9,0x5E,0xAD,0x8D}) ||
  794. !ff_guidcmp(g, (const ff_asf_guid){0x70,0xE9,0xF1,0xF8,0x89,0xA4,0x4C,0x4D,0x83,0x73,0xB8,0x12,0xE0,0xD5,0xF8,0x1E}) ||
  795. !ff_guidcmp(g, (const ff_asf_guid){0x96,0xC3,0xD2,0xC2,0x7E,0x9A,0xDA,0x11,0x8B,0xF7,0x00,0x07,0xE9,0x5E,0xAD,0x8D}) ||
  796. !ff_guidcmp(g, (const ff_asf_guid){0x97,0xC3,0xD2,0xC2,0x7E,0x9A,0xDA,0x11,0x8B,0xF7,0x00,0x07,0xE9,0x5E,0xAD,0x8D}) ||
  797. !ff_guidcmp(g, (const ff_asf_guid){0xA1,0xC3,0xD2,0xC2,0x7E,0x9A,0xDA,0x11,0x8B,0xF7,0x00,0x07,0xE9,0x5E,0xAD,0x8D}) ||
  798. !ff_guidcmp(g, (const ff_asf_guid){0xF7,0x10,0x02,0xB9,0xEE,0x7C,0xED,0x4E,0xBD,0x7F,0x05,0x40,0x35,0x86,0x18,0xA1})) {
  799. //ignore known guids
  800. } else
  801. av_log(s, AV_LOG_WARNING, "unsupported chunk:"FF_PRI_GUID"\n", FF_ARG_GUID(g));
  802. avio_skip(pb, WTV_PAD8(len) - consumed);
  803. }
  804. return AVERROR_EOF;
  805. }
  806. static int read_header(AVFormatContext *s, AVFormatParameters *ap)
  807. {
  808. WtvContext *wtv = s->priv_data;
  809. int root_sector, root_size;
  810. uint8_t root[WTV_SECTOR_SIZE];
  811. AVIOContext *pb;
  812. int64_t timeline_pos;
  813. int ret;
  814. wtv->epoch =
  815. wtv->pts =
  816. wtv->last_valid_pts = AV_NOPTS_VALUE;
  817. /* read root directory sector */
  818. avio_skip(s->pb, 0x30);
  819. root_size = avio_rl32(s->pb);
  820. if (root_size > sizeof(root)) {
  821. av_log(s, AV_LOG_ERROR, "root directory size exceeds sector size\n");
  822. return AVERROR_INVALIDDATA;
  823. }
  824. avio_skip(s->pb, 4);
  825. root_sector = avio_rl32(s->pb);
  826. avio_seek(s->pb, root_sector << WTV_SECTOR_BITS, SEEK_SET);
  827. root_size = avio_read(s->pb, root, root_size);
  828. if (root_size < 0)
  829. return AVERROR_INVALIDDATA;
  830. /* parse chunks up until first data chunk */
  831. wtv->pb = wtvfile_open(s, root, root_size, ff_timeline_le16);
  832. if (!wtv->pb) {
  833. av_log(s, AV_LOG_ERROR, "timeline data missing\n");
  834. return AVERROR_INVALIDDATA;
  835. }
  836. ret = parse_chunks(s, SEEK_TO_DATA, 0, 0);
  837. if (ret < 0)
  838. return ret;
  839. avio_seek(wtv->pb, -32, SEEK_CUR);
  840. timeline_pos = avio_tell(s->pb); // save before opening another file
  841. /* read metadata */
  842. pb = wtvfile_open(s, root, root_size, ff_table_0_entries_legacy_attrib_le16);
  843. if (pb) {
  844. parse_legacy_attrib(s, pb);
  845. wtvfile_close(pb);
  846. }
  847. /* read seek index */
  848. if (s->nb_streams) {
  849. AVStream *st = s->streams[0];
  850. pb = wtvfile_open(s, root, root_size, ff_table_0_entries_time_le16);
  851. if (pb) {
  852. while(1) {
  853. uint64_t timestamp = avio_rl64(pb);
  854. uint64_t frame_nb = avio_rl64(pb);
  855. if (url_feof(pb))
  856. break;
  857. ff_add_index_entry(&wtv->index_entries, &wtv->nb_index_entries, &wtv->index_entries_allocated_size,
  858. 0, timestamp, frame_nb, 0, AVINDEX_KEYFRAME);
  859. }
  860. wtvfile_close(pb);
  861. if (wtv->nb_index_entries) {
  862. pb = wtvfile_open(s, root, root_size, ff_timeline_table_0_entries_Events_le16);
  863. if (pb) {
  864. int i;
  865. while (1) {
  866. uint64_t frame_nb = avio_rl64(pb);
  867. uint64_t position = avio_rl64(pb);
  868. if (url_feof(pb))
  869. break;
  870. for (i = wtv->nb_index_entries - 1; i >= 0; i--) {
  871. AVIndexEntry *e = wtv->index_entries + i;
  872. if (frame_nb > e->size)
  873. break;
  874. if (position > e->pos)
  875. e->pos = position;
  876. }
  877. }
  878. wtvfile_close(pb);
  879. st->duration = wtv->index_entries[wtv->nb_index_entries - 1].timestamp;
  880. }
  881. }
  882. }
  883. }
  884. avio_seek(s->pb, timeline_pos, SEEK_SET);
  885. return 0;
  886. }
  887. static int read_packet(AVFormatContext *s, AVPacket *pkt)
  888. {
  889. WtvContext *wtv = s->priv_data;
  890. AVIOContext *pb = wtv->pb;
  891. int stream_index, len, ret;
  892. stream_index = parse_chunks(s, SEEK_TO_DATA, 0, &len);
  893. if (stream_index < 0)
  894. return stream_index;
  895. ret = av_get_packet(pb, pkt, len - 32);
  896. if (ret < 0)
  897. return ret;
  898. pkt->stream_index = stream_index;
  899. pkt->pts = wtv->pts;
  900. avio_skip(pb, WTV_PAD8(len) - len);
  901. return 0;
  902. }
  903. static int read_seek(AVFormatContext *s, int stream_index,
  904. int64_t ts, int flags)
  905. {
  906. WtvContext *wtv = s->priv_data;
  907. AVIOContext *pb = wtv->pb;
  908. AVStream *st = s->streams[0];
  909. int64_t ts_relative;
  910. int i;
  911. if ((flags & AVSEEK_FLAG_FRAME) || (flags & AVSEEK_FLAG_BYTE))
  912. return AVERROR(ENOSYS);
  913. /* timestamp adjustment is required because wtv->pts values are absolute,
  914. * whereas AVIndexEntry->timestamp values are relative to epoch. */
  915. ts_relative = ts;
  916. if (wtv->epoch != AV_NOPTS_VALUE)
  917. ts_relative -= wtv->epoch;
  918. i = ff_index_search_timestamp(wtv->index_entries, wtv->nb_index_entries, ts_relative, flags);
  919. if (i < 0) {
  920. if (wtv->last_valid_pts == AV_NOPTS_VALUE || ts < wtv->last_valid_pts) {
  921. if (avio_seek(pb, 0, SEEK_SET) < 0)
  922. return -1;
  923. } else if (st->duration != AV_NOPTS_VALUE && ts_relative > st->duration && wtv->nb_index_entries) {
  924. if (avio_seek(pb, wtv->index_entries[wtv->nb_index_entries - 1].pos, SEEK_SET) < 0)
  925. return -1;
  926. }
  927. if (parse_chunks(s, SEEK_TO_PTS, ts, 0) < 0)
  928. return AVERROR(ERANGE);
  929. return 0;
  930. }
  931. if (avio_seek(pb, wtv->index_entries[i].pos, SEEK_SET) < 0)
  932. return -1;
  933. wtv->pts = wtv->index_entries[i].timestamp;
  934. if (wtv->epoch != AV_NOPTS_VALUE)
  935. wtv->pts += wtv->epoch;
  936. wtv->last_valid_pts = wtv->pts;
  937. return 0;
  938. }
  939. static int read_close(AVFormatContext *s)
  940. {
  941. WtvContext *wtv = s->priv_data;
  942. av_freep(&wtv->index_entries);
  943. wtvfile_close(wtv->pb);
  944. return 0;
  945. }
  946. AVInputFormat ff_wtv_demuxer = {
  947. .name = "wtv",
  948. .long_name = NULL_IF_CONFIG_SMALL("Windows Television (WTV)"),
  949. .priv_data_size = sizeof(WtvContext),
  950. .read_probe = read_probe,
  951. .read_header = read_header,
  952. .read_packet = read_packet,
  953. .read_seek = read_seek,
  954. .read_close = read_close,
  955. .flags = AVFMT_SHOW_IDS,
  956. };