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