ffmpeg / libavformat / matroskaenc.c @ f9ff7179
History | View | Annotate | Download (34.4 KB)
1 |
/*
|
---|---|
2 |
* Matroska muxer
|
3 |
* Copyright (c) 2007 David Conrad
|
4 |
*
|
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 |
#include "avformat.h" |
23 |
#include "riff.h" |
24 |
#include "isom.h" |
25 |
#include "matroska.h" |
26 |
#include "avc.h" |
27 |
#include "flacenc.h" |
28 |
#include "libavutil/intreadwrite.h" |
29 |
#include "libavutil/md5.h" |
30 |
#include "libavcodec/xiph.h" |
31 |
#include "libavcodec/mpeg4audio.h" |
32 |
|
33 |
typedef struct ebml_master { |
34 |
int64_t pos; ///< absolute offset in the file where the master's elements start
|
35 |
int sizebytes; ///< how many bytes were reserved for the size |
36 |
} ebml_master; |
37 |
|
38 |
typedef struct mkv_seekhead_entry { |
39 |
unsigned int elementid; |
40 |
uint64_t segmentpos; |
41 |
} mkv_seekhead_entry; |
42 |
|
43 |
typedef struct mkv_seekhead { |
44 |
int64_t filepos; |
45 |
int64_t segment_offset; ///< the file offset to the beginning of the segment
|
46 |
int reserved_size; ///< -1 if appending to file |
47 |
int max_entries;
|
48 |
mkv_seekhead_entry *entries; |
49 |
int num_entries;
|
50 |
} mkv_seekhead; |
51 |
|
52 |
typedef struct { |
53 |
uint64_t pts; |
54 |
int tracknum;
|
55 |
int64_t cluster_pos; ///< file offset of the cluster containing the block
|
56 |
} mkv_cuepoint; |
57 |
|
58 |
typedef struct { |
59 |
int64_t segment_offset; |
60 |
mkv_cuepoint *entries; |
61 |
int num_entries;
|
62 |
} mkv_cues; |
63 |
|
64 |
typedef struct { |
65 |
int write_dts;
|
66 |
} mkv_track; |
67 |
|
68 |
typedef struct MatroskaMuxContext { |
69 |
ByteIOContext *dyn_bc; |
70 |
ebml_master segment; |
71 |
int64_t segment_offset; |
72 |
int64_t segment_uid; |
73 |
ebml_master cluster; |
74 |
int64_t cluster_pos; ///< file offset of the current cluster
|
75 |
int64_t cluster_pts; |
76 |
int64_t duration_offset; |
77 |
int64_t duration; |
78 |
mkv_seekhead *main_seekhead; |
79 |
mkv_seekhead *cluster_seekhead; |
80 |
mkv_cues *cues; |
81 |
mkv_track *tracks; |
82 |
|
83 |
struct AVMD5 *md5_ctx;
|
84 |
} MatroskaMuxContext; |
85 |
|
86 |
|
87 |
/** 2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit
|
88 |
* offset, 4 bytes for target EBML ID */
|
89 |
#define MAX_SEEKENTRY_SIZE 21 |
90 |
|
91 |
/** per-cuepoint-track - 3 1-byte EBML IDs, 3 1-byte EBML sizes, 2
|
92 |
* 8-byte uint max */
|
93 |
#define MAX_CUETRACKPOS_SIZE 22 |
94 |
|
95 |
/** per-cuepoint - 2 1-byte EBML IDs, 2 1-byte EBML sizes, 8-byte uint max */
|
96 |
#define MAX_CUEPOINT_SIZE(num_tracks) 12 + MAX_CUETRACKPOS_SIZE*num_tracks |
97 |
|
98 |
|
99 |
static int ebml_id_size(unsigned int id) |
100 |
{ |
101 |
return (av_log2(id+1)-1)/7+1; |
102 |
} |
103 |
|
104 |
static void put_ebml_id(ByteIOContext *pb, unsigned int id) |
105 |
{ |
106 |
int i = ebml_id_size(id);
|
107 |
while (i--)
|
108 |
put_byte(pb, id >> (i*8));
|
109 |
} |
110 |
|
111 |
/**
|
112 |
* Write an EBML size meaning "unknown size".
|
113 |
*
|
114 |
* @param bytes The number of bytes the size should occupy (maximum: 8).
|
115 |
*/
|
116 |
static void put_ebml_size_unknown(ByteIOContext *pb, int bytes) |
117 |
{ |
118 |
assert(bytes <= 8);
|
119 |
put_byte(pb, 0x1ff >> bytes);
|
120 |
while (--bytes)
|
121 |
put_byte(pb, 0xff);
|
122 |
} |
123 |
|
124 |
/**
|
125 |
* Calculate how many bytes are needed to represent a given number in EBML.
|
126 |
*/
|
127 |
static int ebml_num_size(uint64_t num) |
128 |
{ |
129 |
int bytes = 1; |
130 |
while ((num+1) >> bytes*7) bytes++; |
131 |
return bytes;
|
132 |
} |
133 |
|
134 |
/**
|
135 |
* Write a number in EBML variable length format.
|
136 |
*
|
137 |
* @param bytes The number of bytes that need to be used to write the number.
|
138 |
* If zero, any number of bytes can be used.
|
139 |
*/
|
140 |
static void put_ebml_num(ByteIOContext *pb, uint64_t num, int bytes) |
141 |
{ |
142 |
int i, needed_bytes = ebml_num_size(num);
|
143 |
|
144 |
// sizes larger than this are currently undefined in EBML
|
145 |
assert(num < (1ULL<<56)-1); |
146 |
|
147 |
if (bytes == 0) |
148 |
// don't care how many bytes are used, so use the min
|
149 |
bytes = needed_bytes; |
150 |
// the bytes needed to write the given size would exceed the bytes
|
151 |
// that we need to use, so write unknown size. This shouldn't happen.
|
152 |
assert(bytes >= needed_bytes); |
153 |
|
154 |
num |= 1ULL << bytes*7; |
155 |
for (i = bytes - 1; i >= 0; i--) |
156 |
put_byte(pb, num >> i*8);
|
157 |
} |
158 |
|
159 |
static void put_ebml_uint(ByteIOContext *pb, unsigned int elementid, uint64_t val) |
160 |
{ |
161 |
int i, bytes = 1; |
162 |
uint64_t tmp = val; |
163 |
while (tmp>>=8) bytes++; |
164 |
|
165 |
put_ebml_id(pb, elementid); |
166 |
put_ebml_num(pb, bytes, 0);
|
167 |
for (i = bytes - 1; i >= 0; i--) |
168 |
put_byte(pb, val >> i*8);
|
169 |
} |
170 |
|
171 |
static void put_ebml_float(ByteIOContext *pb, unsigned int elementid, double val) |
172 |
{ |
173 |
put_ebml_id(pb, elementid); |
174 |
put_ebml_num(pb, 8, 0); |
175 |
put_be64(pb, av_dbl2int(val)); |
176 |
} |
177 |
|
178 |
static void put_ebml_binary(ByteIOContext *pb, unsigned int elementid, |
179 |
const uint8_t *buf, int size) |
180 |
{ |
181 |
put_ebml_id(pb, elementid); |
182 |
put_ebml_num(pb, size, 0);
|
183 |
put_buffer(pb, buf, size); |
184 |
} |
185 |
|
186 |
static void put_ebml_string(ByteIOContext *pb, unsigned int elementid, const char *str) |
187 |
{ |
188 |
put_ebml_binary(pb, elementid, str, strlen(str)); |
189 |
} |
190 |
|
191 |
/**
|
192 |
* Writes a void element of a given size. Useful for reserving space in
|
193 |
* the file to be written to later.
|
194 |
*
|
195 |
* @param size The number of bytes to reserve, which must be at least 2.
|
196 |
*/
|
197 |
static void put_ebml_void(ByteIOContext *pb, uint64_t size) |
198 |
{ |
199 |
int64_t currentpos = url_ftell(pb); |
200 |
|
201 |
assert(size >= 2);
|
202 |
|
203 |
put_ebml_id(pb, EBML_ID_VOID); |
204 |
// we need to subtract the length needed to store the size from the
|
205 |
// size we need to reserve so 2 cases, we use 8 bytes to store the
|
206 |
// size if possible, 1 byte otherwise
|
207 |
if (size < 10) |
208 |
put_ebml_num(pb, size-1, 0); |
209 |
else
|
210 |
put_ebml_num(pb, size-9, 8); |
211 |
while(url_ftell(pb) < currentpos + size)
|
212 |
put_byte(pb, 0);
|
213 |
} |
214 |
|
215 |
static ebml_master start_ebml_master(ByteIOContext *pb, unsigned int elementid, uint64_t expectedsize) |
216 |
{ |
217 |
int bytes = expectedsize ? ebml_num_size(expectedsize) : 8; |
218 |
put_ebml_id(pb, elementid); |
219 |
put_ebml_size_unknown(pb, bytes); |
220 |
return (ebml_master){ url_ftell(pb), bytes };
|
221 |
} |
222 |
|
223 |
static void end_ebml_master(ByteIOContext *pb, ebml_master master) |
224 |
{ |
225 |
int64_t pos = url_ftell(pb); |
226 |
|
227 |
if (url_fseek(pb, master.pos - master.sizebytes, SEEK_SET) < 0) |
228 |
return;
|
229 |
put_ebml_num(pb, pos - master.pos, master.sizebytes); |
230 |
url_fseek(pb, pos, SEEK_SET); |
231 |
} |
232 |
|
233 |
static void put_xiph_size(ByteIOContext *pb, int size) |
234 |
{ |
235 |
int i;
|
236 |
for (i = 0; i < size / 255; i++) |
237 |
put_byte(pb, 255);
|
238 |
put_byte(pb, size % 255);
|
239 |
} |
240 |
|
241 |
/**
|
242 |
* Initialize a mkv_seekhead element to be ready to index level 1 Matroska
|
243 |
* elements. If a maximum number of elements is specified, enough space
|
244 |
* will be reserved at the current file location to write a seek head of
|
245 |
* that size.
|
246 |
*
|
247 |
* @param segment_offset The absolute offset to the position in the file
|
248 |
* where the segment begins.
|
249 |
* @param numelements The maximum number of elements that will be indexed
|
250 |
* by this seek head, 0 if unlimited.
|
251 |
*/
|
252 |
static mkv_seekhead * mkv_start_seekhead(ByteIOContext *pb, int64_t segment_offset, int numelements) |
253 |
{ |
254 |
mkv_seekhead *new_seekhead = av_mallocz(sizeof(mkv_seekhead));
|
255 |
if (new_seekhead == NULL) |
256 |
return NULL; |
257 |
|
258 |
new_seekhead->segment_offset = segment_offset; |
259 |
|
260 |
if (numelements > 0) { |
261 |
new_seekhead->filepos = url_ftell(pb); |
262 |
// 21 bytes max for a seek entry, 10 bytes max for the SeekHead ID
|
263 |
// and size, and 3 bytes to guarantee that an EBML void element
|
264 |
// will fit afterwards
|
265 |
new_seekhead->reserved_size = numelements * MAX_SEEKENTRY_SIZE + 13;
|
266 |
new_seekhead->max_entries = numelements; |
267 |
put_ebml_void(pb, new_seekhead->reserved_size); |
268 |
} |
269 |
return new_seekhead;
|
270 |
} |
271 |
|
272 |
static int mkv_add_seekhead_entry(mkv_seekhead *seekhead, unsigned int elementid, uint64_t filepos) |
273 |
{ |
274 |
mkv_seekhead_entry *entries = seekhead->entries; |
275 |
|
276 |
// don't store more elements than we reserved space for
|
277 |
if (seekhead->max_entries > 0 && seekhead->max_entries <= seekhead->num_entries) |
278 |
return -1; |
279 |
|
280 |
entries = av_realloc(entries, (seekhead->num_entries + 1) * sizeof(mkv_seekhead_entry)); |
281 |
if (entries == NULL) |
282 |
return AVERROR(ENOMEM);
|
283 |
|
284 |
entries[seekhead->num_entries ].elementid = elementid; |
285 |
entries[seekhead->num_entries++].segmentpos = filepos - seekhead->segment_offset; |
286 |
|
287 |
seekhead->entries = entries; |
288 |
return 0; |
289 |
} |
290 |
|
291 |
/**
|
292 |
* Write the seek head to the file and free it. If a maximum number of
|
293 |
* elements was specified to mkv_start_seekhead(), the seek head will
|
294 |
* be written at the location reserved for it. Otherwise, it is written
|
295 |
* at the current location in the file.
|
296 |
*
|
297 |
* @return The file offset where the seekhead was written,
|
298 |
* -1 if an error occurred.
|
299 |
*/
|
300 |
static int64_t mkv_write_seekhead(ByteIOContext *pb, mkv_seekhead *seekhead)
|
301 |
{ |
302 |
ebml_master metaseek, seekentry; |
303 |
int64_t currentpos; |
304 |
int i;
|
305 |
|
306 |
currentpos = url_ftell(pb); |
307 |
|
308 |
if (seekhead->reserved_size > 0) |
309 |
if (url_fseek(pb, seekhead->filepos, SEEK_SET) < 0) |
310 |
return -1; |
311 |
|
312 |
metaseek = start_ebml_master(pb, MATROSKA_ID_SEEKHEAD, seekhead->reserved_size); |
313 |
for (i = 0; i < seekhead->num_entries; i++) { |
314 |
mkv_seekhead_entry *entry = &seekhead->entries[i]; |
315 |
|
316 |
seekentry = start_ebml_master(pb, MATROSKA_ID_SEEKENTRY, MAX_SEEKENTRY_SIZE); |
317 |
|
318 |
put_ebml_id(pb, MATROSKA_ID_SEEKID); |
319 |
put_ebml_num(pb, ebml_id_size(entry->elementid), 0);
|
320 |
put_ebml_id(pb, entry->elementid); |
321 |
|
322 |
put_ebml_uint(pb, MATROSKA_ID_SEEKPOSITION, entry->segmentpos); |
323 |
end_ebml_master(pb, seekentry); |
324 |
} |
325 |
end_ebml_master(pb, metaseek); |
326 |
|
327 |
if (seekhead->reserved_size > 0) { |
328 |
uint64_t remaining = seekhead->filepos + seekhead->reserved_size - url_ftell(pb); |
329 |
put_ebml_void(pb, remaining); |
330 |
url_fseek(pb, currentpos, SEEK_SET); |
331 |
|
332 |
currentpos = seekhead->filepos; |
333 |
} |
334 |
av_free(seekhead->entries); |
335 |
av_free(seekhead); |
336 |
|
337 |
return currentpos;
|
338 |
} |
339 |
|
340 |
static mkv_cues * mkv_start_cues(int64_t segment_offset)
|
341 |
{ |
342 |
mkv_cues *cues = av_mallocz(sizeof(mkv_cues));
|
343 |
if (cues == NULL) |
344 |
return NULL; |
345 |
|
346 |
cues->segment_offset = segment_offset; |
347 |
return cues;
|
348 |
} |
349 |
|
350 |
static int mkv_add_cuepoint(mkv_cues *cues, int stream, int64_t ts, int64_t cluster_pos) |
351 |
{ |
352 |
mkv_cuepoint *entries = cues->entries; |
353 |
|
354 |
entries = av_realloc(entries, (cues->num_entries + 1) * sizeof(mkv_cuepoint)); |
355 |
if (entries == NULL) |
356 |
return AVERROR(ENOMEM);
|
357 |
|
358 |
if (ts < 0) |
359 |
return 0; |
360 |
|
361 |
entries[cues->num_entries ].pts = ts; |
362 |
entries[cues->num_entries ].tracknum = stream + 1;
|
363 |
entries[cues->num_entries++].cluster_pos = cluster_pos - cues->segment_offset; |
364 |
|
365 |
cues->entries = entries; |
366 |
return 0; |
367 |
} |
368 |
|
369 |
static int64_t mkv_write_cues(ByteIOContext *pb, mkv_cues *cues, int num_tracks) |
370 |
{ |
371 |
ebml_master cues_element; |
372 |
int64_t currentpos; |
373 |
int i, j;
|
374 |
|
375 |
currentpos = url_ftell(pb); |
376 |
cues_element = start_ebml_master(pb, MATROSKA_ID_CUES, 0);
|
377 |
|
378 |
for (i = 0; i < cues->num_entries; i++) { |
379 |
ebml_master cuepoint, track_positions; |
380 |
mkv_cuepoint *entry = &cues->entries[i]; |
381 |
uint64_t pts = entry->pts; |
382 |
|
383 |
cuepoint = start_ebml_master(pb, MATROSKA_ID_POINTENTRY, MAX_CUEPOINT_SIZE(num_tracks)); |
384 |
put_ebml_uint(pb, MATROSKA_ID_CUETIME, pts); |
385 |
|
386 |
// put all the entries from different tracks that have the exact same
|
387 |
// timestamp into the same CuePoint
|
388 |
for (j = 0; j < cues->num_entries - i && entry[j].pts == pts; j++) { |
389 |
track_positions = start_ebml_master(pb, MATROSKA_ID_CUETRACKPOSITION, MAX_CUETRACKPOS_SIZE); |
390 |
put_ebml_uint(pb, MATROSKA_ID_CUETRACK , entry[j].tracknum ); |
391 |
put_ebml_uint(pb, MATROSKA_ID_CUECLUSTERPOSITION, entry[j].cluster_pos); |
392 |
end_ebml_master(pb, track_positions); |
393 |
} |
394 |
i += j - 1;
|
395 |
end_ebml_master(pb, cuepoint); |
396 |
} |
397 |
end_ebml_master(pb, cues_element); |
398 |
|
399 |
av_free(cues->entries); |
400 |
av_free(cues); |
401 |
return currentpos;
|
402 |
} |
403 |
|
404 |
static int put_xiph_codecpriv(AVFormatContext *s, ByteIOContext *pb, AVCodecContext *codec) |
405 |
{ |
406 |
uint8_t *header_start[3];
|
407 |
int header_len[3]; |
408 |
int first_header_size;
|
409 |
int j;
|
410 |
|
411 |
if (codec->codec_id == CODEC_ID_VORBIS)
|
412 |
first_header_size = 30;
|
413 |
else
|
414 |
first_header_size = 42;
|
415 |
|
416 |
if (ff_split_xiph_headers(codec->extradata, codec->extradata_size,
|
417 |
first_header_size, header_start, header_len) < 0) {
|
418 |
av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
|
419 |
return -1; |
420 |
} |
421 |
|
422 |
put_byte(pb, 2); // number packets - 1 |
423 |
for (j = 0; j < 2; j++) { |
424 |
put_xiph_size(pb, header_len[j]); |
425 |
} |
426 |
for (j = 0; j < 3; j++) |
427 |
put_buffer(pb, header_start[j], header_len[j]); |
428 |
|
429 |
return 0; |
430 |
} |
431 |
|
432 |
static void get_aac_sample_rates(AVFormatContext *s, AVCodecContext *codec, int *sample_rate, int *output_sample_rate) |
433 |
{ |
434 |
int sri;
|
435 |
|
436 |
if (codec->extradata_size < 2) { |
437 |
av_log(s, AV_LOG_WARNING, "No AAC extradata, unable to determine samplerate.\n");
|
438 |
return;
|
439 |
} |
440 |
|
441 |
sri = ((codec->extradata[0] << 1) & 0xE) | (codec->extradata[1] >> 7); |
442 |
if (sri > 12) { |
443 |
av_log(s, AV_LOG_WARNING, "AAC samplerate index out of bounds\n");
|
444 |
return;
|
445 |
} |
446 |
*sample_rate = ff_mpeg4audio_sample_rates[sri]; |
447 |
|
448 |
// if sbr, get output sample rate as well
|
449 |
if (codec->extradata_size == 5) { |
450 |
sri = (codec->extradata[4] >> 3) & 0xF; |
451 |
if (sri > 12) { |
452 |
av_log(s, AV_LOG_WARNING, "AAC output samplerate index out of bounds\n");
|
453 |
return;
|
454 |
} |
455 |
*output_sample_rate = ff_mpeg4audio_sample_rates[sri]; |
456 |
} |
457 |
} |
458 |
|
459 |
static int mkv_write_codecprivate(AVFormatContext *s, ByteIOContext *pb, AVCodecContext *codec, int native_id, int qt_id) |
460 |
{ |
461 |
ByteIOContext *dyn_cp; |
462 |
uint8_t *codecpriv; |
463 |
int ret, codecpriv_size;
|
464 |
|
465 |
ret = url_open_dyn_buf(&dyn_cp); |
466 |
if(ret < 0) |
467 |
return ret;
|
468 |
|
469 |
if (native_id) {
|
470 |
if (codec->codec_id == CODEC_ID_VORBIS || codec->codec_id == CODEC_ID_THEORA)
|
471 |
ret = put_xiph_codecpriv(s, dyn_cp, codec); |
472 |
else if (codec->codec_id == CODEC_ID_FLAC) |
473 |
ret = ff_flac_write_header(dyn_cp, codec); |
474 |
else if (codec->codec_id == CODEC_ID_H264) |
475 |
ret = ff_isom_write_avcc(dyn_cp, codec->extradata, codec->extradata_size); |
476 |
else if (codec->extradata_size) |
477 |
put_buffer(dyn_cp, codec->extradata, codec->extradata_size); |
478 |
} else if (codec->codec_type == CODEC_TYPE_VIDEO) { |
479 |
if (qt_id) {
|
480 |
if (!codec->codec_tag)
|
481 |
codec->codec_tag = ff_codec_get_tag(codec_movvideo_tags, codec->codec_id); |
482 |
if (codec->extradata_size)
|
483 |
put_buffer(dyn_cp, codec->extradata, codec->extradata_size); |
484 |
} else {
|
485 |
if (!codec->codec_tag)
|
486 |
codec->codec_tag = ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id); |
487 |
if (!codec->codec_tag) {
|
488 |
av_log(s, AV_LOG_ERROR, "No bmp codec ID found.");
|
489 |
ret = -1;
|
490 |
} |
491 |
|
492 |
ff_put_bmp_header(dyn_cp, codec, ff_codec_bmp_tags, 0);
|
493 |
} |
494 |
|
495 |
} else if (codec->codec_type == CODEC_TYPE_AUDIO) { |
496 |
if (!codec->codec_tag)
|
497 |
codec->codec_tag = ff_codec_get_tag(ff_codec_wav_tags, codec->codec_id); |
498 |
if (!codec->codec_tag) {
|
499 |
av_log(s, AV_LOG_ERROR, "No wav codec ID found.");
|
500 |
ret = -1;
|
501 |
} |
502 |
|
503 |
ff_put_wav_header(dyn_cp, codec); |
504 |
} |
505 |
|
506 |
codecpriv_size = url_close_dyn_buf(dyn_cp, &codecpriv); |
507 |
if (codecpriv_size)
|
508 |
put_ebml_binary(pb, MATROSKA_ID_CODECPRIVATE, codecpriv, codecpriv_size); |
509 |
av_free(codecpriv); |
510 |
return ret;
|
511 |
} |
512 |
|
513 |
static int mkv_write_tracks(AVFormatContext *s) |
514 |
{ |
515 |
MatroskaMuxContext *mkv = s->priv_data; |
516 |
ByteIOContext *pb = s->pb; |
517 |
ebml_master tracks; |
518 |
int i, j, ret;
|
519 |
|
520 |
ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TRACKS, url_ftell(pb)); |
521 |
if (ret < 0) return ret; |
522 |
|
523 |
tracks = start_ebml_master(pb, MATROSKA_ID_TRACKS, 0);
|
524 |
for (i = 0; i < s->nb_streams; i++) { |
525 |
AVStream *st = s->streams[i]; |
526 |
AVCodecContext *codec = st->codec; |
527 |
ebml_master subinfo, track; |
528 |
int native_id = 0; |
529 |
int qt_id = 0; |
530 |
int bit_depth = av_get_bits_per_sample(codec->codec_id);
|
531 |
int sample_rate = codec->sample_rate;
|
532 |
int output_sample_rate = 0; |
533 |
AVMetadataTag *tag; |
534 |
|
535 |
if (!bit_depth)
|
536 |
bit_depth = av_get_bits_per_sample_format(codec->sample_fmt); |
537 |
|
538 |
if (codec->codec_id == CODEC_ID_AAC)
|
539 |
get_aac_sample_rates(s, codec, &sample_rate, &output_sample_rate); |
540 |
|
541 |
track = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY, 0);
|
542 |
put_ebml_uint (pb, MATROSKA_ID_TRACKNUMBER , i + 1);
|
543 |
put_ebml_uint (pb, MATROSKA_ID_TRACKUID , i + 1);
|
544 |
put_ebml_uint (pb, MATROSKA_ID_TRACKFLAGLACING , 0); // no lacing (yet) |
545 |
put_ebml_float(pb, MATROSKA_ID_TRACKTIMECODESCALE, 1.0); |
546 |
|
547 |
if ((tag = av_metadata_get(st->metadata, "title", NULL, 0))) |
548 |
put_ebml_string(pb, MATROSKA_ID_TRACKNAME, tag->value); |
549 |
tag = av_metadata_get(st->metadata, "language", NULL, 0); |
550 |
put_ebml_string(pb, MATROSKA_ID_TRACKLANGUAGE, tag ? tag->value:"und");
|
551 |
|
552 |
if (st->disposition)
|
553 |
put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGDEFAULT, !!(st->disposition & AV_DISPOSITION_DEFAULT)); |
554 |
|
555 |
// look for a codec ID string specific to mkv to use,
|
556 |
// if none are found, use AVI codes
|
557 |
for (j = 0; ff_mkv_codec_tags[j].id != CODEC_ID_NONE; j++) { |
558 |
if (ff_mkv_codec_tags[j].id == codec->codec_id) {
|
559 |
put_ebml_string(pb, MATROSKA_ID_CODECID, ff_mkv_codec_tags[j].str); |
560 |
native_id = 1;
|
561 |
break;
|
562 |
} |
563 |
} |
564 |
|
565 |
switch (codec->codec_type) {
|
566 |
case CODEC_TYPE_VIDEO:
|
567 |
put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_VIDEO); |
568 |
|
569 |
if (!native_id &&
|
570 |
ff_codec_get_tag(codec_movvideo_tags, codec->codec_id) && |
571 |
(!ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id) |
572 |
|| codec->codec_id == CODEC_ID_SVQ1 |
573 |
|| codec->codec_id == CODEC_ID_SVQ3 |
574 |
|| codec->codec_id == CODEC_ID_CINEPAK)) |
575 |
qt_id = 1;
|
576 |
|
577 |
if (qt_id)
|
578 |
put_ebml_string(pb, MATROSKA_ID_CODECID, "V_QUICKTIME");
|
579 |
else if (!native_id) { |
580 |
// if there is no mkv-specific codec ID, use VFW mode
|
581 |
put_ebml_string(pb, MATROSKA_ID_CODECID, "V_MS/VFW/FOURCC");
|
582 |
mkv->tracks[i].write_dts = 1;
|
583 |
} |
584 |
|
585 |
subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKVIDEO, 0);
|
586 |
// XXX: interlace flag?
|
587 |
put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELWIDTH , codec->width); |
588 |
put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELHEIGHT, codec->height); |
589 |
if (st->sample_aspect_ratio.num) {
|
590 |
int d_width = codec->width*av_q2d(st->sample_aspect_ratio);
|
591 |
put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , d_width); |
592 |
put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, codec->height); |
593 |
} |
594 |
end_ebml_master(pb, subinfo); |
595 |
break;
|
596 |
|
597 |
case CODEC_TYPE_AUDIO:
|
598 |
put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_AUDIO); |
599 |
|
600 |
if (!native_id)
|
601 |
// no mkv-specific ID, use ACM mode
|
602 |
put_ebml_string(pb, MATROSKA_ID_CODECID, "A_MS/ACM");
|
603 |
|
604 |
subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 0);
|
605 |
put_ebml_uint (pb, MATROSKA_ID_AUDIOCHANNELS , codec->channels); |
606 |
put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, sample_rate); |
607 |
if (output_sample_rate)
|
608 |
put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate); |
609 |
if (bit_depth)
|
610 |
put_ebml_uint(pb, MATROSKA_ID_AUDIOBITDEPTH, bit_depth); |
611 |
end_ebml_master(pb, subinfo); |
612 |
break;
|
613 |
|
614 |
case CODEC_TYPE_SUBTITLE:
|
615 |
put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_SUBTITLE); |
616 |
break;
|
617 |
default:
|
618 |
av_log(s, AV_LOG_ERROR, "Only audio, video, and subtitles are supported for Matroska.");
|
619 |
break;
|
620 |
} |
621 |
ret = mkv_write_codecprivate(s, pb, codec, native_id, qt_id); |
622 |
if (ret < 0) return ret; |
623 |
|
624 |
end_ebml_master(pb, track); |
625 |
|
626 |
// ms precision is the de-facto standard timescale for mkv files
|
627 |
av_set_pts_info(st, 64, 1, 1000); |
628 |
} |
629 |
end_ebml_master(pb, tracks); |
630 |
return 0; |
631 |
} |
632 |
|
633 |
static int mkv_write_chapters(AVFormatContext *s) |
634 |
{ |
635 |
MatroskaMuxContext *mkv = s->priv_data; |
636 |
ByteIOContext *pb = s->pb; |
637 |
ebml_master chapters, editionentry; |
638 |
AVRational scale = {1, 1E9}; |
639 |
int i, ret;
|
640 |
|
641 |
if (!s->nb_chapters)
|
642 |
return 0; |
643 |
|
644 |
ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CHAPTERS, url_ftell(pb)); |
645 |
if (ret < 0) return ret; |
646 |
|
647 |
chapters = start_ebml_master(pb, MATROSKA_ID_CHAPTERS , 0);
|
648 |
editionentry = start_ebml_master(pb, MATROSKA_ID_EDITIONENTRY, 0);
|
649 |
put_ebml_uint(pb, MATROSKA_ID_EDITIONFLAGDEFAULT, 1);
|
650 |
put_ebml_uint(pb, MATROSKA_ID_EDITIONFLAGHIDDEN , 0);
|
651 |
for (i = 0; i < s->nb_chapters; i++) { |
652 |
ebml_master chapteratom, chapterdisplay; |
653 |
AVChapter *c = s->chapters[i]; |
654 |
AVMetadataTag *t = NULL;
|
655 |
|
656 |
chapteratom = start_ebml_master(pb, MATROSKA_ID_CHAPTERATOM, 0);
|
657 |
put_ebml_uint(pb, MATROSKA_ID_CHAPTERUID, c->id); |
658 |
put_ebml_uint(pb, MATROSKA_ID_CHAPTERTIMESTART, |
659 |
av_rescale_q(c->start, c->time_base, scale)); |
660 |
put_ebml_uint(pb, MATROSKA_ID_CHAPTERTIMEEND, |
661 |
av_rescale_q(c->end, c->time_base, scale)); |
662 |
put_ebml_uint(pb, MATROSKA_ID_CHAPTERFLAGHIDDEN , 0);
|
663 |
put_ebml_uint(pb, MATROSKA_ID_CHAPTERFLAGENABLED, 1);
|
664 |
if ((t = av_metadata_get(c->metadata, "title", NULL, 0))) { |
665 |
chapterdisplay = start_ebml_master(pb, MATROSKA_ID_CHAPTERDISPLAY, 0);
|
666 |
put_ebml_string(pb, MATROSKA_ID_CHAPSTRING, t->value); |
667 |
put_ebml_string(pb, MATROSKA_ID_CHAPLANG , "und");
|
668 |
end_ebml_master(pb, chapterdisplay); |
669 |
} |
670 |
end_ebml_master(pb, chapteratom); |
671 |
} |
672 |
end_ebml_master(pb, editionentry); |
673 |
end_ebml_master(pb, chapters); |
674 |
return 0; |
675 |
} |
676 |
|
677 |
static int mkv_write_header(AVFormatContext *s) |
678 |
{ |
679 |
MatroskaMuxContext *mkv = s->priv_data; |
680 |
ByteIOContext *pb = s->pb; |
681 |
ebml_master ebml_header, segment_info; |
682 |
AVMetadataTag *tag; |
683 |
int ret;
|
684 |
|
685 |
mkv->md5_ctx = av_mallocz(av_md5_size); |
686 |
av_md5_init(mkv->md5_ctx); |
687 |
mkv->tracks = av_mallocz(s->nb_streams * sizeof(*mkv->tracks));
|
688 |
|
689 |
ebml_header = start_ebml_master(pb, EBML_ID_HEADER, 0);
|
690 |
put_ebml_uint (pb, EBML_ID_EBMLVERSION , 1);
|
691 |
put_ebml_uint (pb, EBML_ID_EBMLREADVERSION , 1);
|
692 |
put_ebml_uint (pb, EBML_ID_EBMLMAXIDLENGTH , 4);
|
693 |
put_ebml_uint (pb, EBML_ID_EBMLMAXSIZELENGTH , 8);
|
694 |
put_ebml_string (pb, EBML_ID_DOCTYPE , "matroska");
|
695 |
put_ebml_uint (pb, EBML_ID_DOCTYPEVERSION , 2);
|
696 |
put_ebml_uint (pb, EBML_ID_DOCTYPEREADVERSION , 2);
|
697 |
end_ebml_master(pb, ebml_header); |
698 |
|
699 |
mkv->segment = start_ebml_master(pb, MATROSKA_ID_SEGMENT, 0);
|
700 |
mkv->segment_offset = url_ftell(pb); |
701 |
|
702 |
// we write 2 seek heads - one at the end of the file to point to each
|
703 |
// cluster, and one at the beginning to point to all other level one
|
704 |
// elements (including the seek head at the end of the file), which
|
705 |
// isn't more than 10 elements if we only write one of each other
|
706 |
// currently defined level 1 element
|
707 |
mkv->main_seekhead = mkv_start_seekhead(pb, mkv->segment_offset, 10);
|
708 |
mkv->cluster_seekhead = mkv_start_seekhead(pb, mkv->segment_offset, 0);
|
709 |
if (mkv->main_seekhead == NULL || mkv->cluster_seekhead == NULL) |
710 |
return AVERROR(ENOMEM);
|
711 |
|
712 |
ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_INFO, url_ftell(pb)); |
713 |
if (ret < 0) return ret; |
714 |
|
715 |
segment_info = start_ebml_master(pb, MATROSKA_ID_INFO, 0);
|
716 |
put_ebml_uint(pb, MATROSKA_ID_TIMECODESCALE, 1000000);
|
717 |
if ((tag = av_metadata_get(s->metadata, "title", NULL, 0))) |
718 |
put_ebml_string(pb, MATROSKA_ID_TITLE, tag->value); |
719 |
if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) { |
720 |
put_ebml_string(pb, MATROSKA_ID_MUXINGAPP , LIBAVFORMAT_IDENT); |
721 |
put_ebml_string(pb, MATROSKA_ID_WRITINGAPP, LIBAVFORMAT_IDENT); |
722 |
|
723 |
// reserve space to write the segment UID later
|
724 |
mkv->segment_uid = url_ftell(pb); |
725 |
put_ebml_void(pb, 19);
|
726 |
} |
727 |
|
728 |
// reserve space for the duration
|
729 |
mkv->duration = 0;
|
730 |
mkv->duration_offset = url_ftell(pb); |
731 |
put_ebml_void(pb, 11); // assumes double-precision float to be written |
732 |
end_ebml_master(pb, segment_info); |
733 |
|
734 |
ret = mkv_write_tracks(s); |
735 |
if (ret < 0) return ret; |
736 |
|
737 |
ret = mkv_write_chapters(s); |
738 |
if (ret < 0) return ret; |
739 |
|
740 |
if (url_is_streamed(s->pb))
|
741 |
mkv_write_seekhead(pb, mkv->main_seekhead); |
742 |
|
743 |
mkv->cues = mkv_start_cues(mkv->segment_offset); |
744 |
if (mkv->cues == NULL) |
745 |
return AVERROR(ENOMEM);
|
746 |
|
747 |
put_flush_packet(pb); |
748 |
return 0; |
749 |
} |
750 |
|
751 |
static int mkv_blockgroup_size(int pkt_size) |
752 |
{ |
753 |
int size = pkt_size + 4; |
754 |
size += ebml_num_size(size); |
755 |
size += 2; // EBML ID for block and block duration |
756 |
size += 8; // max size of block duration |
757 |
size += ebml_num_size(size); |
758 |
size += 1; // blockgroup EBML ID |
759 |
return size;
|
760 |
} |
761 |
|
762 |
static int ass_get_duration(const uint8_t *p) |
763 |
{ |
764 |
int sh, sm, ss, sc, eh, em, es, ec;
|
765 |
uint64_t start, end; |
766 |
|
767 |
if (sscanf(p, "%*[^,],%d:%d:%d%*c%d,%d:%d:%d%*c%d", |
768 |
&sh, &sm, &ss, &sc, &eh, &em, &es, &ec) != 8)
|
769 |
return 0; |
770 |
start = 3600000*sh + 60000*sm + 1000*ss + 10*sc; |
771 |
end = 3600000*eh + 60000*em + 1000*es + 10*ec; |
772 |
return end - start;
|
773 |
} |
774 |
|
775 |
static int mkv_write_ass_blocks(AVFormatContext *s, ByteIOContext *pb, AVPacket *pkt) |
776 |
{ |
777 |
MatroskaMuxContext *mkv = s->priv_data; |
778 |
int i, layer = 0, max_duration = 0, size, line_size, data_size = pkt->size; |
779 |
uint8_t *start, *end, *data = pkt->data; |
780 |
ebml_master blockgroup; |
781 |
char buffer[2048]; |
782 |
|
783 |
while (data_size) {
|
784 |
int duration = ass_get_duration(data);
|
785 |
max_duration = FFMAX(duration, max_duration); |
786 |
end = memchr(data, '\n', data_size);
|
787 |
size = line_size = end ? end-data+1 : data_size;
|
788 |
size -= end ? (end[-1]=='\r')+1 : 0; |
789 |
start = data; |
790 |
for (i=0; i<3; i++, start++) |
791 |
if (!(start = memchr(start, ',', size-(start-data)))) |
792 |
return max_duration;
|
793 |
size -= start - data; |
794 |
sscanf(data, "Dialogue: %d,", &layer);
|
795 |
i = snprintf(buffer, sizeof(buffer), "%"PRId64",%d,", |
796 |
s->streams[pkt->stream_index]->nb_frames++, layer); |
797 |
size = FFMIN(i+size, sizeof(buffer));
|
798 |
memcpy(buffer+i, start, size-i); |
799 |
|
800 |
av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, " |
801 |
"pts %" PRId64 ", duration %d\n", |
802 |
url_ftell(pb), size, pkt->pts, duration); |
803 |
blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(size)); |
804 |
put_ebml_id(pb, MATROSKA_ID_BLOCK); |
805 |
put_ebml_num(pb, size+4, 0); |
806 |
put_byte(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126 |
807 |
put_be16(pb, pkt->pts - mkv->cluster_pts); |
808 |
put_byte(pb, 0);
|
809 |
put_buffer(pb, buffer, size); |
810 |
put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration); |
811 |
end_ebml_master(pb, blockgroup); |
812 |
|
813 |
data += line_size; |
814 |
data_size -= line_size; |
815 |
} |
816 |
|
817 |
return max_duration;
|
818 |
} |
819 |
|
820 |
static void mkv_write_block(AVFormatContext *s, ByteIOContext *pb, |
821 |
unsigned int blockid, AVPacket *pkt, int flags) |
822 |
{ |
823 |
MatroskaMuxContext *mkv = s->priv_data; |
824 |
AVCodecContext *codec = s->streams[pkt->stream_index]->codec; |
825 |
uint8_t *data = NULL;
|
826 |
int size = pkt->size;
|
827 |
int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts; |
828 |
|
829 |
av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, " |
830 |
"pts %" PRId64 ", dts %" PRId64 ", duration %d, flags %d\n", |
831 |
url_ftell(pb), pkt->size, pkt->pts, pkt->dts, pkt->duration, flags); |
832 |
if (codec->codec_id == CODEC_ID_H264 && codec->extradata_size > 0 && |
833 |
(AV_RB24(codec->extradata) == 1 || AV_RB32(codec->extradata) == 1)) |
834 |
ff_avc_parse_nal_units_buf(pkt->data, &data, &size); |
835 |
else
|
836 |
data = pkt->data; |
837 |
put_ebml_id(pb, blockid); |
838 |
put_ebml_num(pb, size+4, 0); |
839 |
put_byte(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126 |
840 |
put_be16(pb, ts - mkv->cluster_pts); |
841 |
put_byte(pb, flags); |
842 |
put_buffer(pb, data, size); |
843 |
if (data != pkt->data)
|
844 |
av_free(data); |
845 |
} |
846 |
|
847 |
static void mkv_flush_dynbuf(AVFormatContext *s) |
848 |
{ |
849 |
MatroskaMuxContext *mkv = s->priv_data; |
850 |
int bufsize;
|
851 |
uint8_t *dyn_buf; |
852 |
|
853 |
if (!mkv->dyn_bc)
|
854 |
return;
|
855 |
|
856 |
bufsize = url_close_dyn_buf(mkv->dyn_bc, &dyn_buf); |
857 |
put_buffer(s->pb, dyn_buf, bufsize); |
858 |
av_free(dyn_buf); |
859 |
mkv->dyn_bc = NULL;
|
860 |
} |
861 |
|
862 |
static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt) |
863 |
{ |
864 |
MatroskaMuxContext *mkv = s->priv_data; |
865 |
ByteIOContext *pb = s->pb; |
866 |
AVCodecContext *codec = s->streams[pkt->stream_index]->codec; |
867 |
int keyframe = !!(pkt->flags & PKT_FLAG_KEY);
|
868 |
int duration = pkt->duration;
|
869 |
int ret;
|
870 |
int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts; |
871 |
|
872 |
if (ts == AV_NOPTS_VALUE) {
|
873 |
av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
|
874 |
return AVERROR(EINVAL);
|
875 |
} |
876 |
|
877 |
if (url_is_streamed(s->pb)) {
|
878 |
if (!mkv->dyn_bc)
|
879 |
url_open_dyn_buf(&mkv->dyn_bc); |
880 |
pb = mkv->dyn_bc; |
881 |
} |
882 |
|
883 |
if (!mkv->cluster_pos) {
|
884 |
ret = mkv_add_seekhead_entry(mkv->cluster_seekhead, MATROSKA_ID_CLUSTER, url_ftell(pb)); |
885 |
if (ret < 0) return ret; |
886 |
|
887 |
mkv->cluster_pos = url_ftell(s->pb); |
888 |
mkv->cluster = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0);
|
889 |
put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, FFMAX(0, ts));
|
890 |
mkv->cluster_pts = FFMAX(0, ts);
|
891 |
av_md5_update(mkv->md5_ctx, pkt->data, FFMIN(200, pkt->size));
|
892 |
} |
893 |
|
894 |
if (codec->codec_type != CODEC_TYPE_SUBTITLE) {
|
895 |
mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe << 7);
|
896 |
} else if (codec->codec_id == CODEC_ID_SSA) { |
897 |
duration = mkv_write_ass_blocks(s, pb, pkt); |
898 |
} else {
|
899 |
ebml_master blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(pkt->size)); |
900 |
duration = pkt->convergence_duration; |
901 |
mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 0);
|
902 |
put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration); |
903 |
end_ebml_master(pb, blockgroup); |
904 |
} |
905 |
|
906 |
if (codec->codec_type == CODEC_TYPE_VIDEO && keyframe) {
|
907 |
ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, ts, mkv->cluster_pos); |
908 |
if (ret < 0) return ret; |
909 |
} |
910 |
|
911 |
// start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming
|
912 |
if (url_is_streamed(s->pb) && (url_ftell(pb) > 32*1024 || ts > mkv->cluster_pts + 1000) |
913 |
|| url_ftell(pb) > mkv->cluster_pos + 5*1024*1024 || ts > mkv->cluster_pts + 5000) { |
914 |
av_log(s, AV_LOG_DEBUG, "Starting new cluster at offset %" PRIu64
|
915 |
" bytes, pts %" PRIu64 "\n", url_ftell(pb), ts); |
916 |
end_ebml_master(pb, mkv->cluster); |
917 |
mkv->cluster_pos = 0;
|
918 |
if (mkv->dyn_bc)
|
919 |
mkv_flush_dynbuf(s); |
920 |
} |
921 |
|
922 |
mkv->duration = FFMAX(mkv->duration, ts + duration); |
923 |
return 0; |
924 |
} |
925 |
|
926 |
static int mkv_write_trailer(AVFormatContext *s) |
927 |
{ |
928 |
MatroskaMuxContext *mkv = s->priv_data; |
929 |
ByteIOContext *pb = s->pb; |
930 |
int64_t currentpos, second_seekhead, cuespos; |
931 |
int ret;
|
932 |
|
933 |
if (mkv->dyn_bc) {
|
934 |
end_ebml_master(mkv->dyn_bc, mkv->cluster); |
935 |
mkv_flush_dynbuf(s); |
936 |
} else if (mkv->cluster_pos) { |
937 |
end_ebml_master(pb, mkv->cluster); |
938 |
} |
939 |
|
940 |
if (!url_is_streamed(pb)) {
|
941 |
cuespos = mkv_write_cues(pb, mkv->cues, s->nb_streams); |
942 |
second_seekhead = mkv_write_seekhead(pb, mkv->cluster_seekhead); |
943 |
|
944 |
ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CUES , cuespos); |
945 |
if (ret < 0) return ret; |
946 |
if (second_seekhead >= 0) { |
947 |
ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_SEEKHEAD, second_seekhead); |
948 |
if (ret < 0) return ret; |
949 |
} |
950 |
mkv_write_seekhead(pb, mkv->main_seekhead); |
951 |
|
952 |
// update the duration
|
953 |
av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration); |
954 |
currentpos = url_ftell(pb); |
955 |
url_fseek(pb, mkv->duration_offset, SEEK_SET); |
956 |
put_ebml_float(pb, MATROSKA_ID_DURATION, mkv->duration); |
957 |
|
958 |
// write the md5sum of some frames as the segment UID
|
959 |
if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) { |
960 |
uint8_t segment_uid[16];
|
961 |
av_md5_final(mkv->md5_ctx, segment_uid); |
962 |
url_fseek(pb, mkv->segment_uid, SEEK_SET); |
963 |
put_ebml_binary(pb, MATROSKA_ID_SEGMENTUID, segment_uid, 16);
|
964 |
} |
965 |
url_fseek(pb, currentpos, SEEK_SET); |
966 |
} |
967 |
|
968 |
end_ebml_master(pb, mkv->segment); |
969 |
av_free(mkv->md5_ctx); |
970 |
av_free(mkv->tracks); |
971 |
put_flush_packet(pb); |
972 |
return 0; |
973 |
} |
974 |
|
975 |
AVOutputFormat matroska_muxer = { |
976 |
"matroska",
|
977 |
NULL_IF_CONFIG_SMALL("Matroska file format"),
|
978 |
"video/x-matroska",
|
979 |
"mkv",
|
980 |
sizeof(MatroskaMuxContext),
|
981 |
CODEC_ID_MP2, |
982 |
CODEC_ID_MPEG4, |
983 |
mkv_write_header, |
984 |
mkv_write_packet, |
985 |
mkv_write_trailer, |
986 |
.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS, |
987 |
.codec_tag = (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, 0}, |
988 |
.subtitle_codec = CODEC_ID_TEXT, |
989 |
}; |
990 |
|
991 |
AVOutputFormat matroska_audio_muxer = { |
992 |
"matroska",
|
993 |
NULL_IF_CONFIG_SMALL("Matroska file format"),
|
994 |
"audio/x-matroska",
|
995 |
"mka",
|
996 |
sizeof(MatroskaMuxContext),
|
997 |
CODEC_ID_MP2, |
998 |
CODEC_ID_NONE, |
999 |
mkv_write_header, |
1000 |
mkv_write_packet, |
1001 |
mkv_write_trailer, |
1002 |
.flags = AVFMT_GLOBALHEADER, |
1003 |
.codec_tag = (const AVCodecTag* const []){ff_codec_wav_tags, 0}, |
1004 |
}; |