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