?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix segfault if an 'strf' chunk couldn't be found in avi
[mplayer/glamo.git] / libmpdemux / demux_mkv.c
bloba18018a1a4922b235e4f768d708ee1d2bb384956
1 /*
2 * native Matroska demuxer
3 * Written by Aurelien Jacobs <aurel@gnuage.org>
4 * Based on the one written by Ronald Bultje for gstreamer
5 * and on demux_mkv.cpp from Moritz Bunkus.
6 * Licence: GPL
7 */
8
9 #include "config.h"
10
11 #include <stdlib.h>
12 #include <stdio.h>
13 #include <ctype.h>
14 #include <inttypes.h>
15
16 #include "stream/stream.h"
17 #include "demuxer.h"
18 #include "stheader.h"
19 #include "ebml.h"
20 #include "matroska.h"
21
22 #include "mp_msg.h"
23 #include "help_mp.h"
24
25 #include "subreader.h"
26 #include "libvo/sub.h"
27
28 #include "libass/ass.h"
29 #include "libass/ass_mp.h"
30
31 #include "libavutil/common.h"
32
33 #ifdef USE_QTX_CODECS
34 #include "loader/qtx/qtxsdk/components.h"
35 #endif
36
37 #ifdef HAVE_ZLIB
38 #include <zlib.h>
39 #endif
40
41 #ifdef USE_LIBAVUTIL_SO
42 #include <ffmpeg/lzo.h>
43 #include <ffmpeg/intreadwrite.h>
44 #else
45 #include "libavutil/lzo.h"
46 #include "libavutil/intreadwrite.h"
47 #endif
48 #include "libavutil/avstring.h"
49
50 static unsigned char sipr_swaps[38][2]={
51 {0,63},{1,22},{2,44},{3,90},{5,81},{7,31},{8,86},{9,58},{10,36},{12,68},
52 {13,39},{14,73},{15,53},{16,69},{17,57},{19,88},{20,34},{21,71},{24,46},
53 {25,94},{26,54},{28,75},{29,50},{32,70},{33,92},{35,74},{38,85},{40,56},
54 {42,87},{43,65},{45,59},{48,79},{49,93},{51,89},{55,95},{61,76},{67,83},
55 {77,80} };
56
57 // Map flavour to bytes per second
58 #define SIPR_FLAVORS 4
59 #define ATRC_FLAVORS 8
60 #define COOK_FLAVORS 34
61 static int sipr_fl2bps[SIPR_FLAVORS] = {813, 1062, 625, 2000};
62 static int atrc_fl2bps[ATRC_FLAVORS] = {8269, 11714, 13092, 16538, 18260, 22050, 33075, 44100};
63 static int cook_fl2bps[COOK_FLAVORS] = {1000, 1378, 2024, 2584, 4005, 5513, 8010, 4005, 750, 2498,
64 4048, 5513, 8010, 11973, 8010, 2584, 4005, 2067, 2584, 2584,
65 4005, 4005, 5513, 5513, 8010, 12059, 1550, 8010, 12059, 5513,
66 12016, 16408, 22911, 33506};
67
68 typedef struct
69 {
70 uint32_t order, type, scope;
71 uint32_t comp_algo;
72 uint8_t *comp_settings;
73 int comp_settings_len;
74 } mkv_content_encoding_t;
75
76 typedef struct mkv_track
77 {
78 int tnum;
79 char *name;
80
81 char *codec_id;
82 int ms_compat;
83 char *language;
84
85 int type;
86
87 uint32_t v_width, v_height, v_dwidth, v_dheight;
88 float v_frate;
89
90 uint32_t a_formattag;
91 uint32_t a_channels, a_bps;
92 float a_sfreq;
93
94 float default_duration;
95
96 int default_track;
97
98 void *private_data;
99 unsigned int private_size;
100
101 /* stuff for realmedia */
102 int realmedia;
103 int rv_kf_base, rv_kf_pts;
104 float rv_pts; /* previous video timestamp */
105 float ra_pts; /* previous audio timestamp */
106
107 /** realaudio descrambling */
108 int sub_packet_size; ///< sub packet size, per stream
109 int sub_packet_h; ///< number of coded frames per block
110 int coded_framesize; ///< coded frame size, per stream
111 int audiopk_size; ///< audio packet size
112 unsigned char *audio_buf; ///< place to store reordered audio data
113 float *audio_timestamp; ///< timestamp for each audio packet
114 int sub_packet_cnt; ///< number of subpacket already received
115 int audio_filepos; ///< file position of first audio packet in block
116
117 /* stuff for quicktime */
118 int fix_i_bps;
119 float qt_last_a_pts;
120
121 int subtitle_type;
122
123 /* The timecodes of video frames might have to be reordered if they're
124 in display order (the timecodes, not the frames themselves!). In this
125 case demux packets have to be cached with the help of these variables. */
126 int reorder_timecodes;
127 demux_packet_t **cached_dps;
128 int num_cached_dps, num_allocated_dps;
129 float max_pts;
130
131 /* generic content encoding support */
132 mkv_content_encoding_t *encodings;
133 int num_encodings;
134
135 /* For VobSubs and SSA/ASS */
136 sh_sub_t *sh_sub;
137 } mkv_track_t;
138
139 typedef struct mkv_index
140 {
141 int tnum;
142 uint64_t timecode, filepos;
143 } mkv_index_t;
144
145 typedef struct mkv_attachment
146 {
147 char* name;
148 char* mime;
149 uint64_t uid;
150 void* data;
151 unsigned int data_size;
152 } mkv_attachment_t;
153
154 typedef struct mkv_demuxer
155 {
156 off_t segment_start;
157
158 float duration, last_pts;
159 uint64_t last_filepos;
160
161 mkv_track_t **tracks;
162 int num_tracks;
163
164 uint64_t tc_scale, cluster_tc, first_tc;
165 int has_first_tc;
166
167 uint64_t cluster_size;
168 uint64_t blockgroup_size;
169
170 mkv_index_t *indexes;
171 int num_indexes;
172
173 off_t *parsed_cues;
174 int parsed_cues_num;
175 off_t *parsed_seekhead;
176 int parsed_seekhead_num;
177
178 uint64_t *cluster_positions;
179 int num_cluster_pos;
180
181 int64_t skip_to_timecode;
182 int v_skip_to_keyframe, a_skip_to_keyframe;
183
184 int64_t stop_timecode;
185
186 int last_aid;
187 int audio_tracks[MAX_A_STREAMS];
188
189 mkv_attachment_t *attachments;
190 int num_attachments;
191 } mkv_demuxer_t;
192
193 #define REALHEADER_SIZE 16
194 #define RVPROPERTIES_SIZE 34
195 #define RAPROPERTIES4_SIZE 56
196 #define RAPROPERTIES5_SIZE 70
197
198 /* for e.g. "-slang ger" */
199 extern char *dvdsub_lang;
200 extern char *audio_lang;
201 extern int dvdsub_id;
202
203 /**
204 * \brief ensures there is space for at least one additional element
205 * \param array array to grow
206 * \param nelem current number of elements in array
207 * \param elsize size of one array element
208 */
209 static void grow_array(void **array, int nelem, size_t elsize) {
210 if (!(nelem & 31))
211 *array = realloc(*array, (nelem + 32) * elsize);
212 }
213
214 static mkv_track_t *
215 demux_mkv_find_track_by_num (mkv_demuxer_t *d, int n, int type)
216 {
217 int i, id;
218
219 for (i=0, id=0; i < d->num_tracks; i++)
220 if (d->tracks[i] != NULL && d->tracks[i]->type == type)
221 if (id++ == n)
222 return d->tracks[i];
223
224 return NULL;
225 }
226
227 static mkv_track_t *
228 demux_mkv_find_track_by_language (mkv_demuxer_t *d, char *language, int type)
229 {
230 int i, len;
231
232 language += strspn(language,",");
233 while((len = strcspn(language,",")) > 0)
234 {
235 for (i=0; i < d->num_tracks; i++)
236 if (d->tracks[i] != NULL && d->tracks[i]->language != NULL &&
237 d->tracks[i]->type == type &&
238 !strncmp(d->tracks[i]->language, language, len))
239 return d->tracks[i];
240 language += len;
241 language += strspn(language,",");
242 }
243
244 return NULL;
245 }
246
247 static void
248 add_cluster_position (mkv_demuxer_t *mkv_d, uint64_t position)
249 {
250 int i = mkv_d->num_cluster_pos;
251
252 while (i--)
253 if (mkv_d->cluster_positions[i] == position)
254 return;
255
256 grow_array(&mkv_d->cluster_positions, mkv_d->num_cluster_pos,
257 sizeof(uint64_t));
258 mkv_d->cluster_positions[mkv_d->num_cluster_pos++] = position;
259 }
260
261
262 #define AAC_SYNC_EXTENSION_TYPE 0x02b7
263 static int
264 aac_get_sample_rate_index (uint32_t sample_rate)
265 {
266 if (92017 <= sample_rate)
267 return 0;
268 else if (75132 <= sample_rate)
269 return 1;
270 else if (55426 <= sample_rate)
271 return 2;
272 else if (46009 <= sample_rate)
273 return 3;
274 else if (37566 <= sample_rate)
275 return 4;
276 else if (27713 <= sample_rate)
277 return 5;
278 else if (23004 <= sample_rate)
279 return 6;
280 else if (18783 <= sample_rate)
281 return 7;
282 else if (13856 <= sample_rate)
283 return 8;
284 else if (11502 <= sample_rate)
285 return 9;
286 else if (9391 <= sample_rate)
287 return 10;
288 else
289 return 11;
290 }
291
292
293 static int
294 vobsub_parse_size (sh_sub_t *sh, const char *start)
295 {
296 if (sscanf(&start[6], "%dx%d", &sh->width, &sh->height) == 2)
297 {
298 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] VobSub size: %ux%u\n",
299 sh->width, sh->height);
300 return 1;
301 }
302 return 0;
303 }
304
305 static int
306 vobsub_parse_palette (sh_sub_t *sh, const char *start)
307 {
308 int i, r, g, b, y, u, v, tmp;
309
310 start += 8;
311 while (isspace(*start))
312 start++;
313 for (i = 0; i < 16; i++)
314 {
315 if (sscanf(start, "%06x", &tmp) != 1)
316 break;
317 r = tmp >> 16 & 0xff;
318 g = tmp >> 8 & 0xff;
319 b = tmp & 0xff;
320 y = av_clip_uint8( 0.1494 * r + 0.6061 * g + 0.2445 * b);
321 u = av_clip_uint8( 0.6066 * r - 0.4322 * g - 0.1744 * b + 128);
322 v = av_clip_uint8(-0.08435 * r - 0.3422 * g + 0.4266 * b + 128);
323 sh->palette[i] = y << 16 | u << 8 | v;
324 start += 6;
325 while ((*start == ',') || isspace(*start))
326 start++;
327 }
328 if (i == 16)
329 {
330 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] VobSub palette: %06x,%06x,"
331 "%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,"
332 "%06x,%06x,%06x\n", sh->palette[0],
333 sh->palette[1], sh->palette[2],
334 sh->palette[3], sh->palette[4],
335 sh->palette[5], sh->palette[6],
336 sh->palette[7], sh->palette[8],
337 sh->palette[9], sh->palette[10],
338 sh->palette[11], sh->palette[12],
339 sh->palette[13], sh->palette[14],
340 sh->palette[15]);
341 sh->has_palette = 1;
342 return 2;
343 }
344 return 0;
345 }
346
347 static int
348 vobsub_parse_custom_colors (sh_sub_t *sh, const char *start)
349 {
350 int use_custom_colors, i;
351
352 use_custom_colors = 0;
353 start += 14;
354 while (isspace(*start))
355 start++;
356 if (!strncasecmp(start, "ON", 2) || (*start == '1'))
357 use_custom_colors = 1;
358 else if (!strncasecmp(start, "OFF", 3) || (*start == '0'))
359 use_custom_colors = 0;
360 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] VobSub custom colors: %s\n",
361 use_custom_colors ? "ON" : "OFF");
362 if ((start = strstr(start, "colors:")) != NULL)
363 {
364 start += 7;
365 while (isspace(*start))
366 start++;
367 for (i = 0; i < 4; i++)
368 {
369 if (sscanf(start, "%06x", &sh->colors[i]) != 1)
370 break;
371 start += 6;
372 while ((*start == ',') || isspace(*start))
373 start++;
374 }
375 if (i == 4)
376 {
377 sh->custom_colors = 4;
378 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] VobSub colors: %06x,"
379 "%06x,%06x,%06x\n", sh->colors[0],
380 sh->colors[1], sh->colors[2],
381 sh->colors[3]);
382 }
383 }
384 if (!use_custom_colors)
385 sh->custom_colors = 0;
386 return 4;
387 }
388
389 static int
390 vobsub_parse_forced_subs (sh_sub_t *sh, const char *start)
391 {
392 start += 12;
393 while (isspace(*start))
394 start++;
395 if (!strncasecmp(start, "on", 2) || (*start == '1'))
396 sh->forced_subs_only = 1;
397 else if (!strncasecmp(start, "off", 3) || (*start == '0'))
398 sh->forced_subs_only = 0;
399 else
400 return 0;
401 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] VobSub forced subs: %d\n",
402 sh->forced_subs_only);
403 return 8;
404 }
405
406 /** \brief Free cached demux packets
407 *
408 * Reordering the timecodes requires caching of demux packets. This function
409 * frees all these cached packets and the memory for the cached pointers
410 * itself.
411 *
412 * \param demuxer The demuxer for which the cache is to be freed.
413 */
414 static void
415 free_cached_dps (demuxer_t *demuxer)
416 {
417 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
418 mkv_track_t *track;
419 int i, k;
420
421 for (k = 0; k < mkv_d->num_tracks; k++)
422 {
423 track = mkv_d->tracks[k];
424 for (i = 0; i < track->num_cached_dps; i++)
425 free_demux_packet (track->cached_dps[i]);
426 free(track->cached_dps);
427 track->cached_dps = NULL;
428 track->num_cached_dps = 0;
429 track->num_allocated_dps = 0;
430 track->max_pts = 0;
431 }
432 }
433
434 static int
435 demux_mkv_parse_idx (mkv_track_t *t)
436 {
437 int things_found, last;
438 char *buf, *pos, *start;
439
440 if ((t->private_data == NULL) || (t->private_size == 0))
441 return 0;
442
443 things_found = 0;
444 buf = malloc(t->private_size + 1);
445 if (buf == NULL)
446 return 0;
447 memcpy(buf, t->private_data, t->private_size);
448 buf[t->private_size] = 0;
449 t->sh_sub->has_palette = 0;
450
451 pos = buf;
452 start = buf;
453 last = 0;
454 do
455 {
456 if ((*pos == 0) || (*pos == '\r') || (*pos == '\n'))
457 {
458 if (*pos == 0)
459 last = 1;
460 *pos = 0;
461
462 if (!strncasecmp(start, "size: ", 6))
463 things_found |= vobsub_parse_size(t->sh_sub, start);
464 else if (!strncasecmp(start, "palette:", 8))
465 things_found |= vobsub_parse_palette(t->sh_sub, start);
466 else if (!strncasecmp(start, "custom colors:", 14))
467 things_found |= vobsub_parse_custom_colors(t->sh_sub, start);
468 else if (!strncasecmp(start, "forced subs:", 12))
469 things_found |= vobsub_parse_forced_subs(t->sh_sub, start);
470
471 if (last)
472 break;
473 do
474 {
475 pos++;
476 }
477 while ((*pos == '\r') || (*pos == '\n'));
478 start = pos;
479 }
480 else
481 pos++;
482 }
483 while (!last && (*start != 0));
484
485 free(buf);
486
487 return (things_found & 3) == 3;
488 }
489
490
491 static int
492 demux_mkv_decode (mkv_track_t *track, uint8_t *src, uint8_t **dest,
493 uint32_t *size, uint32_t type)
494 {
495 int i, result;
496 int modified = 0;
497
498 *dest = src;
499 if (track->num_encodings <= 0)
500 return 0;
501
502 for (i=0; i<track->num_encodings; i++)
503 {
504 if (!(track->encodings[i].scope & type))
505 continue;
506
507 #ifdef HAVE_ZLIB
508 if (track->encodings[i].comp_algo == 0)
509 {
510 /* zlib encoded track */
511 z_stream zstream;
512
513 zstream.zalloc = (alloc_func) 0;
514 zstream.zfree = (free_func) 0;
515 zstream.opaque = (voidpf) 0;
516 if (inflateInit (&zstream) != Z_OK)
517 {
518 mp_msg (MSGT_DEMUX, MSGL_WARN,
519 MSGTR_MPDEMUX_MKV_ZlibInitializationFailed);
520 return modified;
521 }
522 zstream.next_in = (Bytef *) src;
523 zstream.avail_in = *size;
524
525 modified = 1;
526 *dest = NULL;
527 zstream.avail_out = *size;
528 do {
529 *size += 4000;
530 *dest = realloc (*dest, *size);
531 zstream.next_out = (Bytef *) (*dest + zstream.total_out);
532 result = inflate (&zstream, Z_NO_FLUSH);
533 if (result != Z_OK && result != Z_STREAM_END)
534 {
535 mp_msg (MSGT_DEMUX, MSGL_WARN,
536 MSGTR_MPDEMUX_MKV_ZlibDecompressionFailed);
537 free(*dest);
538 *dest = NULL;
539 inflateEnd (&zstream);
540 return modified;
541 }
542 zstream.avail_out += 4000;
543 } while (zstream.avail_out == 4000 &&
544 zstream.avail_in != 0 && result != Z_STREAM_END);
545
546 *size = zstream.total_out;
547 inflateEnd (&zstream);
548 }
549 #endif
550 if (track->encodings[i].comp_algo == 2)
551 {
552 /* lzo encoded track */
553 int dstlen = *size * 3;
554
555 *dest = NULL;
556 while (1)
557 {
558 int srclen = *size;
559 if (dstlen > SIZE_MAX - LZO_OUTPUT_PADDING) goto lzo_fail;
560 *dest = realloc (*dest, dstlen + LZO_OUTPUT_PADDING);
561 result = lzo1x_decode (*dest, &dstlen, src, &srclen);
562 if (result == 0)
563 break;
564 if (!(result & LZO_OUTPUT_FULL))
565 {
566 lzo_fail:
567 mp_msg (MSGT_DEMUX, MSGL_WARN,
568 MSGTR_MPDEMUX_MKV_LzoDecompressionFailed);
569 free(*dest);
570 *dest = NULL;
571 return modified;
572 }
573 mp_msg (MSGT_DEMUX, MSGL_DBG2,
574 "[mkv] lzo decompression buffer too small.\n");
575 dstlen *= 2;
576 }
577 *size = dstlen;
578 }
579 }
580
581 return modified;
582 }
583
584
585 static int
586 demux_mkv_read_info (demuxer_t *demuxer)
587 {
588 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
589 stream_t *s = demuxer->stream;
590 uint64_t length, l;
591 int il;
592 uint64_t tc_scale = 1000000;
593 long double duration = 0.;
594
595 length = ebml_read_length (s, NULL);
596 while (length > 0)
597 {
598 switch (ebml_read_id (s, &il))
599 {
600 case MATROSKA_ID_TIMECODESCALE:
601 {
602 uint64_t num = ebml_read_uint (s, &l);
603 if (num == EBML_UINT_INVALID)
604 return 1;
605 tc_scale = num;
606 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + timecode scale: %"PRIu64"\n",
607 tc_scale);
608 break;
609 }
610
611 case MATROSKA_ID_DURATION:
612 {
613 long double num = ebml_read_float (s, &l);
614 if (num == EBML_FLOAT_INVALID)
615 return 1;
616 duration = num;
617 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + duration: %.3Lfs\n",
618 duration * tc_scale / 1000000000.0);
619 break;
620 }
621
622 default:
623 ebml_read_skip (s, &l);
624 break;
625 }
626 length -= l + il;
627 }
628 mkv_d->tc_scale = tc_scale;
629 mkv_d->duration = duration * tc_scale / 1000000000.0;
630 return 0;
631 }
632
633 /**
634 * \brief free array of kv_content_encoding_t
635 * \param encodings pointer to array
636 * \param numencodings number of encodings in array
637 */
638 static void
639 demux_mkv_free_encodings(mkv_content_encoding_t *encodings, int numencodings)
640 {
641 while (numencodings-- > 0)
642 free(encodings[numencodings].comp_settings);
643 free(encodings);
644 }
645
646 static int
647 demux_mkv_read_trackencodings (demuxer_t *demuxer, mkv_track_t *track)
648 {
649 stream_t *s = demuxer->stream;
650 mkv_content_encoding_t *ce, e;
651 uint64_t len, length, l;
652 int il, n;
653
654 ce = malloc (sizeof (*ce));
655 n = 0;
656
657 len = length = ebml_read_length (s, &il);
658 len += il;
659 while (length > 0)
660 {
661 switch (ebml_read_id (s, &il))
662 {
663 case MATROSKA_ID_CONTENTENCODING:
664 {
665 uint64_t len;
666 int i;
667
668 memset (&e, 0, sizeof (e));
669 e.scope = 1;
670
671 len = ebml_read_length (s, &i);
672 l = len + i;
673
674 while (len > 0)
675 {
676 uint64_t num, l;
677 int il;
678
679 switch (ebml_read_id (s, &il))
680 {
681 case MATROSKA_ID_CONTENTENCODINGORDER:
682 num = ebml_read_uint (s, &l);
683 if (num == EBML_UINT_INVALID)
684 goto err_out;
685 e.order = num;
686 break;
687
688 case MATROSKA_ID_CONTENTENCODINGSCOPE:
689 num = ebml_read_uint (s, &l);
690 if (num == EBML_UINT_INVALID)
691 goto err_out;
692 e.scope = num;
693 break;
694
695 case MATROSKA_ID_CONTENTENCODINGTYPE:
696 num = ebml_read_uint (s, &l);
697 if (num == EBML_UINT_INVALID)
698 goto err_out;
699 e.type = num;
700 break;
701
702 case MATROSKA_ID_CONTENTCOMPRESSION:
703 {
704 uint64_t le;
705
706 le = ebml_read_length (s, &i);
707 l = le + i;
708
709 while (le > 0)
710 {
711 uint64_t l;
712 int il;
713
714 switch (ebml_read_id (s, &il))
715 {
716 case MATROSKA_ID_CONTENTCOMPALGO:
717 num = ebml_read_uint (s, &l);
718 if (num == EBML_UINT_INVALID)
719 goto err_out;
720 e.comp_algo = num;
721 break;
722
723 case MATROSKA_ID_CONTENTCOMPSETTINGS:
724 l = ebml_read_length (s, &i);
725 e.comp_settings = malloc (l);
726 stream_read (s, e.comp_settings, l);
727 e.comp_settings_len = l;
728 l += i;
729 break;
730
731 default:
732 ebml_read_skip (s, &l);
733 break;
734 }
735 le -= l + il;
736 }
737
738 if (e.type == 1)
739 {
740 mp_msg(MSGT_DEMUX, MSGL_WARN,
741 MSGTR_MPDEMUX_MKV_TrackEncrypted, track->tnum);
742 }
743 else if (e.type != 0)
744 {
745 mp_msg(MSGT_DEMUX, MSGL_WARN,
746 MSGTR_MPDEMUX_MKV_UnknownContentEncoding, track->tnum);
747 }
748
749 if (e.comp_algo != 0 && e.comp_algo != 2)
750 {
751 mp_msg (MSGT_DEMUX, MSGL_WARN,
752 MSGTR_MPDEMUX_MKV_UnknownCompression,
753 track->tnum, e.comp_algo);
754 }
755 #ifndef HAVE_ZLIB
756 else if (e.comp_algo == 0)
757 {
758 mp_msg (MSGT_DEMUX, MSGL_WARN,
759 MSGTR_MPDEMUX_MKV_ZlibCompressionUnsupported,
760 track->tnum);
761 }
762 #endif
763
764 break;
765 }
766
767 default:
768 ebml_read_skip (s, &l);
769 break;
770 }
771 len -= l + il;
772 }
773 for (i=0; i<n; i++)
774 if (e.order <= ce[i].order)
775 break;
776 ce = realloc (ce, (n+1) *sizeof (*ce));
777 memmove (ce+i+1, ce+i, (n-i) * sizeof (*ce));
778 memcpy (ce+i, &e, sizeof (e));
779 n++;
780 break;
781 }
782
783 default:
784 ebml_read_skip (s, &l);
785 break;
786 }
787
788 length -= l + il;
789 }
790
791 track->encodings = ce;
792 track->num_encodings = n;
793 return len;
794
795 err_out:
796 demux_mkv_free_encodings(ce, n);
797 return 0;
798 }
799
800 static int
801 demux_mkv_read_trackaudio (demuxer_t *demuxer, mkv_track_t *track)
802 {
803 stream_t *s = demuxer->stream;
804 uint64_t len, length, l;
805 int il;
806
807 track->a_sfreq = 8000.0;
808 track->a_channels = 1;
809
810 len = length = ebml_read_length (s, &il);
811 len += il;
812 while (length > 0)
813 {
814 switch (ebml_read_id (s, &il))
815 {
816 case MATROSKA_ID_AUDIOSAMPLINGFREQ:
817 {
818 long double num = ebml_read_float (s, &l);
819 if (num == EBML_FLOAT_INVALID)
820 return 0;
821 track->a_sfreq = num;
822 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Sampling frequency: %f\n",
823 track->a_sfreq);
824 break;
825 }
826
827 case MATROSKA_ID_AUDIOBITDEPTH:
828 {
829 uint64_t num = ebml_read_uint (s, &l);
830 if (num == EBML_UINT_INVALID)
831 return 0;
832 track->a_bps = num;
833 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Bit depth: %u\n",
834 track->a_bps);
835 break;
836 }
837
838 case MATROSKA_ID_AUDIOCHANNELS:
839 {
840 uint64_t num = ebml_read_uint (s, &l);
841 if (num == EBML_UINT_INVALID)
842 return 0;
843 track->a_channels = num;
844 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Channels: %u\n",
845 track->a_channels);
846 break;
847 }
848
849 default:
850 ebml_read_skip (s, &l);
851 break;
852 }
853 length -= l + il;
854 }
855 return len;
856 }
857
858 static int
859 demux_mkv_read_trackvideo (demuxer_t *demuxer, mkv_track_t *track)
860 {
861 stream_t *s = demuxer->stream;
862 uint64_t len, length, l;
863 int il;
864
865 len = length = ebml_read_length (s, &il);
866 len += il;
867 while (length > 0)
868 {
869 switch (ebml_read_id (s, &il))
870 {
871 case MATROSKA_ID_VIDEOFRAMERATE:
872 {
873 long double num = ebml_read_float (s, &l);
874 if (num == EBML_FLOAT_INVALID)
875 return 0;
876 track->v_frate = num;
877 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Frame rate: %f\n",
878 track->v_frate);
879 if (track->v_frate > 0)
880 track->default_duration = 1 / track->v_frate;
881 break;
882 }
883
884 case MATROSKA_ID_VIDEODISPLAYWIDTH:
885 {
886 uint64_t num = ebml_read_uint (s, &l);
887 if (num == EBML_UINT_INVALID)
888 return 0;
889 track->v_dwidth = num;
890 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Display width: %u\n",
891 track->v_dwidth);
892 break;
893 }
894
895 case MATROSKA_ID_VIDEODISPLAYHEIGHT:
896 {
897 uint64_t num = ebml_read_uint (s, &l);
898 if (num == EBML_UINT_INVALID)
899 return 0;
900 track->v_dheight = num;
901 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Display height: %u\n",
902 track->v_dheight);
903 break;
904 }
905
906 case MATROSKA_ID_VIDEOPIXELWIDTH:
907 {
908 uint64_t num = ebml_read_uint (s, &l);
909 if (num == EBML_UINT_INVALID)
910 return 0;
911 track->v_width = num;
912 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Pixel width: %u\n",
913 track->v_width);
914 break;
915 }
916
917 case MATROSKA_ID_VIDEOPIXELHEIGHT:
918 {
919 uint64_t num = ebml_read_uint (s, &l);
920 if (num == EBML_UINT_INVALID)
921 return 0;
922 track->v_height = num;
923 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Pixel height: %u\n",
924 track->v_height);
925 break;
926 }
927
928 default:
929 ebml_read_skip (s, &l);
930 break;
931 }
932 length -= l + il;
933 }
934 return len;
935 }
936
937 /**
938 * \brief free any data associated with given track
939 * \param track track of which to free data
940 */
941 static void
942 demux_mkv_free_trackentry(mkv_track_t *track) {
943 if (track->name)
944 free (track->name);
945 if (track->codec_id)
946 free (track->codec_id);
947 if (track->language)
948 free (track->language);
949 if (track->private_data)
950 free (track->private_data);
951 if (track->audio_buf)
952 free (track->audio_buf);
953 if (track->audio_timestamp)
954 free (track->audio_timestamp);
955 #ifdef USE_ASS
956 if (track->sh_sub && track->sh_sub->ass_track)
957 ass_free_track (track->sh_sub->ass_track);
958 #endif
959 demux_mkv_free_encodings(track->encodings, track->num_encodings);
960 free(track);
961 }
962
963 static int
964 demux_mkv_read_trackentry (demuxer_t *demuxer)
965 {
966 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
967 stream_t *s = demuxer->stream;
968 mkv_track_t *track;
969 uint64_t len, length, l;
970 int il;
971
972 track = calloc (1, sizeof (*track));
973 /* set default values */
974 track->default_track = 1;
975 track->name = 0;
976 track->language = strdup("eng");
977
978 len = length = ebml_read_length (s, &il);
979 len += il;
980 while (length > 0)
981 {
982 switch (ebml_read_id (s, &il))
983 {
984 case MATROSKA_ID_TRACKNUMBER:
985 {
986 uint64_t num = ebml_read_uint (s, &l);
987 if (num == EBML_UINT_INVALID)
988 goto err_out;
989 track->tnum = num;
990 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Track number: %u\n",
991 track->tnum);
992 break;
993 }
994
995 case MATROSKA_ID_TRACKNAME:
996 {
997 track->name = ebml_read_utf8 (s, &l);
998 if (track->name == NULL)
999 goto err_out;
1000 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Name: %s\n",
1001 track->name);
1002 break;
1003 }
1004
1005 case MATROSKA_ID_TRACKTYPE:
1006 {
1007 uint64_t num = ebml_read_uint (s, &l);
1008 if (num == EBML_UINT_INVALID)
1009 return 0;
1010 track->type = num;
1011 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Track type: ");
1012 switch (track->type)
1013 {
1014 case MATROSKA_TRACK_AUDIO:
1015 mp_msg (MSGT_DEMUX, MSGL_V, "Audio\n");
1016 break;
1017 case MATROSKA_TRACK_VIDEO:
1018 mp_msg (MSGT_DEMUX, MSGL_V, "Video\n");
1019 break;
1020 case MATROSKA_TRACK_SUBTITLE:
1021 mp_msg (MSGT_DEMUX, MSGL_V, "Subtitle\n");
1022 break;
1023 default:
1024 mp_msg (MSGT_DEMUX, MSGL_V, "unknown\n");
1025 break;
1026 }
1027 break;
1028 }
1029
1030 case MATROSKA_ID_TRACKAUDIO:
1031 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Audio track\n");
1032 l = demux_mkv_read_trackaudio (demuxer, track);
1033 if (l == 0)
1034 goto err_out;
1035 break;
1036
1037 case MATROSKA_ID_TRACKVIDEO:
1038 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Video track\n");
1039 l = demux_mkv_read_trackvideo (demuxer, track);
1040 if (l == 0)
1041 goto err_out;
1042 break;
1043
1044 case MATROSKA_ID_CODECID:
1045 track->codec_id = ebml_read_ascii (s, &l);
1046 if (track->codec_id == NULL)
1047 goto err_out;
1048 if (!strcmp (track->codec_id, MKV_V_MSCOMP) ||
1049 !strcmp (track->codec_id, MKV_A_ACM))
1050 track->ms_compat = 1;
1051 else if (!strcmp (track->codec_id, MKV_S_VOBSUB))
1052 track->subtitle_type = MATROSKA_SUBTYPE_VOBSUB;
1053 else if (!strcmp (track->codec_id, MKV_S_TEXTSSA)
1054 || !strcmp (track->codec_id, MKV_S_TEXTASS)
1055 || !strcmp (track->codec_id, MKV_S_SSA)
1056 || !strcmp (track->codec_id, MKV_S_ASS))
1057 {
1058 track->subtitle_type = MATROSKA_SUBTYPE_SSA;
1059 }
1060 else if (!strcmp (track->codec_id, MKV_S_TEXTASCII))
1061 track->subtitle_type = MATROSKA_SUBTYPE_TEXT;
1062 if (!strcmp (track->codec_id, MKV_S_TEXTUTF8))
1063 {
1064 track->subtitle_type = MATROSKA_SUBTYPE_TEXT;
1065 }
1066 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Codec ID: %s\n",
1067 track->codec_id);
1068 break;
1069
1070 case MATROSKA_ID_CODECPRIVATE:
1071 {
1072 int x;
1073 uint64_t num = ebml_read_length (s, &x);
1074 // audit: cheap guard against overflows later..
1075 if (num > SIZE_MAX - 1000) return 0;
1076 l = x + num;
1077 track->private_data = malloc (num + LZO_INPUT_PADDING);
1078 if (stream_read(s, track->private_data, num) != (int) num)
1079 goto err_out;
1080 track->private_size = num;
1081 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + CodecPrivate, length "
1082 "%u\n", track->private_size);
1083 break;
1084 }
1085
1086 case MATROSKA_ID_TRACKLANGUAGE:
1087 free(track->language);
1088 track->language = ebml_read_utf8 (s, &l);
1089 if (track->language == NULL)
1090 goto err_out;
1091 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Language: %s\n",
1092 track->language);
1093 break;
1094
1095 case MATROSKA_ID_TRACKFLAGDEFAULT:
1096 {
1097 uint64_t num = ebml_read_uint (s, &l);
1098 if (num == EBML_UINT_INVALID)
1099 goto err_out;
1100 track->default_track = num;
1101 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Default flag: %u\n",
1102 track->default_track);
1103 break;
1104 }
1105
1106 case MATROSKA_ID_TRACKDEFAULTDURATION:
1107 {
1108 uint64_t num = ebml_read_uint (s, &l);
1109 if (num == EBML_UINT_INVALID)
1110 goto err_out;
1111 if (num == 0)
1112 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Default duration: 0");
1113 else
1114 {
1115 track->v_frate = 1000000000.0 / num;
1116 track->default_duration = num / 1000000000.0;
1117 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Default duration: "
1118 "%.3fms ( = %.3f fps)\n",num/1000000.0,track->v_frate);
1119 }
1120 break;
1121 }
1122
1123 case MATROSKA_ID_TRACKENCODINGS:
1124 l = demux_mkv_read_trackencodings (demuxer, track);
1125 if (l == 0)
1126 goto err_out;
1127 break;
1128
1129 default:
1130 ebml_read_skip (s, &l);
1131 break;
1132 }
1133 length -= l + il;
1134 }
1135
1136 mkv_d->tracks[mkv_d->num_tracks++] = track;
1137 return len;
1138
1139 err_out:
1140 demux_mkv_free_trackentry(track);
1141 return 0;
1142 }
1143
1144 static int
1145 demux_mkv_read_tracks (demuxer_t *demuxer)
1146 {
1147 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1148 stream_t *s = demuxer->stream;
1149 uint64_t length, l;
1150 int il;
1151
1152 mkv_d->tracks = malloc (sizeof (*mkv_d->tracks));
1153 mkv_d->num_tracks = 0;
1154
1155 length = ebml_read_length (s, NULL);
1156 while (length > 0)
1157 {
1158 switch (ebml_read_id (s, &il))
1159 {
1160 case MATROSKA_ID_TRACKENTRY:
1161 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + a track...\n");
1162 mkv_d->tracks = realloc (mkv_d->tracks,
1163 (mkv_d->num_tracks+1)
1164 *sizeof (*mkv_d->tracks));
1165 l = demux_mkv_read_trackentry (demuxer);
1166 if (l == 0)
1167 return 1;
1168 break;
1169
1170 default:
1171 ebml_read_skip (s, &l);
1172 break;
1173 }
1174 length -= l + il;
1175 }
1176 return 0;
1177 }
1178
1179 static int
1180 demux_mkv_read_cues (demuxer_t *demuxer)
1181 {
1182 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1183 stream_t *s = demuxer->stream;
1184 uint64_t length, l, time, track, pos;
1185 off_t off;
1186 int i, il;
1187
1188 if (index_mode == 0) {
1189 ebml_read_skip (s, NULL);
1190 return 0;
1191 }
1192 off = stream_tell (s);
1193 for (i=0; i<mkv_d->parsed_cues_num; i++)
1194 if (mkv_d->parsed_cues[i] == off)
1195 {
1196 ebml_read_skip (s, NULL);
1197 return 0;
1198 }
1199 mkv_d->parsed_cues = realloc (mkv_d->parsed_cues,
1200 (mkv_d->parsed_cues_num+1)
1201 * sizeof (off_t));
1202 mkv_d->parsed_cues[mkv_d->parsed_cues_num++] = off;
1203
1204 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing cues ] -----------\n");
1205 length = ebml_read_length (s, NULL);
1206
1207 while (length > 0)
1208 {
1209 time = track = pos = EBML_UINT_INVALID;
1210
1211 switch (ebml_read_id (s, &il))
1212 {
1213 case MATROSKA_ID_POINTENTRY:
1214 {
1215 uint64_t len;
1216
1217 len = ebml_read_length (s, &i);
1218 l = len + i;
1219
1220 while (len > 0)
1221 {
1222 uint64_t l;
1223 int il;
1224
1225 switch (ebml_read_id (s, &il))
1226 {
1227 case MATROSKA_ID_CUETIME:
1228 time = ebml_read_uint (s, &l);
1229 break;
1230
1231 case MATROSKA_ID_CUETRACKPOSITION:
1232 {
1233 uint64_t le;
1234
1235 le = ebml_read_length (s, &i);
1236 l = le + i;
1237
1238 while (le > 0)
1239 {
1240 uint64_t l;
1241 int il;
1242
1243 switch (ebml_read_id (s, &il))
1244 {
1245 case MATROSKA_ID_CUETRACK:
1246 track = ebml_read_uint (s, &l);
1247 break;
1248
1249 case MATROSKA_ID_CUECLUSTERPOSITION:
1250 pos = ebml_read_uint (s, &l);
1251 break;
1252
1253 default:
1254 ebml_read_skip (s, &l);
1255 break;
1256 }
1257 le -= l + il;
1258 }
1259 break;
1260 }
1261
1262 default:
1263 ebml_read_skip (s, &l);
1264 break;
1265 }
1266 len -= l + il;
1267 }
1268 break;
1269 }
1270
1271 default:
1272 ebml_read_skip (s, &l);
1273 break;
1274 }
1275
1276 length -= l + il;
1277
1278 if (time != EBML_UINT_INVALID && track != EBML_UINT_INVALID
1279 && pos != EBML_UINT_INVALID)
1280 {
1281 grow_array(&mkv_d->indexes, mkv_d->num_indexes, sizeof(mkv_index_t));
1282 mkv_d->indexes[mkv_d->num_indexes].tnum = track;
1283 mkv_d->indexes[mkv_d->num_indexes].timecode = time;
1284 mkv_d->indexes[mkv_d->num_indexes].filepos =mkv_d->segment_start+pos;
1285 mp_msg (MSGT_DEMUX, MSGL_DBG2, "[mkv] |+ found cue point "
1286 "for track %"PRIu64": timecode %"PRIu64", filepos: %"PRIu64"\n",
1287 track, time, mkv_d->segment_start + pos);
1288 mkv_d->num_indexes++;
1289 }
1290 }
1291
1292 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] \\---- [ parsing cues ] -----------\n");
1293 return 0;
1294 }
1295
1296 static int
1297 demux_mkv_read_chapters (demuxer_t *demuxer)
1298 {
1299 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1300 stream_t *s = demuxer->stream;
1301 uint64_t length, l;
1302 int il;
1303
1304 if (demuxer->chapters)
1305 {
1306 ebml_read_skip (s, NULL);
1307 return 0;
1308 }
1309
1310 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing chapters ] ---------\n");
1311 length = ebml_read_length (s, NULL);
1312
1313 while (length > 0)
1314 {
1315 switch (ebml_read_id (s, &il))
1316 {
1317 case MATROSKA_ID_EDITIONENTRY:
1318 {
1319 uint64_t len;
1320 int i;
1321
1322 len = ebml_read_length (s, &i);
1323 l = len + i;
1324
1325 while (len > 0)
1326 {
1327 uint64_t l;
1328 int il;
1329
1330 switch (ebml_read_id (s, &il))
1331 {
1332 case MATROSKA_ID_CHAPTERATOM:
1333 {
1334 uint64_t len, start=0, end=0;
1335 char* name = 0;
1336 int i;
1337 int cid;
1338
1339 len = ebml_read_length (s, &i);
1340 l = len + i;
1341
1342 while (len > 0)
1343 {
1344 uint64_t l;
1345 int il;
1346
1347 switch (ebml_read_id (s, &il))
1348 {
1349 case MATROSKA_ID_CHAPTERTIMESTART:
1350 start = ebml_read_uint (s, &l) / 1000000;
1351 break;
1352
1353 case MATROSKA_ID_CHAPTERTIMEEND:
1354 end = ebml_read_uint (s, &l) / 1000000;
1355 break;
1356
1357 case MATROSKA_ID_CHAPTERDISPLAY:
1358 {
1359 uint64_t len;
1360 int i;
1361
1362 len = ebml_read_length (s, &i);
1363 l = len + i;
1364 while (len > 0)
1365 {
1366 uint64_t l;
1367 int il;
1368
1369 switch (ebml_read_id (s, &il))
1370 {
1371 case MATROSKA_ID_CHAPSTRING:
1372 name = ebml_read_utf8 (s, &l);
1373 break;
1374 default:
1375 ebml_read_skip (s, &l);
1376 break;
1377 }
1378 len -= l + il;
1379 }
1380 }
1381 break;
1382
1383 default:
1384 ebml_read_skip (s, &l);
1385 break;
1386 }
1387 len -= l + il;
1388 }
1389
1390 if (!name)
1391 name = strdup("(unnamed)");
1392
1393 cid = demuxer_add_chapter(demuxer, name, start, end);
1394
1395 mp_msg(MSGT_DEMUX, MSGL_V,
1396 "[mkv] Chapter %u from %02d:%02d:%02d."
1397 "%03d to %02d:%02d:%02d.%03d, %s\n",
1398 cid,
1399 (int) (start / 60 / 60 / 1000),
1400 (int) ((start / 60 / 1000) % 60),
1401 (int) ((start / 1000) % 60),
1402 (int) (start % 1000),
1403 (int) (end / 60 / 60 / 1000),
1404 (int) ((end / 60 / 1000) % 60),
1405 (int) ((end / 1000) % 60),
1406 (int) (end % 1000), name);
1407
1408 free(name);
1409 break;
1410 }
1411
1412 default:
1413 ebml_read_skip (s, &l);
1414 break;
1415 }
1416 len -= l + il;
1417 }
1418 break;
1419 }
1420
1421 default:
1422 ebml_read_skip (s, &l);
1423 break;
1424 }
1425
1426 length -= l + il;
1427 }
1428
1429 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] \\---- [ parsing chapters ] ---------\n");
1430 return 0;
1431 }
1432
1433 static int
1434 demux_mkv_read_tags (demuxer_t *demuxer)
1435 {
1436 ebml_read_skip (demuxer->stream, NULL);
1437 return 0;
1438 }
1439
1440 static int
1441 demux_mkv_read_attachments (demuxer_t *demuxer)
1442 {
1443 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1444 stream_t *s = demuxer->stream;
1445 uint64_t length, l;
1446 int il;
1447
1448 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing attachments ] ---------\n");
1449 length = ebml_read_length (s, NULL);
1450
1451 while (length > 0)
1452 {
1453 switch (ebml_read_id (s, &il))
1454 {
1455 case MATROSKA_ID_ATTACHEDFILE:
1456 {
1457 uint64_t len;
1458 int i;
1459 char* name = NULL;
1460 char* mime = NULL;
1461 uint64_t uid = 0;
1462 char* data = NULL;
1463 int data_size = 0;
1464
1465 len = ebml_read_length (s, &i);
1466 l = len + i;
1467
1468 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + an attachment...\n");
1469
1470 grow_array(&mkv_d->attachments, mkv_d->num_attachments,
1471 sizeof(*mkv_d->attachments));
1472
1473 while (len > 0)
1474 {
1475 uint64_t l;
1476 int il;
1477
1478 switch (ebml_read_id (s, &il))
1479 {
1480 case MATROSKA_ID_FILENAME:
1481 name = ebml_read_utf8 (s, &l);
1482 if (name == NULL)
1483 return 0;
1484 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + FileName: %s\n",
1485 name);
1486 break;
1487
1488 case MATROSKA_ID_FILEMIMETYPE:
1489 mime = ebml_read_ascii (s, &l);
1490 if (mime == NULL)
1491 return 0;
1492 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + FileMimeType: %s\n",
1493 mime);
1494 break;
1495
1496 case MATROSKA_ID_FILEUID:
1497 uid = ebml_read_uint (s, &l);
1498 break;
1499
1500 case MATROSKA_ID_FILEDATA:
1501 {
1502 int x;
1503 uint64_t num = ebml_read_length (s, &x);
1504 l = x + num;
1505 free(data);
1506 data = malloc (num);
1507 if (stream_read(s, data, num) != (int) num)
1508 {
1509 free(data);
1510 return 0;
1511 }
1512 data_size = num;
1513 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + FileData, length "
1514 "%u\n", data_size);
1515 break;
1516 }
1517
1518 default:
1519 ebml_read_skip (s, &l);
1520 break;
1521 }
1522 len -= l + il;
1523 }
1524
1525 mkv_d->attachments[mkv_d->num_attachments].name = name;
1526 mkv_d->attachments[mkv_d->num_attachments].mime = mime;
1527 mkv_d->attachments[mkv_d->num_attachments].uid = uid;
1528 mkv_d->attachments[mkv_d->num_attachments].data = data;
1529 mkv_d->attachments[mkv_d->num_attachments].data_size = data_size;
1530 mkv_d->num_attachments ++;
1531 mp_msg(MSGT_DEMUX, MSGL_V,
1532 "[mkv] Attachment: %s, %s, %u bytes\n",
1533 name, mime, data_size);
1534 #ifdef USE_ASS
1535 if (ass_library &&
1536 extract_embedded_fonts && name && data && data_size &&
1537 mime && (strcmp(mime, "application/x-truetype-font") == 0 ||
1538 strcmp(mime, "application/x-font") == 0))
1539 ass_add_font(ass_library, name, data, data_size);
1540 #endif
1541 break;
1542 }
1543
1544 default:
1545 ebml_read_skip (s, &l);
1546 break;
1547 }
1548 length -= l + il;
1549 }
1550
1551 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] \\---- [ parsing attachments ] ---------\n");
1552 return 0;
1553 }
1554
1555 static int
1556 demux_mkv_read_seekhead (demuxer_t *demuxer)
1557 {
1558 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1559 stream_t *s = demuxer->stream;
1560 uint64_t length, l, seek_pos, saved_pos, num;
1561 uint32_t seek_id;
1562 int i, il, res = 0;
1563 off_t off;
1564
1565 off = stream_tell (s);
1566 for (i=0; i<mkv_d->parsed_seekhead_num; i++)
1567 if (mkv_d->parsed_seekhead[i] == off)
1568 {
1569 ebml_read_skip (s, NULL);
1570 return 0;
1571 }
1572 mkv_d->parsed_seekhead = realloc (mkv_d->parsed_seekhead,
1573 (mkv_d->parsed_seekhead_num+1)
1574 * sizeof (off_t));
1575 mkv_d->parsed_seekhead[mkv_d->parsed_seekhead_num++] = off;
1576
1577 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing seek head ] ---------\n");
1578 length = ebml_read_length (s, NULL);
1579 /* off now holds the position of the next element after the seek head. */
1580 off = stream_tell (s) + length;
1581 while (length > 0 && !res)
1582 {
1583
1584 seek_id = 0;
1585 seek_pos = EBML_UINT_INVALID;
1586
1587 switch (ebml_read_id (s, &il))
1588 {
1589 case MATROSKA_ID_SEEKENTRY:
1590 {
1591 uint64_t len;
1592
1593 len = ebml_read_length (s, &i);
1594 l = len + i;
1595
1596 while (len > 0)
1597 {
1598 uint64_t l;
1599 int il;
1600
1601 switch (ebml_read_id (s, &il))
1602 {
1603 case MATROSKA_ID_SEEKID:
1604 num = ebml_read_uint (s, &l);
1605 if (num != EBML_UINT_INVALID)
1606 seek_id = num;
1607 break;
1608
1609 case MATROSKA_ID_SEEKPOSITION:
1610 seek_pos = ebml_read_uint (s, &l);
1611 break;
1612
1613 default:
1614 ebml_read_skip (s, &l);
1615 break;
1616 }
1617 len -= l + il;
1618 }
1619
1620 break;
1621 }
1622
1623 default:
1624 ebml_read_skip (s, &l);
1625 break;
1626 }
1627 length -= l + il;
1628
1629 if (seek_id == 0 || seek_id == MATROSKA_ID_CLUSTER
1630 || seek_pos == EBML_UINT_INVALID ||
1631 ((mkv_d->segment_start + seek_pos) >= (uint64_t)demuxer->movi_end))
1632 continue;
1633
1634 saved_pos = stream_tell (s);
1635 if (!stream_seek (s, mkv_d->segment_start + seek_pos))
1636 res = 1;
1637 else
1638 {
1639 if (ebml_read_id (s, &il) != seek_id)
1640 res = 1;
1641 else
1642 switch (seek_id)
1643 {
1644 case MATROSKA_ID_CUES:
1645 if (demux_mkv_read_cues (demuxer))
1646 res = 1;
1647 break;
1648
1649 case MATROSKA_ID_TAGS:
1650 if (demux_mkv_read_tags (demuxer))
1651 res = 1;
1652 break;
1653
1654 case MATROSKA_ID_SEEKHEAD:
1655 if (demux_mkv_read_seekhead (demuxer))
1656 res = 1;
1657 break;
1658
1659 case MATROSKA_ID_CHAPTERS:
1660 if (demux_mkv_read_chapters (demuxer))
1661 res = 1;
1662 break;
1663 }
1664 }
1665
1666 stream_seek (s, saved_pos);
1667 }
1668 if (res)
1669 {
1670 /* If there was an error then try to skip this seek head. */
1671 if (stream_seek (s, off))
1672 res = 0;
1673 }
1674 else
1675 if (length > 0)
1676 stream_seek (s, stream_tell (s) + length);
1677 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] \\---- [ parsing seek head ] ---------\n");
1678 return res;
1679 }
1680
1681 static int
1682 demux_mkv_open_video (demuxer_t *demuxer, mkv_track_t *track, int vid);
1683 static int
1684 demux_mkv_open_audio (demuxer_t *demuxer, mkv_track_t *track, int aid);
1685 static int
1686 demux_mkv_open_sub (demuxer_t *demuxer, mkv_track_t *track, int sid);
1687
1688 static void
1689 display_create_tracks (demuxer_t *demuxer)
1690 {
1691 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *)demuxer->priv;
1692 int i, vid=0, aid=0, sid=0;
1693
1694 for (i=0; i<mkv_d->num_tracks; i++)
1695 {
1696 char *type = "unknown", str[32];
1697 *str = '\0';
1698 switch (mkv_d->tracks[i]->type)
1699 {
1700 case MATROSKA_TRACK_VIDEO:
1701 type = "video";
1702 demux_mkv_open_video(demuxer, mkv_d->tracks[i], vid);
1703 if (mkv_d->tracks[i]->name)
1704 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VID_%d_NAME=%s\n", vid, mkv_d->tracks[i]->name);
1705 sprintf (str, "-vid %u", vid++);
1706 break;
1707 case MATROSKA_TRACK_AUDIO:
1708 type = "audio";
1709 demux_mkv_open_audio(demuxer, mkv_d->tracks[i], aid);
1710 if (mkv_d->tracks[i]->name)
1711 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_NAME=%s\n", aid, mkv_d->tracks[i]->name);
1712 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_LANG=%s\n", aid, mkv_d->tracks[i]->language);
1713 sprintf (str, "-aid %u, -alang %.5s",aid++,mkv_d->tracks[i]->language);
1714 break;
1715 case MATROSKA_TRACK_SUBTITLE:
1716 type = "subtitles";
1717 demux_mkv_open_sub(demuxer, mkv_d->tracks[i], sid);
1718 if (mkv_d->tracks[i]->name)
1719 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_NAME=%s\n", sid, mkv_d->tracks[i]->name);
1720 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_LANG=%s\n", sid, mkv_d->tracks[i]->language);
1721 sprintf (str, "-sid %u, -slang %.5s",sid++,mkv_d->tracks[i]->language);
1722 break;
1723 }
1724 if (mkv_d->tracks[i]->name)
1725 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_MPDEMUX_MKV_TrackIDName,
1726 mkv_d->tracks[i]->tnum, type, mkv_d->tracks[i]->codec_id, mkv_d->tracks[i]->name, str);
1727 else
1728 mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_MPDEMUX_MKV_TrackID,
1729 mkv_d->tracks[i]->tnum, type, mkv_d->tracks[i]->codec_id, str);
1730 }
1731 }
1732
1733 typedef struct {
1734 char *id;
1735 int fourcc;
1736 int extradata;
1737 } videocodec_info_t;
1738
1739 static const videocodec_info_t vinfo[] = {
1740 { MKV_V_MPEG1, mmioFOURCC('m', 'p', 'g', '1'), 0 },
1741 { MKV_V_MPEG2, mmioFOURCC('m', 'p', 'g', '2'), 0 },
1742 { MKV_V_MPEG4_SP, mmioFOURCC('m', 'p', '4', 'v'), 1 },
1743 { MKV_V_MPEG4_ASP, mmioFOURCC('m', 'p', '4', 'v'), 1 },
1744 { MKV_V_MPEG4_AP, mmioFOURCC('m', 'p', '4', 'v'), 1 },
1745 { MKV_V_MPEG4_AVC, mmioFOURCC('a', 'v', 'c', '1'), 1 },
1746 { MKV_V_THEORA, mmioFOURCC('t', 'h', 'e', 'o'), 1 },
1747 { NULL, 0, 0 }
1748 };
1749
1750 static int
1751 demux_mkv_open_video (demuxer_t *demuxer, mkv_track_t *track, int vid)
1752 {
1753 BITMAPINFOHEADER *bih;
1754 void *ImageDesc = NULL;
1755 sh_video_t *sh_v;
1756
1757 if (track->ms_compat) /* MS compatibility mode */
1758 {
1759 BITMAPINFOHEADER *src;
1760
1761 if (track->private_data == NULL
1762 || track->private_size < sizeof (BITMAPINFOHEADER))
1763 return 1;
1764
1765 src = (BITMAPINFOHEADER *) track->private_data;
1766 bih = calloc (1, track->private_size);
1767 bih->biSize = le2me_32 (src->biSize);
1768 bih->biWidth = le2me_32 (src->biWidth);
1769 bih->biHeight = le2me_32 (src->biHeight);
1770 bih->biPlanes = le2me_16 (src->biPlanes);
1771 bih->biBitCount = le2me_16 (src->biBitCount);
1772 bih->biCompression = le2me_32 (src->biCompression);
1773 bih->biSizeImage = le2me_32 (src->biSizeImage);
1774 bih->biXPelsPerMeter = le2me_32 (src->biXPelsPerMeter);
1775 bih->biYPelsPerMeter = le2me_32 (src->biYPelsPerMeter);
1776 bih->biClrUsed = le2me_32 (src->biClrUsed);
1777 bih->biClrImportant = le2me_32 (src->biClrImportant);
1778 memcpy((char *) bih + sizeof (BITMAPINFOHEADER),
1779 (char *) src + sizeof (BITMAPINFOHEADER),
1780 track->private_size - sizeof (BITMAPINFOHEADER));
1781
1782 if (track->v_width == 0)
1783 track->v_width = bih->biWidth;
1784 if (track->v_height == 0)
1785 track->v_height = bih->biHeight;
1786 }
1787 else
1788 {
1789 bih = calloc (1, sizeof (BITMAPINFOHEADER));
1790 bih->biSize = sizeof (BITMAPINFOHEADER);
1791 bih->biWidth = track->v_width;
1792 bih->biHeight = track->v_height;
1793 bih->biBitCount = 24;
1794 bih->biSizeImage = bih->biWidth * bih->biHeight * bih->biBitCount/8;
1795
1796 if (track->private_size >= RVPROPERTIES_SIZE
1797 && (!strcmp (track->codec_id, MKV_V_REALV10)
1798 || !strcmp (track->codec_id, MKV_V_REALV20)
1799 || !strcmp (track->codec_id, MKV_V_REALV30)
1800 || !strcmp (track->codec_id, MKV_V_REALV40)))
1801 {
1802 unsigned char *dst, *src;
1803 uint32_t type2;
1804 unsigned int cnt;
1805
1806 src = track->private_data + RVPROPERTIES_SIZE;
1807
1808 cnt = track->private_size - RVPROPERTIES_SIZE;
1809 bih = realloc(bih, sizeof (BITMAPINFOHEADER)+8+cnt);
1810 bih->biSize = 48+cnt;
1811 bih->biPlanes = 1;
1812 type2 = AV_RB32(src - 4);
1813 if (type2 == 0x10003000 || type2 == 0x10003001)
1814 bih->biCompression=mmioFOURCC('R','V','1','3');
1815 else
1816 bih->biCompression=mmioFOURCC('R','V',track->codec_id[9],'0');
1817 dst = (unsigned char *) (bih + 1);
1818 // copy type1 and type2 info from rv properties
1819 memcpy(dst, src - 8, 8);
1820 stream_read(demuxer->stream, dst+8, cnt);
1821 track->realmedia = 1;
1822
1823 #ifdef USE_QTX_CODECS
1824 }
1825 else if (track->private_size >= sizeof (ImageDescription)
1826 && !strcmp(track->codec_id, MKV_V_QUICKTIME))
1827 {
1828 ImageDescriptionPtr idesc;
1829
1830 idesc = (ImageDescriptionPtr) track->private_data;
1831 idesc->idSize = be2me_32 (idesc->idSize);
1832 idesc->cType = be2me_32 (idesc->cType);
1833 idesc->version = be2me_16 (idesc->version);
1834 idesc->revisionLevel = be2me_16 (idesc->revisionLevel);
1835 idesc->vendor = be2me_32 (idesc->vendor);
1836 idesc->temporalQuality = be2me_32 (idesc->temporalQuality);
1837 idesc->spatialQuality = be2me_32 (idesc->spatialQuality);
1838 idesc->width = be2me_16 (idesc->width);
1839 idesc->height = be2me_16 (idesc->height);
1840 idesc->hRes = be2me_32 (idesc->hRes);
1841 idesc->vRes = be2me_32 (idesc->vRes);
1842 idesc->dataSize = be2me_32 (idesc->dataSize);
1843 idesc->frameCount = be2me_16 (idesc->frameCount);
1844 idesc->depth = be2me_16 (idesc->depth);
1845 idesc->clutID = be2me_16 (idesc->clutID);
1846 bih->biPlanes = 1;
1847 bih->biCompression = idesc->cType;
1848 ImageDesc = idesc;
1849 #endif /* USE_QTX_CODECS */
1850
1851 }
1852 else
1853 {
1854 const videocodec_info_t *vi = vinfo;
1855 while (vi->id && strcmp(vi->id, track->codec_id)) vi++;
1856 bih->biCompression = vi->fourcc;
1857 if (vi->extradata && track->private_data && (track->private_size > 0))
1858 {
1859 bih->biSize += track->private_size;
1860 bih = realloc (bih, bih->biSize);
1861 memcpy (bih + 1, track->private_data, track->private_size);
1862 }
1863 track->reorder_timecodes = !correct_pts;
1864 if (!vi->id) {
1865 mp_msg (MSGT_DEMUX,MSGL_WARN, MSGTR_MPDEMUX_MKV_UnknownCodecID,
1866 track->codec_id, track->tnum);
1867 free(bih);
1868 return 1;
1869 }
1870 }
1871 }
1872
1873 sh_v = new_sh_video_vid (demuxer, track->tnum, vid);
1874 sh_v->bih = bih;
1875 sh_v->format = sh_v->bih->biCompression;
1876 if (track->v_frate == 0.0)
1877 track->v_frate = 25.0;
1878 sh_v->fps = track->v_frate;
1879 sh_v->frametime = 1 / track->v_frate;
1880 sh_v->aspect = 0;
1881 if (!track->realmedia)
1882 {
1883 sh_v->disp_w = track->v_width;
1884 sh_v->disp_h = track->v_height;
1885 if (track->v_dheight)
1886 sh_v->aspect = (float)track->v_dwidth / (float)track->v_dheight;
1887 }
1888 else
1889 {
1890 // vd_realvid.c will set aspect to disp_w/disp_h and rederive
1891 // disp_w and disp_h from the RealVideo stream contents returned
1892 // by the Real DLLs. If DisplayWidth/DisplayHeight was not set in
1893 // the Matroska file then it has already been set to PixelWidth/Height
1894 // by check_track_information.
1895 sh_v->disp_w = track->v_dwidth;
1896 sh_v->disp_h = track->v_dheight;
1897 }
1898 sh_v->ImageDesc = ImageDesc;
1899 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] Aspect: %f\n", sh_v->aspect);
1900
1901 sh_v->ds = demuxer->video;
1902 return 0;
1903 }
1904
1905 static int
1906 demux_mkv_open_audio (demuxer_t *demuxer, mkv_track_t *track, int aid)
1907 {
1908 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1909 sh_audio_t *sh_a = new_sh_audio_aid(demuxer, track->tnum, aid);
1910 demux_packet_t *dp;
1911 if(!sh_a) return 1;
1912 mkv_d->audio_tracks[mkv_d->last_aid] = track->tnum;
1913
1914 sh_a->ds = demuxer->audio;
1915 sh_a->wf = malloc (sizeof (WAVEFORMATEX));
1916 if (track->ms_compat && (track->private_size >= sizeof(WAVEFORMATEX)))
1917 {
1918 WAVEFORMATEX *wf = (WAVEFORMATEX *)track->private_data;
1919 sh_a->wf = realloc(sh_a->wf, track->private_size);
1920 sh_a->wf->wFormatTag = le2me_16 (wf->wFormatTag);
1921 sh_a->wf->nChannels = le2me_16 (wf->nChannels);
1922 sh_a->wf->nSamplesPerSec = le2me_32 (wf->nSamplesPerSec);
1923 sh_a->wf->nAvgBytesPerSec = le2me_32 (wf->nAvgBytesPerSec);
1924 sh_a->wf->nBlockAlign = le2me_16 (wf->nBlockAlign);
1925 sh_a->wf->wBitsPerSample = le2me_16 (wf->wBitsPerSample);
1926 sh_a->wf->cbSize = track->private_size - sizeof(WAVEFORMATEX);
1927 memcpy(sh_a->wf + 1, wf + 1, track->private_size - sizeof(WAVEFORMATEX));
1928 if (track->a_sfreq == 0.0)
1929 track->a_sfreq = sh_a->wf->nSamplesPerSec;
1930 if (track->a_channels == 0)
1931 track->a_channels = sh_a->wf->nChannels;
1932 if (track->a_bps == 0)
1933 track->a_bps = sh_a->wf->wBitsPerSample;
1934 track->a_formattag = sh_a->wf->wFormatTag;
1935 }
1936 else
1937 {
1938 memset(sh_a->wf, 0, sizeof (WAVEFORMATEX));
1939 if (!strcmp(track->codec_id, MKV_A_MP3) ||
1940 !strcmp(track->codec_id, MKV_A_MP2))
1941 track->a_formattag = 0x0055;
1942 else if (!strncmp(track->codec_id, MKV_A_AC3, strlen(MKV_A_AC3)))
1943 track->a_formattag = 0x2000;
1944 else if (!strcmp(track->codec_id, MKV_A_DTS))
1945 track->a_formattag = 0x2001;
1946 else if (!strcmp(track->codec_id, MKV_A_PCM) ||
1947 !strcmp(track->codec_id, MKV_A_PCM_BE))
1948 track->a_formattag = 0x0001;
1949 else if (!strcmp(track->codec_id, MKV_A_AAC_2MAIN) ||
1950 !strncmp(track->codec_id, MKV_A_AAC_2LC,
1951 strlen(MKV_A_AAC_2LC)) ||
1952 !strcmp(track->codec_id, MKV_A_AAC_2SSR) ||
1953 !strcmp(track->codec_id, MKV_A_AAC_4MAIN) ||
1954 !strncmp(track->codec_id, MKV_A_AAC_4LC,
1955 strlen(MKV_A_AAC_4LC)) ||
1956 !strcmp(track->codec_id, MKV_A_AAC_4SSR) ||
1957 !strcmp(track->codec_id, MKV_A_AAC_4LTP) ||
1958 !strcmp(track->codec_id, MKV_A_AAC))
1959 track->a_formattag = mmioFOURCC('M', 'P', '4', 'A');
1960 else if (!strcmp(track->codec_id, MKV_A_VORBIS))
1961 {
1962 if (track->private_data == NULL)
1963 return 1;
1964 track->a_formattag = mmioFOURCC('v', 'r', 'b', 's');
1965 }
1966 else if (!strcmp(track->codec_id, MKV_A_QDMC))
1967 track->a_formattag = mmioFOURCC('Q', 'D', 'M', 'C');
1968 else if (!strcmp(track->codec_id, MKV_A_QDMC2))
1969 track->a_formattag = mmioFOURCC('Q', 'D', 'M', '2');
1970 else if (!strcmp(track->codec_id, MKV_A_FLAC))
1971 {
1972 if (track->private_data == NULL || track->private_size == 0)
1973 {
1974 mp_msg (MSGT_DEMUX, MSGL_WARN,
1975 MSGTR_MPDEMUX_MKV_FlacTrackDoesNotContainValidHeaders);
1976 return 1;
1977 }
1978 track->a_formattag = mmioFOURCC ('f', 'L', 'a', 'C');
1979 }
1980 else if (track->private_size >= RAPROPERTIES4_SIZE)
1981 {
1982 if (!strcmp(track->codec_id, MKV_A_REAL28))
1983 track->a_formattag = mmioFOURCC('2', '8', '_', '8');
1984 else if (!strcmp(track->codec_id, MKV_A_REALATRC))
1985 track->a_formattag = mmioFOURCC('a', 't', 'r', 'c');
1986 else if (!strcmp(track->codec_id, MKV_A_REALCOOK))
1987 track->a_formattag = mmioFOURCC('c', 'o', 'o', 'k');
1988 else if (!strcmp(track->codec_id, MKV_A_REALDNET))
1989 track->a_formattag = mmioFOURCC('d', 'n', 'e', 't');
1990 else if (!strcmp(track->codec_id, MKV_A_REALSIPR))
1991 track->a_formattag = mmioFOURCC('s', 'i', 'p', 'r');
1992 }
1993 else
1994 {
1995 mp_msg (MSGT_DEMUX, MSGL_WARN, MSGTR_MPDEMUX_MKV_UnknownAudioCodec,
1996 track->codec_id, track->tnum);
1997 free_sh_audio(demuxer, track->tnum);
1998 return 1;
1999 }
2000 }
2001
2002 sh_a->format = track->a_formattag;
2003 sh_a->wf->wFormatTag = track->a_formattag;
2004 sh_a->channels = track->a_channels;
2005 sh_a->wf->nChannels = track->a_channels;
2006 sh_a->samplerate = (uint32_t) track->a_sfreq;
2007 sh_a->wf->nSamplesPerSec = (uint32_t) track->a_sfreq;
2008 if (track->a_bps == 0)
2009 {
2010 sh_a->samplesize = 2;
2011 sh_a->wf->wBitsPerSample = 16;
2012 }
2013 else
2014 {
2015 sh_a->samplesize = track->a_bps / 8;
2016 sh_a->wf->wBitsPerSample = track->a_bps;
2017 }
2018 if (track->a_formattag == 0x0055) /* MP3 || MP2 */
2019 {
2020 sh_a->wf->nAvgBytesPerSec = 16000;
2021 sh_a->wf->nBlockAlign = 1152;
2022 }
2023 else if ((track->a_formattag == 0x2000) || /* AC3 */
2024 (track->a_formattag == 0x2001)) /* DTS */
2025 {
2026 free(sh_a->wf);
2027 sh_a->wf = NULL;
2028 }
2029 else if (track->a_formattag == 0x0001) /* PCM || PCM_BE */
2030 {
2031 sh_a->wf->nAvgBytesPerSec = sh_a->channels * sh_a->samplerate*2;
2032 sh_a->wf->nBlockAlign = sh_a->wf->nAvgBytesPerSec;
2033 if (!strcmp(track->codec_id, MKV_A_PCM_BE))
2034 sh_a->format = mmioFOURCC('t', 'w', 'o', 's');
2035 }
2036 else if (!strcmp(track->codec_id, MKV_A_QDMC) ||
2037 !strcmp(track->codec_id, MKV_A_QDMC2))
2038 {
2039 sh_a->wf->nAvgBytesPerSec = 16000;
2040 sh_a->wf->nBlockAlign = 1486;
2041 track->fix_i_bps = 1;
2042 track->qt_last_a_pts = 0.0;
2043 if (track->private_data != NULL)
2044 {
2045 sh_a->codecdata=malloc(track->private_size);
2046 memcpy (sh_a->codecdata, track->private_data,
2047 track->private_size);
2048 sh_a->codecdata_len = track->private_size;
2049 }
2050 }
2051 else if (track->a_formattag == mmioFOURCC('M', 'P', '4', 'A'))
2052 {
2053 int profile, srate_idx;
2054
2055 sh_a->wf->nAvgBytesPerSec = 16000;
2056 sh_a->wf->nBlockAlign = 1024;
2057
2058 if (!strcmp (track->codec_id, MKV_A_AAC) &&
2059 (NULL != track->private_data))
2060 {
2061 sh_a->codecdata=malloc(track->private_size);
2062 memcpy (sh_a->codecdata, track->private_data,
2063 track->private_size);
2064 sh_a->codecdata_len = track->private_size;
2065 return 0;
2066 }
2067
2068 /* Recreate the 'private data' */
2069 /* which faad2 uses in its initialization */
2070 srate_idx = aac_get_sample_rate_index (sh_a->samplerate);
2071 if (!strncmp (&track->codec_id[12], "MAIN", 4))
2072 profile = 0;
2073 else if (!strncmp (&track->codec_id[12], "LC", 2))
2074 profile = 1;
2075 else if (!strncmp (&track->codec_id[12], "SSR", 3))
2076 profile = 2;
2077 else
2078 profile = 3;
2079 sh_a->codecdata = malloc (5);
2080 sh_a->codecdata[0] = ((profile+1) << 3) | ((srate_idx&0xE) >> 1);
2081 sh_a->codecdata[1] = ((srate_idx&0x1)<<7)|(track->a_channels<<3);
2082
2083 if (strstr(track->codec_id, "SBR") != NULL)
2084 {
2085 /* HE-AAC (aka SBR AAC) */
2086 sh_a->codecdata_len = 5;
2087
2088 sh_a->samplerate *= 2;
2089 sh_a->wf->nSamplesPerSec *= 2;
2090 srate_idx = aac_get_sample_rate_index(sh_a->samplerate);
2091 sh_a->codecdata[2] = AAC_SYNC_EXTENSION_TYPE >> 3;
2092 sh_a->codecdata[3] = ((AAC_SYNC_EXTENSION_TYPE&0x07)<<5) | 5;
2093 sh_a->codecdata[4] = (1 << 7) | (srate_idx << 3);
2094 track->default_duration = 1024.0 / (sh_a->samplerate / 2);
2095 }
2096 else
2097 {
2098 sh_a->codecdata_len = 2;
2099 track->default_duration = 1024.0 / (float)sh_a->samplerate;
2100 }
2101 }
2102 else if (track->a_formattag == mmioFOURCC('v', 'r', 'b', 's')) /* VORBIS */
2103 {
2104 sh_a->wf->cbSize = track->private_size;
2105 sh_a->wf = realloc(sh_a->wf, sizeof(WAVEFORMATEX) + sh_a->wf->cbSize);
2106 memcpy((unsigned char *) (sh_a->wf+1), track->private_data, sh_a->wf->cbSize);
2107 }
2108 else if (track->private_size >= RAPROPERTIES4_SIZE
2109 && !strncmp (track->codec_id, MKV_A_REALATRC, 7))
2110 {
2111 /* Common initialization for all RealAudio codecs */
2112 unsigned char *src = track->private_data;
2113 int codecdata_length, version;
2114 int flavor;
2115
2116 sh_a->wf->nAvgBytesPerSec = 0; /* FIXME !? */
2117
2118 version = AV_RB16(src + 4);
2119 flavor = AV_RB16(src + 22);
2120 track->coded_framesize = AV_RB32(src + 24);
2121 track->sub_packet_h = AV_RB16(src + 40);
2122 sh_a->wf->nBlockAlign =
2123 track->audiopk_size = AV_RB16(src + 42);
2124 track->sub_packet_size = AV_RB16(src + 44);
2125 if (version == 4)
2126 {
2127 src += RAPROPERTIES4_SIZE;
2128 src += src[0] + 1;
2129 src += src[0] + 1;
2130 }
2131 else
2132 src += RAPROPERTIES5_SIZE;
2133
2134 src += 3;
2135 if (version == 5)
2136 src++;
2137 codecdata_length = AV_RB32(src);
2138 src += 4;
2139 sh_a->wf->cbSize = codecdata_length;
2140 sh_a->wf = realloc (sh_a->wf,
2141 sizeof (WAVEFORMATEX) +
2142 sh_a->wf->cbSize);
2143 memcpy(((char *)(sh_a->wf + 1)), src, codecdata_length);
2144
2145 switch (track->a_formattag) {
2146 case mmioFOURCC('a', 't', 'r', 'c'):
2147 sh_a->wf->nAvgBytesPerSec = atrc_fl2bps[flavor];
2148 sh_a->wf->nBlockAlign = track->sub_packet_size;
2149 track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
2150 track->audio_timestamp = malloc(track->sub_packet_h * sizeof(float));
2151 break;
2152 case mmioFOURCC('c', 'o', 'o', 'k'):
2153 sh_a->wf->nAvgBytesPerSec = cook_fl2bps[flavor];
2154 sh_a->wf->nBlockAlign = track->sub_packet_size;
2155 track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
2156 track->audio_timestamp = malloc(track->sub_packet_h * sizeof(float));
2157 break;
2158 case mmioFOURCC('s', 'i', 'p', 'r'):
2159 sh_a->wf->nAvgBytesPerSec = sipr_fl2bps[flavor];
2160 sh_a->wf->nBlockAlign = track->coded_framesize;
2161 track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
2162 track->audio_timestamp = malloc(track->sub_packet_h * sizeof(float));
2163 break;
2164 case mmioFOURCC('2', '8', '_', '8'):
2165 sh_a->wf->nAvgBytesPerSec = 3600;
2166 sh_a->wf->nBlockAlign = track->coded_framesize;
2167 track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
2168 track->audio_timestamp = malloc(track->sub_packet_h * sizeof(float));
2169 break;
2170 }
2171
2172 track->realmedia = 1;
2173 }
2174 else if (!strcmp(track->codec_id, MKV_A_FLAC) ||
2175 (track->a_formattag == 0xf1ac))
2176 {
2177 unsigned char *ptr;
2178 int size;
2179 free(sh_a->wf);
2180 sh_a->wf = NULL;
2181
2182 if (track->a_formattag == mmioFOURCC('f', 'L', 'a', 'C'))
2183 {
2184 ptr = (unsigned char *)track->private_data;
2185 size = track->private_size;
2186 }
2187 else
2188 {
2189 sh_a->format = mmioFOURCC('f', 'L', 'a', 'C');
2190 ptr = (unsigned char *) track->private_data
2191 + sizeof (WAVEFORMATEX);
2192 size = track->private_size - sizeof (WAVEFORMATEX);
2193 }
2194 if (size < 4 || ptr[0] != 'f' || ptr[1] != 'L' ||
2195 ptr[2] != 'a' || ptr[3] != 'C')
2196 {
2197 dp = new_demux_packet (4);
2198 memcpy (dp->buffer, "fLaC", 4);
2199 }
2200 else
2201 {
2202 dp = new_demux_packet (size);
2203 memcpy (dp->buffer, ptr, size);
2204 }
2205 dp->pts = 0;
2206 dp->flags = 0;
2207 ds_add_packet (demuxer->audio, dp);
2208 }
2209 else if (!track->ms_compat || (track->private_size < sizeof(WAVEFORMATEX)))
2210 {
2211 free_sh_audio(demuxer, track->tnum);
2212 return 1;
2213 }
2214
2215 return 0;
2216 }
2217
2218 /** \brief Parse the private data for VobSub subtitle tracks.
2219
2220 This function tries to parse the private data for all VobSub tracks.
2221 The private data contains the normal text from the original .idx file.
2222 Things like the palette, subtitle dimensions and custom colors are
2223 stored here.
2224
2225 \param demuxer The generic demuxer.
2226 */
2227 static void
2228 demux_mkv_parse_vobsub_data (demuxer_t *demuxer)
2229 {
2230 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2231 mkv_track_t *track;
2232 int i, m, size;
2233 uint8_t *buffer;
2234
2235 for (i = 0; i < mkv_d->num_tracks; i++)
2236 {
2237 track = mkv_d->tracks[i];
2238 if ((track->type != MATROSKA_TRACK_SUBTITLE) ||
2239 (track->subtitle_type != MATROSKA_SUBTYPE_VOBSUB))
2240 continue;
2241
2242 size = track->private_size;
2243 m = demux_mkv_decode (track,track->private_data,&buffer,&size,2);
2244 if (buffer && m)
2245 {
2246 free (track->private_data);
2247 track->private_data = buffer;
2248 track->private_size = size;
2249 }
2250 if (!demux_mkv_parse_idx (track))
2251 {
2252 free (track->private_data);
2253 track->private_data = NULL;
2254 track->private_size = 0;
2255 }
2256 }
2257 }
2258
2259 /** \brief Parse the private data for SSA/ASS subtitle tracks.
2260
2261 This function tries to parse the private data for all SSA/ASS tracks.
2262 The private data contains the normal text from the original script,
2263 from the start to the beginning of 'Events' section, including '[Events]' line.
2264
2265 \param demuxer The generic demuxer.
2266 */
2267 #ifdef USE_ASS
2268 static void
2269 demux_mkv_parse_ass_data (demuxer_t *demuxer)
2270 {
2271 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2272 mkv_track_t *track;
2273 int i, m, size;
2274 uint8_t *buffer;
2275
2276 for (i = 0; i < mkv_d->num_tracks; i++)
2277 {
2278 track = mkv_d->tracks[i];
2279 if (track->type != MATROSKA_TRACK_SUBTITLE ||
2280 track->subtitle_type == MATROSKA_SUBTYPE_VOBSUB)
2281 continue;
2282
2283 if (track->subtitle_type == MATROSKA_SUBTYPE_SSA)
2284 {
2285 track->sh_sub->ass_track = ass_new_track(ass_library);
2286 size = track->private_size;
2287 m = demux_mkv_decode (track,track->private_data,&buffer,&size,2);
2288 if (buffer && m)
2289 {
2290 free (track->private_data);
2291 track->private_data = buffer;
2292 track->private_size = size;
2293 }
2294 ass_process_codec_private(track->sh_sub->ass_track, track->private_data, track->private_size);
2295 }
2296 }
2297 }
2298 #endif
2299
2300 static int
2301 demux_mkv_open_sub (demuxer_t *demuxer, mkv_track_t *track, int sid)
2302 {
2303 if (track->subtitle_type != MATROSKA_SUBTYPE_UNKNOWN)
2304 {
2305 sh_sub_t *sh = new_sh_sub_sid(demuxer, track->tnum, sid);
2306 track->sh_sub = sh;
2307 sh->type = 't';
2308 if (track->subtitle_type == MATROSKA_SUBTYPE_VOBSUB)
2309 sh->type = 'v';
2310 if (track->subtitle_type == MATROSKA_SUBTYPE_SSA)
2311 sh->type = 'a';
2312 }
2313 else
2314 {
2315 mp_msg (MSGT_DEMUX, MSGL_ERR, MSGTR_MPDEMUX_MKV_SubtitleTypeNotSupported,
2316 track->codec_id);
2317 return 1;
2318 }
2319
2320 return 0;
2321 }
2322
2323 static void demux_mkv_seek (demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags);
2324
2325 /** \brief Given a matroska track number and type, find the id that mplayer would ask for.
2326 * \param d The demuxer for which the subtitle id should be returned.
2327 * \param num The matroska track number we are looking up.
2328 * \param type The track type.
2329 */
2330 static int demux_mkv_reverse_id(mkv_demuxer_t *d, int num, int type)
2331 {
2332 int i, id;
2333
2334 for (i=0, id=0; i < d->num_tracks; i++)
2335 if (d->tracks[i] != NULL && d->tracks[i]->type == type) {
2336 if (d->tracks[i]->tnum == num)
2337 return id;
2338 id++;
2339 }
2340
2341 return -1;
2342 }
2343
2344 static int
2345 demux_mkv_open (demuxer_t *demuxer)
2346 {
2347 stream_t *s = demuxer->stream;
2348 mkv_demuxer_t *mkv_d;
2349 mkv_track_t *track;
2350 int i, version, cont = 0;
2351 char *str;
2352
2353 stream_seek(s, s->start_pos);
2354 str = ebml_read_header (s, &version);
2355 if (str == NULL || strcmp (str, "matroska") || version > 2)
2356 {
2357 mp_msg (MSGT_DEMUX, MSGL_DBG2, "[mkv] no head found\n");
2358 return 0;
2359 }
2360 free (str);
2361
2362 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] Found the head...\n");
2363
2364 if (ebml_read_id (s, NULL) != MATROSKA_ID_SEGMENT)
2365 {
2366 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] but no segment :(\n");
2367 return 0;
2368 }
2369 ebml_read_length (s, NULL); /* return bytes number until EOF */
2370
2371 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] + a segment...\n");
2372
2373 mkv_d = calloc (1, sizeof (mkv_demuxer_t));
2374 demuxer->priv = mkv_d;
2375 mkv_d->tc_scale = 1000000;
2376 mkv_d->segment_start = stream_tell (s);
2377 mkv_d->parsed_cues = malloc (sizeof (off_t));
2378 mkv_d->parsed_seekhead = malloc (sizeof (off_t));
2379
2380 while (!cont)
2381 {
2382 switch (ebml_read_id (s, NULL))
2383 {
2384 case MATROSKA_ID_INFO:
2385 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] |+ segment information...\n");
2386 cont = demux_mkv_read_info (demuxer);
2387 break;
2388
2389 case MATROSKA_ID_TRACKS:
2390 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] |+ segment tracks...\n");
2391 cont = demux_mkv_read_tracks (demuxer);
2392 break;
2393
2394 case MATROSKA_ID_CUES:
2395 cont = demux_mkv_read_cues (demuxer);
2396 break;
2397
2398 case MATROSKA_ID_TAGS:
2399 cont = demux_mkv_read_tags (demuxer);
2400 break;
2401
2402 case MATROSKA_ID_SEEKHEAD:
2403 cont = demux_mkv_read_seekhead (demuxer);
2404 break;
2405
2406 case MATROSKA_ID_CHAPTERS:
2407 cont = demux_mkv_read_chapters (demuxer);
2408 break;
2409
2410 case MATROSKA_ID_ATTACHMENTS:
2411 cont = demux_mkv_read_attachments (demuxer);
2412 break;
2413
2414 case MATROSKA_ID_CLUSTER:
2415 {
2416 int p, l;
2417 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] |+ found cluster, headers are "
2418 "parsed completely :)\n");
2419 /* get the first cluster timecode */
2420 p = stream_tell(s);
2421 l = ebml_read_length (s, NULL);
2422 while (ebml_read_id (s, NULL) != MATROSKA_ID_CLUSTERTIMECODE)
2423 {
2424 ebml_read_skip (s, NULL);
2425 if (stream_tell (s) >= p + l)
2426 break;
2427 }
2428 if (stream_tell (s) < p + l)
2429 {
2430 uint64_t num = ebml_read_uint (s, NULL);
2431 if (num == EBML_UINT_INVALID)
2432 return 0;
2433 mkv_d->first_tc = num * mkv_d->tc_scale / 1000000.0;
2434 mkv_d->has_first_tc = 1;
2435 }
2436 stream_seek (s, p - 4);
2437 cont = 1;
2438 break;
2439 }
2440
2441 default:
2442 cont = 1;
2443 case EBML_ID_VOID:
2444 ebml_read_skip (s, NULL);
2445 break;
2446 }
2447 }
2448
2449 display_create_tracks (demuxer);
2450
2451 /* select video track */
2452 track = NULL;
2453 if (demuxer->video->id == -1) /* automatically select a video track */
2454 {
2455 /* search for a video track that has the 'default' flag set */
2456 for (i=0; i<mkv_d->num_tracks; i++)
2457 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO
2458 && mkv_d->tracks[i]->default_track)
2459 {
2460 track = mkv_d->tracks[i];
2461 break;
2462 }
2463
2464 if (track == NULL)
2465 /* no track has the 'default' flag set */
2466 /* let's take the first video track */
2467 for (i=0; i<mkv_d->num_tracks; i++)
2468 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO)
2469 {
2470 track = mkv_d->tracks[i];
2471 break;
2472 }
2473 }
2474 else if (demuxer->video->id != -2) /* -2 = no video at all */
2475 track = demux_mkv_find_track_by_num (mkv_d, demuxer->video->id,
2476 MATROSKA_TRACK_VIDEO);
2477
2478 if (track && demuxer->v_streams[track->tnum])
2479 {
2480 mp_msg (MSGT_DEMUX, MSGL_INFO,
2481 MSGTR_MPDEMUX_MKV_WillPlayVideoTrack, track->tnum);
2482 demuxer->video->id = track->tnum;
2483 demuxer->video->sh = demuxer->v_streams[track->tnum];
2484 }
2485 else
2486 {
2487 mp_msg (MSGT_DEMUX, MSGL_INFO, MSGTR_MPDEMUX_MKV_NoVideoTrackFound);
2488 demuxer->video->id = -2;
2489 }
2490
2491 /* select audio track */
2492 track = NULL;
2493 if (demuxer->audio->id == -1) /* automatically select an audio track */
2494 {
2495 /* check if the user specified an audio language */
2496 if (audio_lang != NULL)
2497 track = demux_mkv_find_track_by_language(mkv_d, audio_lang,
2498 MATROSKA_TRACK_AUDIO);
2499 if (track == NULL)
2500 /* no audio language specified, or language not found */
2501 /* search for an audio track that has the 'default' flag set */
2502 for (i=0; i < mkv_d->num_tracks; i++)
2503 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO
2504 && mkv_d->tracks[i]->default_track)
2505 {
2506 track = mkv_d->tracks[i];
2507 break;
2508 }
2509
2510 if (track == NULL)
2511 /* no track has the 'default' flag set */
2512 /* let's take the first audio track */
2513 for (i=0; i < mkv_d->num_tracks; i++)
2514 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO)
2515 {
2516 track = mkv_d->tracks[i];
2517 break;
2518 }
2519 }
2520 else if (demuxer->audio->id != -2) /* -2 = no audio at all */
2521 track = demux_mkv_find_track_by_num (mkv_d, demuxer->audio->id,
2522 MATROSKA_TRACK_AUDIO);
2523 else
2524 {
2525 mp_msg (MSGT_DEMUX, MSGL_INFO, MSGTR_MPDEMUX_MKV_NoAudioTrackFound);
2526 demuxer->audio->id = -2;
2527 }
2528
2529
2530 if(demuxer->audio->id != -2)
2531 for (i=0; i < mkv_d->num_tracks; i++)
2532 {
2533 if(mkv_d->tracks[i]->type != MATROSKA_TRACK_AUDIO)
2534 continue;
2535 if(demuxer->a_streams[track->tnum])
2536 {
2537 if(track && mkv_d->tracks[i] == track)
2538 {
2539 demuxer->audio->id = track->tnum;
2540 demuxer->audio->sh = demuxer->a_streams[track->tnum];
2541 }
2542 mkv_d->last_aid++;
2543 if(mkv_d->last_aid == MAX_A_STREAMS)
2544 break;
2545 }
2546 }
2547
2548 demux_mkv_parse_vobsub_data (demuxer);
2549 #ifdef USE_ASS
2550 if (ass_enabled)
2551 demux_mkv_parse_ass_data (demuxer);
2552 #endif
2553 /* DO NOT automatically select a subtitle track and behave like DVD */
2554 /* playback: only show subtitles if the user explicitely wants them. */
2555 track = NULL;
2556 if (demuxer->sub->id >= 0)
2557 track = demux_mkv_find_track_by_num (mkv_d, demuxer->sub->id,
2558 MATROSKA_TRACK_SUBTITLE);
2559 else if (dvdsub_lang != NULL)
2560 track = demux_mkv_find_track_by_language (mkv_d, dvdsub_lang,
2561 MATROSKA_TRACK_SUBTITLE);
2562
2563 if (track)
2564 {
2565 mp_msg (MSGT_DEMUX, MSGL_INFO,
2566 MSGTR_MPDEMUX_MKV_WillDisplaySubtitleTrack, track->tnum);
2567 dvdsub_id = demux_mkv_reverse_id(mkv_d, track->tnum, MATROSKA_TRACK_SUBTITLE);
2568 demuxer->sub->id = track->tnum;
2569 demuxer->sub->sh = demuxer->s_streams[track->tnum];
2570 }
2571 else
2572 demuxer->sub->id = -2;
2573
2574 if (demuxer->chapters)
2575 {
2576 for (i=0; i < (int)demuxer->num_chapters; i++)
2577 {
2578 demuxer->chapters[i].start -= mkv_d->first_tc;
2579 demuxer->chapters[i].end -= mkv_d->first_tc;
2580 }
2581 if (dvd_last_chapter > 0 && dvd_last_chapter <= demuxer->num_chapters)
2582 {
2583 if (demuxer->chapters[dvd_last_chapter-1].end != 0)
2584 mkv_d->stop_timecode = demuxer->chapters[dvd_last_chapter-1].end;
2585 else if (dvd_last_chapter + 1 <= demuxer->num_chapters)
2586 mkv_d->stop_timecode = demuxer->chapters[dvd_last_chapter].start;
2587 }
2588 }
2589
2590 if (s->end_pos == 0 || (mkv_d->indexes == NULL && index_mode < 0))
2591 demuxer->seekable = 0;
2592 else
2593 {
2594 demuxer->movi_start = s->start_pos;
2595 demuxer->movi_end = s->end_pos;
2596 demuxer->seekable = 1;
2597 if (demuxer->chapters && dvd_chapter>1 && dvd_chapter<=demuxer->num_chapters)
2598 {
2599 if (!mkv_d->has_first_tc)
2600 {
2601 mkv_d->first_tc = 0;
2602 mkv_d->has_first_tc = 1;
2603 }
2604 demux_mkv_seek (demuxer,
2605 demuxer->chapters[dvd_chapter-1].start/1000.0, 0.0, 1);
2606 }
2607 }
2608
2609 return DEMUXER_TYPE_MATROSKA;
2610 }
2611
2612 static void
2613 demux_close_mkv (demuxer_t *demuxer)
2614 {
2615 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2616
2617 if (mkv_d)
2618 {
2619 int i;
2620 free_cached_dps (demuxer);
2621 if (mkv_d->tracks)
2622 {
2623 for (i=0; i<mkv_d->num_tracks; i++)
2624 demux_mkv_free_trackentry(mkv_d->tracks[i]);
2625 free (mkv_d->tracks);
2626 }
2627 if (mkv_d->indexes)
2628 free (mkv_d->indexes);
2629 if (mkv_d->cluster_positions)
2630 free (mkv_d->cluster_positions);
2631 if (mkv_d->parsed_cues)
2632 free (mkv_d->parsed_cues);
2633 if (mkv_d->parsed_seekhead)
2634 free (mkv_d->parsed_seekhead);
2635 if (mkv_d->attachments) {
2636 for (i = 0; i < mkv_d->num_attachments; ++i) {
2637 if (mkv_d->attachments[i].name)
2638 free (mkv_d->attachments[i].name);
2639 if (mkv_d->attachments[i].mime)
2640 free (mkv_d->attachments[i].mime);
2641 if (mkv_d->attachments[i].data)
2642 free (mkv_d->attachments[i].data);
2643 }
2644 free (mkv_d->attachments);
2645 }
2646 free (mkv_d);
2647 }
2648 }
2649
2650 static int
2651 demux_mkv_read_block_lacing (uint8_t *buffer, uint64_t *size,
2652 uint8_t *laces, uint32_t **all_lace_sizes)
2653 {
2654 uint32_t total = 0, *lace_size;
2655 uint8_t flags;
2656 int i;
2657
2658 *all_lace_sizes = NULL;
2659 lace_size = NULL;
2660 /* lacing flags */
2661 flags = *buffer++;
2662 (*size)--;
2663
2664 switch ((flags & 0x06) >> 1)
2665 {
2666 case 0: /* no lacing */
2667 *laces = 1;
2668 lace_size = calloc(*laces, sizeof(uint32_t));
2669 lace_size[0] = *size;
2670 break;
2671
2672 case 1: /* xiph lacing */
2673 case 2: /* fixed-size lacing */
2674 case 3: /* EBML lacing */
2675 *laces = *buffer++;
2676 (*size)--;
2677 (*laces)++;
2678 lace_size = calloc(*laces, sizeof(uint32_t));
2679
2680 switch ((flags & 0x06) >> 1)
2681 {
2682 case 1: /* xiph lacing */
2683 for (i=0; i < *laces-1; i++)
2684 {
2685 lace_size[i] = 0;
2686 do
2687 {
2688 lace_size[i] += *buffer;
2689 (*size)--;
2690 } while (*buffer++ == 0xFF);
2691 total += lace_size[i];
2692 }
2693 lace_size[i] = *size - total;
2694 break;
2695
2696 case 2: /* fixed-size lacing */
2697 for (i=0; i < *laces; i++)
2698 lace_size[i] = *size / *laces;
2699 break;
2700
2701 case 3: /* EBML lacing */
2702 {
2703 int l;
2704 uint64_t num = ebml_read_vlen_uint (buffer, &l);
2705 if (num == EBML_UINT_INVALID) {
2706 free(lace_size);
2707 return 1;
2708 }
2709 buffer += l;
2710 *size -= l;
2711
2712 total = lace_size[0] = num;
2713 for (i=1; i < *laces-1; i++)
2714 {
2715 int64_t snum;
2716 snum = ebml_read_vlen_int (buffer, &l);
2717 if (snum == EBML_INT_INVALID) {
2718 free(lace_size);
2719 return 1;
2720 }
2721 buffer += l;
2722 *size -= l;
2723 lace_size[i] = lace_size[i-1] + snum;
2724 total += lace_size[i];
2725 }
2726 lace_size[i] = *size - total;
2727 break;
2728 }
2729 }
2730 break;
2731 }
2732 *all_lace_sizes = lace_size;
2733 return 0;
2734 }
2735
2736 static void
2737 handle_subtitles(demuxer_t *demuxer, mkv_track_t *track, char *block,
2738 int64_t size, uint64_t block_duration, uint64_t timecode)
2739 {
2740 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2741 demux_packet_t *dp;
2742 char *ptr1;
2743 int i;
2744
2745 if (block_duration == 0)
2746 {
2747 mp_msg (MSGT_DEMUX, MSGL_WARN,
2748 MSGTR_MPDEMUX_MKV_NoBlockDurationForSubtitleTrackFound);
2749 return;
2750 }
2751
2752 #ifdef USE_ASS
2753 if (ass_enabled && track->subtitle_type == MATROSKA_SUBTYPE_SSA) {
2754 ass_process_chunk(track->sh_sub->ass_track, block, size, (long long)timecode, (long long)block_duration);
2755 return;
2756 }
2757 #endif
2758
2759 ptr1 = block;
2760 if (track->subtitle_type == MATROSKA_SUBTYPE_SSA)
2761 {
2762 /* Find text section. */
2763 for (i=0; i < 8 && *ptr1 != '\0'; ptr1++)
2764 if (*ptr1 == ',')
2765 i++;
2766 if (*ptr1 == '\0') /* Broken line? */
2767 return;
2768 }
2769
2770 sub_utf8 = 1;
2771 size -= ptr1 - block;
2772 dp = new_demux_packet(size);
2773 memcpy(dp->buffer, ptr1, size);
2774 dp->pts = timecode / 1000.0f;
2775 dp->endpts = (timecode + block_duration) / 1000.0f;
2776 ds_add_packet(demuxer->sub, dp);
2777 }
2778
2779 // Taken from demux_real.c. Thanks to the original developpers :)
2780 #define SKIP_BITS(n) buffer <<= n
2781 #define SHOW_BITS(n) ((buffer) >> (32 - (n)))
2782
2783 static float real_fix_timestamp(mkv_track_t *track, unsigned char *s,
2784 int timestamp) {
2785 float v_pts;
2786 uint32_t buffer = (s[0] << 24) + (s[1] << 16) + (s[2] << 8) + s[3];
2787 int kf = timestamp;
2788 int pict_type;
2789 int orig_kf;
2790
2791 if (!strcmp(track->codec_id, MKV_V_REALV30) ||
2792 !strcmp(track->codec_id, MKV_V_REALV40)) {
2793
2794 if (!strcmp(track->codec_id, MKV_V_REALV30)) {
2795 SKIP_BITS(3);
2796 pict_type = SHOW_BITS(2);
2797 SKIP_BITS(2 + 7);
2798 }else{
2799 SKIP_BITS(1);
2800 pict_type = SHOW_BITS(2);
2801 SKIP_BITS(2 + 7 + 3);
2802 }
2803 kf = SHOW_BITS(13); // kf= 2*SHOW_BITS(12);
2804 orig_kf = kf;
2805 if (pict_type <= 1) {
2806 // I frame, sync timestamps:
2807 track->rv_kf_base = timestamp - kf;
2808 mp_msg(MSGT_DEMUX, MSGL_DBG2, "\nTS: base=%08X\n", track->rv_kf_base);
2809 kf = timestamp;
2810 } else {
2811 // P/B frame, merge timestamps:
2812 int tmp = timestamp - track->rv_kf_base;
2813 kf |= tmp & (~0x1fff); // combine with packet timestamp
2814 if (kf < (tmp - 4096)) // workaround wrap-around problems
2815 kf += 8192;
2816 else if (kf > (tmp + 4096))
2817 kf -= 8192;
2818 kf += track->rv_kf_base;
2819 }
2820 if (pict_type != 3) { // P || I frame -> swap timestamps
2821 int tmp = kf;
2822 kf = track->rv_kf_pts;
2823 track->rv_kf_pts = tmp;
2824 }
2825 mp_msg(MSGT_DEMUX, MSGL_DBG2, "\nTS: %08X -> %08X (%04X) %d %02X %02X %02X "
2826 "%02X %5d\n", timestamp, kf, orig_kf, pict_type, s[0], s[1], s[2],
2827 s[3], kf - (int)(1000.0 * track->rv_pts));
2828 }
2829 v_pts = kf * 0.001f;
2830 track->rv_pts = v_pts;
2831
2832 return v_pts;
2833 }
2834
2835 static void
2836 handle_realvideo (demuxer_t *demuxer, mkv_track_t *track, uint8_t *buffer,
2837 uint32_t size, int block_bref)
2838 {
2839 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2840 demux_packet_t *dp;
2841 uint32_t timestamp = mkv_d->last_pts * 1000;
2842 uint32_t *hdr;
2843 uint8_t chunks;
2844 int isize;
2845 #ifdef WORDS_BIGENDIAN
2846 uint8_t *p;
2847 int i;
2848 #endif
2849
2850 chunks = *buffer++;
2851 isize = --size - (chunks+1)*8;
2852 dp = new_demux_packet (REALHEADER_SIZE + size);
2853 memcpy (dp->buffer + REALHEADER_SIZE, buffer + (chunks+1)*8, isize);
2854 #ifdef WORDS_BIGENDIAN
2855 p = (uint8_t *)(dp->buffer + REALHEADER_SIZE + isize);
2856 for (i = 0; i<(chunks+1)*8; i+=4) {
2857 p[i] = *((uint8_t *)buffer+i+3);
2858 p[i+1] = *((uint8_t *)buffer+i+2);
2859 p[i+2] = *((uint8_t *)buffer+i+1);
2860 p[i+3] = *((uint8_t *)buffer+i);
2861 }
2862 #else
2863 memcpy (dp->buffer + REALHEADER_SIZE + isize, buffer, (chunks+1)*8);
2864 #endif
2865
2866 hdr = dp->buffer;
2867 *hdr++ = chunks; // number of chunks
2868 *hdr++ = timestamp; // timestamp from packet header
2869 *hdr++ = isize; // length of actual data
2870 *hdr++ = REALHEADER_SIZE + isize; // offset to chunk offset array
2871
2872 if (mkv_d->v_skip_to_keyframe)
2873 {
2874 dp->pts = mkv_d->last_pts;
2875 track->rv_kf_base = 0;
2876 track->rv_kf_pts = timestamp;
2877 }
2878 else
2879 dp->pts = real_fix_timestamp (track, dp->buffer + REALHEADER_SIZE,
2880 timestamp);
2881 dp->pos = demuxer->filepos;
2882 dp->flags = block_bref ? 0 : 0x10;
2883
2884 ds_add_packet(demuxer->video, dp);
2885 }
2886
2887 static void
2888 handle_realaudio (demuxer_t *demuxer, mkv_track_t *track, uint8_t *buffer,
2889 uint32_t size, int block_bref)
2890 {
2891 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2892 int sps = track->sub_packet_size;
2893 int sph = track->sub_packet_h;
2894 int cfs = track->coded_framesize;
2895 int w = track->audiopk_size;
2896 int spc = track->sub_packet_cnt;
2897 demux_packet_t *dp;
2898 int x;
2899
2900 if ((track->a_formattag == mmioFOURCC('2', '8', '_', '8')) ||
2901 (track->a_formattag == mmioFOURCC('c', 'o', 'o', 'k')) ||
2902 (track->a_formattag == mmioFOURCC('a', 't', 'r', 'c')) ||
2903 (track->a_formattag == mmioFOURCC('s', 'i', 'p', 'r')))
2904 {
2905 // if(!block_bref)
2906 // spc = track->sub_packet_cnt = 0;
2907 switch (track->a_formattag) {
2908 case mmioFOURCC('2', '8', '_', '8'):
2909 for (x = 0; x < sph / 2; x++)
2910 memcpy(track->audio_buf + x * 2 * w + spc * cfs, buffer + cfs * x, cfs);
2911 break;
2912 case mmioFOURCC('c', 'o', 'o', 'k'):
2913 case mmioFOURCC('a', 't', 'r', 'c'):
2914 for (x = 0; x < w / sps; x++)
2915 memcpy(track->audio_buf + sps * (sph * x + ((sph + 1) / 2) * (spc & 1) + (spc >> 1)), buffer + sps * x, sps);
2916 break;
2917 case mmioFOURCC('s', 'i', 'p', 'r'):
2918 memcpy(track->audio_buf + spc * w, buffer, w);
2919 if (spc == sph - 1)
2920 {
2921 int n;
2922 int bs = sph * w * 2 / 96; // nibbles per subpacket
2923 // Perform reordering
2924 for(n=0; n < 38; n++)
2925 {
2926 int j;
2927 int i = bs * sipr_swaps[n][0];
2928 int o = bs * sipr_swaps[n][1];
2929 // swap nibbles of block 'i' with 'o' TODO: optimize
2930 for(j = 0;j < bs; j++)
2931 {
2932 int x = (i & 1) ? (track->audio_buf[i >> 1] >> 4) : (track->audio_buf[i >> 1] & 0x0F);
2933 int y = (o & 1) ? (track->audio_buf[o >> 1] >> 4) : (track->audio_buf[o >> 1] & 0x0F);
2934 if(o & 1)
2935 track->audio_buf[o >> 1] = (track->audio_buf[o >> 1] & 0x0F) | (x << 4);
2936 else
2937 track->audio_buf[o >> 1] = (track->audio_buf[o >> 1] & 0xF0) | x;
2938 if(i & 1)
2939 track->audio_buf[i >> 1] = (track->audio_buf[i >> 1] & 0x0F) | (y << 4);
2940 else
2941 track->audio_buf[i >> 1] = (track->audio_buf[i >> 1] & 0xF0) | y;
2942 ++i; ++o;
2943 }
2944 }
2945 }
2946 break;
2947 }
2948 track->audio_timestamp[track->sub_packet_cnt] = (track->ra_pts == mkv_d->last_pts) ? 0 : (mkv_d->last_pts);
2949 track->ra_pts = mkv_d->last_pts;
2950 if (track->sub_packet_cnt == 0)
2951 track->audio_filepos = demuxer->filepos;
2952 if (++(track->sub_packet_cnt) == sph)
2953 {
2954 int apk_usize = ((WAVEFORMATEX*)((sh_audio_t*)demuxer->audio->sh)->wf)->nBlockAlign;
2955 track->sub_packet_cnt = 0;
2956 // Release all the audio packets
2957 for (x = 0; x < sph*w/apk_usize; x++)
2958 {
2959 dp = new_demux_packet(apk_usize);
2960 memcpy(dp->buffer, track->audio_buf + x * apk_usize, apk_usize);
2961 /* Put timestamp only on packets that correspond to original audio packets in file */
2962 dp->pts = (x * apk_usize % w) ? 0 : track->audio_timestamp[x * apk_usize / w];
2963 dp->pos = track->audio_filepos; // all equal
2964 dp->flags = x ? 0 : 0x10; // Mark first packet as keyframe
2965 ds_add_packet(demuxer->audio, dp);
2966 }
2967 }
2968 } else { // Not a codec that require reordering
2969 dp = new_demux_packet (size);
2970 memcpy(dp->buffer, buffer, size);
2971 if (track->ra_pts == mkv_d->last_pts && !mkv_d->a_skip_to_keyframe)
2972 dp->pts = 0;
2973 else
2974 dp->pts = mkv_d->last_pts;
2975 track->ra_pts = mkv_d->last_pts;
2976
2977 dp->pos = demuxer->filepos;
2978 dp->flags = block_bref ? 0 : 0x10;
2979 ds_add_packet (demuxer->audio, dp);
2980 }
2981 }
2982
2983 /** Reorder timecodes and add cached demux packets to the queues.
2984 *
2985 * Timecode reordering is needed if a video track contains B frames that
2986 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2987 * MPlayer doesn't like timestamps in display order. This function adjusts
2988 * the timestamp of cached frames (which are exactly one I/P frame followed
2989 * by one or more B frames) so that they are in coding order again.
2990 *
2991 * Example: The track with 25 FPS contains four frames with the timecodes
2992 * I at 0ms, P at 120ms, B at 40ms and B at 80ms. As soon as the next I
2993 * or P frame arrives these timecodes can be changed to I at 0ms, P at 40ms,
2994 * B at 80ms and B at 120ms.
2995 *
2996 * This works for simple H.264 B-frame pyramids, but not for arbitrary orders.
2997 *
2998 * \param demuxer The Matroska demuxer struct for this instance.
2999 * \param track The track structure whose cache should be handled.
3000 */
3001 static void
3002 flush_cached_dps (demuxer_t *demuxer, mkv_track_t *track)
3003 {
3004 int i, ok;
3005
3006 if (track->num_cached_dps == 0)
3007 return;
3008
3009 do {
3010 ok = 1;
3011 for (i = 1; i < track->num_cached_dps; i++)
3012 if (track->cached_dps[i - 1]->pts > track->cached_dps[i]->pts) {
3013 float tmp_pts = track->cached_dps[i - 1]->pts;
3014 track->cached_dps[i - 1]->pts = track->cached_dps[i]->pts;
3015 track->cached_dps[i]->pts = tmp_pts;
3016 ok = 0;
3017 }
3018 } while (!ok);
3019
3020 for (i = 0; i < track->num_cached_dps; i++)
3021 ds_add_packet (demuxer->video, track->cached_dps[i]);
3022 track->num_cached_dps = 0;
3023 }
3024
3025 /** Cache video frames if timecodes have to be reordered.
3026 *
3027 * Timecode reordering is needed if a video track contains B frames that
3028 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
3029 * This function takes in a Matroska block read from the file, allocates a
3030 * demux packet for it, fills in its values, allocates space for storing
3031 * pointers to the cached demux packets and adds the packet to it. If
3032 * the packet contains an I or a P frame then ::flush_cached_dps is called
3033 * in order to send the old cached frames downstream.
3034 *
3035 * \param demuxer The Matroska demuxer struct for this instance.
3036 * \param track The packet is meant for this track.
3037 * \param buffer The actual frame contents.
3038 * \param size The frame size in bytes.
3039 * \param block_bref A relative timecode (backward reference). If it is \c 0
3040 * then the frame is an I frame.
3041 * \param block_fref A relative timecode (forward reference). If it is \c 0
3042 * then the frame is either an I frame or a P frame depending on the value
3043 * of \a block_bref. Otherwise it's a B frame.
3044 */
3045 static void
3046 handle_video_bframes (demuxer_t *demuxer, mkv_track_t *track, uint8_t *buffer,
3047 uint32_t size, int block_bref, int block_fref)
3048 {
3049 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3050 demux_packet_t *dp;
3051
3052 dp = new_demux_packet (size);
3053 memcpy(dp->buffer, buffer, size);
3054 dp->pos = demuxer->filepos;
3055 dp->pts = mkv_d->last_pts;
3056 if ((track->num_cached_dps > 0) && (dp->pts < track->max_pts))
3057 block_fref = 1;
3058 if (block_fref == 0) /* I or P frame */
3059 flush_cached_dps (demuxer, track);
3060 if (block_bref != 0) /* I frame, don't cache it */
3061 dp->flags = 0x10;
3062 if ((track->num_cached_dps + 1) > track->num_allocated_dps)
3063 {
3064 track->cached_dps = (demux_packet_t **)
3065 realloc(track->cached_dps, (track->num_cached_dps + 10) *
3066 sizeof(demux_packet_t *));
3067 track->num_allocated_dps += 10;
3068 }
3069 track->cached_dps[track->num_cached_dps] = dp;
3070 track->num_cached_dps++;
3071 if (dp->pts > track->max_pts)
3072 track->max_pts = dp->pts;
3073 }
3074
3075 static int
3076 handle_block (demuxer_t *demuxer, uint8_t *block, uint64_t length,
3077 uint64_t block_duration, int64_t block_bref, int64_t block_fref, uint8_t simpleblock)
3078 {
3079 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3080 mkv_track_t *track = NULL;
3081 demux_stream_t *ds = NULL;
3082 uint64_t old_length;
3083 int64_t tc;
3084 uint32_t *lace_size;
3085 uint8_t laces, flags;
3086 int i, num, tmp, use_this_block = 1;
3087 float current_pts;
3088 int16_t time;
3089
3090 /* first byte(s): track num */
3091 num = ebml_read_vlen_uint (block, &tmp);
3092 block += tmp;
3093 /* time (relative to cluster time) */
3094 time = block[0] << 8 | block[1];
3095 block += 2;
3096 length -= tmp + 2;
3097 old_length = length;
3098 flags = block[0];
3099 if (demux_mkv_read_block_lacing (block, &length, &laces, &lace_size))
3100 return 0;
3101 block += old_length - length;
3102
3103 tc = ((time*mkv_d->tc_scale+mkv_d->cluster_tc) /1000000.0 - mkv_d->first_tc);
3104 if (tc < 0)
3105 tc = 0;
3106 if (mkv_d->stop_timecode > 0 && tc > mkv_d->stop_timecode) {
3107 free(lace_size);
3108 return -1;
3109 }
3110 current_pts = tc / 1000.0;
3111
3112 for (i=0; i<mkv_d->num_tracks; i++)
3113 if (mkv_d->tracks[i]->tnum == num) {
3114 track = mkv_d->tracks[i];
3115 break;
3116 }
3117 if (track == NULL)
3118 {
3119 free(lace_size);
3120 return 1;
3121 }
3122 if (num == demuxer->audio->id)
3123 {
3124 ds = demuxer->audio;
3125
3126 if (mkv_d->a_skip_to_keyframe)
3127 {
3128 if (simpleblock)
3129 {
3130 if (!(flags&0x80)) /*current frame isn't a keyframe*/
3131 use_this_block = 0;
3132 }
3133 else if (block_bref != 0)
3134 use_this_block = 0;
3135 }
3136 else if (mkv_d->v_skip_to_keyframe)
3137 use_this_block = 0;
3138
3139 if (track->fix_i_bps && use_this_block)
3140 {
3141 sh_audio_t *sh = (sh_audio_t *) ds->sh;
3142
3143 if (block_duration != 0)
3144 {
3145 sh->i_bps = length * 1000 / block_duration;
3146 track->fix_i_bps = 0;
3147 }
3148 else if (track->qt_last_a_pts == 0.0)
3149 track->qt_last_a_pts = current_pts;
3150 else if(track->qt_last_a_pts != current_pts)
3151 {
3152 sh->i_bps = length / (current_pts - track->qt_last_a_pts);
3153 track->fix_i_bps = 0;
3154 }
3155 }
3156 }
3157 else if (tc < mkv_d->skip_to_timecode)
3158 use_this_block = 0;
3159 else if (num == demuxer->video->id)
3160 {
3161 ds = demuxer->video;
3162 if (mkv_d->v_skip_to_keyframe)
3163 {
3164 if (simpleblock)
3165 {
3166 if (!(flags&0x80)) /*current frame isn't a keyframe*/
3167 use_this_block = 0;
3168 }
3169 else if (block_bref != 0 || block_fref != 0)
3170 use_this_block = 0;
3171 }
3172 }
3173 else if (num == demuxer->sub->id)
3174 {
3175 ds = demuxer->sub;
3176 if (track->subtitle_type != MATROSKA_SUBTYPE_VOBSUB)
3177 {
3178 if (!mkv_d->v_skip_to_keyframe)
3179 handle_subtitles (demuxer, track, block, length,
3180 block_duration, tc);
3181 use_this_block = 0;
3182 }
3183 }
3184 else
3185 use_this_block = 0;
3186
3187 if (use_this_block)
3188 {
3189 mkv_d->last_pts = current_pts;
3190 mkv_d->last_filepos = demuxer->filepos;
3191
3192 for (i=0; i < laces; i++)
3193 {
3194 if (ds == demuxer->video && track->realmedia)
3195 handle_realvideo (demuxer, track, block, lace_size[i], block_bref);
3196 else if (ds == demuxer->audio && track->realmedia)
3197 handle_realaudio (demuxer, track, block, lace_size[i], block_bref);
3198 else if (ds == demuxer->video && track->reorder_timecodes)
3199 handle_video_bframes (demuxer, track, block, lace_size[i],
3200 block_bref, block_fref);
3201 else
3202 {
3203 int modified, size = lace_size[i];
3204 demux_packet_t *dp;
3205 uint8_t *buffer;
3206 modified = demux_mkv_decode (track, block, &buffer, &size, 1);
3207 if (buffer)
3208 {
3209 dp = new_demux_packet (size);
3210 memcpy (dp->buffer, buffer, size);
3211 if (modified)
3212 free (buffer);
3213 dp->flags = (block_bref == 0 && block_fref == 0) ? 0x10 : 0;
3214 /* If default_duration is 0, assume no pts value is known
3215 * for packets after the first one (rather than all pts
3216 * values being the same) */
3217 if (i == 0 || track->default_duration)
3218 dp->pts = mkv_d->last_pts + i * track->default_duration;
3219 ds_add_packet (ds, dp);
3220 }
3221 }
3222 block += lace_size[i];
3223 }
3224
3225 if (ds == demuxer->video)
3226 {
3227 mkv_d->v_skip_to_keyframe = 0;
3228 mkv_d->skip_to_timecode = 0;
3229 }
3230 else if (ds == demuxer->audio)
3231 mkv_d->a_skip_to_keyframe = 0;
3232
3233 free(lace_size);
3234 return 1;
3235 }
3236
3237 free(lace_size);
3238 return 0;
3239 }
3240
3241 static int
3242 demux_mkv_fill_buffer (demuxer_t *demuxer, demux_stream_t *ds)
3243 {
3244 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3245 stream_t *s = demuxer->stream;
3246 uint64_t l;
3247 int il, tmp;
3248
3249 while (1)
3250 {
3251 while (mkv_d->cluster_size > 0)
3252 {
3253 uint64_t block_duration = 0, block_length = 0;
3254 int64_t block_bref = 0, block_fref = 0;
3255 uint8_t *block = NULL;
3256
3257 while (mkv_d->blockgroup_size > 0)
3258 {
3259 switch (ebml_read_id (s, &il))
3260 {
3261 case MATROSKA_ID_BLOCKDURATION:
3262 {
3263 block_duration = ebml_read_uint (s, &l);
3264 if (block_duration == EBML_UINT_INVALID) {
3265 free(block);
3266 return 0;
3267 }
3268 block_duration *= mkv_d->tc_scale / 1000000.0;
3269 break;
3270 }
3271
3272 case MATROSKA_ID_BLOCK:
3273 block_length = ebml_read_length (s, &tmp);
3274 free(block);
3275 if (block_length > SIZE_MAX - LZO_INPUT_PADDING) return 0;
3276 block = malloc (block_length + LZO_INPUT_PADDING);
3277 demuxer->filepos = stream_tell (s);
3278 if (stream_read (s,block,block_length) != (int) block_length)
3279 {
3280 free(block);
3281 return 0;
3282 }
3283 l = tmp + block_length;
3284 break;
3285
3286 case MATROSKA_ID_REFERENCEBLOCK:
3287 {
3288 int64_t num = ebml_read_int (s, &l);
3289 if (num == EBML_INT_INVALID) {
3290 free(block);
3291 return 0;
3292 }
3293 if (num <= 0)
3294 block_bref = num;
3295 else
3296 block_fref = num;
3297 break;
3298 }
3299
3300 case EBML_ID_INVALID:
3301 free(block);
3302 return 0;
3303
3304 default:
3305 ebml_read_skip (s, &l);
3306 break;
3307 }
3308 mkv_d->blockgroup_size -= l + il;
3309 mkv_d->cluster_size -= l + il;
3310 }
3311
3312 if (block)
3313 {
3314 int res = handle_block (demuxer, block, block_length,
3315 block_duration, block_bref, block_fref, 0);
3316 free (block);
3317 if (res < 0)
3318 return 0;
3319 if (res)
3320 return 1;
3321 }
3322
3323 if (mkv_d->cluster_size > 0)
3324 {
3325 switch (ebml_read_id (s, &il))
3326 {
3327 case MATROSKA_ID_CLUSTERTIMECODE:
3328 {
3329 uint64_t num = ebml_read_uint (s, &l);
3330 if (num == EBML_UINT_INVALID)
3331 return 0;
3332 if (!mkv_d->has_first_tc)
3333 {
3334 mkv_d->first_tc = num * mkv_d->tc_scale / 1000000.0;
3335 mkv_d->has_first_tc = 1;
3336 }
3337 mkv_d->cluster_tc = num * mkv_d->tc_scale;
3338 break;
3339 }
3340
3341 case MATROSKA_ID_BLOCKGROUP:
3342 mkv_d->blockgroup_size = ebml_read_length (s, &tmp);
3343 l = tmp;
3344 break;
3345
3346 case MATROSKA_ID_SIMPLEBLOCK:
3347 {
3348 int res;
3349 block_length = ebml_read_length (s, &tmp);
3350 block = malloc (block_length);
3351 demuxer->filepos = stream_tell (s);
3352 if (stream_read (s,block,block_length) != (int) block_length)
3353 {
3354 free(block);
3355 return 0;
3356 }
3357 l = tmp + block_length;
3358 res = handle_block (demuxer, block, block_length,
3359 block_duration, block_bref, block_fref, 1);
3360 free (block);
3361 mkv_d->cluster_size -= l + il;
3362 if (res < 0)
3363 return 0;
3364 else if (res)
3365 return 1;
3366 else mkv_d->cluster_size += l + il;
3367 break;
3368 }
3369 case EBML_ID_INVALID:
3370 return 0;
3371
3372 default:
3373 ebml_read_skip (s, &l);
3374 break;
3375 }
3376 mkv_d->cluster_size -= l + il;
3377 }
3378 }
3379
3380 if (ebml_read_id (s, &il) != MATROSKA_ID_CLUSTER)
3381 return 0;
3382 add_cluster_position(mkv_d, stream_tell(s)-il);
3383 mkv_d->cluster_size = ebml_read_length (s, NULL);
3384 }
3385
3386 return 0;
3387 }
3388
3389 static void
3390 demux_mkv_seek (demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags)
3391 {
3392 free_cached_dps (demuxer);
3393 if (!(flags & 2)) /* time in secs */
3394 {
3395 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3396 stream_t *s = demuxer->stream;
3397 int64_t target_timecode = 0, diff, min_diff=0xFFFFFFFFFFFFFFFLL;
3398 int i;
3399
3400 if (!(flags & 1)) /* relative seek */
3401 target_timecode = (int64_t) (mkv_d->last_pts * 1000.0);
3402 target_timecode += (int64_t)(rel_seek_secs * 1000.0);
3403 if (target_timecode < 0)
3404 target_timecode = 0;
3405
3406 if (mkv_d->indexes == NULL) /* no index was found */
3407 {
3408 uint64_t target_filepos, cluster_pos, max_pos;
3409
3410 target_filepos = (uint64_t) (target_timecode * mkv_d->last_filepos
3411 / (mkv_d->last_pts * 1000.0));
3412
3413 max_pos = mkv_d->cluster_positions[mkv_d->num_cluster_pos-1];
3414 if (target_filepos > max_pos)
3415 {
3416 if ((off_t) max_pos > stream_tell (s))
3417 stream_seek (s, max_pos);
3418 else
3419 stream_seek (s, stream_tell (s) + mkv_d->cluster_size);
3420 /* parse all the clusters upto target_filepos */
3421 while (!s->eof && stream_tell(s) < (off_t) target_filepos)
3422 {
3423 switch (ebml_read_id (s, &i))
3424 {
3425 case MATROSKA_ID_CLUSTER:
3426 add_cluster_position(mkv_d, (uint64_t) stream_tell(s)-i);
3427 break;
3428
3429 case MATROSKA_ID_CUES:
3430 demux_mkv_read_cues (demuxer);
3431 break;
3432 }
3433 ebml_read_skip (s, NULL);
3434 }
3435 if (s->eof)
3436 stream_reset(s);
3437 }
3438
3439 if (mkv_d->indexes == NULL)
3440 {
3441 cluster_pos = mkv_d->cluster_positions[0];
3442 /* Let's find the nearest cluster */
3443 for (i=0; i < mkv_d->num_cluster_pos; i++)
3444 {
3445 diff = mkv_d->cluster_positions[i] - target_filepos;
3446 if (rel_seek_secs < 0 && diff < 0 && -diff < min_diff)
3447 {
3448 cluster_pos = mkv_d->cluster_positions[i];
3449 min_diff = -diff;
3450 }
3451 else if (rel_seek_secs > 0
3452 && (diff < 0 ? -1 * diff : diff) < min_diff)
3453 {
3454 cluster_pos = mkv_d->cluster_positions[i];
3455 min_diff = diff < 0 ? -1 * diff : diff;
3456 }
3457 }
3458 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
3459 stream_seek (s, cluster_pos);
3460 }
3461 }
3462 else
3463 {
3464 mkv_index_t *index = NULL;
3465 int seek_id = (demuxer->video->id < 0) ? demuxer->audio->id : demuxer->video->id;
3466
3467 /* let's find the entry in the indexes with the smallest */
3468 /* difference to the wanted timecode. */
3469 for (i=0; i < mkv_d->num_indexes; i++)
3470 if (mkv_d->indexes[i].tnum == seek_id)
3471 {
3472 diff = target_timecode + mkv_d->first_tc -
3473 (int64_t) mkv_d->indexes[i].timecode * mkv_d->tc_scale / 1000000.0;
3474
3475 if ((flags & 1 || target_timecode <= mkv_d->last_pts*1000)) {
3476 // Absolute seek or seek backward: find the last index
3477 // position before target time
3478 if (diff < 0 || diff >= min_diff)
3479 continue;
3480 }
3481 else {
3482 // Relative seek forward: find the first index position
3483 // after target time. If no such index exists, find last
3484 // position between current position and target time.
3485 if (diff <= 0) {
3486 if (min_diff <= 0 && diff <= min_diff)
3487 continue;
3488 }
3489 else if (diff >= FFMIN(target_timecode - mkv_d->last_pts,
3490 min_diff))
3491 continue;
3492 }
3493 min_diff = diff;
3494 index = mkv_d->indexes + i;
3495 }
3496
3497 if (index) /* We've found an entry. */
3498 {
3499 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
3500 stream_seek (s, index->filepos);
3501 }
3502 }
3503
3504 if (demuxer->video->id >= 0)
3505 mkv_d->v_skip_to_keyframe = 1;
3506 if (rel_seek_secs > 0.0)
3507 mkv_d->skip_to_timecode = target_timecode;
3508 mkv_d->a_skip_to_keyframe = 1;
3509
3510 demux_mkv_fill_buffer(demuxer, NULL);
3511 }
3512 else if ((demuxer->movi_end <= 0) || !(flags & 1))
3513 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] seek unsupported flags\n");
3514 else
3515 {
3516 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3517 stream_t *s = demuxer->stream;
3518 uint64_t target_filepos;
3519 mkv_index_t *index = NULL;
3520 int i;
3521
3522 if (mkv_d->indexes == NULL) /* no index was found */
3523 { /* I'm lazy... */
3524 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] seek unsupported flags\n");
3525 return;
3526 }
3527
3528 target_filepos = (uint64_t)(demuxer->movi_end * rel_seek_secs);
3529 for (i=0; i < mkv_d->num_indexes; i++)
3530 if (mkv_d->indexes[i].tnum == demuxer->video->id)
3531 if ((index == NULL) ||
3532 ((mkv_d->indexes[i].filepos >= target_filepos) &&
3533 ((index->filepos < target_filepos) ||
3534 (mkv_d->indexes[i].filepos < index->filepos))))
3535 index = &mkv_d->indexes[i];
3536
3537 if (!index)
3538 return;
3539
3540 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
3541 stream_seek (s, index->filepos);
3542
3543 if (demuxer->video->id >= 0)
3544 mkv_d->v_skip_to_keyframe = 1;
3545 mkv_d->skip_to_timecode = index->timecode;
3546 mkv_d->a_skip_to_keyframe = 1;
3547
3548 demux_mkv_fill_buffer(demuxer, NULL);
3549 }
3550 }
3551
3552 static int
3553 demux_mkv_control (demuxer_t *demuxer, int cmd, void *arg)
3554 {
3555 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3556
3557 switch (cmd)
3558 {
3559 case DEMUXER_CTRL_GET_TIME_LENGTH:
3560 if (mkv_d->duration == 0)
3561 return DEMUXER_CTRL_DONTKNOW;
3562
3563 *((double *)arg) = (double)mkv_d->duration;
3564 return DEMUXER_CTRL_OK;
3565
3566 case DEMUXER_CTRL_GET_PERCENT_POS:
3567 if (mkv_d->duration == 0)
3568 {
3569 return DEMUXER_CTRL_DONTKNOW;
3570 }
3571
3572 *((int *) arg) = (int) (100 * mkv_d->last_pts / mkv_d->duration);
3573 return DEMUXER_CTRL_OK;
3574
3575 case DEMUXER_CTRL_SWITCH_AUDIO:
3576 if (demuxer->audio && demuxer->audio->sh) {
3577 sh_audio_t *sh = demuxer->a_streams[demuxer->audio->id];
3578 int aid = *(int*)arg;
3579 if (aid < 0)
3580 aid = (sh->aid + 1) % mkv_d->last_aid;
3581 if (aid != sh->aid) {
3582 mkv_track_t *track = demux_mkv_find_track_by_num (mkv_d, aid, MATROSKA_TRACK_AUDIO);
3583 if (track) {
3584 demuxer->audio->id = track->tnum;
3585 sh = demuxer->a_streams[demuxer->audio->id];
3586 ds_free_packs(demuxer->audio);
3587 }
3588 }
3589 *(int*)arg = sh->aid;
3590 } else
3591 *(int*)arg = -2;
3592 return DEMUXER_CTRL_OK;
3593
3594 default:
3595 return DEMUXER_CTRL_NOTIMPL;
3596 }
3597 }
3598
3599 /** \brief Get the language code for a subtitle track.
3600
3601 Retrieves the language code for a subtitle track if it is known.
3602 If the language code is "und" then do not copy it ("und" = "undefined").
3603
3604 \param demuxer The demuxer to work on
3605 \param track_num The subtitle track number to get the language from
3606 \param lang Store the language here
3607 \param maxlen The maximum number of characters to copy into lang
3608 */
3609 void
3610 demux_mkv_get_sub_lang(demuxer_t *demuxer, int track_num, char *lang,
3611 int maxlen)
3612 {
3613 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3614 mkv_track_t *track = demux_mkv_find_track_by_num (mkv_d, track_num, MATROSKA_TRACK_SUBTITLE);
3615 if (track && track->language && strcmp(track->language, "und"))
3616 av_strlcpy(lang, track->language, maxlen);
3617 }
3618
3619 /** \brief Get the language code for an audio track.
3620
3621 Retrieves the language code for an audio track if it is known.
3622 If the language code is "und" then do not copy it ("und" = "undefined").
3623
3624 \param demuxer The demuxer to work on
3625 \param track_num The n'th audio track to get the language from
3626 \param lang Store the language here
3627 \param maxlen The maximum number of characters to copy into lang
3628 */
3629 void
3630 demux_mkv_get_audio_lang(demuxer_t *demuxer, int track_num, char *lang,
3631 int maxlen)
3632 {
3633 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3634 mkv_track_t *track = demux_mkv_find_track_by_num (mkv_d, track_num, MATROSKA_TRACK_AUDIO);
3635 if (track && track->language && strcmp(track->language, "und"))
3636 av_strlcpy(lang, track->language, maxlen);
3637 }
3638
3639
3640 demuxer_desc_t demuxer_desc_matroska = {
3641 "Matroska demuxer",
3642 "mkv",
3643 "Matroska",
3644 "Aurelien Jacobs",
3645 "",
3646 DEMUXER_TYPE_MATROSKA,
3647 1, // safe autodetect
3648 demux_mkv_open,
3649 demux_mkv_fill_buffer,
3650 NULL,
3651 demux_close_mkv,
3652 demux_mkv_seek,
3653 demux_mkv_control
3654 };
mplayer with SMedia Glamo drivers