git.sesse.net Git - ffmpeg/blob - 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 "avio_internal.h"
  32 #include "internal.h"
  33 #include "wtv.h"
  34 #include "asf.h"
  35
  36 #define WTV_BIGSECTOR_SIZE (1 << WTV_BIGSECTOR_BITS)
  37 #define INDEX_BASE 0x2
  38 #define MAX_NB_INDEX 10
  39
  40 /* declare utf16le strings */
  41 #define _ , 0,
  42 static const uint8_t timeline_table_0_header_events[] =
  43     {'t'_'i'_'m'_'e'_'l'_'i'_'n'_'e'_'.'_'t'_'a'_'b'_'l'_'e'_'.'_'0'_'.'_'h'_'e'_'a'_'d'_'e'_'r'_'.'_'E'_'v'_'e'_'n'_'t'_'s', 0};
  44 static const uint8_t table_0_header_legacy_attrib[] =
  45     {'t'_'a'_'b'_'l'_'e'_'.'_'0'_'.'_'h'_'e'_'a'_'d'_'e'_'r'_'.'_'l'_'e'_'g'_'a'_'c'_'y'_'_'_'a'_'t'_'t'_'r'_'i'_'b', 0};
  46 static const uint8_t table_0_redirector_legacy_attrib[] =
  47     {'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};
  48 static const uint8_t table_0_header_time[] =
  49     {'t'_'a'_'b'_'l'_'e'_'.'_'0'_'.'_'h'_'e'_'a'_'d'_'e'_'r'_'.'_'t'_'i'_'m'_'e', 0};
  50 static const uint8_t legacy_attrib[] =
  51     {'l'_'e'_'g'_'a'_'c'_'y'_'_'_'a'_'t'_'t'_'r'_'i'_'b', 0};
  52 #undef _
  53
  54 static const ff_asf_guid sub_wtv_guid =
  55     {0x8C,0xC3,0xD2,0xC2,0x7E,0x9A,0xDA,0x11,0x8B,0xF7,0x00,0x07,0xE9,0x5E,0xAD,0x8D};
  56
  57 enum WtvFileIndex {
  58     WTV_TIMELINE_TABLE_0_HEADER_EVENTS = 0,
  59     WTV_TIMELINE_TABLE_0_ENTRIES_EVENTS,
  60     WTV_TIMELINE,
  61     WTV_TABLE_0_HEADER_LEGACY_ATTRIB,
  62     WTV_TABLE_0_ENTRIES_LEGACY_ATTRIB,
  63     WTV_TABLE_0_REDIRECTOR_LEGACY_ATTRIB,
  64     WTV_TABLE_0_HEADER_TIME,
  65     WTV_TABLE_0_ENTRIES_TIME,
  66     WTV_FILES
  67 };
  68
  69 typedef struct {
  70     int64_t length;
  71     const void *header;
  72     int depth;
  73     int first_sector;
  74 } WtvFile;
  75
  76 typedef struct {
  77     int64_t             pos;
  78     int64_t             serial;
  79     const ff_asf_guid * guid;
  80     int                 stream_id;
  81 } WtvChunkEntry;
  82
  83 typedef struct {
  84     int64_t serial;
  85     int64_t value;
  86 } WtvSyncEntry;
  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 last_timestamp_pos; /**< last timestamp chunk position */
  94     int64_t first_index_pos;    /**< first index_chunk position */
  95
  96     WtvChunkEntry index[MAX_NB_INDEX];
  97     int nb_index;
  98     int first_video_flag;
  99
 100     WtvSyncEntry *st_pairs; /* (serial, timestamp) pairs */
 101     int nb_st_pairs;
 102     WtvSyncEntry *sp_pairs; /* (serial, position) pairs */
 103     int nb_sp_pairs;
 104
 105     int64_t last_pts;
 106     int64_t last_serial;
 107
 108     AVPacket thumbnail;
 109 } WtvContext;
 110
 111
 112 static void add_serial_pair(WtvSyncEntry ** list, int * count, int64_t serial, int64_t value)
 113 {
 114     int new_count = *count + 1;
 115     WtvSyncEntry *new_list = av_realloc(*list, new_count * sizeof(WtvSyncEntry));
 116     if (!new_list)
 117         return;
 118     new_list[*count] = (WtvSyncEntry){serial, value};
 119     *list  = new_list;
 120     *count = new_count;
 121 }
 122
 123 typedef int WTVHeaderWriteFunc(AVIOContext *pb);
 124
 125 typedef struct {
 126     const uint8_t *header;
 127     int header_size;
 128     WTVHeaderWriteFunc *write_header;
 129 } WTVRootEntryTable;
 130
 131 #define write_pad(pb, size) ffio_fill(pb, 0, size)
 132
 133 static const ff_asf_guid *get_codec_guid(enum AVCodecID id, const AVCodecGuid *av_guid)
 134 {
 135     int i;
 136     for (i = 0; av_guid[i].id != AV_CODEC_ID_NONE; i++) {
 137         if (id == av_guid[i].id)
 138             return &(av_guid[i].guid);
 139     }
 140     return NULL;
 141 }
 142
 143 /**
 144  * Write chunk header. If header chunk (0x80000000 set) then add to list of header chunks
 145  */
 146 static void write_chunk_header(AVFormatContext *s, const ff_asf_guid *guid, int length, int stream_id)
 147 {
 148     WtvContext *wctx = s->priv_data;
 149     AVIOContext *pb = s->pb;
 150
 151     wctx->last_chunk_pos = avio_tell(pb) - wctx->timeline_start_pos;
 152     ff_put_guid(pb, guid);
 153     avio_wl32(pb, 32 + length);
 154     avio_wl32(pb, stream_id);
 155     avio_wl64(pb, wctx->serial);
 156
 157     if ((stream_id & 0x80000000) && guid != &ff_index_guid) {
 158         WtvChunkEntry *t = wctx->index + wctx->nb_index;
 159         av_assert0(wctx->nb_index < MAX_NB_INDEX);
 160         t->pos       = wctx->last_chunk_pos;
 161         t->serial    = wctx->serial;
 162         t->guid      = guid;
 163         t->stream_id = stream_id & 0x3FFFFFFF;
 164         wctx->nb_index++;
 165     }
 166 }
 167
 168 static void write_chunk_header2(AVFormatContext *s, const ff_asf_guid *guid, int stream_id)
 169 {
 170     WtvContext *wctx = s->priv_data;
 171     AVIOContext *pb = s->pb;
 172
 173     int64_t last_chunk_pos = wctx->last_chunk_pos;
 174     write_chunk_header(s, guid, 0, stream_id); // length updated later
 175     avio_wl64(pb, last_chunk_pos);
 176 }
 177
 178 static void finish_chunk_noindex(AVFormatContext *s)
 179 {
 180     WtvContext *wctx = s->priv_data;
 181     AVIOContext *pb = s->pb;
 182
 183     // update the chunk_len field and pad.
 184     int64_t chunk_len = avio_tell(pb) - (wctx->last_chunk_pos + wctx->timeline_start_pos);
 185     avio_seek(pb, -(chunk_len - 16), SEEK_CUR);
 186     avio_wl32(pb, chunk_len);
 187     avio_seek(pb, chunk_len - (16 + 4), SEEK_CUR);
 188
 189     write_pad(pb, WTV_PAD8(chunk_len) - chunk_len);
 190     wctx->serial++;
 191 }
 192
 193 static void write_index(AVFormatContext *s)
 194 {
 195     AVIOContext *pb = s->pb;
 196     WtvContext *wctx = s->priv_data;
 197     int i;
 198
 199     write_chunk_header2(s, &ff_index_guid, 0x80000000);
 200     avio_wl32(pb, 0);
 201     avio_wl32(pb, 0);
 202
 203     for (i = 0; i < wctx->nb_index; i++) {
 204         WtvChunkEntry *t = wctx->index + i;
 205         ff_put_guid(pb,  t->guid);
 206         avio_wl64(pb, t->pos);
 207         avio_wl32(pb, t->stream_id);
 208         avio_wl32(pb, 0); // checksum?
 209         avio_wl64(pb, t->serial);
 210     }
 211     wctx->nb_index = 0;   // reset index
 212     finish_chunk_noindex(s);
 213
 214     if (!wctx->first_index_pos)
 215         wctx->first_index_pos = wctx->last_chunk_pos;
 216 }
 217
 218 static void finish_chunk(AVFormatContext *s)
 219 {
 220     WtvContext *wctx = s->priv_data;
 221     finish_chunk_noindex(s);
 222     if (wctx->nb_index == MAX_NB_INDEX)
 223         write_index(s);
 224 }
 225
 226 static void put_videoinfoheader2(AVIOContext *pb, AVStream *st)
 227 {
 228     AVRational dar = av_mul_q(st->sample_aspect_ratio, (AVRational){st->codec->width, st->codec->height});
 229     unsigned int num, den;
 230     av_reduce(&num, &den, dar.num, dar.den, 0xFFFFFFFF);
 231
 232     /* VIDEOINFOHEADER2 */
 233     avio_wl32(pb, 0);
 234     avio_wl32(pb, 0);
 235     avio_wl32(pb, st->codec->width);
 236     avio_wl32(pb, st->codec->height);
 237
 238     avio_wl32(pb, 0);
 239     avio_wl32(pb, 0);
 240     avio_wl32(pb, 0);
 241     avio_wl32(pb, 0);
 242
 243     avio_wl32(pb, st->codec->bit_rate);
 244     avio_wl32(pb, 0);
 245     avio_wl64(pb, st->avg_frame_rate.num && st->avg_frame_rate.den ? INT64_C(10000000) / av_q2d(st->avg_frame_rate) : 0);
 246     avio_wl32(pb, 0);
 247     avio_wl32(pb, 0);
 248
 249     avio_wl32(pb, num);
 250     avio_wl32(pb, den);
 251     avio_wl32(pb, 0);
 252     avio_wl32(pb, 0);
 253
 254     ff_put_bmp_header(pb, st->codec, ff_codec_bmp_tags, 0, 1);
 255
 256     if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
 257         /* MPEG2VIDEOINFO */
 258         avio_wl32(pb, 0);
 259         avio_wl32(pb, st->codec->extradata_size);
 260         avio_wl32(pb, -1);
 261         avio_wl32(pb, -1);
 262         avio_wl32(pb, 0);
 263         avio_write(pb, st->codec->extradata, st->codec->extradata_size);
 264         avio_wl64(pb, 0);
 265     }
 266 }
 267
 268 static int write_stream_codec_info(AVFormatContext *s, AVStream *st)
 269 {
 270     const ff_asf_guid *g, *media_type, *format_type;
 271     const AVCodecTag *tags;
 272     AVIOContext *pb = s->pb;
 273     int64_t  hdr_pos_start;
 274     int hdr_size = 0;
 275
 276     if (st->codec->codec_type  == AVMEDIA_TYPE_VIDEO) {
 277         g = get_codec_guid(st->codec->codec_id, ff_video_guids);
 278         media_type = &ff_mediatype_video;
 279         format_type = st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO ? &ff_format_mpeg2_video : &ff_format_videoinfo2;
 280         tags = ff_codec_bmp_tags;
 281     } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
 282         g = get_codec_guid(st->codec->codec_id, ff_codec_wav_guids);
 283         media_type = &ff_mediatype_audio;
 284         format_type = &ff_format_waveformatex;
 285         tags = ff_codec_wav_tags;
 286     } else {
 287         av_log(s, AV_LOG_ERROR, "unknown codec_type (0x%x)\n", st->codec->codec_type);
 288         return -1;
 289     }
 290
 291     ff_put_guid(pb, media_type); // mediatype
 292     ff_put_guid(pb, &ff_mediasubtype_cpfilters_processed); // subtype
 293     write_pad(pb, 12);
 294     ff_put_guid(pb,&ff_format_cpfilters_processed); // format type
 295     avio_wl32(pb, 0); // size
 296
 297     hdr_pos_start = avio_tell(pb);
 298     if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 299         put_videoinfoheader2(pb, st);
 300     } else {
 301         if (ff_put_wav_header(pb, st->codec) < 0)
 302             format_type = &ff_format_none;
 303     }
 304     hdr_size = avio_tell(pb) - hdr_pos_start;
 305
 306     // seek back write hdr_size
 307     avio_seek(pb, -(hdr_size + 4), SEEK_CUR);
 308     avio_wl32(pb, hdr_size + 32);
 309     avio_seek(pb, hdr_size, SEEK_CUR);
 310     if (g) {
 311         ff_put_guid(pb, g);           // actual_subtype
 312     } else {
 313         int tag = ff_codec_get_tag(tags, st->codec->codec_id);
 314         if (!tag) {
 315             av_log(s, AV_LOG_ERROR, "unsupported codec_id (0x%x)\n", st->codec->codec_id);
 316             return -1;
 317         }
 318         avio_wl32(pb, tag);
 319         avio_write(pb, (const uint8_t[]){FF_MEDIASUBTYPE_BASE_GUID}, 12);
 320     }
 321     ff_put_guid(pb, format_type); // actual_formattype
 322
 323     return 0;
 324 }
 325
 326 static int write_stream_codec(AVFormatContext *s, AVStream * st)
 327 {
 328     AVIOContext *pb = s->pb;
 329     int ret;
 330     write_chunk_header2(s, &ff_stream1_guid, 0x80000000 | 0x01);
 331
 332     avio_wl32(pb,  0x01);
 333     write_pad(pb, 4);
 334     write_pad(pb, 4);
 335
 336     ret = write_stream_codec_info(s, st);
 337     if (ret < 0) {
 338         av_log(s, AV_LOG_ERROR, "write stream codec info failed codec_type(0x%x)\n", st->codec->codec_type);
 339         return -1;
 340     }
 341
 342     finish_chunk(s);
 343     return 0;
 344 }
 345
 346 static void write_sync(AVFormatContext *s)
 347 {
 348     AVIOContext *pb = s->pb;
 349     WtvContext *wctx = s->priv_data;
 350     int64_t last_chunk_pos = wctx->last_chunk_pos;
 351
 352     write_chunk_header(s, &ff_sync_guid, 0x18, 0);
 353     avio_wl64(pb, wctx->first_index_pos);
 354     avio_wl64(pb, wctx->last_timestamp_pos);
 355     avio_wl64(pb, 0);
 356
 357     finish_chunk(s);
 358     add_serial_pair(&wctx->sp_pairs, &wctx->nb_sp_pairs, wctx->serial, wctx->last_chunk_pos);
 359
 360     wctx->last_chunk_pos = last_chunk_pos;
 361 }
 362
 363 static int write_stream_data(AVFormatContext *s, AVStream *st)
 364 {
 365     AVIOContext *pb = s->pb;
 366     int ret;
 367
 368     write_chunk_header2(s, &ff_SBE2_STREAM_DESC_EVENT, 0x80000000 | (st->index + INDEX_BASE));
 369     avio_wl32(pb, 0x00000001);
 370     avio_wl32(pb, st->index + INDEX_BASE); //stream_id
 371     avio_wl32(pb, 0x00000001);
 372     write_pad(pb, 8);
 373
 374     ret = write_stream_codec_info(s, st);
 375     if (ret < 0) {
 376         av_log(s, AV_LOG_ERROR, "write stream codec info failed codec_type(0x%x)\n", st->codec->codec_type);
 377         return -1;
 378     }
 379     finish_chunk(s);
 380
 381     avpriv_set_pts_info(st, 64, 1, 10000000);
 382
 383     return 0;
 384 }
 385
 386 static int write_header(AVFormatContext *s)
 387 {
 388     AVIOContext *pb = s->pb;
 389     WtvContext *wctx = s->priv_data;
 390     int i, pad, ret;
 391     AVStream *st;
 392
 393     wctx->last_chunk_pos     = -1;
 394     wctx->last_timestamp_pos = -1;
 395
 396     ff_put_guid(pb, &ff_wtv_guid);
 397     ff_put_guid(pb, &sub_wtv_guid);
 398
 399     avio_wl32(pb, 0x01);
 400     avio_wl32(pb, 0x02);
 401     avio_wl32(pb, 1 << WTV_SECTOR_BITS);
 402     avio_wl32(pb, 1 << WTV_BIGSECTOR_BITS);
 403
 404     //write initial root fields
 405     avio_wl32(pb, 0); // root_size, update later
 406     write_pad(pb, 4);
 407     avio_wl32(pb, 0); // root_sector, update it later.
 408
 409     write_pad(pb, 32);
 410     avio_wl32(pb, 0); // file ends pointer, update it later.
 411
 412     pad = (1 << WTV_SECTOR_BITS) - avio_tell(pb);
 413     write_pad(pb, pad);
 414
 415     wctx->timeline_start_pos = avio_tell(pb);
 416
 417     wctx->serial = 1;
 418     wctx->last_chunk_pos = -1;
 419     wctx->first_video_flag = 1;
 420
 421     for (i = 0; i < s->nb_streams; i++) {
 422         st = s->streams[i];
 423         if (st->codec->codec_id == AV_CODEC_ID_MJPEG)
 424             continue;
 425         ret = write_stream_codec(s, st);
 426         if (ret < 0) {
 427             av_log(s, AV_LOG_ERROR, "write stream codec failed codec_type(0x%x)\n", st->codec->codec_type);
 428             return -1;
 429         }
 430         if (!i)
 431             write_sync(s);
 432     }
 433
 434     for (i = 0; i < s->nb_streams; i++) {
 435         st = s->streams[i];
 436         if (st->codec->codec_id == AV_CODEC_ID_MJPEG)
 437             continue;
 438         ret  = write_stream_data(s, st);
 439         if (ret < 0) {
 440             av_log(s, AV_LOG_ERROR, "write stream data failed codec_type(0x%x)\n", st->codec->codec_type);
 441             return -1;
 442         }
 443     }
 444
 445     if (wctx->nb_index)
 446         write_index(s);
 447
 448     return 0;
 449 }
 450
 451 static void write_timestamp(AVFormatContext *s, AVPacket *pkt)
 452 {
 453     AVIOContext *pb = s->pb;
 454     WtvContext  *wctx = s->priv_data;
 455     AVCodecContext *enc = s->streams[pkt->stream_index]->codec;
 456
 457     write_chunk_header(s, &ff_timestamp_guid, 56, 0x40000000 | (INDEX_BASE + pkt->stream_index));
 458     write_pad(pb, 8);
 459     avio_wl64(pb, pkt->pts == AV_NOPTS_VALUE ? -1 : pkt->pts);
 460     avio_wl64(pb, pkt->pts == AV_NOPTS_VALUE ? -1 : pkt->pts);
 461     avio_wl64(pb, pkt->pts == AV_NOPTS_VALUE ? -1 : pkt->pts);
 462     avio_wl64(pb, 0);
 463     avio_wl64(pb, enc->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & AV_PKT_FLAG_KEY) ? 1 : 0);
 464     avio_wl64(pb, 0);
 465
 466     wctx->last_timestamp_pos = wctx->last_chunk_pos;
 467 }
 468
 469 static int write_packet(AVFormatContext *s, AVPacket *pkt)
 470 {
 471     AVIOContext *pb = s->pb;
 472     WtvContext  *wctx = s->priv_data;
 473
 474     if (s->streams[pkt->stream_index]->codec->codec_id == AV_CODEC_ID_MJPEG && !wctx->thumbnail.size) {
 475         av_copy_packet(&wctx->thumbnail, pkt);
 476         return 0;
 477     }
 478
 479     /* emit sync chunk and 'timeline.table.0.entries.Event' record every 50 frames */
 480     if (wctx->serial - (wctx->nb_sp_pairs ? wctx->sp_pairs[wctx->nb_sp_pairs - 1].serial : 0) >= 50)
 481         write_sync(s);
 482
 483     /* emit 'table.0.entries.time' record every 500ms */
 484     if (pkt->pts != AV_NOPTS_VALUE && pkt->pts - (wctx->nb_st_pairs ? wctx->st_pairs[wctx->nb_st_pairs - 1].value : 0) >= 5000000)
 485         add_serial_pair(&wctx->st_pairs, &wctx->nb_st_pairs, wctx->serial, pkt->pts);
 486
 487     if (pkt->pts != AV_NOPTS_VALUE && pkt->pts > wctx->last_pts) {
 488         wctx->last_pts = pkt->pts;
 489         wctx->last_serial = wctx->serial;
 490     }
 491
 492     // write timestamp chunk
 493     write_timestamp(s, pkt);
 494
 495     write_chunk_header(s, &ff_data_guid, pkt->size, INDEX_BASE + pkt->stream_index);
 496     avio_write(pb, pkt->data, pkt->size);
 497     write_pad(pb, WTV_PAD8(pkt->size) - pkt->size);
 498
 499     wctx->serial++;
 500     return 0;
 501 }
 502
 503 static int write_table0_header_events(AVIOContext *pb)
 504 {
 505     avio_wl32(pb, 0x10);
 506     write_pad(pb, 84);
 507     avio_wl64(pb, 0x32);
 508     return 96;
 509 }
 510
 511 static int write_table0_header_legacy_attrib(AVIOContext *pb)
 512 {
 513     int pad = 0;
 514     avio_wl32(pb, 0xFFFFFFFF);
 515     write_pad(pb, 12);
 516     avio_write(pb, legacy_attrib, sizeof(legacy_attrib));
 517     pad = WTV_PAD8(sizeof(legacy_attrib)) - sizeof(legacy_attrib);
 518     write_pad(pb, pad);
 519     write_pad(pb, 32);
 520     return 48 + WTV_PAD8(sizeof(legacy_attrib));
 521 }
 522
 523 static int write_table0_header_time(AVIOContext *pb)
 524 {
 525     avio_wl32(pb, 0x10);
 526     write_pad(pb, 76);
 527     avio_wl64(pb, 0x40);
 528     return 88;
 529 }
 530
 531 static const WTVRootEntryTable wtv_root_entry_table[] = {
 532     { timeline_table_0_header_events,          sizeof(timeline_table_0_header_events),          write_table0_header_events},
 533     { ff_timeline_table_0_entries_Events_le16, sizeof(ff_timeline_table_0_entries_Events_le16), NULL},
 534     { ff_timeline_le16,                        sizeof(ff_timeline_le16),                        NULL},
 535     { table_0_header_legacy_attrib,            sizeof(table_0_header_legacy_attrib),            write_table0_header_legacy_attrib},
 536     { ff_table_0_entries_legacy_attrib_le16,   sizeof(ff_table_0_entries_legacy_attrib_le16),   NULL},
 537     { table_0_redirector_legacy_attrib,        sizeof(table_0_redirector_legacy_attrib),        NULL},
 538     { table_0_header_time,                     sizeof(table_0_header_time),                     write_table0_header_time},
 539     { ff_table_0_entries_time_le16,            sizeof(ff_table_0_entries_time_le16),            NULL},
 540 };
 541
 542 static int write_root_table(AVFormatContext *s, int64_t sector_pos)
 543 {
 544     AVIOContext *pb = s->pb;
 545     WtvContext  *wctx = s->priv_data;
 546     int size, pad;
 547     int i;
 548
 549     const WTVRootEntryTable *h = wtv_root_entry_table;
 550     for (i = 0; i < sizeof(wtv_root_entry_table)/sizeof(WTVRootEntryTable); i++, h++) {
 551         WtvFile *w = &wctx->file[i];
 552         int filename_padding = WTV_PAD8(h->header_size) - h->header_size;
 553         WTVHeaderWriteFunc *write = h->write_header;
 554         int len = 0;
 555         int64_t len_pos;
 556
 557         ff_put_guid(pb, &ff_dir_entry_guid);
 558         len_pos = avio_tell(pb);
 559         avio_wl16(pb, 40 + h->header_size + filename_padding + 8); // maybe updated later
 560         write_pad(pb, 6);
 561         avio_wl64(pb, write ? 0 : w->length);// maybe update later
 562         avio_wl32(pb, (h->header_size + filename_padding) >> 1);
 563         write_pad(pb, 4);
 564
 565         avio_write(pb, h->header, h->header_size);
 566         write_pad(pb, filename_padding);
 567
 568         if (write) {
 569             len = write(pb);
 570             // update length field
 571             avio_seek(pb, len_pos, SEEK_SET);
 572             avio_wl64(pb, 40 + h->header_size + filename_padding + len);
 573             avio_wl64(pb, len |(1ULL<<62) | (1ULL<<60));
 574             avio_seek(pb, 8 + h->header_size + filename_padding + len, SEEK_CUR);
 575         } else {
 576             avio_wl32(pb, w->first_sector);
 577             avio_wl32(pb, w->depth);
 578         }
 579     }
 580
 581     // caculate root table size
 582     size = avio_tell(pb) - sector_pos;
 583     pad = WTV_SECTOR_SIZE- size;
 584     write_pad(pb, pad);
 585
 586     return size;
 587 }
 588
 589 static void write_fat(AVIOContext *pb, int start_sector, int nb_sectors, int shift)
 590 {
 591     int i;
 592     for (i = 0; i < nb_sectors; i++) {
 593         avio_wl32(pb, start_sector + (i << shift));
 594     }
 595     // pad left sector pointer size
 596     write_pad(pb, WTV_SECTOR_SIZE - ((nb_sectors << 2) % WTV_SECTOR_SIZE));
 597 }
 598
 599 static int64_t write_fat_sector(AVFormatContext *s, int64_t start_pos, int nb_sectors, int sector_bits, int depth)
 600 {
 601     int64_t start_sector = start_pos >> WTV_SECTOR_BITS;
 602     int shift = sector_bits - WTV_SECTOR_BITS;
 603
 604     int64_t fat = avio_tell(s->pb);
 605     write_fat(s->pb, start_sector, nb_sectors, shift);
 606
 607     if (depth == 2) {
 608         int64_t start_sector1 = fat >> WTV_SECTOR_BITS;
 609         int nb_sectors1 = ((nb_sectors << 2) + WTV_SECTOR_SIZE - 1) / WTV_SECTOR_SIZE;
 610         int64_t fat1 = avio_tell(s->pb);
 611
 612        write_fat(s->pb, start_sector1, nb_sectors1, 0);
 613        return fat1;
 614     }
 615
 616     return fat;
 617 }
 618
 619 static void write_table_entries_events(AVFormatContext *s)
 620 {
 621     AVIOContext *pb = s->pb;
 622     WtvContext *wctx = s->priv_data;
 623     int i;
 624     for (i = 0; i < wctx->nb_sp_pairs; i++) {
 625         avio_wl64(pb, wctx->sp_pairs[i].serial);
 626         avio_wl64(pb, wctx->sp_pairs[i].value);
 627     }
 628 }
 629
 630 static void write_table_entries_time(AVFormatContext *s)
 631 {
 632     AVIOContext *pb = s->pb;
 633     WtvContext *wctx = s->priv_data;
 634     int i;
 635     for (i = 0; i < wctx->nb_st_pairs; i++) {
 636         avio_wl64(pb, wctx->st_pairs[i].value);
 637         avio_wl64(pb, wctx->st_pairs[i].serial);
 638     }
 639     avio_wl64(pb, wctx->last_pts);
 640     avio_wl64(pb, wctx->last_serial);
 641 }
 642
 643 static void write_metadata_header(AVIOContext *pb, int type, const char *key, int value_size)
 644 {
 645     ff_put_guid(pb, &ff_metadata_guid);
 646     avio_wl32(pb, type);
 647     avio_wl32(pb, value_size);
 648     avio_put_str16le(pb, key);
 649 }
 650
 651 static int metadata_header_size(const char *key)
 652 {
 653     return 16 + 4 + 4 + strlen(key)*2 + 2;
 654 }
 655
 656 static void write_tag_int32(AVIOContext *pb, const char *key, int value)
 657 {
 658     write_metadata_header(pb, 0, key, 4);
 659     avio_wl32(pb, value);
 660 }
 661
 662 static void write_tag(AVIOContext *pb, const char *key, const char *value)
 663 {
 664     write_metadata_header(pb, 1, key, strlen(value)*2 + 2);
 665     avio_put_str16le(pb, value);
 666 }
 667
 668 static int attachment_value_size(const AVPacket *pkt, const AVDictionaryEntry *e)
 669 {
 670     return strlen("image/jpeg")*2 + 2 + 1 + (e ? strlen(e->value)*2 : 0) + 2 + 4 + pkt->size;
 671 }
 672
 673 static void write_table_entries_attrib(AVFormatContext *s)
 674 {
 675     WtvContext *wctx = s->priv_data;
 676     AVIOContext *pb = s->pb;
 677     AVDictionaryEntry *tag = 0;
 678
 679     //FIXME: translate special tags (e.g. WM/Bitrate) to binary representation
 680     ff_metadata_conv(&s->metadata, ff_asf_metadata_conv, NULL);
 681     while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX)))
 682         write_tag(pb, tag->key, tag->value);
 683
 684     if (wctx->thumbnail.size) {
 685         AVStream *st = s->streams[wctx->thumbnail.stream_index];
 686         tag = av_dict_get(st->metadata, "title", NULL, 0);
 687         write_metadata_header(pb, 2, "WM/Picture", attachment_value_size(&wctx->thumbnail, tag));
 688
 689         avio_put_str16le(pb, "image/jpeg");
 690         avio_w8(pb, 0x10);
 691         avio_put_str16le(pb, tag ? tag->value : "");
 692
 693         avio_wl32(pb, wctx->thumbnail.size);
 694         avio_write(pb, wctx->thumbnail.data, wctx->thumbnail.size);
 695
 696         write_tag_int32(pb, "WM/MediaThumbType", 2);
 697     }
 698 }
 699
 700 static void write_table_redirector_legacy_attrib(AVFormatContext *s)
 701 {
 702     WtvContext *wctx = s->priv_data;
 703     AVIOContext *pb = s->pb;
 704     AVDictionaryEntry *tag = 0;
 705     int64_t pos = 0;
 706
 707     //FIXME: translate special tags to binary representation
 708     while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 709         avio_wl64(pb, pos);
 710         pos += metadata_header_size(tag->key) + strlen(tag->value)*2 + 2;
 711     }
 712
 713     if (wctx->thumbnail.size) {
 714         AVStream *st = s->streams[wctx->thumbnail.stream_index];
 715         avio_wl64(pb, pos);
 716         pos += metadata_header_size("WM/Picture") + attachment_value_size(&wctx->thumbnail, av_dict_get(st->metadata, "title", NULL, 0));
 717
 718         avio_wl64(pb, pos);
 719         pos += metadata_header_size("WM/MediaThumbType") + 4;
 720     }
 721 }
 722
 723 /**
 724  * Pad the remainder of a file
 725  * Write out fat table
 726  * @return <0 on error
 727  */
 728 static int finish_file(AVFormatContext *s, enum WtvFileIndex index, int64_t start_pos)
 729 {
 730     WtvContext *wctx = s->priv_data;
 731     AVIOContext *pb = s->pb;
 732     WtvFile *w = &wctx->file[index];
 733     int64_t end_pos = avio_tell(pb);
 734     int sector_bits, nb_sectors, pad;
 735
 736     av_assert0(index < WTV_FILES);
 737
 738     w->length = (end_pos - start_pos);
 739
 740     // determine optimal fat table depth, sector_bits, nb_sectors
 741     if (w->length <= WTV_SECTOR_SIZE) {
 742         w->depth = 0;
 743         sector_bits = WTV_SECTOR_BITS;
 744     } else if (w->length <= (WTV_SECTOR_SIZE / 4) * WTV_SECTOR_SIZE) {
 745         w->depth = 1;
 746         sector_bits = WTV_SECTOR_BITS;
 747     } else if (w->length <= (WTV_SECTOR_SIZE / 4) * WTV_BIGSECTOR_SIZE) {
 748         w->depth = 1;
 749         sector_bits = WTV_BIGSECTOR_BITS;
 750     } else if (w->length <= (int64_t)(WTV_SECTOR_SIZE / 4) * (WTV_SECTOR_SIZE / 4) * WTV_SECTOR_SIZE) {
 751         w->depth = 2;
 752         sector_bits = WTV_SECTOR_BITS;
 753     } else if (w->length <= (int64_t)(WTV_SECTOR_SIZE / 4) * (WTV_SECTOR_SIZE / 4) * WTV_BIGSECTOR_SIZE) {
 754         w->depth = 2;
 755         sector_bits = WTV_BIGSECTOR_BITS;
 756     } else {
 757         av_log(s, AV_LOG_ERROR, "unsupported file allocation table depth (%"PRIi64" bytes)\n", w->length);
 758         return -1;
 759     }
 760
 761     // determine the nb_sectors
 762     nb_sectors = (int)(w->length >> sector_bits);
 763
 764     // pad sector of timeline
 765     pad = (1 << sector_bits) - (w->length % (1 << sector_bits));
 766     if (pad) {
 767         nb_sectors++;
 768         write_pad(pb, pad);
 769     }
 770
 771     //write fat table
 772     if (w->depth > 0) {
 773         w->first_sector = write_fat_sector(s, start_pos, nb_sectors, sector_bits, w->depth) >> WTV_SECTOR_BITS;
 774     } else {
 775         w->first_sector = start_pos >> WTV_SECTOR_BITS;
 776     }
 777
 778     w->length |= 1ULL<<60;
 779     if (sector_bits == WTV_SECTOR_BITS)
 780         w->length |= 1ULL<<63;
 781
 782     return 0;
 783 }
 784
 785 static int write_trailer(AVFormatContext *s)
 786 {
 787     WtvContext *wctx = s->priv_data;
 788     AVIOContext *pb = s->pb;
 789     int root_size;
 790     int64_t sector_pos;
 791     int64_t start_pos, file_end_pos;
 792
 793     if (finish_file(s, WTV_TIMELINE, wctx->timeline_start_pos) < 0)
 794         return -1;
 795
 796     start_pos = avio_tell(pb);
 797     write_table_entries_events(s);
 798     if (finish_file(s, WTV_TIMELINE_TABLE_0_ENTRIES_EVENTS, start_pos) < 0)
 799         return -1;
 800
 801     start_pos = avio_tell(pb);
 802     write_table_entries_attrib(s);
 803     if (finish_file(s, WTV_TABLE_0_ENTRIES_LEGACY_ATTRIB, start_pos) < 0)
 804         return -1;
 805
 806     start_pos = avio_tell(pb);
 807     write_table_redirector_legacy_attrib(s);
 808     if (finish_file(s, WTV_TABLE_0_REDIRECTOR_LEGACY_ATTRIB, start_pos) < 0)
 809         return -1;
 810
 811     start_pos = avio_tell(pb);
 812     write_table_entries_time(s);
 813     if (finish_file(s, WTV_TABLE_0_ENTRIES_TIME, start_pos) < 0)
 814         return -1;
 815
 816     // write root table
 817     sector_pos = avio_tell(pb);
 818     root_size = write_root_table(s, sector_pos);
 819
 820     file_end_pos = avio_tell(pb);
 821     // update root value
 822     avio_seek(pb, 0x30, SEEK_SET);
 823     avio_wl32(pb, root_size);
 824     avio_seek(pb, 4, SEEK_CUR);
 825     avio_wl32(pb, sector_pos >> WTV_SECTOR_BITS);
 826     avio_seek(pb, 0x5c, SEEK_SET);
 827     avio_wl32(pb, file_end_pos >> WTV_SECTOR_BITS);
 828
 829     avio_flush(pb);
 830
 831     av_free(wctx->sp_pairs);
 832     av_free(wctx->st_pairs);
 833     av_free_packet(&wctx->thumbnail);
 834     return 0;
 835 }
 836
 837 AVOutputFormat ff_wtv_muxer = {
 838     .name           = "wtv",
 839     .long_name      = NULL_IF_CONFIG_SMALL("Windows Television (WTV)"),
 840     .extensions     = "wtv",
 841     .priv_data_size = sizeof(WtvContext),
 842     .audio_codec    = AV_CODEC_ID_AC3,
 843     .video_codec    = AV_CODEC_ID_MPEG2VIDEO,
 844     .write_header   = write_header,
 845     .write_packet   = write_packet,
 846     .write_trailer  = write_trailer,
 847     .codec_tag      = (const AVCodecTag* const []){ ff_codec_bmp_tags,
 848                                                     ff_codec_wav_tags, 0 },
 849 };