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