e86bfeb779741f3749b1b3cb3af3f224ad615df5
[ffmpeg.git] / libavformat / wtvenc.c
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 "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,
41 static const uint8_t timeline_table_0_header_events[] =
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};
43 static const uint8_t table_0_header_legacy_attrib[] =
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};
45 static const uint8_t table_0_redirector_legacy_attrib[] =
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
56 enum WtvFileIndex {
57     WTV_TIMELINE_TABLE_0_HEADER_EVENTS = 0,
58     WTV_TIMELINE_TABLE_0_ENTRIES_EVENTS,
59     WTV_TIMELINE,
60     WTV_TABLE_0_HEADER_LEGACY_ATTRIB,
61     WTV_TABLE_0_ENTRIES_LEGACY_ATTRIB,
62     WTV_TABLE_0_REDIRECTOR_LEGACY_ATTRIB,
63     WTV_TABLE_0_HEADER_TIME,
64     WTV_TABLE_0_ENTRIES_TIME,
65     WTV_FILES
66 };
67
68 typedef struct {
69     int64_t length;
70     const void *header;
71     int depth;
72     int first_sector;
73 } WtvFile;
74
75 typedef struct {
76     int64_t             pos;
77     int64_t             serial;
78     const ff_asf_guid * guid;
79     int                 stream_id;
80 } WtvChunkEntry;
81
82 typedef struct {
83     int64_t timeline_start_pos;
84     WtvFile file[WTV_FILES];
85     int64_t serial;         /** chunk serial number */
86     int64_t last_chunk_pos; /** last chunk position */
87     int64_t frame_nb;
88
89     WtvChunkEntry index[MAX_NB_INDEX];
90     int nb_index;
91     int first_video_flag;
92     int64_t sync_pos;
93 } WtvContext;
94
95 typedef int WTVHeaderWriteFunc(AVIOContext *pb);
96
97 typedef struct {
98     const uint8_t *header;
99     int header_size;
100     WTVHeaderWriteFunc *write_header;
101 } WTVRootEntryTable;
102
103 static int write_pad(AVIOContext *pb, int size)
104 {
105     for (; size > 0; size--)
106         avio_w8(pb, 0);
107     return 0;
108 }
109
110 static const ff_asf_guid *get_codec_guid(enum AVCodecID id, const AVCodecGuid *av_guid)
111 {
112     int i;
113     for (i = 0; av_guid[i].id != AV_CODEC_ID_NONE; i++) {
114         if (id == av_guid[i].id)
115             return &(av_guid[i].guid);
116     }
117     return NULL;
118 }
119
120 /**
121  * Write chunk header. If header chunk (0x80000000 set) then add to list of header chunks
122  */
123 static void write_chunk_header(AVFormatContext *s, const ff_asf_guid *guid, int length, int stream_id)
124 {
125     WtvContext *wctx = s->priv_data;
126     AVIOContext *pb = s->pb;
127
128     wctx->last_chunk_pos = avio_tell(pb) - wctx->timeline_start_pos;
129     ff_put_guid(pb, guid);
130     avio_wl32(pb, 32 + length);
131     avio_wl32(pb, stream_id);
132     avio_wl64(pb, wctx->serial);
133
134     if ((stream_id & 0x80000000) && guid != &ff_index_guid) {
135         WtvChunkEntry *t = wctx->index + wctx->nb_index;
136         av_assert0(wctx->nb_index < MAX_NB_INDEX);
137         t->pos       = wctx->last_chunk_pos;
138         t->serial    = wctx->serial;
139         t->guid      = guid;
140         t->stream_id = stream_id & 0x3FFFFFFF;
141         wctx->nb_index++;
142     }
143 }
144
145 static void write_chunk_header2(AVFormatContext *s, const ff_asf_guid *guid, int stream_id)
146 {
147     WtvContext *wctx = s->priv_data;
148     AVIOContext *pb = s->pb;
149
150     int64_t last_chunk_pos = wctx->last_chunk_pos;
151     write_chunk_header(s, guid, 0, stream_id); // length updated later
152     avio_wl64(pb, last_chunk_pos);
153 }
154
155 static void finish_chunk_noindex(AVFormatContext *s)
156 {
157     WtvContext *wctx = s->priv_data;
158     AVIOContext *pb = s->pb;
159
160     // update the chunk_len field and pad.
161     int64_t chunk_len = avio_tell(pb) - (wctx->last_chunk_pos + wctx->timeline_start_pos);
162     avio_seek(pb, -(chunk_len - 16), SEEK_CUR);
163     avio_wl32(pb, chunk_len);
164     avio_seek(pb, chunk_len - (16 + 4), SEEK_CUR);
165
166     write_pad(pb, WTV_PAD8(chunk_len) - chunk_len);
167     wctx->serial++;
168 }
169
170 static void write_index(AVFormatContext *s)
171 {
172     AVIOContext *pb = s->pb;
173     WtvContext *wctx = s->priv_data;
174     int i;
175
176     write_chunk_header2(s, &ff_index_guid, 0x80000000);
177     avio_wl32(pb, 0);
178     avio_wl32(pb, 0);
179
180     for (i = 0; i < wctx->nb_index; i++) {
181         WtvChunkEntry *t = wctx->index + i;
182         ff_put_guid(pb,  t->guid);
183         avio_wl64(pb, t->pos);
184         avio_wl32(pb, t->stream_id);
185         avio_wl32(pb, 0); // checksum?
186         avio_wl64(pb, t->serial);
187     }
188     wctx->nb_index = 0;   // reset index
189     finish_chunk_noindex(s);
190 }
191
192 static void finish_chunk(AVFormatContext *s)
193 {
194     WtvContext *wctx = s->priv_data;
195     finish_chunk_noindex(s);
196     if (wctx->nb_index == MAX_NB_INDEX)
197         write_index(s);
198 }
199
200 static int write_stream_codec_info(AVFormatContext *s, AVStream *st)
201 {
202     WtvContext *wctx = s->priv_data;
203     const ff_asf_guid *g, *media_type, *format_type;
204     AVIOContext *pb = s->pb;
205     int64_t  hdr_pos_start;
206     int hdr_size = 0;
207
208     if (st->codec->codec_type  == AVMEDIA_TYPE_VIDEO) {
209         g = get_codec_guid(st->codec->codec_id, ff_video_guids);
210         media_type = &ff_mediatype_video;
211         format_type = &ff_format_mpeg2_video;
212     } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
213         g = get_codec_guid(st->codec->codec_id, ff_codec_wav_guids);
214         media_type = &ff_mediatype_audio;
215         format_type = &ff_format_waveformatex;
216     } else {
217         av_log(s, AV_LOG_ERROR, "unknown codec_type (0x%x)\n", st->codec->codec_type);
218         return -1;
219     }
220
221     if (g == NULL) {
222         av_log(s, AV_LOG_ERROR, "can't get video codec_id (0x%x) guid.\n", st->codec->codec_id);
223         return -1;
224     }
225
226     ff_put_guid(pb, media_type); // mediatype
227     ff_put_guid(pb, &ff_mediasubtype_cpfilters_processed); // subtype
228     write_pad(pb, 12);
229     ff_put_guid(pb,&ff_format_cpfilters_processed); // format type
230     avio_wl32(pb, 0); // size
231
232     hdr_pos_start = avio_tell(pb);
233     if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
234         if (wctx->first_video_flag) {
235             write_pad(pb, 216); //The size is sensitive.
236             wctx->first_video_flag = 0;
237         } else {
238             write_pad(pb, 72); // aspect ratio
239             ff_put_bmp_header(pb, st->codec, ff_codec_bmp_tags, 0);
240         }
241     } else {
242         ff_put_wav_header(pb, st->codec);
243     }
244     hdr_size = avio_tell(pb) - hdr_pos_start;
245
246     // seek back write hdr_size
247     avio_seek(pb, -(hdr_size + 4), SEEK_CUR);
248     avio_wl32(pb, hdr_size + 32);
249     avio_seek(pb, hdr_size, SEEK_CUR);
250     ff_put_guid(pb, g);           // actual_subtype
251     ff_put_guid(pb, format_type); // actual_formattype
252
253     return 0;
254 }
255
256 static int write_stream_codec(AVFormatContext *s, AVStream * st)
257 {
258     AVIOContext *pb = s->pb;
259     int ret;
260     write_chunk_header2(s, &ff_stream1_guid, 0x80000000 | 0x01);
261
262     avio_wl32(pb,  0x01);
263     write_pad(pb, 4);
264     write_pad(pb, 4);
265
266     ret = write_stream_codec_info(s, st);
267     if (ret < 0) {
268         av_log(s, AV_LOG_ERROR, "write stream codec info failed codec_type(0x%x)\n", st->codec->codec_type);
269         return -1;
270     }
271
272     finish_chunk(s);
273     return 0;
274 }
275
276 static void write_sync(AVFormatContext *s)
277 {
278     AVIOContext *pb = s->pb;
279     WtvContext *wctx = s->priv_data;
280     int64_t last_chunk_pos = wctx->last_chunk_pos;
281     wctx->sync_pos = avio_tell(pb) - wctx->timeline_start_pos;
282
283     write_chunk_header(s, &ff_sync_guid, 0x18, 0);
284     write_pad(pb, 24);
285
286     finish_chunk(s);
287
288     wctx->last_chunk_pos = last_chunk_pos;
289 }
290
291 static int write_stream_data(AVFormatContext *s, AVStream *st)
292 {
293     AVIOContext *pb = s->pb;
294     int ret;
295
296     write_chunk_header2(s, &ff_SBE2_STREAM_DESC_EVENT, 0x80000000 | (st->index + INDEX_BASE));
297     avio_wl32(pb, 0x00000001);
298     avio_wl32(pb, st->index + INDEX_BASE); //stream_id
299     avio_wl32(pb, 0x00000001);
300     write_pad(pb, 8);
301
302     ret = write_stream_codec_info(s, st);
303     if (ret < 0) {
304         av_log(s, AV_LOG_ERROR, "write stream codec info failed codec_type(0x%x)\n", st->codec->codec_type);
305         return -1;
306     }
307     finish_chunk(s);
308
309     avpriv_set_pts_info(st, 64, 1, 10000000);
310
311     return 0;
312 }
313
314 static int write_header(AVFormatContext *s)
315 {
316     AVIOContext *pb = s->pb;
317     WtvContext *wctx = s->priv_data;
318     int i, pad, ret;
319     AVStream *st;
320
321     ff_put_guid(pb, &ff_wtv_guid);
322     ff_put_guid(pb, &sub_wtv_guid);
323
324     avio_wl32(pb, 0x01);
325     avio_wl32(pb, 0x02);
326     avio_wl32(pb, 1 << WTV_SECTOR_BITS);
327     avio_wl32(pb, 1 << WTV_BIGSECTOR_BITS);
328
329     //write initial root fields
330     avio_wl32(pb, 0); // root_size, update later
331     write_pad(pb, 4);
332     avio_wl32(pb, 0); // root_sector, update it later.
333
334     write_pad(pb, 32);
335     avio_wl32(pb, 0); // file ends pointer, update it later.
336
337     pad = (1 << WTV_SECTOR_BITS) - avio_tell(pb);
338     write_pad(pb, pad);
339     wctx->timeline_start_pos = avio_tell(pb);
340
341     wctx->serial = 1;
342     wctx->last_chunk_pos = -1;
343     wctx->first_video_flag = 1;
344
345     for (i = 0; i < s->nb_streams; i++) {
346         st = s->streams[i];
347         ret = write_stream_codec(s, st);
348         if (ret < 0) {
349             av_log(s, AV_LOG_ERROR, "write stream codec failed codec_type(0x%x)\n", st->codec->codec_type);
350             return -1;
351         }
352         if (!i)
353             write_sync(s);
354     }
355
356     for (i = 0; i < s->nb_streams; i++) {
357         st = s->streams[i];
358         ret  = write_stream_data(s, st);
359         if (ret < 0) {
360             av_log(s, AV_LOG_ERROR, "write stream data failed codec_type(0x%x)\n", st->codec->codec_type);
361             return -1;
362         }
363     }
364
365     if (wctx->nb_index)
366         write_index(s);
367
368     return 0;
369 }
370
371 static void write_timestamp(AVFormatContext *s, AVPacket *pkt)
372 {
373     AVIOContext *pb = s->pb;
374     WtvContext  *wctx = s->priv_data;
375     AVCodecContext *enc = s->streams[pkt->stream_index]->codec;
376     int flag = 0;
377     int64_t frame_number = 0;
378
379     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
380         wctx->frame_nb++;
381         frame_number = wctx->frame_nb;
382         flag = pkt->flags & AV_PKT_FLAG_KEY ? 1 : 0;
383     }
384     write_chunk_header(s, &ff_timestamp_guid, 56, 0x40000000 | (INDEX_BASE + pkt->stream_index));
385     write_pad(pb, 8);
386     avio_wl64(pb, pkt->pts == AV_NOPTS_VALUE ? -1 : pkt->pts);
387     avio_wl64(pb, pkt->pts == AV_NOPTS_VALUE ? -1 : pkt->pts);
388
389     avio_wl64(pb, frame_number);
390     avio_wl64(pb, 0);
391     avio_wl64(pb, flag);
392     avio_wl64(pb, 0);
393 }
394
395 static int write_packet(AVFormatContext *s, AVPacket *pkt)
396 {
397     AVIOContext *pb = s->pb;
398     WtvContext  *wctx = s->priv_data;
399
400     // write timestamp chunk
401     write_timestamp(s, pkt);
402
403     write_chunk_header(s, &ff_data_guid, pkt->size, INDEX_BASE + pkt->stream_index);
404     avio_write(pb, pkt->data, pkt->size);
405     write_pad(pb, WTV_PAD8(pkt->size) - pkt->size);
406
407     wctx->serial++;
408     avio_flush(pb);
409     return 0;
410 }
411
412 static int write_table0_header_events(AVIOContext *pb)
413 {
414     avio_wl32(pb, 0x10);
415     write_pad(pb, 84);
416     avio_wl64(pb, 0x32);
417     return 96;
418 }
419
420 static int write_table0_header_legacy_attrib(AVIOContext *pb)
421 {
422     int pad = 0;
423     avio_wl32(pb, 0xFFFFFFFF);
424     write_pad(pb, 12);
425     avio_write(pb, legacy_attrib, sizeof(legacy_attrib));
426     pad = WTV_PAD8(sizeof(legacy_attrib)) - sizeof(legacy_attrib);
427     write_pad(pb, pad);
428     write_pad(pb, 32);
429     return 48 + WTV_PAD8(sizeof(legacy_attrib));
430 }
431
432 static int write_table0_header_time(AVIOContext *pb)
433 {
434     avio_wl32(pb, 0x10);
435     write_pad(pb, 76);
436     avio_wl64(pb, 0x40);
437     return 88;
438 }
439
440 static const WTVRootEntryTable wtv_root_entry_table[] = {
441     { timeline_table_0_header_events,          sizeof(timeline_table_0_header_events),          write_table0_header_events},
442     { ff_timeline_table_0_entries_Events_le16, sizeof(ff_timeline_table_0_entries_Events_le16), NULL},
443     { ff_timeline_le16,                        sizeof(ff_timeline_le16),                        NULL},
444     { table_0_header_legacy_attrib,            sizeof(table_0_header_legacy_attrib),            write_table0_header_legacy_attrib},
445     { ff_table_0_entries_legacy_attrib_le16,   sizeof(ff_table_0_entries_legacy_attrib_le16),   NULL},
446     { table_0_redirector_legacy_attrib,        sizeof(table_0_redirector_legacy_attrib),        NULL},
447     { table_0_header_time,                     sizeof(table_0_header_time),                     write_table0_header_time},
448     { ff_table_0_entries_time_le16,            sizeof(ff_table_0_entries_time_le16),            NULL},
449 };
450
451 static int write_root_table(AVFormatContext *s, int64_t sector_pos)
452 {
453     AVIOContext *pb = s->pb;
454     WtvContext  *wctx = s->priv_data;
455     int size, pad;
456     int i;
457
458     const WTVRootEntryTable *h = wtv_root_entry_table;
459     for (i = 0; i < sizeof(wtv_root_entry_table)/sizeof(WTVRootEntryTable); i++, h++) {
460         WtvFile *w = &wctx->file[i];
461         int filename_padding = WTV_PAD8(h->header_size) - h->header_size;
462         WTVHeaderWriteFunc *write = h->write_header;
463         int len = 0;
464         int64_t len_pos;
465
466         ff_put_guid(pb, &ff_dir_entry_guid);
467         len_pos = avio_tell(pb);
468         avio_wl16(pb, 40 + h->header_size + filename_padding + 8); // maybe updated later
469         write_pad(pb, 6);
470         avio_wl64(pb, write ? 0 : w->length);// maybe update later
471         avio_wl32(pb, (h->header_size + filename_padding) >> 1);
472         write_pad(pb, 4);
473
474         avio_write(pb, h->header, h->header_size);
475         write_pad(pb, filename_padding);
476
477         if (write) {
478             len = write(pb);
479             // update length field
480             avio_seek(pb, len_pos, SEEK_SET);
481             avio_wl64(pb, 40 + h->header_size + filename_padding + len);
482             avio_wl64(pb, len |(1ULL<<62) | (1ULL<<60));
483             avio_seek(pb, 8 + h->header_size + filename_padding + len, SEEK_CUR);
484         } else {
485             avio_wl32(pb, w->first_sector);
486             avio_wl32(pb, w->depth);
487         }
488     }
489
490     // caculate root table size
491     size = avio_tell(pb) - sector_pos;
492     pad = WTV_SECTOR_SIZE- size;
493     write_pad(pb, pad);
494
495     return size;
496 }
497
498 static void write_fat(AVIOContext *pb, int start_sector, int nb_sectors, int shift)
499 {
500     int i;
501     for (i = 0; i < nb_sectors; i++) {
502         avio_wl32(pb, start_sector + (i << shift));
503     }
504     // pad left sector pointer size
505     write_pad(pb, WTV_SECTOR_SIZE - ((nb_sectors << 2) % WTV_SECTOR_SIZE));
506 }
507
508 static int write_fat_sector(AVFormatContext *s, int64_t start_pos, int nb_sectors, int sector_bits, int depth)
509 {
510     int64_t start_sector = start_pos >> WTV_SECTOR_BITS;
511     int shift = sector_bits - WTV_SECTOR_BITS;
512
513     int64_t fat = avio_tell(s->pb);
514     write_fat(s->pb, start_sector, nb_sectors, shift);
515
516     if (depth == 2) {
517         int64_t start_sector1 = fat >> WTV_SECTOR_BITS;
518         int nb_sectors1 = ((nb_sectors << 2) + WTV_SECTOR_SIZE - 1) / WTV_SECTOR_SIZE;
519         int64_t fat1 = avio_tell(s->pb);
520
521        write_fat(s->pb, start_sector1, nb_sectors1, 0);
522        return fat1;
523     }
524
525     return fat;
526 }
527
528 static void write_table_entries_events(AVFormatContext *s)
529 {
530     AVIOContext *pb = s->pb;
531     WtvContext *wctx = s->priv_data;
532
533     //FIXME: output frame_nb, position pairs.
534     //We only set the first sync_chunk position here.
535     avio_wl64(pb, 0x2);   avio_wl64(pb, wctx->sync_pos);
536 }
537
538 static void write_tag(AVIOContext *pb, const char *key, const char *value)
539 {
540     ff_put_guid(pb, &ff_metadata_guid);
541     avio_wl32(pb, 1);
542     avio_wl32(pb, strlen(value)*2 + 2);
543     avio_put_str16le(pb, key);
544     avio_put_str16le(pb, value);
545 }
546
547 static void write_table_entries_attrib(AVFormatContext *s)
548 {
549     AVDictionaryEntry *tag = 0;
550
551     //FIXME: translate special tags (e.g. WM/Bitrate) to binary representation
552     ff_metadata_conv(&s->metadata, ff_asf_metadata_conv, NULL);
553     while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX)))
554         write_tag(s->pb, tag->key, tag->value);
555 }
556
557 static void write_table_redirector_legacy_attrib(AVFormatContext *s)
558 {
559     AVIOContext *pb = s->pb;
560     AVDictionaryEntry *tag = 0;
561     int64_t pos = 0;
562
563     //FIXME: translate special tags to binary representation
564     while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
565         avio_wl64(pb, pos);
566         pos += 16 + 4 + 4 + strlen(tag->key)*2 + 2 + strlen(tag->value)*2 + 2;
567     }
568 }
569
570 /**
571  * Pad the remainder of a file
572  * Write out fat table
573  * @return <0 on error
574  */
575 static int finish_file(AVFormatContext *s, enum WtvFileIndex index, int64_t start_pos)
576 {
577     WtvContext *wctx = s->priv_data;
578     AVIOContext *pb = s->pb;
579     WtvFile *w = &wctx->file[index];
580     int64_t end_pos = avio_tell(pb);
581     int sector_bits, nb_sectors, pad;
582
583     av_assert0(index < WTV_FILES);
584
585     w->length = (end_pos - start_pos);
586
587     // determine optimal fat table depth, sector_bits, nb_sectors
588     if (w->length <= WTV_SECTOR_SIZE) {
589         w->depth = 0;
590         sector_bits = WTV_SECTOR_BITS;
591     } else if (w->length <= (WTV_SECTOR_SIZE / 4) * WTV_SECTOR_SIZE) {
592         w->depth = 1;
593         sector_bits = WTV_SECTOR_BITS;
594     } else if (w->length <= (WTV_SECTOR_SIZE / 4) * WTV_BIGSECTOR_SIZE) {
595         w->depth = 1;
596         sector_bits = WTV_BIGSECTOR_BITS;
597     } else if (w->length <= (int64_t)(WTV_SECTOR_SIZE / 4) * (WTV_SECTOR_SIZE / 4) * WTV_SECTOR_SIZE) {
598         w->depth = 2;
599         sector_bits = WTV_SECTOR_BITS;
600     } else if (w->length <= (int64_t)(WTV_SECTOR_SIZE / 4) * (WTV_SECTOR_SIZE / 4) * WTV_BIGSECTOR_SIZE) {
601         w->depth = 2;
602         sector_bits = WTV_BIGSECTOR_BITS;
603     } else {
604         av_log(s, AV_LOG_ERROR, "unsupported file allocation table depth (%"PRIi64" bytes)\n", w->length);
605         return -1;
606     }
607
608     // determine the nb_sectors
609     nb_sectors = (int)(w->length >> sector_bits);
610
611     // pad sector of timeline
612     pad = (1 << sector_bits) - (w->length % (1 << sector_bits));
613     if (pad) {
614         nb_sectors++;
615         write_pad(pb, pad);
616     }
617
618     //write fat table
619     if (w->depth > 0) {
620         w->first_sector = write_fat_sector(s, start_pos, nb_sectors, sector_bits, w->depth);
621     } else {
622         w->first_sector = start_pos;
623     }
624     w->first_sector >>= WTV_SECTOR_BITS;
625
626     w->length |= 1ULL<<60;
627     if (sector_bits == WTV_SECTOR_BITS)
628         w->length |= 1ULL<<63;
629
630     return 0;
631 }
632
633 static int write_trailer(AVFormatContext *s)
634 {
635     WtvContext *wctx = s->priv_data;
636     AVIOContext *pb = s->pb;
637     int root_size;
638     int64_t sector_pos;
639     int64_t start_pos, file_end_pos;
640
641     if (finish_file(s, WTV_TIMELINE, wctx->timeline_start_pos) < 0)
642         return -1;
643
644     start_pos = avio_tell(pb);
645     write_table_entries_events(s);
646     if (finish_file(s, WTV_TIMELINE_TABLE_0_ENTRIES_EVENTS, start_pos) < 0)
647         return -1;
648
649     start_pos = avio_tell(pb);
650     write_table_entries_attrib(s);
651     if (finish_file(s, WTV_TABLE_0_ENTRIES_LEGACY_ATTRIB, start_pos) < 0)
652         return -1;
653
654     start_pos = avio_tell(pb);
655     write_table_redirector_legacy_attrib(s);
656     if (finish_file(s, WTV_TABLE_0_REDIRECTOR_LEGACY_ATTRIB, start_pos) < 0)
657         return -1;
658
659     start_pos = avio_tell(pb);
660     //FIXME: output timestamp, frame_nb pairs here.
661     if (finish_file(s, WTV_TABLE_0_ENTRIES_TIME, start_pos) < 0)
662         return -1;
663
664     // write root table
665     sector_pos = avio_tell(pb);
666     root_size = write_root_table(s, sector_pos);
667
668     file_end_pos = avio_tell(pb);
669     // update root value
670     avio_seek(pb, 0x30, SEEK_SET);
671     avio_wl32(pb, root_size);
672     avio_seek(pb, 4, SEEK_CUR);
673     avio_wl32(pb, sector_pos >> WTV_SECTOR_BITS);
674     avio_seek(pb, 0x5c, SEEK_SET);
675     avio_wl32(pb, file_end_pos >> WTV_SECTOR_BITS);
676
677     avio_flush(pb);
678     return 0;
679 }
680
681 AVOutputFormat ff_wtv_muxer = {
682     .name           = "wtv",
683     .long_name      = NULL_IF_CONFIG_SMALL("Windows Television (WTV)"),
684     .extensions     = "wtv",
685     .priv_data_size = sizeof(WtvContext),
686     .audio_codec    = AV_CODEC_ID_AC3,
687     .video_codec    = AV_CODEC_ID_MPEG2VIDEO,
688     .write_header   = write_header,
689     .write_packet   = write_packet,
690     .write_trailer  = write_trailer,
691     .codec_tag      = (const AVCodecTag* const []){ ff_codec_bmp_tags,
692                                                     ff_codec_wav_tags, 0 },
693 };