FFmpeg  1.2.12
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 
28 #include "libavutil/intreadwrite.h"
29 #include "libavutil/avassert.h"
30 #include "avformat.h"
31 #include "internal.h"
32 #include "wtv.h"
33 #include "asf.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;
91  int64_t last_chunk_pos;
93  int64_t first_index_pos;
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 static int write_pad(AVIOContext *pb, int size)
131 {
132  for (; size > 0; size--)
133  avio_w8(pb, 0);
134  return 0;
135 }
136 
137 static const ff_asf_guid *get_codec_guid(enum AVCodecID id, const AVCodecGuid *av_guid)
138 {
139  int i;
140  for (i = 0; av_guid[i].id != AV_CODEC_ID_NONE; i++) {
141  if (id == av_guid[i].id)
142  return &(av_guid[i].guid);
143  }
144  return NULL;
145 }
146 
150 static void write_chunk_header(AVFormatContext *s, const ff_asf_guid *guid, int length, int stream_id)
151 {
152  WtvContext *wctx = s->priv_data;
153  AVIOContext *pb = s->pb;
154 
155  wctx->last_chunk_pos = avio_tell(pb) - wctx->timeline_start_pos;
156  ff_put_guid(pb, guid);
157  avio_wl32(pb, 32 + length);
158  avio_wl32(pb, stream_id);
159  avio_wl64(pb, wctx->serial);
160 
161  if ((stream_id & 0x80000000) && guid != &ff_index_guid) {
162  WtvChunkEntry *t = wctx->index + wctx->nb_index;
164  t->pos = wctx->last_chunk_pos;
165  t->serial = wctx->serial;
166  t->guid = guid;
167  t->stream_id = stream_id & 0x3FFFFFFF;
168  wctx->nb_index++;
169  }
170 }
171 
172 static void write_chunk_header2(AVFormatContext *s, const ff_asf_guid *guid, int stream_id)
173 {
174  WtvContext *wctx = s->priv_data;
175  AVIOContext *pb = s->pb;
176 
177  int64_t last_chunk_pos = wctx->last_chunk_pos;
178  write_chunk_header(s, guid, 0, stream_id); // length updated later
179  avio_wl64(pb, last_chunk_pos);
180 }
181 
183 {
184  WtvContext *wctx = s->priv_data;
185  AVIOContext *pb = s->pb;
186 
187  // update the chunk_len field and pad.
188  int64_t chunk_len = avio_tell(pb) - (wctx->last_chunk_pos + wctx->timeline_start_pos);
189  avio_seek(pb, -(chunk_len - 16), SEEK_CUR);
190  avio_wl32(pb, chunk_len);
191  avio_seek(pb, chunk_len - (16 + 4), SEEK_CUR);
192 
193  write_pad(pb, WTV_PAD8(chunk_len) - chunk_len);
194  wctx->serial++;
195 }
196 
198 {
199  AVIOContext *pb = s->pb;
200  WtvContext *wctx = s->priv_data;
201  int i;
202 
203  write_chunk_header2(s, &ff_index_guid, 0x80000000);
204  avio_wl32(pb, 0);
205  avio_wl32(pb, 0);
206 
207  for (i = 0; i < wctx->nb_index; i++) {
208  WtvChunkEntry *t = wctx->index + i;
209  ff_put_guid(pb, t->guid);
210  avio_wl64(pb, t->pos);
211  avio_wl32(pb, t->stream_id);
212  avio_wl32(pb, 0); // checksum?
213  avio_wl64(pb, t->serial);
214  }
215  wctx->nb_index = 0; // reset index
217 
218  if (!wctx->first_index_pos)
219  wctx->first_index_pos = wctx->last_chunk_pos;
220 }
221 
223 {
224  WtvContext *wctx = s->priv_data;
226  if (wctx->nb_index == MAX_NB_INDEX)
227  write_index(s);
228 }
229 
231 {
233  unsigned int num, den;
234  av_reduce(&num, &den, dar.num, dar.den, 0xFFFFFFFF);
235 
236  /* VIDEOINFOHEADER2 */
237  avio_wl32(pb, 0);
238  avio_wl32(pb, 0);
239  avio_wl32(pb, st->codec->width);
240  avio_wl32(pb, st->codec->height);
241 
242  avio_wl32(pb, 0);
243  avio_wl32(pb, 0);
244  avio_wl32(pb, 0);
245  avio_wl32(pb, 0);
246 
247  avio_wl32(pb, st->codec->bit_rate);
248  avio_wl32(pb, 0);
249  avio_wl64(pb, st->avg_frame_rate.num && st->avg_frame_rate.den ? INT64_C(10000000) / av_q2d(st->avg_frame_rate) : 0);
250  avio_wl32(pb, 0);
251  avio_wl32(pb, 0);
252 
253  avio_wl32(pb, num);
254  avio_wl32(pb, den);
255  avio_wl32(pb, 0);
256  avio_wl32(pb, 0);
257 
258  ff_put_bmp_header(pb, st->codec, ff_codec_bmp_tags, 0, 1);
259 
260  if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
261  /* MPEG2VIDEOINFO */
262  avio_wl32(pb, 0);
263  avio_wl32(pb, st->codec->extradata_size);
264  avio_wl32(pb, -1);
265  avio_wl32(pb, -1);
266  avio_wl32(pb, 0);
267  avio_write(pb, st->codec->extradata, st->codec->extradata_size);
268  avio_wl64(pb, 0);
269  }
270 }
271 
273 {
274  const ff_asf_guid *g, *media_type, *format_type;
275  AVIOContext *pb = s->pb;
276  int64_t hdr_pos_start;
277  int hdr_size = 0;
278 
279  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
281  media_type = &ff_mediatype_video;
282  format_type = &ff_format_mpeg2_video;
283  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
285  media_type = &ff_mediatype_audio;
286  format_type = &ff_format_waveformatex;
287  } else {
288  av_log(s, AV_LOG_ERROR, "unknown codec_type (0x%x)\n", st->codec->codec_type);
289  return -1;
290  }
291 
292  if (g == NULL) {
293  av_log(s, AV_LOG_ERROR, "can't get video codec_id (0x%x) guid.\n", st->codec->codec_id);
294  return -1;
295  }
296 
297  ff_put_guid(pb, media_type); // mediatype
299  write_pad(pb, 12);
300  ff_put_guid(pb,&ff_format_cpfilters_processed); // format type
301  avio_wl32(pb, 0); // size
302 
303  hdr_pos_start = avio_tell(pb);
304  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
305  put_videoinfoheader2(pb, st);
306  } else {
307  ff_put_wav_header(pb, st->codec);
308  }
309  hdr_size = avio_tell(pb) - hdr_pos_start;
310 
311  // seek back write hdr_size
312  avio_seek(pb, -(hdr_size + 4), SEEK_CUR);
313  avio_wl32(pb, hdr_size + 32);
314  avio_seek(pb, hdr_size, SEEK_CUR);
315  ff_put_guid(pb, g); // actual_subtype
316  ff_put_guid(pb, format_type); // actual_formattype
317 
318  return 0;
319 }
320 
322 {
323  AVIOContext *pb = s->pb;
324  int ret;
325  write_chunk_header2(s, &ff_stream1_guid, 0x80000000 | 0x01);
326 
327  avio_wl32(pb, 0x01);
328  write_pad(pb, 4);
329  write_pad(pb, 4);
330 
331  ret = write_stream_codec_info(s, st);
332  if (ret < 0) {
333  av_log(s, AV_LOG_ERROR, "write stream codec info failed codec_type(0x%x)\n", st->codec->codec_type);
334  return -1;
335  }
336 
337  finish_chunk(s);
338  return 0;
339 }
340 
342 {
343  AVIOContext *pb = s->pb;
344  WtvContext *wctx = s->priv_data;
345  int64_t last_chunk_pos = wctx->last_chunk_pos;
346 
347  write_chunk_header(s, &ff_sync_guid, 0x18, 0);
348  avio_wl64(pb, wctx->first_index_pos);
349  avio_wl64(pb, wctx->last_timestamp_pos);
350  avio_wl64(pb, 0);
351 
352  finish_chunk(s);
353  add_serial_pair(&wctx->sp_pairs, &wctx->nb_sp_pairs, wctx->serial, wctx->last_chunk_pos);
354 
355  wctx->last_chunk_pos = last_chunk_pos;
356 }
357 
359 {
360  AVIOContext *pb = s->pb;
361  int ret;
362 
364  avio_wl32(pb, 0x00000001);
365  avio_wl32(pb, st->index + INDEX_BASE); //stream_id
366  avio_wl32(pb, 0x00000001);
367  write_pad(pb, 8);
368 
369  ret = write_stream_codec_info(s, st);
370  if (ret < 0) {
371  av_log(s, AV_LOG_ERROR, "write stream codec info failed codec_type(0x%x)\n", st->codec->codec_type);
372  return -1;
373  }
374  finish_chunk(s);
375 
376  avpriv_set_pts_info(st, 64, 1, 10000000);
377 
378  return 0;
379 }
380 
382 {
383  AVIOContext *pb = s->pb;
384  WtvContext *wctx = s->priv_data;
385  int i, pad, ret;
386  AVStream *st;
387 
388  wctx->last_chunk_pos = -1;
389  wctx->last_timestamp_pos = -1;
390 
391  ff_put_guid(pb, &ff_wtv_guid);
393 
394  avio_wl32(pb, 0x01);
395  avio_wl32(pb, 0x02);
396  avio_wl32(pb, 1 << WTV_SECTOR_BITS);
397  avio_wl32(pb, 1 << WTV_BIGSECTOR_BITS);
398 
399  //write initial root fields
400  avio_wl32(pb, 0); // root_size, update later
401  write_pad(pb, 4);
402  avio_wl32(pb, 0); // root_sector, update it later.
403 
404  write_pad(pb, 32);
405  avio_wl32(pb, 0); // file ends pointer, update it later.
406 
407  pad = (1 << WTV_SECTOR_BITS) - avio_tell(pb);
408  write_pad(pb, pad);
409 
410  wctx->timeline_start_pos = avio_tell(pb);
411 
412  wctx->serial = 1;
413  wctx->last_chunk_pos = -1;
414  wctx->first_video_flag = 1;
415 
416  for (i = 0; i < s->nb_streams; i++) {
417  st = s->streams[i];
418  if (st->codec->codec_id == AV_CODEC_ID_MJPEG)
419  continue;
420  ret = write_stream_codec(s, st);
421  if (ret < 0) {
422  av_log(s, AV_LOG_ERROR, "write stream codec failed codec_type(0x%x)\n", st->codec->codec_type);
423  return -1;
424  }
425  if (!i)
426  write_sync(s);
427  }
428 
429  for (i = 0; i < s->nb_streams; i++) {
430  st = s->streams[i];
431  if (st->codec->codec_id == AV_CODEC_ID_MJPEG)
432  continue;
433  ret = write_stream_data(s, st);
434  if (ret < 0) {
435  av_log(s, AV_LOG_ERROR, "write stream data failed codec_type(0x%x)\n", st->codec->codec_type);
436  return -1;
437  }
438  }
439 
440  if (wctx->nb_index)
441  write_index(s);
442 
443  return 0;
444 }
445 
447 {
448  AVIOContext *pb = s->pb;
449  WtvContext *wctx = s->priv_data;
450  AVCodecContext *enc = s->streams[pkt->stream_index]->codec;
451 
452  write_chunk_header(s, &ff_timestamp_guid, 56, 0x40000000 | (INDEX_BASE + pkt->stream_index));
453  write_pad(pb, 8);
454  avio_wl64(pb, pkt->pts == AV_NOPTS_VALUE ? -1 : pkt->pts);
455  avio_wl64(pb, pkt->pts == AV_NOPTS_VALUE ? -1 : pkt->pts);
456  avio_wl64(pb, pkt->pts == AV_NOPTS_VALUE ? -1 : pkt->pts);
457  avio_wl64(pb, 0);
458  avio_wl64(pb, enc->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & AV_PKT_FLAG_KEY) ? 1 : 0);
459  avio_wl64(pb, 0);
460 
461  wctx->last_timestamp_pos = wctx->last_chunk_pos;
462 }
463 
465 {
466  AVIOContext *pb = s->pb;
467  WtvContext *wctx = s->priv_data;
468 
469  if (s->streams[pkt->stream_index]->codec->codec_id == AV_CODEC_ID_MJPEG && !wctx->thumbnail.size) {
470  av_copy_packet(&wctx->thumbnail, pkt);
471  return 0;
472  }
473 
474  /* emit sync chunk and 'timeline.table.0.entries.Event' record every 50 frames */
475  if (wctx->serial - (wctx->nb_sp_pairs ? wctx->sp_pairs[wctx->nb_sp_pairs - 1].serial : 0) >= 50)
476  write_sync(s);
477 
478  /* emit 'table.0.entries.time' record every 500ms */
479  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts - (wctx->nb_st_pairs ? wctx->st_pairs[wctx->nb_st_pairs - 1].value : 0) >= 5000000)
480  add_serial_pair(&wctx->st_pairs, &wctx->nb_st_pairs, wctx->serial, pkt->pts);
481 
482  if (pkt->pts != AV_NOPTS_VALUE && pkt->pts > wctx->last_pts) {
483  wctx->last_pts = pkt->pts;
484  wctx->last_serial = wctx->serial;
485  }
486 
487  // write timestamp chunk
488  write_timestamp(s, pkt);
489 
491  avio_write(pb, pkt->data, pkt->size);
492  write_pad(pb, WTV_PAD8(pkt->size) - pkt->size);
493 
494  wctx->serial++;
495  avio_flush(pb);
496  return 0;
497 }
498 
500 {
501  avio_wl32(pb, 0x10);
502  write_pad(pb, 84);
503  avio_wl64(pb, 0x32);
504  return 96;
505 }
506 
508 {
509  int pad = 0;
510  avio_wl32(pb, 0xFFFFFFFF);
511  write_pad(pb, 12);
512  avio_write(pb, legacy_attrib, sizeof(legacy_attrib));
513  pad = WTV_PAD8(sizeof(legacy_attrib)) - sizeof(legacy_attrib);
514  write_pad(pb, pad);
515  write_pad(pb, 32);
516  return 48 + WTV_PAD8(sizeof(legacy_attrib));
517 }
518 
520 {
521  avio_wl32(pb, 0x10);
522  write_pad(pb, 76);
523  avio_wl64(pb, 0x40);
524  return 88;
525 }
526 
536 };
537 
538 static int write_root_table(AVFormatContext *s, int64_t sector_pos)
539 {
540  AVIOContext *pb = s->pb;
541  WtvContext *wctx = s->priv_data;
542  int size, pad;
543  int i;
544 
546  for (i = 0; i < sizeof(wtv_root_entry_table)/sizeof(WTVRootEntryTable); i++, h++) {
547  WtvFile *w = &wctx->file[i];
548  int filename_padding = WTV_PAD8(h->header_size) - h->header_size;
549  WTVHeaderWriteFunc *write = h->write_header;
550  int len = 0;
551  int64_t len_pos;
552 
554  len_pos = avio_tell(pb);
555  avio_wl16(pb, 40 + h->header_size + filename_padding + 8); // maybe updated later
556  write_pad(pb, 6);
557  avio_wl64(pb, write ? 0 : w->length);// maybe update later
558  avio_wl32(pb, (h->header_size + filename_padding) >> 1);
559  write_pad(pb, 4);
560 
561  avio_write(pb, h->header, h->header_size);
562  write_pad(pb, filename_padding);
563 
564  if (write) {
565  len = write(pb);
566  // update length field
567  avio_seek(pb, len_pos, SEEK_SET);
568  avio_wl64(pb, 40 + h->header_size + filename_padding + len);
569  avio_wl64(pb, len |(1ULL<<62) | (1ULL<<60));
570  avio_seek(pb, 8 + h->header_size + filename_padding + len, SEEK_CUR);
571  } else {
572  avio_wl32(pb, w->first_sector);
573  avio_wl32(pb, w->depth);
574  }
575  }
576 
577  // caculate root table size
578  size = avio_tell(pb) - sector_pos;
579  pad = WTV_SECTOR_SIZE- size;
580  write_pad(pb, pad);
581 
582  return size;
583 }
584 
585 static void write_fat(AVIOContext *pb, int start_sector, int nb_sectors, int shift)
586 {
587  int i;
588  for (i = 0; i < nb_sectors; i++) {
589  avio_wl32(pb, start_sector + (i << shift));
590  }
591  // pad left sector pointer size
592  write_pad(pb, WTV_SECTOR_SIZE - ((nb_sectors << 2) % WTV_SECTOR_SIZE));
593 }
594 
595 static int64_t write_fat_sector(AVFormatContext *s, int64_t start_pos, int nb_sectors, int sector_bits, int depth)
596 {
597  int64_t start_sector = start_pos >> WTV_SECTOR_BITS;
598  int shift = sector_bits - WTV_SECTOR_BITS;
599 
600  int64_t fat = avio_tell(s->pb);
601  write_fat(s->pb, start_sector, nb_sectors, shift);
602 
603  if (depth == 2) {
604  int64_t start_sector1 = fat >> WTV_SECTOR_BITS;
605  int nb_sectors1 = ((nb_sectors << 2) + WTV_SECTOR_SIZE - 1) / WTV_SECTOR_SIZE;
606  int64_t fat1 = avio_tell(s->pb);
607 
608  write_fat(s->pb, start_sector1, nb_sectors1, 0);
609  return fat1;
610  }
611 
612  return fat;
613 }
614 
616 {
617  AVIOContext *pb = s->pb;
618  WtvContext *wctx = s->priv_data;
619  int i;
620  for (i = 0; i < wctx->nb_sp_pairs; i++) {
621  avio_wl64(pb, wctx->sp_pairs[i].serial);
622  avio_wl64(pb, wctx->sp_pairs[i].value);
623  }
624 }
625 
627 {
628  AVIOContext *pb = s->pb;
629  WtvContext *wctx = s->priv_data;
630  int i;
631  for (i = 0; i < wctx->nb_st_pairs; i++) {
632  avio_wl64(pb, wctx->st_pairs[i].value);
633  avio_wl64(pb, wctx->st_pairs[i].serial);
634  }
635  avio_wl64(pb, wctx->last_pts);
636  avio_wl64(pb, wctx->last_serial);
637 }
638 
639 static void write_metadata_header(AVIOContext *pb, int type, const char *key, int value_size)
640 {
642  avio_wl32(pb, type);
643  avio_wl32(pb, value_size);
644  avio_put_str16le(pb, key);
645 }
646 
647 static int metadata_header_size(const char *key)
648 {
649  return 16 + 4 + 4 + strlen(key)*2 + 2;
650 }
651 
652 static void write_tag_int32(AVIOContext *pb, const char *key, int value)
653 {
654  write_metadata_header(pb, 0, key, 4);
655  avio_wl32(pb, value);
656 }
657 
658 static void write_tag(AVIOContext *pb, const char *key, const char *value)
659 {
660  write_metadata_header(pb, 1, key, strlen(value)*2 + 2);
661  avio_put_str16le(pb, value);
662 }
663 
665 {
666  return strlen("image/jpeg")*2 + 2 + 1 + (e ? strlen(e->value)*2 : 0) + 2 + 4 + pkt->size;
667 }
668 
670 {
671  WtvContext *wctx = s->priv_data;
672  AVIOContext *pb = s->pb;
673  AVDictionaryEntry *tag = 0;
674 
675  //FIXME: translate special tags (e.g. WM/Bitrate) to binary representation
677  while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX)))
678  write_tag(pb, tag->key, tag->value);
679 
680  if (wctx->thumbnail.size) {
681  AVStream *st = s->streams[wctx->thumbnail.stream_index];
682  tag = av_dict_get(st->metadata, "title", NULL, 0);
683  write_metadata_header(pb, 2, "WM/Picture", attachment_value_size(&wctx->thumbnail, tag));
684 
685  avio_put_str16le(pb, "image/jpeg");
686  avio_w8(pb, 0x10);
687  avio_put_str16le(pb, tag ? tag->value : "");
688 
689  avio_wl32(pb, wctx->thumbnail.size);
690  avio_write(pb, wctx->thumbnail.data, wctx->thumbnail.size);
691 
692  write_tag_int32(pb, "WM/MediaThumbType", 2);
693  }
694 }
695 
697 {
698  WtvContext *wctx = s->priv_data;
699  AVIOContext *pb = s->pb;
700  AVDictionaryEntry *tag = 0;
701  int64_t pos = 0;
702 
703  //FIXME: translate special tags to binary representation
704  while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
705  avio_wl64(pb, pos);
706  pos += metadata_header_size(tag->key) + strlen(tag->value)*2 + 2;
707  }
708 
709  if (wctx->thumbnail.size) {
710  AVStream *st = s->streams[wctx->thumbnail.stream_index];
711  avio_wl64(pb, pos);
712  pos += metadata_header_size("WM/Picture") + attachment_value_size(&wctx->thumbnail, av_dict_get(st->metadata, "title", NULL, 0));
713 
714  avio_wl64(pb, pos);
715  pos += metadata_header_size("WM/MediaThumbType") + 4;
716  }
717 }
718 
724 static int finish_file(AVFormatContext *s, enum WtvFileIndex index, int64_t start_pos)
725 {
726  WtvContext *wctx = s->priv_data;
727  AVIOContext *pb = s->pb;
728  WtvFile *w = &wctx->file[index];
729  int64_t end_pos = avio_tell(pb);
730  int sector_bits, nb_sectors, pad;
731 
732  av_assert0(index < WTV_FILES);
733 
734  w->length = (end_pos - start_pos);
735 
736  // determine optimal fat table depth, sector_bits, nb_sectors
737  if (w->length <= WTV_SECTOR_SIZE) {
738  w->depth = 0;
739  sector_bits = WTV_SECTOR_BITS;
740  } else if (w->length <= (WTV_SECTOR_SIZE / 4) * WTV_SECTOR_SIZE) {
741  w->depth = 1;
742  sector_bits = WTV_SECTOR_BITS;
743  } else if (w->length <= (WTV_SECTOR_SIZE / 4) * WTV_BIGSECTOR_SIZE) {
744  w->depth = 1;
745  sector_bits = WTV_BIGSECTOR_BITS;
746  } else if (w->length <= (int64_t)(WTV_SECTOR_SIZE / 4) * (WTV_SECTOR_SIZE / 4) * WTV_SECTOR_SIZE) {
747  w->depth = 2;
748  sector_bits = WTV_SECTOR_BITS;
749  } else if (w->length <= (int64_t)(WTV_SECTOR_SIZE / 4) * (WTV_SECTOR_SIZE / 4) * WTV_BIGSECTOR_SIZE) {
750  w->depth = 2;
751  sector_bits = WTV_BIGSECTOR_BITS;
752  } else {
753  av_log(s, AV_LOG_ERROR, "unsupported file allocation table depth (%"PRIi64" bytes)\n", w->length);
754  return -1;
755  }
756 
757  // determine the nb_sectors
758  nb_sectors = (int)(w->length >> sector_bits);
759 
760  // pad sector of timeline
761  pad = (1 << sector_bits) - (w->length % (1 << sector_bits));
762  if (pad) {
763  nb_sectors++;
764  write_pad(pb, pad);
765  }
766 
767  //write fat table
768  if (w->depth > 0) {
769  w->first_sector = write_fat_sector(s, start_pos, nb_sectors, sector_bits, w->depth) >> WTV_SECTOR_BITS;
770  } else {
771  w->first_sector = start_pos >> WTV_SECTOR_BITS;
772  }
773 
774  w->length |= 1ULL<<60;
775  if (sector_bits == WTV_SECTOR_BITS)
776  w->length |= 1ULL<<63;
777 
778  return 0;
779 }
780 
782 {
783  WtvContext *wctx = s->priv_data;
784  AVIOContext *pb = s->pb;
785  int root_size;
786  int64_t sector_pos;
787  int64_t start_pos, file_end_pos;
788 
789  if (finish_file(s, WTV_TIMELINE, wctx->timeline_start_pos) < 0)
790  return -1;
791 
792  start_pos = avio_tell(pb);
794  if (finish_file(s, WTV_TIMELINE_TABLE_0_ENTRIES_EVENTS, start_pos) < 0)
795  return -1;
796 
797  start_pos = avio_tell(pb);
799  if (finish_file(s, WTV_TABLE_0_ENTRIES_LEGACY_ATTRIB, start_pos) < 0)
800  return -1;
801 
802  start_pos = avio_tell(pb);
804  if (finish_file(s, WTV_TABLE_0_REDIRECTOR_LEGACY_ATTRIB, start_pos) < 0)
805  return -1;
806 
807  start_pos = avio_tell(pb);
809  if (finish_file(s, WTV_TABLE_0_ENTRIES_TIME, start_pos) < 0)
810  return -1;
811 
812  // write root table
813  sector_pos = avio_tell(pb);
814  root_size = write_root_table(s, sector_pos);
815 
816  file_end_pos = avio_tell(pb);
817  // update root value
818  avio_seek(pb, 0x30, SEEK_SET);
819  avio_wl32(pb, root_size);
820  avio_seek(pb, 4, SEEK_CUR);
821  avio_wl32(pb, sector_pos >> WTV_SECTOR_BITS);
822  avio_seek(pb, 0x5c, SEEK_SET);
823  avio_wl32(pb, file_end_pos >> WTV_SECTOR_BITS);
824 
825  avio_flush(pb);
826 
827  av_free(wctx->sp_pairs);
828  av_free(wctx->st_pairs);
829  av_free_packet(&wctx->thumbnail);
830  return 0;
831 }
832 
834  .name = "wtv",
835  .long_name = NULL_IF_CONFIG_SMALL("Windows Television (WTV)"),
836  .extensions = "wtv",
837  .priv_data_size = sizeof(WtvContext),
838  .audio_codec = AV_CODEC_ID_AC3,
839  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
843  .codec_tag = (const AVCodecTag* const []){ ff_codec_bmp_tags,
844  ff_codec_wav_tags, 0 },
845 };