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