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