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