FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
wtvenc.c
Go to the documentation of this file.
1 /*
2  * Windows Television (WTV) muxer
3  * Copyright (c) 2011 Zhentan Feng <spyfeng at gmail dot com>
4  * Copyright (c) 2011 Peter Ross <pross@xvid.org>
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 Zhentan Feng <spyfeng at gmail dot com>
26  */
27 
28 #include "libavutil/intreadwrite.h"
29 #include "libavutil/avassert.h"
30 #include "avformat.h"
31 #include "avio_internal.h"
32 #include "internal.h"
33 #include "wtv.h"
34 
35 #define WTV_BIGSECTOR_SIZE (1 << WTV_BIGSECTOR_BITS)
36 #define INDEX_BASE 0x2
37 #define MAX_NB_INDEX 10
38 
39 /* declare utf16le strings */
40 #define _ , 0,
42  {'t'_'i'_'m'_'e'_'l'_'i'_'n'_'e'_'.'_'t'_'a'_'b'_'l'_'e'_'.'_'0'_'.'_'h'_'e'_'a'_'d'_'e'_'r'_'.'_'E'_'v'_'e'_'n'_'t'_'s', 0};
44  {'t'_'a'_'b'_'l'_'e'_'.'_'0'_'.'_'h'_'e'_'a'_'d'_'e'_'r'_'.'_'l'_'e'_'g'_'a'_'c'_'y'_'_'_'a'_'t'_'t'_'r'_'i'_'b', 0};
46  {'t'_'a'_'b'_'l'_'e'_'.'_'0'_'.'_'r'_'e'_'d'_'i'_'r'_'e'_'c'_'t'_'o'_'r'_'.'_'l'_'e'_'g'_'a'_'c'_'y'_'_'_'a'_'t'_'t'_'r'_'i'_'b', 0};
47 static const uint8_t table_0_header_time[] =
48  {'t'_'a'_'b'_'l'_'e'_'.'_'0'_'.'_'h'_'e'_'a'_'d'_'e'_'r'_'.'_'t'_'i'_'m'_'e', 0};
49 static const uint8_t legacy_attrib[] =
50  {'l'_'e'_'g'_'a'_'c'_'y'_'_'_'a'_'t'_'t'_'r'_'i'_'b', 0};
51 #undef _
52 
53 static const ff_asf_guid sub_wtv_guid =
54  {0x8C,0xC3,0xD2,0xC2,0x7E,0x9A,0xDA,0x11,0x8B,0xF7,0x00,0x07,0xE9,0x5E,0xAD,0x8D};
55 
66 };
67 
68 typedef struct {
69  int64_t length;
70  const void *header;
71  int depth;
73 } WtvFile;
74 
75 typedef struct {
76  int64_t pos;
77  int64_t serial;
78  const ff_asf_guid * guid;
79  int stream_id;
81 
82 typedef struct {
83  int64_t serial;
84  int64_t value;
85 } WtvSyncEntry;
86 
87 typedef struct {
90  int64_t serial; /**< chunk serial number */
91  int64_t last_chunk_pos; /**< last chunk position */
92  int64_t last_timestamp_pos; /**< last timestamp chunk position */
93  int64_t first_index_pos; /**< first index_chunk position */
94 
96  int nb_index;
98 
99  WtvSyncEntry *st_pairs; /* (serial, timestamp) pairs */
101  WtvSyncEntry *sp_pairs; /* (serial, position) pairs */
103 
104  int64_t last_pts;
105  int64_t last_serial;
106 
108 } WtvContext;
109 
110 
111 static void add_serial_pair(WtvSyncEntry ** list, int * count, int64_t serial, int64_t value)
112 {
113  int new_count = *count + 1;
114  WtvSyncEntry *new_list = av_realloc(*list, new_count * sizeof(WtvSyncEntry));
115  if (!new_list)
116  return;
117  new_list[*count] = (WtvSyncEntry){serial, value};
118  *list = new_list;
119  *count = new_count;
120 }
121 
123 
124 typedef struct {
125  const uint8_t *header;
129 
130 #define write_pad(pb, size) ffio_fill(pb, 0, size)
131 
132 /**
133  * Write chunk header. If header chunk (0x80000000 set) then add to list of header chunks
134  */
135 static void write_chunk_header(AVFormatContext *s, const ff_asf_guid *guid, int length, int stream_id)
136 {
137  WtvContext *wctx = s->priv_data;
138  AVIOContext *pb = s->pb;
139 
140  wctx->last_chunk_pos = avio_tell(pb) - wctx->timeline_start_pos;
141  ff_put_guid(pb, guid);
142  avio_wl32(pb, 32 + length);
143  avio_wl32(pb, stream_id);
144  avio_wl64(pb, wctx->serial);
145 
146  if ((stream_id & 0x80000000) && guid != &ff_index_guid) {
147  WtvChunkEntry *t = wctx->index + wctx->nb_index;
149  t->pos = wctx->last_chunk_pos;
150  t->serial = wctx->serial;
151  t->guid = guid;
152  t->stream_id = stream_id & 0x3FFFFFFF;
153  wctx->nb_index++;
154  }
155 }
156 
157 static void write_chunk_header2(AVFormatContext *s, const ff_asf_guid *guid, int stream_id)
158 {
159  WtvContext *wctx = s->priv_data;
160  AVIOContext *pb = s->pb;
161 
162  int64_t last_chunk_pos = wctx->last_chunk_pos;
163  write_chunk_header(s, guid, 0, stream_id); // length updated later
164  avio_wl64(pb, last_chunk_pos);
165 }
166 
168 {
169  WtvContext *wctx = s->priv_data;
170  AVIOContext *pb = s->pb;
171 
172  // update the chunk_len field and pad.
173  int64_t chunk_len = avio_tell(pb) - (wctx->last_chunk_pos + wctx->timeline_start_pos);
174  avio_seek(pb, -(chunk_len - 16), SEEK_CUR);
175  avio_wl32(pb, chunk_len);
176  avio_seek(pb, chunk_len - (16 + 4), SEEK_CUR);
177 
178  write_pad(pb, WTV_PAD8(chunk_len) - chunk_len);
179  wctx->serial++;
180 }
181 
183 {
184  AVIOContext *pb = s->pb;
185  WtvContext *wctx = s->priv_data;
186  int i;
187 
188  write_chunk_header2(s, &ff_index_guid, 0x80000000);
189  avio_wl32(pb, 0);
190  avio_wl32(pb, 0);
191 
192  for (i = 0; i < wctx->nb_index; i++) {
193  WtvChunkEntry *t = wctx->index + i;
194  ff_put_guid(pb, t->guid);
195  avio_wl64(pb, t->pos);
196  avio_wl32(pb, t->stream_id);
197  avio_wl32(pb, 0); // checksum?
198  avio_wl64(pb, t->serial);
199  }
200  wctx->nb_index = 0; // reset index
202 
203  if (!wctx->first_index_pos)
204  wctx->first_index_pos = wctx->last_chunk_pos;
205 }
206 
208 {
209  WtvContext *wctx = s->priv_data;
211  if (wctx->nb_index == MAX_NB_INDEX)
212  write_index(s);
213 }
214 
216 {
218  unsigned int num, den;
219  av_reduce(&num, &den, dar.num, dar.den, 0xFFFFFFFF);
220 
221  /* VIDEOINFOHEADER2 */
222  avio_wl32(pb, 0);
223  avio_wl32(pb, 0);
224  avio_wl32(pb, st->codec->width);
225  avio_wl32(pb, st->codec->height);
226 
227  avio_wl32(pb, 0);
228  avio_wl32(pb, 0);
229  avio_wl32(pb, 0);
230  avio_wl32(pb, 0);
231 
232  avio_wl32(pb, st->codec->bit_rate);
233  avio_wl32(pb, 0);
234  avio_wl64(pb, st->avg_frame_rate.num && st->avg_frame_rate.den ? INT64_C(10000000) / av_q2d(st->avg_frame_rate) : 0);
235  avio_wl32(pb, 0);
236  avio_wl32(pb, 0);
237 
238  avio_wl32(pb, num);
239  avio_wl32(pb, den);
240  avio_wl32(pb, 0);
241  avio_wl32(pb, 0);
242 
243  ff_put_bmp_header(pb, st->codec, ff_codec_bmp_tags, 0, 1);
244 
245  if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
246  /* MPEG2VIDEOINFO */
247  avio_wl32(pb, 0);
248  avio_wl32(pb, st->codec->extradata_size);
249  avio_wl32(pb, -1);
250  avio_wl32(pb, -1);
251  avio_wl32(pb, 0);
252  avio_write(pb, st->codec->extradata, st->codec->extradata_size);
253  avio_wl64(pb, 0);
254  }
255 }
256 
258 {
259  const ff_asf_guid *g, *media_type, *format_type;
260  const AVCodecTag *tags;
261  AVIOContext *pb = s->pb;
262  int64_t hdr_pos_start;
263  int hdr_size = 0;
264 
265  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
267  media_type = &ff_mediatype_video;
269  tags = ff_codec_bmp_tags;
270  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
272  media_type = &ff_mediatype_audio;
273  format_type = &ff_format_waveformatex;
274  tags = ff_codec_wav_tags;
275  } else {
276  av_log(s, AV_LOG_ERROR, "unknown codec_type (0x%x)\n", st->codec->codec_type);
277  return -1;
278  }
279 
280  ff_put_guid(pb, media_type); // mediatype
282  write_pad(pb, 12);
283  ff_put_guid(pb,&ff_format_cpfilters_processed); // format type
284  avio_wl32(pb, 0); // size
285 
286  hdr_pos_start = avio_tell(pb);
287  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
288  put_videoinfoheader2(pb, st);
289  } else {
290  if (ff_put_wav_header(pb, st->codec) < 0)
291  format_type = &ff_format_none;
292  }
293  hdr_size = avio_tell(pb) - hdr_pos_start;
294 
295  // seek back write hdr_size
296  avio_seek(pb, -(hdr_size + 4), SEEK_CUR);
297  avio_wl32(pb, hdr_size + 32);
298  avio_seek(pb, hdr_size, SEEK_CUR);
299  if (g) {
300  ff_put_guid(pb, g); // actual_subtype
301  } else {
302  int tag = ff_codec_get_tag(tags, st->codec->codec_id);
303  if (!tag) {
304  av_log(s, AV_LOG_ERROR, "unsupported codec_id (0x%x)\n", st->codec->codec_id);
305  return -1;
306  }
307  avio_wl32(pb, tag);
308  avio_write(pb, (const uint8_t[]){FF_MEDIASUBTYPE_BASE_GUID}, 12);
309  }
310  ff_put_guid(pb, format_type); // actual_formattype
311 
312  return 0;
313 }
314 
316 {
317  AVIOContext *pb = s->pb;
318  int ret;
319  write_chunk_header2(s, &ff_stream1_guid, 0x80000000 | 0x01);
320 
321  avio_wl32(pb, 0x01);
322  write_pad(pb, 4);
323  write_pad(pb, 4);
324 
325  ret = write_stream_codec_info(s, st);
326  if (ret < 0) {
327  av_log(s, AV_LOG_ERROR, "write stream codec info failed codec_type(0x%x)\n", st->codec->codec_type);
328  return -1;
329  }
330 
331  finish_chunk(s);
332  return 0;
333 }
334 
336 {
337  AVIOContext *pb = s->pb;
338  WtvContext *wctx = s->priv_data;
339  int64_t last_chunk_pos = wctx->last_chunk_pos;
340 
341  write_chunk_header(s, &ff_sync_guid, 0x18, 0);
342  avio_wl64(pb, wctx->first_index_pos);
343  avio_wl64(pb, wctx->last_timestamp_pos);
344  avio_wl64(pb, 0);
345 
346  finish_chunk(s);
347  add_serial_pair(&wctx->sp_pairs, &wctx->nb_sp_pairs, wctx->serial, wctx->last_chunk_pos);
348 
349  wctx->last_chunk_pos = last_chunk_pos;
350 }
351 
353 {
354  AVIOContext *pb = s->pb;
355  int ret;
356 
358  avio_wl32(pb, 0x00000001);
359  avio_wl32(pb, st->index + INDEX_BASE); //stream_id
360  avio_wl32(pb, 0x00000001);
361  write_pad(pb, 8);
362 
363  ret = write_stream_codec_info(s, st);
364  if (ret < 0) {
365  av_log(s, AV_LOG_ERROR, "write stream codec info failed codec_type(0x%x)\n", st->codec->codec_type);
366  return -1;
367  }
368  finish_chunk(s);
369 
370  avpriv_set_pts_info(st, 64, 1, 10000000);
371 
372  return 0;
373 }
374 
376 {
377  AVIOContext *pb = s->pb;
378  WtvContext *wctx = s->priv_data;
379  int i, pad, ret;
380  AVStream *st;
381 
382  wctx->last_chunk_pos = -1;
383  wctx->last_timestamp_pos = -1;
384 
385  ff_put_guid(pb, &ff_wtv_guid);
387 
388  avio_wl32(pb, 0x01);
389  avio_wl32(pb, 0x02);
390  avio_wl32(pb, 1 << WTV_SECTOR_BITS);
391  avio_wl32(pb, 1 << WTV_BIGSECTOR_BITS);
392 
393  //write initial root fields
394  avio_wl32(pb, 0); // root_size, update later
395  write_pad(pb, 4);
396  avio_wl32(pb, 0); // root_sector, update it later.
397 
398  write_pad(pb, 32);
399  avio_wl32(pb, 0); // file ends pointer, update it later.
400 
401  pad = (1 << WTV_SECTOR_BITS) - avio_tell(pb);
402  write_pad(pb, pad);
403 
404  wctx->timeline_start_pos = avio_tell(pb);
405 
406  wctx->serial = 1;
407  wctx->last_chunk_pos = -1;
408  wctx->first_video_flag = 1;
409 
410  for (i = 0; i < s->nb_streams; i++) {
411  st = s->streams[i];
412  if (st->codec->codec_id == AV_CODEC_ID_MJPEG)
413  continue;
414  ret = write_stream_codec(s, st);
415  if (ret < 0) {
416  av_log(s, AV_LOG_ERROR, "write stream codec failed codec_type(0x%x)\n", st->codec->codec_type);
417  return -1;
418  }
419  if (!i)
420  write_sync(s);
421  }
422 
423  for (i = 0; i < s->nb_streams; i++) {
424  st = s->streams[i];
425  if (st->codec->codec_id == AV_CODEC_ID_MJPEG)
426  continue;
427  ret = write_stream_data(s, st);
428  if (ret < 0) {
429  av_log(s, AV_LOG_ERROR, "write stream data failed codec_type(0x%x)\n", st->codec->codec_type);
430  return -1;
431  }
432  }
433 
434  if (wctx->nb_index)
435  write_index(s);
436 
437  return 0;
438 }
439 
441 {
442  AVIOContext *pb = s->pb;
443  WtvContext *wctx = s->priv_data;
444  AVCodecContext *enc = s->streams[pkt->stream_index]->codec;
445 
446  write_chunk_header(s, &ff_timestamp_guid, 56, 0x40000000 | (INDEX_BASE + pkt->stream_index));
447  write_pad(pb, 8);
448  avio_wl64(pb, pkt->pts == AV_NOPTS_VALUE ? -1 : pkt->pts);
449  avio_wl64(pb, pkt->pts == AV_NOPTS_VALUE ? -1 : pkt->pts);
450  avio_wl64(pb, pkt->pts == AV_NOPTS_VALUE ? -1 : pkt->pts);
451  avio_wl64(pb, 0);
452  avio_wl64(pb, enc->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & AV_PKT_FLAG_KEY) ? 1 : 0);
453  avio_wl64(pb, 0);
454 
455  wctx->last_timestamp_pos = wctx->last_chunk_pos;
456 }
457 
459 {
460  AVIOContext *pb = s->pb;
461  WtvContext *wctx = s->priv_data;
462 
463  if (s->streams[pkt->stream_index]->codec->codec_id == AV_CODEC_ID_MJPEG && !wctx->thumbnail.size) {
464  av_copy_packet(&wctx->thumbnail, pkt);
465  return 0;
466  }
467 
468  /* emit sync chunk and 'timeline.table.0.entries.Event' record every 50 frames */
469  if (wctx->serial - (wctx->nb_sp_pairs ? wctx->sp_pairs[wctx->nb_sp_pairs - 1].serial : 0) >= 50)
470  write_sync(s);
471 
472  /* emit 'table.0.entries.time' record every 500ms */
473  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts - (wctx->nb_st_pairs ? wctx->st_pairs[wctx->nb_st_pairs - 1].value : 0) >= 5000000)
474  add_serial_pair(&wctx->st_pairs, &wctx->nb_st_pairs, wctx->serial, pkt->pts);
475 
476  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts > wctx->last_pts) {
477  wctx->last_pts = pkt->pts;
478  wctx->last_serial = wctx->serial;
479  }
480 
481  // write timestamp chunk
482  write_timestamp(s, pkt);
483 
485  avio_write(pb, pkt->data, pkt->size);
486  write_pad(pb, WTV_PAD8(pkt->size) - pkt->size);
487 
488  wctx->serial++;
489  return 0;
490 }
491 
493 {
494  avio_wl32(pb, 0x10);
495  write_pad(pb, 84);
496  avio_wl64(pb, 0x32);
497  return 96;
498 }
499 
501 {
502  int pad = 0;
503  avio_wl32(pb, 0xFFFFFFFF);
504  write_pad(pb, 12);
505  avio_write(pb, legacy_attrib, sizeof(legacy_attrib));
506  pad = WTV_PAD8(sizeof(legacy_attrib)) - sizeof(legacy_attrib);
507  write_pad(pb, pad);
508  write_pad(pb, 32);
509  return 48 + WTV_PAD8(sizeof(legacy_attrib));
510 }
511 
513 {
514  avio_wl32(pb, 0x10);
515  write_pad(pb, 76);
516  avio_wl64(pb, 0x40);
517  return 88;
518 }
519 
523  { ff_timeline_le16, sizeof(ff_timeline_le16), NULL},
529 };
530 
531 static int write_root_table(AVFormatContext *s, int64_t sector_pos)
532 {
533  AVIOContext *pb = s->pb;
534  WtvContext *wctx = s->priv_data;
535  int size, pad;
536  int i;
537 
539  for (i = 0; i < sizeof(wtv_root_entry_table)/sizeof(WTVRootEntryTable); i++, h++) {
540  WtvFile *w = &wctx->file[i];
541  int filename_padding = WTV_PAD8(h->header_size) - h->header_size;
542  WTVHeaderWriteFunc *write = h->write_header;
543  int len = 0;
544  int64_t len_pos;
545 
547  len_pos = avio_tell(pb);
548  avio_wl16(pb, 40 + h->header_size + filename_padding + 8); // maybe updated later
549  write_pad(pb, 6);
550  avio_wl64(pb, write ? 0 : w->length);// maybe update later
551  avio_wl32(pb, (h->header_size + filename_padding) >> 1);
552  write_pad(pb, 4);
553 
554  avio_write(pb, h->header, h->header_size);
555  write_pad(pb, filename_padding);
556 
557  if (write) {
558  len = write(pb);
559  // update length field
560  avio_seek(pb, len_pos, SEEK_SET);
561  avio_wl64(pb, 40 + h->header_size + filename_padding + len);
562  avio_wl64(pb, len |(1ULL<<62) | (1ULL<<60));
563  avio_seek(pb, 8 + h->header_size + filename_padding + len, SEEK_CUR);
564  } else {
565  avio_wl32(pb, w->first_sector);
566  avio_wl32(pb, w->depth);
567  }
568  }
569 
570  // caculate root table size
571  size = avio_tell(pb) - sector_pos;
572  pad = WTV_SECTOR_SIZE- size;
573  write_pad(pb, pad);
574 
575  return size;
576 }
577 
578 static void write_fat(AVIOContext *pb, int start_sector, int nb_sectors, int shift)
579 {
580  int i;
581  for (i = 0; i < nb_sectors; i++) {
582  avio_wl32(pb, start_sector + (i << shift));
583  }
584  // pad left sector pointer size
585  write_pad(pb, WTV_SECTOR_SIZE - ((nb_sectors << 2) % WTV_SECTOR_SIZE));
586 }
587 
588 static int64_t write_fat_sector(AVFormatContext *s, int64_t start_pos, int nb_sectors, int sector_bits, int depth)
589 {
590  int64_t start_sector = start_pos >> WTV_SECTOR_BITS;
591  int shift = sector_bits - WTV_SECTOR_BITS;
592 
593  int64_t fat = avio_tell(s->pb);
594  write_fat(s->pb, start_sector, nb_sectors, shift);
595 
596  if (depth == 2) {
597  int64_t start_sector1 = fat >> WTV_SECTOR_BITS;
598  int nb_sectors1 = ((nb_sectors << 2) + WTV_SECTOR_SIZE - 1) / WTV_SECTOR_SIZE;
599  int64_t fat1 = avio_tell(s->pb);
600 
601  write_fat(s->pb, start_sector1, nb_sectors1, 0);
602  return fat1;
603  }
604 
605  return fat;
606 }
607 
609 {
610  AVIOContext *pb = s->pb;
611  WtvContext *wctx = s->priv_data;
612  int i;
613  for (i = 0; i < wctx->nb_sp_pairs; i++) {
614  avio_wl64(pb, wctx->sp_pairs[i].serial);
615  avio_wl64(pb, wctx->sp_pairs[i].value);
616  }
617 }
618 
620 {
621  AVIOContext *pb = s->pb;
622  WtvContext *wctx = s->priv_data;
623  int i;
624  for (i = 0; i < wctx->nb_st_pairs; i++) {
625  avio_wl64(pb, wctx->st_pairs[i].value);
626  avio_wl64(pb, wctx->st_pairs[i].serial);
627  }
628  avio_wl64(pb, wctx->last_pts);
629  avio_wl64(pb, wctx->last_serial);
630 }
631 
632 static void write_metadata_header(AVIOContext *pb, int type, const char *key, int value_size)
633 {
635  avio_wl32(pb, type);
636  avio_wl32(pb, value_size);
637  avio_put_str16le(pb, key);
638 }
639 
640 static int metadata_header_size(const char *key)
641 {
642  return 16 + 4 + 4 + strlen(key)*2 + 2;
643 }
644 
645 static void write_tag_int32(AVIOContext *pb, const char *key, int value)
646 {
647  write_metadata_header(pb, 0, key, 4);
648  avio_wl32(pb, value);
649 }
650 
651 static void write_tag(AVIOContext *pb, const char *key, const char *value)
652 {
653  write_metadata_header(pb, 1, key, strlen(value)*2 + 2);
654  avio_put_str16le(pb, value);
655 }
656 
658 {
659  return strlen("image/jpeg")*2 + 2 + 1 + (e ? strlen(e->value)*2 : 0) + 2 + 4 + pkt->size;
660 }
661 
663 {
664  WtvContext *wctx = s->priv_data;
665  AVIOContext *pb = s->pb;
666  AVDictionaryEntry *tag = 0;
667 
668  //FIXME: translate special tags (e.g. WM/Bitrate) to binary representation
670  while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX)))
671  write_tag(pb, tag->key, tag->value);
672 
673  if (wctx->thumbnail.size) {
674  AVStream *st = s->streams[wctx->thumbnail.stream_index];
675  tag = av_dict_get(st->metadata, "title", NULL, 0);
676  write_metadata_header(pb, 2, "WM/Picture", attachment_value_size(&wctx->thumbnail, tag));
677 
678  avio_put_str16le(pb, "image/jpeg");
679  avio_w8(pb, 0x10);
680  avio_put_str16le(pb, tag ? tag->value : "");
681 
682  avio_wl32(pb, wctx->thumbnail.size);
683  avio_write(pb, wctx->thumbnail.data, wctx->thumbnail.size);
684 
685  write_tag_int32(pb, "WM/MediaThumbType", 2);
686  }
687 }
688 
690 {
691  WtvContext *wctx = s->priv_data;
692  AVIOContext *pb = s->pb;
693  AVDictionaryEntry *tag = 0;
694  int64_t pos = 0;
695 
696  //FIXME: translate special tags to binary representation
697  while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
698  avio_wl64(pb, pos);
699  pos += metadata_header_size(tag->key) + strlen(tag->value)*2 + 2;
700  }
701 
702  if (wctx->thumbnail.size) {
703  AVStream *st = s->streams[wctx->thumbnail.stream_index];
704  avio_wl64(pb, pos);
705  pos += metadata_header_size("WM/Picture") + attachment_value_size(&wctx->thumbnail, av_dict_get(st->metadata, "title", NULL, 0));
706 
707  avio_wl64(pb, pos);
708  pos += metadata_header_size("WM/MediaThumbType") + 4;
709  }
710 }
711 
712 /**
713  * Pad the remainder of a file
714  * Write out fat table
715  * @return <0 on error
716  */
717 static int finish_file(AVFormatContext *s, enum WtvFileIndex index, int64_t start_pos)
718 {
719  WtvContext *wctx = s->priv_data;
720  AVIOContext *pb = s->pb;
721  WtvFile *w = &wctx->file[index];
722  int64_t end_pos = avio_tell(pb);
723  int sector_bits, nb_sectors, pad;
724 
725  av_assert0(index < WTV_FILES);
726 
727  w->length = (end_pos - start_pos);
728 
729  // determine optimal fat table depth, sector_bits, nb_sectors
730  if (w->length <= WTV_SECTOR_SIZE) {
731  w->depth = 0;
732  sector_bits = WTV_SECTOR_BITS;
733  } else if (w->length <= (WTV_SECTOR_SIZE / 4) * WTV_SECTOR_SIZE) {
734  w->depth = 1;
735  sector_bits = WTV_SECTOR_BITS;
736  } else if (w->length <= (WTV_SECTOR_SIZE / 4) * WTV_BIGSECTOR_SIZE) {
737  w->depth = 1;
738  sector_bits = WTV_BIGSECTOR_BITS;
739  } else if (w->length <= (int64_t)(WTV_SECTOR_SIZE / 4) * (WTV_SECTOR_SIZE / 4) * WTV_SECTOR_SIZE) {
740  w->depth = 2;
741  sector_bits = WTV_SECTOR_BITS;
742  } else if (w->length <= (int64_t)(WTV_SECTOR_SIZE / 4) * (WTV_SECTOR_SIZE / 4) * WTV_BIGSECTOR_SIZE) {
743  w->depth = 2;
744  sector_bits = WTV_BIGSECTOR_BITS;
745  } else {
746  av_log(s, AV_LOG_ERROR, "unsupported file allocation table depth (%"PRIi64" bytes)\n", w->length);
747  return -1;
748  }
749 
750  // determine the nb_sectors
751  nb_sectors = (int)(w->length >> sector_bits);
752 
753  // pad sector of timeline
754  pad = (1 << sector_bits) - (w->length % (1 << sector_bits));
755  if (pad) {
756  nb_sectors++;
757  write_pad(pb, pad);
758  }
759 
760  //write fat table
761  if (w->depth > 0) {
762  w->first_sector = write_fat_sector(s, start_pos, nb_sectors, sector_bits, w->depth) >> WTV_SECTOR_BITS;
763  } else {
764  w->first_sector = start_pos >> WTV_SECTOR_BITS;
765  }
766 
767  w->length |= 1ULL<<60;
768  if (sector_bits == WTV_SECTOR_BITS)
769  w->length |= 1ULL<<63;
770 
771  return 0;
772 }
773 
775 {
776  WtvContext *wctx = s->priv_data;
777  AVIOContext *pb = s->pb;
778  int root_size;
779  int64_t sector_pos;
780  int64_t start_pos, file_end_pos;
781 
782  if (finish_file(s, WTV_TIMELINE, wctx->timeline_start_pos) < 0)
783  return -1;
784 
785  start_pos = avio_tell(pb);
787  if (finish_file(s, WTV_TIMELINE_TABLE_0_ENTRIES_EVENTS, start_pos) < 0)
788  return -1;
789 
790  start_pos = avio_tell(pb);
792  if (finish_file(s, WTV_TABLE_0_ENTRIES_LEGACY_ATTRIB, start_pos) < 0)
793  return -1;
794 
795  start_pos = avio_tell(pb);
797  if (finish_file(s, WTV_TABLE_0_REDIRECTOR_LEGACY_ATTRIB, start_pos) < 0)
798  return -1;
799 
800  start_pos = avio_tell(pb);
802  if (finish_file(s, WTV_TABLE_0_ENTRIES_TIME, start_pos) < 0)
803  return -1;
804 
805  // write root table
806  sector_pos = avio_tell(pb);
807  root_size = write_root_table(s, sector_pos);
808 
809  file_end_pos = avio_tell(pb);
810  // update root value
811  avio_seek(pb, 0x30, SEEK_SET);
812  avio_wl32(pb, root_size);
813  avio_seek(pb, 4, SEEK_CUR);
814  avio_wl32(pb, sector_pos >> WTV_SECTOR_BITS);
815  avio_seek(pb, 0x5c, SEEK_SET);
816  avio_wl32(pb, file_end_pos >> WTV_SECTOR_BITS);
817 
818  avio_flush(pb);
819 
820  av_free(wctx->sp_pairs);
821  av_free(wctx->st_pairs);
822  av_free_packet(&wctx->thumbnail);
823  return 0;
824 }
825 
827  .name = "wtv",
828  .long_name = NULL_IF_CONFIG_SMALL("Windows Television (WTV)"),
829  .extensions = "wtv",
830  .priv_data_size = sizeof(WtvContext),
831  .audio_codec = AV_CODEC_ID_AC3,
832  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
836  .codec_tag = (const AVCodecTag* const []){ ff_codec_bmp_tags,
837  ff_codec_wav_tags, 0 },
838 };