Mercurial > mplayer.hg
comparison libmpdemux/demux_mkv.cpp @ 10024:c6fab860ab18
Added Matroska demuxing support.
author | mosu |
---|---|
date | Wed, 30 Apr 2003 11:39:32 +0000 |
parents | |
children | 7ca8b302032f |
comparison
equal
deleted
inserted
replaced
10023:5a06b5774c00 | 10024:c6fab860ab18 |
---|---|
1 extern "C" { | |
2 #include "config.h" | |
3 } | |
4 | |
5 #ifdef HAVE_MATROSKA | |
6 | |
7 extern "C" { | |
8 #include <stdlib.h> | |
9 #include <stdio.h> | |
10 #include <string.h> | |
11 | |
12 #include "../mp_msg.h" | |
13 #include "../help_mp.h" | |
14 #include "stream.h" | |
15 #include "demuxer.h" | |
16 #include "stheader.h" | |
17 | |
18 #include "../subreader.h" | |
19 #include "../libvo/sub.h" | |
20 } | |
21 | |
22 #include <iostream> | |
23 #include <cassert> | |
24 #include <typeinfo> | |
25 | |
26 #include "EbmlHead.h" | |
27 #include "EbmlSubHead.h" | |
28 #include "EbmlStream.h" | |
29 #include "EbmlContexts.h" | |
30 #include "FileKax.h" | |
31 | |
32 #include "KaxAttachements.h" | |
33 #include "KaxBlock.h" | |
34 #include "KaxBlockData.h" | |
35 #include "KaxChapters.h" | |
36 #include "KaxCluster.h" | |
37 #include "KaxClusterData.h" | |
38 #include "KaxContexts.h" | |
39 #include "KaxCues.h" | |
40 #include "KaxCuesData.h" | |
41 #include "KaxInfo.h" | |
42 #include "KaxInfoData.h" | |
43 #include "KaxSeekHead.h" | |
44 #include "KaxSegment.h" | |
45 #include "KaxTracks.h" | |
46 #include "KaxTrackAudio.h" | |
47 #include "KaxTrackVideo.h" | |
48 | |
49 #include "StdIOCallback.h" | |
50 | |
51 #include "matroska.h" | |
52 | |
53 using namespace LIBMATROSKA_NAMESPACE; | |
54 using namespace std; | |
55 | |
56 // default values for Matroska elements | |
57 #define MKVD_TIMECODESCALE 1000000 // 1000000 = 1ms | |
58 | |
59 class mpstream_io_callback: public IOCallback { | |
60 private: | |
61 stream_t *s; | |
62 public: | |
63 mpstream_io_callback(stream_t *stream); | |
64 | |
65 virtual uint32 read(void *buffer, size_t size); | |
66 virtual void setFilePointer(int64 offset, seek_mode mode = seek_beginning); | |
67 virtual size_t write(const void *buffer, size_t size); | |
68 virtual uint64 getFilePointer(); | |
69 virtual void close(); | |
70 }; | |
71 | |
72 mpstream_io_callback::mpstream_io_callback(stream_t *stream) { | |
73 s = stream; | |
74 } | |
75 | |
76 uint32 mpstream_io_callback::read(void *buffer, size_t size) { | |
77 uint32_t result; | |
78 | |
79 result = stream_read(s, (char *)buffer, size); | |
80 | |
81 return result; | |
82 } | |
83 | |
84 void mpstream_io_callback::setFilePointer(int64 offset, seek_mode mode) { | |
85 int64 new_pos; | |
86 | |
87 if (mode == seek_beginning) | |
88 new_pos = offset + s->start_pos; | |
89 else if (mode == seek_end) | |
90 new_pos = s->end_pos - offset; | |
91 else | |
92 new_pos = s->pos + offset; | |
93 | |
94 if (new_pos > s->end_pos) { | |
95 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] seek warning: new_pos %lld > end_pos " | |
96 "%lld\n", new_pos, s->end_pos); | |
97 return; | |
98 } | |
99 | |
100 stream_seek(s, new_pos); | |
101 } | |
102 | |
103 size_t mpstream_io_callback::write(const void */*buffer*/, size_t /*size*/) { | |
104 return 0; | |
105 } | |
106 | |
107 uint64 mpstream_io_callback::getFilePointer() { | |
108 return s->pos - s->buf_len + s->buf_pos; | |
109 } | |
110 | |
111 void mpstream_io_callback::close() { | |
112 } | |
113 | |
114 typedef struct mkv_index_entry { | |
115 uint64_t timecode, filepos; | |
116 int is_key; | |
117 } mkv_index_entry_t; | |
118 | |
119 typedef struct mkv_track_index { | |
120 uint32_t tnum; | |
121 int num_entries; | |
122 mkv_index_entry_t *entries; | |
123 } mkv_track_index_t; | |
124 | |
125 typedef struct mkv_track { | |
126 uint32_t tnum; | |
127 | |
128 char *codec_id; | |
129 int ms_compat; | |
130 | |
131 char type; // 'v' = video, 'a' = audio, 't' = text subs | |
132 | |
133 char v_fourcc[5]; | |
134 uint32_t v_width, v_height; | |
135 float v_frate; | |
136 | |
137 uint16_t a_formattag; | |
138 uint32_t a_channels, a_bps; | |
139 float a_sfreq; | |
140 | |
141 int default_track; | |
142 | |
143 void *private_data; | |
144 unsigned int private_size; | |
145 | |
146 unsigned char *headers[3]; | |
147 uint32_t header_sizes[3]; | |
148 | |
149 int ok; | |
150 } mkv_track_t; | |
151 | |
152 typedef struct mkv_demuxer { | |
153 float duration, last_pts; | |
154 uint64_t last_filepos; | |
155 | |
156 mkv_track_t **tracks; | |
157 int num_tracks; | |
158 mkv_track_t *video, *audio, *subs_track; | |
159 | |
160 uint64_t tc_scale, cluster_tc; | |
161 | |
162 mpstream_io_callback *in; | |
163 | |
164 uint64_t clear_subs_at; | |
165 | |
166 subtitle subs; | |
167 | |
168 EbmlStream *es; | |
169 EbmlElement *saved_l1, *saved_l2; | |
170 KaxSegment *segment; | |
171 KaxCluster *cluster; | |
172 | |
173 mkv_track_index_t *index; | |
174 int num_indexes, cues_found, cues_searched; | |
175 int64_t *cluster_positions; | |
176 int num_cluster_pos; | |
177 | |
178 int skip_to_keyframe; | |
179 } mkv_demuxer_t; | |
180 | |
181 static uint16_t get_uint16(const void *buf) { | |
182 uint16_t ret; | |
183 unsigned char *tmp; | |
184 | |
185 tmp = (unsigned char *) buf; | |
186 | |
187 ret = tmp[1] & 0xff; | |
188 ret = (ret << 8) + (tmp[0] & 0xff); | |
189 | |
190 return ret; | |
191 } | |
192 | |
193 static uint32_t get_uint32(const void *buf) { | |
194 uint32_t ret; | |
195 unsigned char *tmp; | |
196 | |
197 tmp = (unsigned char *) buf; | |
198 | |
199 ret = tmp[3] & 0xff; | |
200 ret = (ret << 8) + (tmp[2] & 0xff); | |
201 ret = (ret << 8) + (tmp[1] & 0xff); | |
202 ret = (ret << 8) + (tmp[0] & 0xff); | |
203 | |
204 return ret; | |
205 } | |
206 | |
207 static void handle_subtitles(demuxer_t *d, KaxBlock *block, int64_t duration) { | |
208 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *)d->priv; | |
209 int len, line, state; | |
210 char *s1, *s2, *buffer; | |
211 | |
212 if (duration == -1) { | |
213 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Warning: No KaxBlockDuration " | |
214 "element for subtitle track found.\n"); | |
215 return; | |
216 } | |
217 | |
218 DataBuffer &data = block->GetBuffer(0); | |
219 len = data.Size(); | |
220 | |
221 buffer = (char *)data.Buffer(); | |
222 s1 = buffer; | |
223 | |
224 while (((*s1 == '\n') || (*s1 == '\r')) && | |
225 ((unsigned int)(s1 - buffer) <= data.Size())) | |
226 s1++; | |
227 | |
228 line = 0; | |
229 s2 = mkv_d->subs.text[0]; | |
230 mkv_d->subs.lines = 1; | |
231 state = 0; | |
232 while ((unsigned int)(s1 - buffer) != data.Size()) { | |
233 if ((*s1 == '\n') || (*s1 == '\r')) { | |
234 if (state == 0) { // normal char --> newline | |
235 if (mkv_d->subs.lines == SUB_MAX_TEXT) | |
236 break; | |
237 *s2 = 0; | |
238 s2 = mkv_d->subs.text[mkv_d->subs.lines]; | |
239 mkv_d->subs.lines++; | |
240 state = 1; | |
241 } | |
242 } else if (*s1 == '<') // skip HTML tags | |
243 state = 2; | |
244 else if (*s1 == '>') | |
245 state = 0; | |
246 else if (state != 2) { // normal character | |
247 state = 0; | |
248 if ((s2 - mkv_d->subs.text[mkv_d->subs.lines - 1]) < 255) { | |
249 *s2 = *s1; | |
250 s2++; | |
251 } | |
252 } | |
253 s1++; | |
254 } | |
255 | |
256 *s2 = 0; | |
257 | |
258 #ifdef USE_ICONV | |
259 subcp_recode1(&mkv_d->subs); | |
260 #endif | |
261 | |
262 vo_sub = &mkv_d->subs; | |
263 vo_osd_changed(OSDTYPE_SUBTITLE); | |
264 | |
265 mkv_d->clear_subs_at = block->GlobalTimecode() / 1000000 + duration; | |
266 } | |
267 | |
268 static mkv_track_t *new_mkv_track(mkv_demuxer_t *d) { | |
269 mkv_track_t *t; | |
270 | |
271 t = (mkv_track_t *)malloc(sizeof(mkv_track_t)); | |
272 if (t != NULL) { | |
273 memset(t, 0, sizeof(mkv_track_t)); | |
274 d->tracks = (mkv_track_t **)realloc(d->tracks, (d->num_tracks + 1) * | |
275 sizeof(mkv_track_t *)); | |
276 if (d->tracks == NULL) | |
277 return NULL; | |
278 d->tracks[d->num_tracks] = t; | |
279 d->num_tracks++; | |
280 } | |
281 | |
282 return t; | |
283 } | |
284 | |
285 static mkv_track_t *find_track_by_num(mkv_demuxer_t *d, uint32_t n, | |
286 mkv_track_t *c) { | |
287 int i; | |
288 | |
289 for (i = 0; i < d->num_tracks; i++) | |
290 if ((d->tracks[i] != NULL) && (d->tracks[i]->tnum == n) && | |
291 (d->tracks[i] != c)) | |
292 return d->tracks[i]; | |
293 | |
294 return NULL; | |
295 } | |
296 | |
297 static int check_track_information(mkv_demuxer_t *d) { | |
298 int i; | |
299 unsigned char *c; | |
300 uint32_t u, offset, length; | |
301 mkv_track_t *t; | |
302 BITMAPINFOHEADER *bih; | |
303 WAVEFORMATEX *wfe; | |
304 | |
305 for (i = 0; i < d->num_tracks; i++) { | |
306 t = d->tracks[i]; | |
307 switch (t->type) { | |
308 case 'v': // video track | |
309 if (t->codec_id == NULL) | |
310 continue; | |
311 if (!strcmp(t->codec_id, MKV_V_MSCOMP)) { | |
312 if ((t->private_data == NULL) || | |
313 (t->private_size < sizeof(BITMAPINFOHEADER))) { | |
314 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] WARNING: CodecID for track " | |
315 "%u is '" MKV_V_MSCOMP "', but there was no " | |
316 "BITMAPINFOHEADER struct present. Therefore we don't have " | |
317 "a FourCC to identify the video codec used.\n", t->tnum); | |
318 continue; | |
319 } else { | |
320 t->ms_compat = 1; | |
321 | |
322 bih = (BITMAPINFOHEADER *)t->private_data; | |
323 | |
324 u = get_uint32(&bih->biWidth); | |
325 if (t->v_width != u) { | |
326 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] WARNING: (MS " | |
327 "compatibility mode, track %u) " | |
328 "Matrosa says video width is %u, but the " | |
329 "BITMAPINFOHEADER says %u.\n", t->tnum, t->v_width, u); | |
330 if (t->v_width == 0) | |
331 t->v_width = u; | |
332 } | |
333 | |
334 u = get_uint32(&bih->biHeight); | |
335 if (t->v_height != u) { | |
336 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] WARNING: (MS compatibility " | |
337 "mode, track %u) " | |
338 "Matrosa video height is %u, but the BITMAPINFOHEADER " | |
339 "says %u.\n", t->tnum, t->v_height, u); | |
340 if (t->v_height == 0) | |
341 t->v_height = u; | |
342 } | |
343 | |
344 memcpy(t->v_fourcc, &bih->biCompression, 4); | |
345 | |
346 if (t->v_frate == 0.0) { | |
347 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] ERROR: (MS compatibility " | |
348 "mode, track %u) " | |
349 "No VideoFrameRate element was found.\n", t->tnum); | |
350 continue; | |
351 } | |
352 } | |
353 } else { | |
354 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Native CodecIDs for video " | |
355 "tracks are not supported yet (track %u).\n", t->tnum); | |
356 continue; | |
357 } | |
358 | |
359 if (t->v_width == 0) { | |
360 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] The width for track %u was " | |
361 "not set.\n", t->tnum); | |
362 continue; | |
363 } | |
364 if (t->v_height == 0) { | |
365 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] The height for track %u was " | |
366 "not set.\n", t->tnum); | |
367 continue; | |
368 } | |
369 | |
370 // This track seems to be ok. | |
371 t->ok = 1; | |
372 | |
373 break; | |
374 | |
375 case 'a': // audio track | |
376 if (t->codec_id == NULL) | |
377 continue; | |
378 if (!strcmp(t->codec_id, MKV_A_ACM)) { | |
379 if ((t->private_data == NULL) || | |
380 (t->private_size < sizeof(WAVEFORMATEX))) { | |
381 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] WARNING: CodecID for track " | |
382 "%u is '" MKV_A_ACM "', " | |
383 "but there was no WAVEFORMATEX struct present. " | |
384 "Therefore we don't have a format ID to identify the audio " | |
385 "codec used.\n", t->tnum); | |
386 continue; | |
387 } else { | |
388 t->ms_compat = 1; | |
389 | |
390 wfe = (WAVEFORMATEX *)t->private_data; | |
391 u = get_uint32(&wfe->nSamplesPerSec); | |
392 if (((uint32_t)t->a_sfreq) != u) { | |
393 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] WARNING: (MS compatibility " | |
394 "mode for track %u) " | |
395 "Matroska says that there are %u samples per second, " | |
396 "but WAVEFORMATEX says that there are %u.\n", t->tnum, | |
397 (uint32_t)t->a_sfreq, u); | |
398 if (t->a_sfreq == 0.0) | |
399 t->a_sfreq = (float)u; | |
400 } | |
401 | |
402 u = get_uint16(&wfe->nChannels); | |
403 if (t->a_channels != u) { | |
404 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] WARNING: (MS " | |
405 "compatibility mode for track %u) " | |
406 "Matroska says that there are %u channels, but the " | |
407 "WAVEFORMATEX says that there are %u.\n", t->tnum, | |
408 t->a_channels, u); | |
409 if (t->a_channels == 0) | |
410 t->a_channels = u; | |
411 } | |
412 | |
413 u = get_uint16(&wfe->wBitsPerSample); | |
414 if (t->a_channels != u) { | |
415 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] WARNING: (MS " | |
416 "compatibility mode for track %u) " | |
417 "Matroska says that there are %u bits per sample, " | |
418 "but the WAVEFORMATEX says that there are %u.\n", t->tnum, | |
419 t->a_bps, u); | |
420 if (t->a_bps == 0) | |
421 t->a_bps = u; | |
422 } | |
423 | |
424 t->a_formattag = get_uint16(&wfe->wFormatTag); | |
425 } | |
426 } else { | |
427 if (!strcmp(t->codec_id, MKV_A_MP3)) | |
428 t->a_formattag = 0x0055; | |
429 else if (!strcmp(t->codec_id, MKV_A_AC3)) | |
430 t->a_formattag = 0x2000; | |
431 else if (!strcmp(t->codec_id, MKV_A_PCM)) | |
432 t->a_formattag = 0x0001; | |
433 else if (!strcmp(t->codec_id, MKV_A_VORBIS)) { | |
434 if (t->private_data == NULL) { | |
435 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] WARNING: CodecID for " | |
436 "track %u is '" MKV_A_VORBIS | |
437 "', but there are no header packets present.", t->tnum); | |
438 continue; | |
439 } | |
440 | |
441 c = (unsigned char *)t->private_data; | |
442 if (c[0] != 2) { | |
443 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Vorbis track does not " | |
444 "contain valid headers.\n"); | |
445 continue; | |
446 } | |
447 | |
448 offset = 1; | |
449 for (i = 0; i < 2; i++) { | |
450 length = 0; | |
451 while ((c[offset] == (unsigned char )255) && | |
452 (length < t->private_size)) { | |
453 length += 255; | |
454 offset++; | |
455 } | |
456 if (offset >= (t->private_size - 1)) { | |
457 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Vorbis track does not " | |
458 "contain valid headers.\n"); | |
459 continue; | |
460 } | |
461 length += c[offset]; | |
462 offset++; | |
463 t->header_sizes[i] = length; | |
464 } | |
465 | |
466 t->headers[0] = &c[offset]; | |
467 t->headers[1] = &c[offset + t->header_sizes[0]]; | |
468 t->headers[2] = &c[offset + t->header_sizes[0] + | |
469 t->header_sizes[1]]; | |
470 t->header_sizes[2] = t->private_size - offset; | |
471 | |
472 t->a_formattag = 0xFFFE; | |
473 } else { | |
474 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Unknown/unsupported audio " | |
475 "codec ID '%s' for track %u.\n", t->codec_id, t->tnum); | |
476 continue; | |
477 } | |
478 } | |
479 | |
480 if (t->a_sfreq == 0.0) { | |
481 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] The sampling frequency was not " | |
482 "set for track %u.\n", t->tnum); | |
483 continue; | |
484 } | |
485 | |
486 if (t->a_channels == 0) { | |
487 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] The number of channels was not " | |
488 "set for track %u.\n", t->tnum); | |
489 continue; | |
490 } | |
491 | |
492 if (t->a_formattag == 0) { | |
493 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] The audio format tag was not " | |
494 "set for track %u.\n", t->tnum); | |
495 continue; | |
496 } | |
497 | |
498 // This track seems to be ok. | |
499 t->ok = 1; | |
500 | |
501 break; | |
502 | |
503 case 's': // Text subtitles do not need any data | |
504 t->ok = 1; // except the CodecID. | |
505 break; | |
506 | |
507 default: // unknown track type!? error in demuxer... | |
508 mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] Error in demux_mkv.cpp: unknown " | |
509 "demuxer type for track %u: '%c'\n", t->tnum, t->type); | |
510 continue; | |
511 } | |
512 | |
513 if (t->ok) | |
514 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Track %u seems to be ok.\n", t->tnum); | |
515 } | |
516 | |
517 return 1; | |
518 } | |
519 | |
520 static void free_mkv_demuxer(mkv_demuxer_t *d) { | |
521 int i; | |
522 | |
523 if (d == NULL) | |
524 return; | |
525 | |
526 for (i = 0; i < d->num_tracks; i++) | |
527 if (d->tracks[i] != NULL) { | |
528 if (d->tracks[i]->private_data != NULL) | |
529 free(d->tracks[i]->private_data); | |
530 free(d->tracks[i]); | |
531 } | |
532 | |
533 for (i = 0; i < d->num_indexes; i++) | |
534 free(d->index[i].entries); | |
535 free(d->index); | |
536 | |
537 if (d->es != NULL) | |
538 delete d->es; | |
539 if (d->saved_l1 != NULL) | |
540 delete d->saved_l1; | |
541 if (d->in != NULL) | |
542 delete d->in; | |
543 if (d->segment != NULL) | |
544 delete d->segment; | |
545 | |
546 free(d); | |
547 } | |
548 | |
549 static void add_index_entry(mkv_demuxer_t *d, uint32_t tnum, uint64_t filepos, | |
550 uint64_t timecode, int is_key) { | |
551 int i, found; | |
552 mkv_index_entry_t *entry; | |
553 | |
554 for (i = 0, found = 0; i < d->num_indexes; i++) | |
555 if (d->index[i].tnum == tnum) { | |
556 found = 1; | |
557 break; | |
558 } | |
559 | |
560 if (!found) { | |
561 d->index = (mkv_track_index_t *)realloc(d->index, (d->num_indexes + 1) * | |
562 sizeof(mkv_track_index_t)); | |
563 if (d->index == NULL) | |
564 return; | |
565 i = d->num_indexes; | |
566 memset(&d->index[i], 0, sizeof(mkv_track_index_t)); | |
567 d->index[i].tnum = tnum; | |
568 d->num_indexes++; | |
569 } | |
570 | |
571 d->index[i].entries = | |
572 (mkv_index_entry_t *)realloc(d->index[i].entries, | |
573 (d->index[i].num_entries + 1) * | |
574 sizeof(mkv_index_entry_t)); | |
575 if (d->index[i].entries == NULL) | |
576 return; | |
577 entry = &d->index[i].entries[d->index[i].num_entries]; | |
578 entry->filepos = filepos; | |
579 entry->timecode = timecode; | |
580 entry->is_key = is_key; | |
581 d->index[i].num_entries++; | |
582 } | |
583 | |
584 static void add_cluster_position(mkv_demuxer_t *mkv_d, int64_t position) { | |
585 mkv_d->cluster_positions = (int64_t *)realloc(mkv_d->cluster_positions, | |
586 (mkv_d->num_cluster_pos + 1) * | |
587 sizeof(int64_t)); | |
588 if (mkv_d->cluster_positions != NULL) { | |
589 mkv_d->cluster_positions[mkv_d->num_cluster_pos] = position; | |
590 mkv_d->num_cluster_pos++; | |
591 } else | |
592 mkv_d->num_cluster_pos = 0; | |
593 } | |
594 | |
595 static int parse_cues(mkv_demuxer_t *mkv_d) { | |
596 EbmlElement *l1 = NULL, *l2 = NULL, *l3 = NULL, *l4 = NULL, *l5 = NULL; | |
597 EbmlStream *es; | |
598 int upper_lvl_el, elements_found, i, k; | |
599 uint64_t tc_scale, filepos = 0, timecode = 0; | |
600 uint32_t tnum = 0; | |
601 mkv_index_entry_t *entry; | |
602 | |
603 es = mkv_d->es; | |
604 tc_scale = mkv_d->tc_scale; | |
605 upper_lvl_el = 0; | |
606 | |
607 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing cues ] -----------\n"); | |
608 | |
609 l1 = es->FindNextElement(mkv_d->segment->Generic().Context, upper_lvl_el, | |
610 0xFFFFFFFFL, true, 1); | |
611 if (l1 == NULL) | |
612 return 0; | |
613 | |
614 if (!(EbmlId(*l1) == KaxCues::ClassInfos.GlobalId)) { | |
615 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] No KaxCues element found but but %s.\n" | |
616 "[mkv] \\---- [ parsing cues ] -----------\n", typeid(*l1).name()); | |
617 | |
618 return 0; | |
619 } | |
620 | |
621 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] |+ found cues\n"); | |
622 | |
623 l2 = es->FindNextElement(l1->Generic().Context, upper_lvl_el, 0xFFFFFFFFL, | |
624 true, 1); | |
625 while (l2 != NULL) { | |
626 if (upper_lvl_el != 0) | |
627 break; | |
628 | |
629 if (EbmlId(*l2) == KaxCuePoint::ClassInfos.GlobalId) { | |
630 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + found cue point\n"); | |
631 | |
632 elements_found = 0; | |
633 | |
634 l3 = es->FindNextElement(l2->Generic().Context, upper_lvl_el, | |
635 0xFFFFFFFFL, true, 1); | |
636 while (l3 != NULL) { | |
637 if (upper_lvl_el != 0) | |
638 break; | |
639 | |
640 if (EbmlId(*l3) == KaxCueTime::ClassInfos.GlobalId) { | |
641 KaxCueTime &cue_time = *static_cast<KaxCueTime *>(l3); | |
642 cue_time.ReadData(es->I_O()); | |
643 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + found cue time: %.3fs\n", | |
644 ((float)uint64(cue_time)) * tc_scale / 1000000000.0); | |
645 | |
646 timecode = uint64(cue_time) * tc_scale / 1000000; | |
647 elements_found |= 1; | |
648 | |
649 } else if (EbmlId(*l3) == | |
650 KaxCueTrackPositions::ClassInfos.GlobalId) { | |
651 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + found cue track " | |
652 "positions\n"); | |
653 | |
654 l4 = es->FindNextElement(l3->Generic().Context, upper_lvl_el, | |
655 0xFFFFFFFFL, true, 1); | |
656 while (l4 != NULL) { | |
657 if (upper_lvl_el != 0) | |
658 break; | |
659 | |
660 if (EbmlId(*l4) == KaxCueTrack::ClassInfos.GlobalId) { | |
661 KaxCueTrack &cue_track = *static_cast<KaxCueTrack *>(l4); | |
662 cue_track.ReadData(es->I_O()); | |
663 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + found cue track: " | |
664 "%u\n", uint32(cue_track)); | |
665 | |
666 tnum = uint32(cue_track); | |
667 elements_found |= 2; | |
668 | |
669 } else if (EbmlId(*l4) == | |
670 KaxCueClusterPosition::ClassInfos.GlobalId) { | |
671 KaxCueClusterPosition &cue_cp = | |
672 *static_cast<KaxCueClusterPosition *>(l4); | |
673 cue_cp.ReadData(es->I_O()); | |
674 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + found cue cluster " | |
675 "position: %llu\n", uint64(cue_cp)); | |
676 | |
677 filepos = mkv_d->segment->GetGlobalPosition(uint64_t(cue_cp)); | |
678 elements_found |= 4; | |
679 | |
680 } else if (EbmlId(*l4) == | |
681 KaxCueBlockNumber::ClassInfos.GlobalId) { | |
682 KaxCueBlockNumber &cue_bn = | |
683 *static_cast<KaxCueBlockNumber *>(l4); | |
684 cue_bn.ReadData(es->I_O()); | |
685 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + found cue block " | |
686 "number: %llu\n", uint64(cue_bn)); | |
687 | |
688 } else if (EbmlId(*l4) == | |
689 KaxCueCodecState::ClassInfos.GlobalId) { | |
690 KaxCueCodecState &cue_cs = | |
691 *static_cast<KaxCueCodecState *>(l4); | |
692 cue_cs.ReadData(es->I_O()); | |
693 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + found cue codec " | |
694 "state: %llu\n", uint64(cue_cs)); | |
695 | |
696 } else if (EbmlId(*l4) == | |
697 KaxCueReference::ClassInfos.GlobalId) { | |
698 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + found cue " | |
699 "reference\n"); | |
700 | |
701 elements_found |= 8; | |
702 | |
703 l5 = es->FindNextElement(l4->Generic().Context, upper_lvl_el, | |
704 0xFFFFFFFFL, true, 1); | |
705 while (l5 != NULL) { | |
706 if (upper_lvl_el != 0) | |
707 break; | |
708 | |
709 if (EbmlId(*l5) == KaxCueRefTime::ClassInfos.GlobalId) { | |
710 KaxCueRefTime &cue_rt = | |
711 *static_cast<KaxCueRefTime *>(l5); | |
712 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + found cue ref " | |
713 "time: %.3fs\n", ((float)uint64(cue_rt)) * tc_scale / | |
714 1000000000.0); | |
715 | |
716 } else if (EbmlId(*l5) == | |
717 KaxCueRefCluster::ClassInfos.GlobalId) { | |
718 KaxCueRefCluster &cue_rc = | |
719 *static_cast<KaxCueRefCluster *>(l5); | |
720 cue_rc.ReadData(es->I_O()); | |
721 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + found cue ref " | |
722 "cluster: %llu\n", uint64(cue_rc)); | |
723 | |
724 } else if (EbmlId(*l5) == | |
725 KaxCueRefNumber::ClassInfos.GlobalId) { | |
726 KaxCueRefNumber &cue_rn = | |
727 *static_cast<KaxCueRefNumber *>(l5); | |
728 cue_rn.ReadData(es->I_O()); | |
729 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + found cue ref " | |
730 "number: %llu\n", uint64(cue_rn)); | |
731 | |
732 } else if (EbmlId(*l5) == | |
733 KaxCueRefCodecState::ClassInfos.GlobalId) { | |
734 KaxCueRefCodecState &cue_rcs = | |
735 *static_cast<KaxCueRefCodecState *>(l5); | |
736 cue_rcs.ReadData(es->I_O()); | |
737 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + found cue ref " | |
738 "codec state: %llu\n", uint64(cue_rcs)); | |
739 | |
740 } else { | |
741 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + unknown " | |
742 "element, level 5: %s\n", typeid(*l5).name()); | |
743 } | |
744 | |
745 l5->SkipData(static_cast<EbmlStream &>(*es), | |
746 l5->Generic().Context); | |
747 delete l5; | |
748 l5 = es->FindNextElement(l4->Generic().Context, | |
749 upper_lvl_el, 0xFFFFFFFFL, true, 1); | |
750 } // while (l5 != NULL) | |
751 | |
752 } else | |
753 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + unknown element, " | |
754 "level 4: %s\n", typeid(*l4).name()); | |
755 | |
756 if (upper_lvl_el > 0) { // we're coming from l5 | |
757 upper_lvl_el--; | |
758 delete l4; | |
759 l4 = l5; | |
760 if (upper_lvl_el > 0) | |
761 break; | |
762 | |
763 } else { | |
764 l4->SkipData(static_cast<EbmlStream &>(*es), | |
765 l4->Generic().Context); | |
766 delete l4; | |
767 l4 = es->FindNextElement(l3->Generic().Context, upper_lvl_el, | |
768 0xFFFFFFFFL, true, 1); | |
769 } | |
770 } // while (l4 != NULL) | |
771 | |
772 } else | |
773 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + unknown element, level 3: " | |
774 "%s\n", typeid(*l3).name()); | |
775 | |
776 if (upper_lvl_el > 0) { // we're coming from l4 | |
777 upper_lvl_el--; | |
778 delete l3; | |
779 l3 = l4; | |
780 if (upper_lvl_el > 0) | |
781 break; | |
782 | |
783 } else { | |
784 l3->SkipData(static_cast<EbmlStream &>(*es), | |
785 l3->Generic().Context); | |
786 delete l3; | |
787 l3 = es->FindNextElement(l2->Generic().Context, upper_lvl_el, | |
788 0xFFFFFFFFL, true, 1); | |
789 } | |
790 } // while (l3 != NULL) | |
791 | |
792 // Three elements must have been found in order for this to be a | |
793 // correct entry: | |
794 // 1: cue time (timecode) | |
795 // 2: cue track (tnum) | |
796 // 4: cue cluster position (filepos) | |
797 // If 8 is also set, then there was a reference element, and the | |
798 // current block is not an I frame. If 8 is not set then this is | |
799 // an I frame. | |
800 if ((elements_found & 7) == 7) | |
801 add_index_entry(mkv_d, tnum, filepos, timecode, | |
802 (elements_found & 8) ? 0 : 1); | |
803 | |
804 } else | |
805 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] | + unknown element, level 2: " | |
806 "%s\n", typeid(*l2).name()); | |
807 | |
808 if (upper_lvl_el > 0) { // we're coming from l3 | |
809 upper_lvl_el--; | |
810 delete l2; | |
811 l2 = l3; | |
812 if (upper_lvl_el > 0) | |
813 break; | |
814 | |
815 } else { | |
816 l2->SkipData(static_cast<EbmlStream &>(*es), | |
817 l2->Generic().Context); | |
818 delete l2; | |
819 l2 = es->FindNextElement(l1->Generic().Context, upper_lvl_el, | |
820 0xFFFFFFFFL, true, 1); | |
821 } | |
822 } // while (l2 != NULL) | |
823 | |
824 // Debug: dump the index | |
825 for (i = 0; i < mkv_d->num_indexes; i++) { | |
826 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] Index for track %u contains %u " | |
827 "entries.\n", mkv_d->index[i].tnum, mkv_d->index[i].num_entries); | |
828 for (k = 0; k < mkv_d->index[i].num_entries; k++) { | |
829 entry = &mkv_d->index[i].entries[k]; | |
830 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] %d: timecode %llu, filepos %llu, " | |
831 "is key: %s\n", k, entry->timecode, entry->filepos, | |
832 entry->is_key ? "yes" : "no"); | |
833 } | |
834 } | |
835 | |
836 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] \\---- [ parsing cues ] -----------\n"); | |
837 | |
838 return 1; | |
839 } | |
840 | |
841 extern "C" int demux_mkv_open(demuxer_t *demuxer) { | |
842 unsigned char signature[4]; | |
843 stream_t *s; | |
844 demux_packet_t *dp; | |
845 mkv_demuxer_t *mkv_d; | |
846 int upper_lvl_el, exit_loop, i; | |
847 // Elements for different levels | |
848 EbmlElement *l0 = NULL, *l1 = NULL, *l2 = NULL, *l3 = NULL, *l4 = NULL; | |
849 EbmlStream *es; | |
850 mkv_track_t *track; | |
851 sh_audio_t *sh_a; | |
852 sh_video_t *sh_v; | |
853 uint64_t seek_pos, current_pos; | |
854 int seek_element_is_cue; | |
855 | |
856 #ifdef USE_ICONV | |
857 subcp_open(); | |
858 #endif | |
859 | |
860 s = demuxer->stream; | |
861 stream_seek(s, s->start_pos); | |
862 memset(signature, 0, 4); | |
863 stream_read(s, (char *)signature, 4); | |
864 if ((signature[0] != 0x1A) || (signature[1] != 0x45) || | |
865 (signature[2] != 0xDF) || (signature[3] != 0xA3)) | |
866 return 0; | |
867 stream_seek(s, s->start_pos); | |
868 | |
869 try { | |
870 // structure for storing the demuxer's private data | |
871 mkv_d = (mkv_demuxer_t *)malloc(sizeof(mkv_demuxer_t)); | |
872 if (mkv_d == NULL) | |
873 return 0; | |
874 memset(mkv_d, 0, sizeof(mkv_demuxer_t)); | |
875 mkv_d->duration = -1.0; | |
876 | |
877 // Create the interface between MPlayer's IO system and | |
878 // libmatroska's IO system. | |
879 mkv_d->in = new mpstream_io_callback(demuxer->stream); | |
880 if (mkv_d->in == NULL) { | |
881 free_mkv_demuxer(mkv_d); | |
882 return 0; | |
883 } | |
884 mpstream_io_callback &io = *static_cast<mpstream_io_callback *>(mkv_d->in); | |
885 mkv_d->es = new EbmlStream(io); | |
886 if (mkv_d->es == NULL) { | |
887 free_mkv_demuxer(mkv_d); | |
888 return 0; | |
889 } | |
890 es = mkv_d->es; | |
891 | |
892 // Find the EbmlHead element. Must be the first one. | |
893 l0 = es->FindNextID(EbmlHead::ClassInfos, 0xFFFFFFFFL); | |
894 if (l0 == NULL) { | |
895 mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] no head found\n"); | |
896 free_mkv_demuxer(mkv_d); | |
897 return 0; | |
898 } | |
899 // Don't verify its data for now. | |
900 l0->SkipData(static_cast<EbmlStream &>(*es), l0->Generic().Context); | |
901 delete l0; | |
902 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Found the head...\n"); | |
903 | |
904 // Next element must be a segment | |
905 l0 = es->FindNextID(KaxSegment::ClassInfos, 0xFFFFFFFFL); | |
906 if (l0 == NULL) { | |
907 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] but no segment :(\n"); | |
908 free_mkv_demuxer(mkv_d); | |
909 return 0; | |
910 } | |
911 if (!(EbmlId(*l0) == KaxSegment::ClassInfos.GlobalId)) { | |
912 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] but no segment :(\n"); | |
913 free_mkv_demuxer(mkv_d); | |
914 return 0; | |
915 } | |
916 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] + a segment...\n"); | |
917 | |
918 mkv_d->segment = (KaxSegment *)l0; | |
919 | |
920 upper_lvl_el = 0; | |
921 exit_loop = 0; | |
922 // We've got our segment, so let's find the tracks | |
923 l1 = es->FindNextElement(l0->Generic().Context, upper_lvl_el, 0xFFFFFFFFL, | |
924 true, 1); | |
925 while (l1 != NULL) { | |
926 if ((upper_lvl_el != 0) || exit_loop) | |
927 break; | |
928 | |
929 if (EbmlId(*l1) == KaxInfo::ClassInfos.GlobalId) { | |
930 // General info about this Matroska file | |
931 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] |+ segment information...\n"); | |
932 | |
933 l2 = es->FindNextElement(l1->Generic().Context, upper_lvl_el, | |
934 0xFFFFFFFFL, true, 1); | |
935 while (l2 != NULL) { | |
936 if ((upper_lvl_el != 0) || exit_loop) | |
937 break; | |
938 | |
939 if (EbmlId(*l2) == KaxTimecodeScale::ClassInfos.GlobalId) { | |
940 KaxTimecodeScale &tc_scale = *static_cast<KaxTimecodeScale *>(l2); | |
941 tc_scale.ReadData(es->I_O()); | |
942 mkv_d->tc_scale = uint64(tc_scale); | |
943 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + timecode scale: %llu\n", | |
944 mkv_d->tc_scale); | |
945 | |
946 } else if (EbmlId(*l2) == KaxDuration::ClassInfos.GlobalId) { | |
947 KaxDuration &duration = *static_cast<KaxDuration *>(l2); | |
948 duration.ReadData(es->I_O()); | |
949 mkv_d->duration = float(duration) * mkv_d->tc_scale / 1000000000.0; | |
950 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + duration: %.3fs\n", | |
951 mkv_d->duration); | |
952 | |
953 } else | |
954 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + unknown element@2: %s\n", | |
955 typeid(*l2).name()); | |
956 | |
957 l2->SkipData(static_cast<EbmlStream &>(*es), | |
958 l2->Generic().Context); | |
959 delete l2; | |
960 l2 = es->FindNextElement(l1->Generic().Context, upper_lvl_el, | |
961 0xFFFFFFFFL, true, 1); | |
962 } | |
963 | |
964 } else if (EbmlId(*l1) == KaxTracks::ClassInfos.GlobalId) { | |
965 // Yep, we've found our KaxTracks element. Now find all tracks | |
966 // contained in this segment. | |
967 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] |+ segment tracks...\n"); | |
968 | |
969 l2 = es->FindNextElement(l1->Generic().Context, upper_lvl_el, | |
970 0xFFFFFFFFL, true, 1); | |
971 while (l2 != NULL) { | |
972 if ((upper_lvl_el != 0) || exit_loop) | |
973 break; | |
974 | |
975 if (EbmlId(*l2) == KaxTrackEntry::ClassInfos.GlobalId) { | |
976 // We actually found a track entry :) We're happy now. | |
977 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + a track...\n"); | |
978 | |
979 track = new_mkv_track(mkv_d); | |
980 if (track == NULL) | |
981 return 0; | |
982 | |
983 l3 = es->FindNextElement(l2->Generic().Context, upper_lvl_el, | |
984 0xFFFFFFFFL, true, 1); | |
985 while (l3 != NULL) { | |
986 if (upper_lvl_el != 0) | |
987 break; | |
988 | |
989 // Now evaluate the data belonging to this track | |
990 if (EbmlId(*l3) == KaxTrackNumber::ClassInfos.GlobalId) { | |
991 KaxTrackNumber &tnum = *static_cast<KaxTrackNumber *>(l3); | |
992 tnum.ReadData(es->I_O()); | |
993 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Track number: %u\n", | |
994 uint32(tnum)); | |
995 track->tnum = uint32(tnum); | |
996 if (find_track_by_num(mkv_d, track->tnum, track) != NULL) | |
997 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] | + WARNING: There's " | |
998 "more than one track with the number %u.\n", | |
999 track->tnum); | |
1000 | |
1001 } else if (EbmlId(*l3) == KaxTrackUID::ClassInfos.GlobalId) { | |
1002 KaxTrackUID &tuid = *static_cast<KaxTrackUID *>(l3); | |
1003 tuid.ReadData(es->I_O()); | |
1004 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Track UID: %u\n", | |
1005 uint32(tuid)); | |
1006 | |
1007 } else if (EbmlId(*l3) == KaxTrackType::ClassInfos.GlobalId) { | |
1008 KaxTrackType &ttype = *static_cast<KaxTrackType *>(l3); | |
1009 ttype.ReadData(es->I_O()); | |
1010 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Track type: "); | |
1011 | |
1012 switch (uint8(ttype)) { | |
1013 case track_audio: | |
1014 mp_msg(MSGT_DEMUX, MSGL_V, "Audio\n"); | |
1015 track->type = 'a'; | |
1016 break; | |
1017 case track_video: | |
1018 mp_msg(MSGT_DEMUX, MSGL_V, "Video\n"); | |
1019 track->type = 'v'; | |
1020 break; | |
1021 case track_subtitle: | |
1022 mp_msg(MSGT_DEMUX, MSGL_V, "Subtitle\n"); | |
1023 track->type = 's'; | |
1024 break; | |
1025 default: | |
1026 mp_msg(MSGT_DEMUX, MSGL_V, "unknown\n"); | |
1027 track->type = '?'; | |
1028 break; | |
1029 } | |
1030 | |
1031 } else if (EbmlId(*l3) == KaxTrackAudio::ClassInfos.GlobalId) { | |
1032 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Audio track\n"); | |
1033 l4 = es->FindNextElement(l3->Generic().Context, upper_lvl_el, | |
1034 0xFFFFFFFFL, true, 1); | |
1035 while (l4 != NULL) { | |
1036 if (upper_lvl_el != 0) | |
1037 break; | |
1038 | |
1039 if (EbmlId(*l4) == | |
1040 KaxAudioSamplingFreq::ClassInfos.GlobalId) { | |
1041 KaxAudioSamplingFreq &freq = | |
1042 *static_cast<KaxAudioSamplingFreq*>(l4); | |
1043 freq.ReadData(es->I_O()); | |
1044 track->a_sfreq = float(freq); | |
1045 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Sampling " | |
1046 "frequency: %f\n", track->a_sfreq); | |
1047 | |
1048 } else if (EbmlId(*l4) == | |
1049 KaxAudioChannels::ClassInfos.GlobalId) { | |
1050 KaxAudioChannels &channels = | |
1051 *static_cast<KaxAudioChannels*>(l4); | |
1052 channels.ReadData(es->I_O()); | |
1053 track->a_channels = uint8(channels); | |
1054 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Channels: %u\n", | |
1055 track->a_channels); | |
1056 | |
1057 } else if (EbmlId(*l4) == | |
1058 KaxAudioBitDepth::ClassInfos.GlobalId) { | |
1059 KaxAudioBitDepth &bps = | |
1060 *static_cast<KaxAudioBitDepth*>(l4); | |
1061 bps.ReadData(es->I_O()); | |
1062 track->a_bps = uint8(bps); | |
1063 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Bit depth: %u\n", | |
1064 track->a_bps); | |
1065 | |
1066 } else | |
1067 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + unknown " | |
1068 "element@4: %s\n", typeid(*l4).name()); | |
1069 | |
1070 l4->SkipData(static_cast<EbmlStream &>(*es), | |
1071 l4->Generic().Context); | |
1072 delete l4; | |
1073 l4 = es->FindNextElement(l3->Generic().Context, upper_lvl_el, | |
1074 0xFFFFFFFFL, true, 1); | |
1075 } // while (l4 != NULL) | |
1076 | |
1077 } else if (EbmlId(*l3) == KaxTrackVideo::ClassInfos.GlobalId) { | |
1078 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Video track\n"); | |
1079 l4 = es->FindNextElement(l3->Generic().Context, upper_lvl_el, | |
1080 0xFFFFFFFFL, true, 1); | |
1081 while (l4 != NULL) { | |
1082 if (upper_lvl_el != 0) | |
1083 break; | |
1084 | |
1085 if (EbmlId(*l4) == KaxVideoPixelWidth::ClassInfos.GlobalId) { | |
1086 KaxVideoPixelWidth &width = | |
1087 *static_cast<KaxVideoPixelWidth *>(l4); | |
1088 width.ReadData(es->I_O()); | |
1089 track->v_width = uint16(width); | |
1090 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Pixel width: %u\n", | |
1091 track->v_width); | |
1092 | |
1093 } else if (EbmlId(*l4) == | |
1094 KaxVideoPixelHeight::ClassInfos.GlobalId) { | |
1095 KaxVideoPixelHeight &height = | |
1096 *static_cast<KaxVideoPixelHeight *>(l4); | |
1097 height.ReadData(es->I_O()); | |
1098 track->v_height = uint16(height); | |
1099 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Pixel height: " | |
1100 "%u\n", track->v_height); | |
1101 | |
1102 } else if (EbmlId(*l4) == | |
1103 KaxVideoFrameRate::ClassInfos.GlobalId) { | |
1104 KaxVideoFrameRate &framerate = | |
1105 *static_cast<KaxVideoFrameRate *>(l4); | |
1106 framerate.ReadData(es->I_O()); | |
1107 track->v_frate = float(framerate); | |
1108 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Frame rate: %f\n", | |
1109 float(framerate)); | |
1110 | |
1111 } else | |
1112 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + unknown " | |
1113 "element@4: %s\n", typeid(*l4).name()); | |
1114 | |
1115 l4->SkipData(static_cast<EbmlStream &>(*es), | |
1116 l4->Generic().Context); | |
1117 delete l4; | |
1118 l4 = es->FindNextElement(l3->Generic().Context, upper_lvl_el, | |
1119 0xFFFFFFFFL, true, 1); | |
1120 } // while (l4 != NULL) | |
1121 | |
1122 } else if (EbmlId(*l3) == KaxCodecID::ClassInfos.GlobalId) { | |
1123 KaxCodecID &codec_id = *static_cast<KaxCodecID*>(l3); | |
1124 codec_id.ReadData(es->I_O()); | |
1125 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Codec ID: %s\n", | |
1126 &binary(codec_id)); | |
1127 track->codec_id = strdup((char *)&binary(codec_id)); | |
1128 | |
1129 } else if (EbmlId(*l3) == KaxCodecPrivate::ClassInfos.GlobalId) { | |
1130 KaxCodecPrivate &c_priv = *static_cast<KaxCodecPrivate*>(l3); | |
1131 c_priv.ReadData(es->I_O()); | |
1132 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + CodecPrivate, length " | |
1133 "%llu\n", c_priv.GetSize()); | |
1134 track->private_size = c_priv.GetSize(); | |
1135 if (track->private_size > 0) { | |
1136 track->private_data = malloc(track->private_size); | |
1137 if (track->private_data == NULL) | |
1138 return 0; | |
1139 memcpy(track->private_data, c_priv.GetBuffer(), | |
1140 track->private_size); | |
1141 } | |
1142 | |
1143 } else if (EbmlId(*l3) == | |
1144 KaxTrackFlagDefault::ClassInfos.GlobalId) { | |
1145 KaxTrackFlagDefault &f_default = | |
1146 *static_cast<KaxTrackFlagDefault *>(l3); | |
1147 f_default.ReadData(es->I_O()); | |
1148 track->default_track = uint32(f_default); | |
1149 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Default flag: %u\n", | |
1150 track->default_track); | |
1151 | |
1152 } else if ((EbmlId(*l3) != | |
1153 KaxTrackFlagLacing::ClassInfos.GlobalId) && | |
1154 (EbmlId(*l3) != | |
1155 KaxTrackMinCache::ClassInfos.GlobalId) && | |
1156 (EbmlId(*l3) != | |
1157 KaxTrackMaxCache::ClassInfos.GlobalId)) | |
1158 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + unknown element@3: " | |
1159 "%s\n", typeid(*l3).name()); | |
1160 | |
1161 if (upper_lvl_el > 0) { // we're coming from l4 | |
1162 upper_lvl_el--; | |
1163 delete l3; | |
1164 l3 = l4; | |
1165 if (upper_lvl_el > 0) | |
1166 break; | |
1167 } else { | |
1168 l3->SkipData(static_cast<EbmlStream &>(*es), | |
1169 l3->Generic().Context); | |
1170 delete l3; | |
1171 l3 = es->FindNextElement(l2->Generic().Context, upper_lvl_el, | |
1172 0xFFFFFFFFL, true, 1); | |
1173 } | |
1174 } // while (l3 != NULL) | |
1175 | |
1176 } else | |
1177 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + unknown element@2: %s\n", | |
1178 typeid(*l2).name()); | |
1179 if (upper_lvl_el > 0) { // we're coming from l3 | |
1180 upper_lvl_el--; | |
1181 delete l2; | |
1182 l2 = l3; | |
1183 if (upper_lvl_el > 0) | |
1184 break; | |
1185 } else { | |
1186 l2->SkipData(static_cast<EbmlStream &>(*es), | |
1187 l2->Generic().Context); | |
1188 delete l2; | |
1189 l2 = es->FindNextElement(l1->Generic().Context, upper_lvl_el, | |
1190 0xFFFFFFFFL, true, 1); | |
1191 } | |
1192 } // while (l2 != NULL) | |
1193 | |
1194 } else if (EbmlId(*l1) == KaxSeekHead::ClassInfos.GlobalId) { | |
1195 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] |+ found seek head\n"); | |
1196 | |
1197 l2 = es->FindNextElement(l1->Generic().Context, upper_lvl_el, | |
1198 0xFFFFFFFFL, true, 1); | |
1199 while (l2 != NULL) { | |
1200 if (upper_lvl_el != 0) | |
1201 break; | |
1202 | |
1203 if (EbmlId(*l2) == KaxSeek::ClassInfos.GlobalId) { | |
1204 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + seek entry\n"); | |
1205 | |
1206 seek_pos = 0; | |
1207 seek_element_is_cue = 0; | |
1208 | |
1209 l3 = es->FindNextElement(l2->Generic().Context, upper_lvl_el, | |
1210 0xFFFFFFFFL, true, 1); | |
1211 while (l3 != NULL) { | |
1212 if (upper_lvl_el != 0) | |
1213 break; | |
1214 | |
1215 if (EbmlId(*l3) == KaxSeekID::ClassInfos.GlobalId) { | |
1216 binary *b; | |
1217 int s; | |
1218 KaxSeekID &seek_id = static_cast<KaxSeekID &>(*l3); | |
1219 seek_id.ReadData(es->I_O()); | |
1220 b = seek_id.GetBuffer(); | |
1221 s = seek_id.GetSize(); | |
1222 EbmlId id(b, s); | |
1223 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + seek ID: "); | |
1224 for (i = 0; i < s; i++) | |
1225 mp_msg(MSGT_DEMUX, MSGL_V, "0x%02x ", | |
1226 ((unsigned char *)b)[i]); | |
1227 mp_msg(MSGT_DEMUX, MSGL_V, "(%s)\n", | |
1228 (id == KaxInfo::ClassInfos.GlobalId) ? | |
1229 "KaxInfo" : | |
1230 (id == KaxCluster::ClassInfos.GlobalId) ? | |
1231 "KaxCluster" : | |
1232 (id == KaxTracks::ClassInfos.GlobalId) ? | |
1233 "KaxTracks" : | |
1234 (id == KaxCues::ClassInfos.GlobalId) ? | |
1235 "KaxCues" : | |
1236 (id == KaxAttachements::ClassInfos.GlobalId) ? | |
1237 "KaxAttachements" : | |
1238 (id == KaxChapters::ClassInfos.GlobalId) ? | |
1239 "KaxChapters" : | |
1240 "unknown"); | |
1241 | |
1242 if (id == KaxCues::ClassInfos.GlobalId) | |
1243 seek_element_is_cue = 1; | |
1244 | |
1245 } else if (EbmlId(*l3) == KaxSeekPosition::ClassInfos.GlobalId) { | |
1246 KaxSeekPosition &kax_seek_pos = | |
1247 static_cast<KaxSeekPosition &>(*l3); | |
1248 kax_seek_pos.ReadData(es->I_O()); | |
1249 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + seek position: %llu\n", | |
1250 uint64(kax_seek_pos)); | |
1251 | |
1252 seek_pos = uint64(kax_seek_pos); | |
1253 | |
1254 } else | |
1255 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + unknown element, " | |
1256 "level 3: %s\n", typeid(*l3).name()); | |
1257 | |
1258 l3->SkipData(static_cast<EbmlStream &>(*es), | |
1259 l3->Generic().Context); | |
1260 delete l3; | |
1261 l3 = es->FindNextElement(l2->Generic().Context, upper_lvl_el, | |
1262 0xFFFFFFFFL, true, 1); | |
1263 } // while (l3 != NULL) | |
1264 | |
1265 if (!mkv_d->cues_found && (seek_pos > 0) && | |
1266 seek_element_is_cue && (s->end_pos != 0)) { | |
1267 current_pos = io.getFilePointer(); | |
1268 io.setFilePointer(mkv_d->segment->GetGlobalPosition(seek_pos)); | |
1269 mkv_d->cues_found = parse_cues(mkv_d); | |
1270 if (s->eof) | |
1271 stream_reset(s); | |
1272 io.setFilePointer(current_pos); | |
1273 } | |
1274 | |
1275 } else | |
1276 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + unknown element, level 2: " | |
1277 "%s\n", typeid(*l2).name()); | |
1278 | |
1279 if (upper_lvl_el > 0) { // we're coming from l3 | |
1280 upper_lvl_el--; | |
1281 delete l2; | |
1282 l2 = l3; | |
1283 if (upper_lvl_el > 0) | |
1284 break; | |
1285 | |
1286 } else { | |
1287 l2->SkipData(static_cast<EbmlStream &>(*es), | |
1288 l2->Generic().Context); | |
1289 delete l2; | |
1290 l2 = es->FindNextElement(l1->Generic().Context, upper_lvl_el, | |
1291 0xFFFFFFFFL, true, 1); | |
1292 } | |
1293 } // while (l2 != NULL) | |
1294 | |
1295 } else if ((EbmlId(*l1) == KaxCues::ClassInfos.GlobalId) && | |
1296 !mkv_d->cues_found) { | |
1297 // If the cues are up front then by all means read them now! | |
1298 current_pos = io.getFilePointer(); | |
1299 io.setFilePointer(l1->GetElementPosition()); | |
1300 mkv_d->cues_found = parse_cues(mkv_d); | |
1301 stream_reset(s); | |
1302 io.setFilePointer(current_pos); | |
1303 | |
1304 } else if (EbmlId(*l1) == KaxCluster::ClassInfos.GlobalId) { | |
1305 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] |+ found cluster, headers are " | |
1306 "parsed completely :)\n"); | |
1307 add_cluster_position(mkv_d, l1->GetElementPosition()); | |
1308 mkv_d->saved_l1 = l1; | |
1309 exit_loop = 1; | |
1310 | |
1311 } else | |
1312 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] |+ unknown element@1: %s\n", | |
1313 typeid(*l1).name()); | |
1314 | |
1315 if (exit_loop) // we've found the first cluster, so get out | |
1316 break; | |
1317 | |
1318 if (upper_lvl_el > 0) { // we're coming from l2 | |
1319 upper_lvl_el--; | |
1320 delete l1; | |
1321 l1 = l2; | |
1322 if (upper_lvl_el > 0) | |
1323 break; | |
1324 } else { | |
1325 l1->SkipData(static_cast<EbmlStream &>(*es), l1->Generic().Context); | |
1326 delete l1; | |
1327 l1 = es->FindNextElement(l0->Generic().Context, upper_lvl_el, | |
1328 0xFFFFFFFFL, true, 1); | |
1329 } | |
1330 } // while (l1 != NULL) | |
1331 | |
1332 if (!exit_loop) { | |
1333 free_mkv_demuxer(mkv_d); | |
1334 return 0; | |
1335 } | |
1336 | |
1337 } catch (exception &ex) { | |
1338 mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] caught exception\n"); | |
1339 return 0; | |
1340 } | |
1341 | |
1342 if (mkv_d->tc_scale == 0) | |
1343 mkv_d->tc_scale = MKVD_TIMECODESCALE; | |
1344 | |
1345 if (!check_track_information(mkv_d)) { | |
1346 free_mkv_demuxer(mkv_d); | |
1347 return 0; | |
1348 } | |
1349 | |
1350 track = NULL; | |
1351 if (demuxer->video->id == -1) { // Automatically select a video track. | |
1352 // Search for a video track that has the 'default' flag set. | |
1353 for (i = 0; i < mkv_d->num_tracks; i++) | |
1354 if ((mkv_d->tracks[i]->type == 'v') && mkv_d->tracks[i]->ok && | |
1355 mkv_d->tracks[i]->default_track) { | |
1356 track = mkv_d->tracks[i]; | |
1357 break; | |
1358 } | |
1359 | |
1360 if (track == NULL) | |
1361 // No track has the 'default' flag set - let's take the first video | |
1362 // track. | |
1363 for (i = 0; i < mkv_d->num_tracks; i++) | |
1364 if ((mkv_d->tracks[i]->type == 'v') && mkv_d->tracks[i]->ok) { | |
1365 track = mkv_d->tracks[i]; | |
1366 break; | |
1367 } | |
1368 } else if (demuxer->video->id != -2) // -2 = no video at all | |
1369 track = find_track_by_num(mkv_d, demuxer->video->id, NULL); | |
1370 | |
1371 if (track) { | |
1372 if (track->ms_compat) { // MS compatibility mode | |
1373 mp_msg(MSGT_DEMUX, MSGL_INFO, "[mkv] Will play video track %u\n", | |
1374 track->tnum); | |
1375 sh_v = new_sh_video(demuxer, track->tnum); | |
1376 sh_v->bih = (BITMAPINFOHEADER *)calloc(1, sizeof(BITMAPINFOHEADER)); | |
1377 if (sh_v->bih == NULL) { | |
1378 free_mkv_demuxer(mkv_d); | |
1379 return 0; | |
1380 } | |
1381 | |
1382 memcpy(sh_v->bih, track->private_data, sizeof(BITMAPINFOHEADER)); | |
1383 sh_v->format = sh_v->bih->biCompression; | |
1384 sh_v->fps = track->v_frate; | |
1385 sh_v->frametime = 1 / track->v_frate; | |
1386 sh_v->disp_w = sh_v->bih->biWidth; | |
1387 sh_v->disp_h = sh_v->bih->biHeight; | |
1388 | |
1389 demuxer->video->id = track->tnum; | |
1390 demuxer->video->sh = sh_v; | |
1391 sh_v->ds = demuxer->video; | |
1392 | |
1393 mkv_d->video = track; | |
1394 } else { | |
1395 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Native CodecIDs not supported at " | |
1396 "the moment (track %u).\n", track->tnum); | |
1397 demuxer->video->id = -2; | |
1398 } | |
1399 } else { | |
1400 mp_msg(MSGT_DEMUX, MSGL_INFO, "[mkv] No video track found/wanted.\n"); | |
1401 demuxer->video->id = -2; | |
1402 } | |
1403 | |
1404 track = NULL; | |
1405 if (demuxer->audio->id == -1) { // Automatically select an audio track. | |
1406 // Search for an audio track that has the 'default' flag set. | |
1407 for (i = 0; i < mkv_d->num_tracks; i++) | |
1408 if ((mkv_d->tracks[i]->type == 'a') && mkv_d->tracks[i]->ok && | |
1409 mkv_d->tracks[i]->default_track) { | |
1410 track = mkv_d->tracks[i]; | |
1411 break; | |
1412 } | |
1413 | |
1414 if (track == NULL) | |
1415 // No track has the 'default' flag set - let's take the first audio | |
1416 // track. | |
1417 for (i = 0; i < mkv_d->num_tracks; i++) | |
1418 if ((mkv_d->tracks[i]->type == 'a') && mkv_d->tracks[i]->ok) { | |
1419 track = mkv_d->tracks[i]; | |
1420 break; | |
1421 } | |
1422 } else if (demuxer->audio->id != -2) // -2 = no audio at all | |
1423 track = find_track_by_num(mkv_d, demuxer->audio->id, NULL); | |
1424 | |
1425 if (track) { | |
1426 mp_msg(MSGT_DEMUX, MSGL_INFO, "[mkv] Will play audio track %u\n", | |
1427 track->tnum); | |
1428 sh_a = new_sh_audio(demuxer, track->tnum); | |
1429 | |
1430 demuxer->audio->id = track->tnum; | |
1431 demuxer->audio->sh = sh_a; | |
1432 sh_a->ds = demuxer->audio; | |
1433 | |
1434 mkv_d->audio = track; | |
1435 | |
1436 if (track->ms_compat) { | |
1437 sh_a->wf = (WAVEFORMATEX *)calloc(1, track->private_size); | |
1438 if (sh_a->wf == NULL) { | |
1439 free_mkv_demuxer(mkv_d); | |
1440 return 0; | |
1441 } | |
1442 memcpy(sh_a->wf, track->private_data, track->private_size); | |
1443 } else { | |
1444 sh_a->wf = (WAVEFORMATEX *)calloc(1, sizeof(WAVEFORMATEX)); | |
1445 if (sh_a->wf == NULL) { | |
1446 free_mkv_demuxer(mkv_d); | |
1447 return 0; | |
1448 } | |
1449 } | |
1450 sh_a->format = sh_a->wf->wFormatTag = track->a_formattag; | |
1451 sh_a->channels = sh_a->wf->nChannels = track->a_channels; | |
1452 sh_a->samplerate = sh_a->wf->nSamplesPerSec = (uint32_t)track->a_sfreq; | |
1453 if (!strcmp(track->codec_id, MKV_A_MP3)) { | |
1454 sh_a->wf->nAvgBytesPerSec = 16000; | |
1455 sh_a->wf->nBlockAlign = 1152; | |
1456 sh_a->wf->wBitsPerSample = 0; | |
1457 sh_a->samplesize = 0; | |
1458 } else if (!strcmp(track->codec_id, MKV_A_AC3)) { | |
1459 sh_a->wf->nAvgBytesPerSec = 16000; | |
1460 sh_a->wf->nBlockAlign = 1536; | |
1461 sh_a->wf->wBitsPerSample = 0; | |
1462 sh_a->samplesize = 0; | |
1463 } else if (!strcmp(track->codec_id, MKV_A_PCM)) { | |
1464 sh_a->wf->nAvgBytesPerSec = sh_a->channels * sh_a->samplerate * 2; | |
1465 sh_a->wf->nBlockAlign = sh_a->wf->nAvgBytesPerSec; | |
1466 sh_a->wf->wBitsPerSample = track->a_bps; | |
1467 sh_a->samplesize = track->a_bps / 8; | |
1468 } else if (!strcmp(track->codec_id, MKV_A_VORBIS)) { | |
1469 for (i = 0; i < 3; i++) { | |
1470 dp = new_demux_packet(track->header_sizes[i]); | |
1471 memcpy(dp->buffer, track->headers[i], track->header_sizes[i]); | |
1472 dp->pts = 0; | |
1473 dp->flags = 0; | |
1474 ds_add_packet(demuxer->audio, dp); | |
1475 } | |
1476 } | |
1477 } else { | |
1478 mp_msg(MSGT_DEMUX, MSGL_INFO, "[mkv] No audio track found/wanted.\n"); | |
1479 demuxer->audio->id = -2; | |
1480 } | |
1481 | |
1482 // DO NOT automatically select a subtitle track and behave like DVD | |
1483 // playback: only show subtitles if the user explicitely wants them. | |
1484 if (demuxer->sub->id >= 0) { | |
1485 track = find_track_by_num(mkv_d, demuxer->sub->id, NULL); | |
1486 if (track) { | |
1487 if (strcmp(track->codec_id, MKV_S_TEXTASCII) && | |
1488 strcmp(track->codec_id, MKV_S_TEXTUTF8)) | |
1489 mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] Subtitle type '%s' is not " | |
1490 "supported. Track will not be displayed.\n", track->codec_id); | |
1491 else { | |
1492 mp_msg(MSGT_DEMUX, MSGL_INFO, "[mkv] Will display subtitle track %u\n", | |
1493 track->tnum); | |
1494 mkv_d->subs_track = track; | |
1495 if (!mkv_d->subs.text[0]) { | |
1496 for (i = 0; i < SUB_MAX_TEXT; i++) | |
1497 mkv_d->subs.text[i] = (char *)malloc(256); | |
1498 | |
1499 if (!strcmp(track->codec_id, MKV_S_TEXTUTF8)) | |
1500 sub_utf8 = 1; // Force UTF-8 conversion. | |
1501 } else | |
1502 mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] File does not contain a " | |
1503 "subtitle track with the id %u.\n", demuxer->sub->id); | |
1504 } | |
1505 } | |
1506 } | |
1507 | |
1508 if (s->end_pos == 0) | |
1509 demuxer->seekable = 0; | |
1510 else { | |
1511 demuxer->movi_start = s->start_pos; | |
1512 demuxer->movi_end = s->end_pos; | |
1513 demuxer->seekable = 1; | |
1514 } | |
1515 | |
1516 demuxer->priv = mkv_d; | |
1517 | |
1518 return 1; | |
1519 } | |
1520 | |
1521 extern "C" int demux_mkv_fill_buffer(demuxer_t *d) { | |
1522 demux_packet_t *dp; | |
1523 demux_stream_t *ds; | |
1524 mkv_demuxer_t *mkv_d; | |
1525 int upper_lvl_el, exit_loop, found_data, i, delete_element, elements_found; | |
1526 // Elements for different levels | |
1527 EbmlElement *l0 = NULL, *l1 = NULL, *l2 = NULL, *l3 = NULL, *l4 = NULL; | |
1528 EbmlStream *es; | |
1529 KaxBlock *block; | |
1530 int64_t block_duration, block_ref1, block_ref2; | |
1531 | |
1532 mkv_d = (mkv_demuxer_t *)d->priv; | |
1533 es = mkv_d->es; | |
1534 l0 = mkv_d->segment; | |
1535 | |
1536 // End of stream | |
1537 if (mkv_d->saved_l1 == NULL) | |
1538 return 0; | |
1539 | |
1540 exit_loop = 0; | |
1541 upper_lvl_el = 0; | |
1542 l1 = mkv_d->saved_l1; | |
1543 mkv_d->saved_l1 = NULL; | |
1544 found_data = 0; | |
1545 try { | |
1546 // The idea is not to handle a complete KaxCluster with each call to | |
1547 // demux_mkv_fill_buffer because those might be rather big. | |
1548 while (l1 != NULL) { | |
1549 if ((upper_lvl_el != 0) || exit_loop) | |
1550 break; | |
1551 | |
1552 if (EbmlId(*l1) == KaxCluster::ClassInfos.GlobalId) { | |
1553 mkv_d->cluster = (KaxCluster *)l1; | |
1554 if (found_data) { | |
1555 mkv_d->saved_l1 = l1; | |
1556 break; | |
1557 } | |
1558 | |
1559 if (mkv_d->saved_l2 != NULL) { | |
1560 l2 = mkv_d->saved_l2; | |
1561 mkv_d->saved_l2 = NULL; | |
1562 } else | |
1563 l2 = es->FindNextElement(l1->Generic().Context, upper_lvl_el, | |
1564 0xFFFFFFFFL, true, 1); | |
1565 while (l2 != NULL) { | |
1566 if (upper_lvl_el != 0) | |
1567 break; | |
1568 | |
1569 // Handle at at least one data packets in one call to | |
1570 // demux_mkv_fill_buffer - but abort if we have found that. | |
1571 if (found_data >= 1) { | |
1572 mkv_d->saved_l2 = l2; | |
1573 mkv_d->saved_l1 = l1; | |
1574 exit_loop = 1; | |
1575 break; | |
1576 } | |
1577 | |
1578 if (EbmlId(*l2) == KaxClusterTimecode::ClassInfos.GlobalId) { | |
1579 KaxClusterTimecode &ctc = *static_cast<KaxClusterTimecode *>(l2); | |
1580 ctc.ReadData(es->I_O()); | |
1581 mkv_d->cluster_tc = uint64(ctc); | |
1582 mkv_d->cluster->InitTimecode(mkv_d->cluster_tc); | |
1583 | |
1584 } else if (EbmlId(*l2) == KaxBlockGroup::ClassInfos.GlobalId) { | |
1585 | |
1586 block = NULL; | |
1587 block_duration = -1; | |
1588 block_ref1 = 0; | |
1589 block_ref2 = 0; | |
1590 elements_found = 0; | |
1591 | |
1592 l3 = es->FindNextElement(l2->Generic().Context, upper_lvl_el, | |
1593 0xFFFFFFFFL, true, 1); | |
1594 while (l3 != NULL) { | |
1595 delete_element = 1; | |
1596 if (upper_lvl_el > 0) | |
1597 break; | |
1598 | |
1599 if (EbmlId(*l3) == KaxBlock::ClassInfos.GlobalId) { | |
1600 block = static_cast<KaxBlock *>(l3); | |
1601 block->SetParent(*mkv_d->cluster); | |
1602 block->ReadData(es->I_O()); | |
1603 delete_element = 0; | |
1604 elements_found |= 1; | |
1605 | |
1606 } else if (EbmlId(*l3) == | |
1607 KaxBlockDuration::ClassInfos.GlobalId) { | |
1608 KaxBlockDuration &duration = | |
1609 *static_cast<KaxBlockDuration *>(l3); | |
1610 duration.ReadData(es->I_O()); | |
1611 block_duration = (int64_t)uint64(duration); | |
1612 elements_found |= 2; | |
1613 | |
1614 } else if (EbmlId(*l3) == | |
1615 KaxReferenceBlock::ClassInfos.GlobalId) { | |
1616 KaxReferenceBlock &ref = | |
1617 *static_cast<KaxReferenceBlock *>(l3); | |
1618 ref.ReadData(es->I_O()); | |
1619 if (block_ref1 == 0) { | |
1620 block_ref1 = int64(ref); | |
1621 elements_found |= 4; | |
1622 } else { | |
1623 block_ref2 = int64(ref); | |
1624 elements_found |= 8; | |
1625 } | |
1626 | |
1627 } | |
1628 | |
1629 if (upper_lvl_el > 0) { // we're coming from l4 | |
1630 upper_lvl_el--; | |
1631 delete l3; | |
1632 l3 = l4; | |
1633 if (upper_lvl_el > 0) | |
1634 break; | |
1635 } else { | |
1636 l3->SkipData(static_cast<EbmlStream &>(*es), | |
1637 l3->Generic().Context); | |
1638 if (delete_element) | |
1639 delete l3; | |
1640 l3 = es->FindNextElement(l2->Generic().Context, upper_lvl_el, | |
1641 0xFFFFFFFFL, true, 1); | |
1642 } | |
1643 } // while (l3 != NULL) | |
1644 | |
1645 if (block != NULL) { | |
1646 // Clear the subtitles if they're obsolete now. | |
1647 if ((mkv_d->clear_subs_at > 0) && | |
1648 (mkv_d->clear_subs_at <= | |
1649 (block->GlobalTimecode() / 1000000))) { | |
1650 mkv_d->subs.lines = 0; | |
1651 vo_sub = &mkv_d->subs; | |
1652 vo_osd_changed(OSDTYPE_SUBTITLE); | |
1653 mkv_d->clear_subs_at = 0; | |
1654 } | |
1655 | |
1656 ds = NULL; | |
1657 if ((mkv_d->video != NULL) && | |
1658 (mkv_d->video->tnum == block->TrackNum())) | |
1659 ds = d->video; | |
1660 else if ((mkv_d->audio != NULL) && | |
1661 (mkv_d->audio->tnum == block->TrackNum())) | |
1662 ds = d->audio; | |
1663 | |
1664 if (!mkv_d->skip_to_keyframe || // Not skipping is ok. | |
1665 (((elements_found & 4) == 0) && // It's a key frame. | |
1666 (ds != NULL) && // Corresponding track found | |
1667 (ds == d->video))) { // track is our video track | |
1668 if (ds != NULL) { | |
1669 for (i = 0; i < (int)block->NumberFrames(); i++) { | |
1670 DataBuffer &data = block->GetBuffer(i); | |
1671 dp = new_demux_packet(data.Size()); | |
1672 memcpy(dp->buffer, data.Buffer(), data.Size()); | |
1673 dp->pts = mkv_d->last_pts; | |
1674 dp->flags = 0; | |
1675 ds_add_packet(ds, dp); | |
1676 found_data++; | |
1677 mkv_d->skip_to_keyframe = 0; | |
1678 } | |
1679 } else if ((mkv_d->subs_track != NULL) && | |
1680 (mkv_d->subs_track->tnum == block->TrackNum())) | |
1681 handle_subtitles(d, block, block_duration); | |
1682 | |
1683 d->filepos = mkv_d->in->getFilePointer(); | |
1684 mkv_d->last_pts = (float)block->GlobalTimecode() / | |
1685 1000000000.0; | |
1686 mkv_d->last_filepos = d->filepos; | |
1687 } | |
1688 | |
1689 delete block; | |
1690 } // block != NULL | |
1691 | |
1692 } | |
1693 | |
1694 if (upper_lvl_el > 0) { // we're coming from l3 | |
1695 upper_lvl_el--; | |
1696 delete l2; | |
1697 l2 = l3; | |
1698 if (upper_lvl_el > 0) | |
1699 break; | |
1700 } else { | |
1701 l2->SkipData(static_cast<EbmlStream &>(*es), | |
1702 l2->Generic().Context); | |
1703 delete l2; | |
1704 l2 = es->FindNextElement(l1->Generic().Context, upper_lvl_el, | |
1705 0xFFFFFFFFL, true, 1); | |
1706 } | |
1707 } // while (l2 != NULL) | |
1708 } else if (EbmlId(*l1) == KaxCues::ClassInfos.GlobalId) | |
1709 return 0; | |
1710 else | |
1711 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Unknown element@1: %s (stream " | |
1712 "position %llu)\n", typeid(*l1).name(), | |
1713 l1->GetElementPosition()); | |
1714 | |
1715 if (exit_loop) | |
1716 break; | |
1717 | |
1718 if (upper_lvl_el > 0) { // we're coming from l2 | |
1719 upper_lvl_el--; | |
1720 delete l1; | |
1721 l1 = l2; | |
1722 if (upper_lvl_el > 0) | |
1723 break; | |
1724 } else { | |
1725 l1->SkipData(static_cast<EbmlStream &>(*es), l1->Generic().Context); | |
1726 delete l1; | |
1727 l1 = es->FindNextElement(l0->Generic().Context, upper_lvl_el, | |
1728 0xFFFFFFFFL, true, 1); | |
1729 if (EbmlId(*l1) == KaxCluster::ClassInfos.GlobalId) | |
1730 add_cluster_position(mkv_d, l1->GetElementPosition()); | |
1731 } | |
1732 } // while (l1 != NULL) | |
1733 } catch (exception ex) { | |
1734 mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] exception caught\n"); | |
1735 return 0; | |
1736 } | |
1737 | |
1738 if (found_data) | |
1739 return 1; | |
1740 | |
1741 return 0; | |
1742 } | |
1743 | |
1744 extern "C" void resync_audio_stream(sh_audio_t *sh_audio); | |
1745 | |
1746 extern "C" void demux_mkv_seek(demuxer_t *demuxer, float rel_seek_secs, | |
1747 int flags) { | |
1748 int i, k, upper_lvl_el; | |
1749 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *)demuxer->priv; | |
1750 int64_t target_timecode, target_filepos = 0, min_diff, diff, current_pos; | |
1751 int64_t cluster_pos; | |
1752 mkv_track_index_t *index; | |
1753 mkv_index_entry_t *entry; | |
1754 EbmlElement *l1; | |
1755 | |
1756 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] SEEK, relss: %.3f, flags: %d\n", | |
1757 rel_seek_secs, flags); | |
1758 | |
1759 if (!mkv_d->cues_found && !mkv_d->cues_searched) { | |
1760 // We've not found an index so far. So let's skip over all level 1 | |
1761 // elements until we either hit another segment, the end of the file | |
1762 // or - suprise - some cues. | |
1763 current_pos = mkv_d->in->getFilePointer(); | |
1764 | |
1765 // Skip the data but do not delete the element! This is our current | |
1766 // cluster, and we need it later on in demux_mkv_fill_buffer. | |
1767 l1 = mkv_d->saved_l1; | |
1768 l1->SkipData(static_cast<EbmlStream &>(*mkv_d->es), l1->Generic().Context); | |
1769 l1 = mkv_d->es->FindNextElement(mkv_d->segment->Generic().Context, | |
1770 upper_lvl_el, 0xFFFFFFFFL, true, 1); | |
1771 while (l1 != NULL) { | |
1772 if (upper_lvl_el) | |
1773 break; | |
1774 | |
1775 if (EbmlId(*l1) == KaxCues::ClassInfos.GlobalId) { | |
1776 mkv_d->in->setFilePointer(l1->GetElementPosition()); | |
1777 delete l1; | |
1778 mkv_d->cues_found = parse_cues(mkv_d); | |
1779 break; | |
1780 } else { | |
1781 if (EbmlId(*l1) == KaxCluster::ClassInfos.GlobalId) | |
1782 add_cluster_position(mkv_d, l1->GetElementPosition()); | |
1783 l1->SkipData(static_cast<EbmlStream &>(*mkv_d->es), | |
1784 l1->Generic().Context); | |
1785 delete l1; | |
1786 l1 = mkv_d->es->FindNextElement(mkv_d->segment->Generic().Context, | |
1787 upper_lvl_el, 0xFFFFFFFFL, true, 1); | |
1788 } | |
1789 } | |
1790 | |
1791 if (demuxer->stream->eof) | |
1792 stream_reset(demuxer->stream); | |
1793 mkv_d->in->setFilePointer(current_pos); | |
1794 | |
1795 mkv_d->cues_searched = 1; | |
1796 } | |
1797 | |
1798 if (!(flags & 2)) { // Time in secs | |
1799 if (flags & 1) // Absolute seek | |
1800 target_timecode = 0; | |
1801 else // Relative seek | |
1802 target_timecode = (int64_t)(mkv_d->last_pts * 1000.0); | |
1803 target_timecode += (int64_t)(rel_seek_secs * 1000.0); | |
1804 if (target_timecode < 0) | |
1805 target_timecode = 0; | |
1806 | |
1807 min_diff = 0xFFFFFFFL; | |
1808 | |
1809 // Let's find the entry in the index with the smallest difference | |
1810 // to the wanted timecode. | |
1811 entry = NULL; | |
1812 for (i = 0; i < mkv_d->num_indexes; i++) | |
1813 if (mkv_d->index[i].tnum == mkv_d->video->tnum) { | |
1814 index = &mkv_d->index[i]; | |
1815 for (k = 0; k < index->num_entries; k++) { | |
1816 if (!index->entries[k].is_key) | |
1817 continue; | |
1818 diff = target_timecode - (int64_t)index->entries[k].timecode; | |
1819 if (diff < 0) | |
1820 diff *= -1; | |
1821 if (diff < min_diff) { | |
1822 min_diff = diff; | |
1823 entry = & index->entries[k]; | |
1824 } | |
1825 } | |
1826 break; | |
1827 } | |
1828 | |
1829 if (mkv_d->saved_l1 != NULL) | |
1830 delete mkv_d->saved_l1; | |
1831 | |
1832 if (mkv_d->saved_l2 != NULL) { | |
1833 delete mkv_d->saved_l2; | |
1834 mkv_d->saved_l2 = NULL; | |
1835 } | |
1836 | |
1837 if (entry != NULL) { // We've found an entry. | |
1838 mkv_d->in->setFilePointer(entry->filepos); | |
1839 upper_lvl_el = 0; | |
1840 mkv_d->saved_l1 = | |
1841 mkv_d->es->FindNextElement(mkv_d->segment->Generic().Context, | |
1842 upper_lvl_el, 0xFFFFFFFFL, true, 1); | |
1843 } else { // We've not found an entry --> no index? | |
1844 target_filepos = (int64_t)(target_timecode * mkv_d->last_filepos / | |
1845 (mkv_d->last_pts * 1000.0)); | |
1846 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] No index entry found. Calculated " | |
1847 "filepos %lld.\n", target_filepos); | |
1848 // Let's find the nearest cluster so that libebml does not have to | |
1849 // do so much work. | |
1850 cluster_pos = 0; | |
1851 min_diff = 0x0FFFFFFFL; | |
1852 for (i = 0; i < mkv_d->num_cluster_pos; i++) { | |
1853 diff = mkv_d->cluster_positions[i] - target_filepos; | |
1854 if (rel_seek_secs < 0) { | |
1855 if ((diff > 0) && (diff < min_diff)) { | |
1856 cluster_pos = mkv_d->cluster_positions[i]; | |
1857 min_diff = diff; | |
1858 } | |
1859 } else if (abs(diff) < min_diff) { | |
1860 cluster_pos = mkv_d->cluster_positions[i]; | |
1861 min_diff = abs(diff); | |
1862 } | |
1863 } | |
1864 if (min_diff != 0x0FFFFFFFL) | |
1865 target_filepos = cluster_pos; | |
1866 if (target_filepos >= demuxer->movi_end) | |
1867 return; | |
1868 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] New target_filepos because of cluster:" | |
1869 " %lld.\n", target_filepos); | |
1870 mkv_d->in->setFilePointer(target_filepos); | |
1871 upper_lvl_el = 0; | |
1872 mkv_d->saved_l1 = | |
1873 mkv_d->es->FindNextElement(mkv_d->segment->Generic().Context, | |
1874 upper_lvl_el, 0xFFFFFFFFL, false, 1); | |
1875 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] seek result: target_timecode %lld, " | |
1876 "did not find an entry. Calculated target_filspos: %lld\n", | |
1877 target_timecode, target_filepos); | |
1878 if ((mkv_d->saved_l1 != NULL) && | |
1879 (EbmlId(*mkv_d->saved_l1) == KaxSegment::ClassInfos.GlobalId)) | |
1880 mkv_d->saved_l1 = | |
1881 mkv_d->es->FindNextElement(mkv_d->saved_l1->Generic().Context, | |
1882 upper_lvl_el, 0xFFFFFFFFL, true, 1); | |
1883 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] seek found %p (%s).\n", | |
1884 mkv_d->saved_l1, mkv_d->saved_l1 == NULL ? "null" : | |
1885 typeid(*mkv_d->saved_l1).name()); | |
1886 } | |
1887 | |
1888 mkv_d->skip_to_keyframe = 1; | |
1889 | |
1890 demux_mkv_fill_buffer(demuxer); | |
1891 | |
1892 mkv_d->subs.lines = 0; | |
1893 vo_sub = &mkv_d->subs; | |
1894 vo_osd_changed(OSDTYPE_SUBTITLE); | |
1895 mkv_d->clear_subs_at = 0; | |
1896 | |
1897 if(demuxer->audio->sh != NULL) | |
1898 resync_audio_stream((sh_audio_t *)demuxer->audio->sh); | |
1899 | |
1900 } else | |
1901 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] seek unsupported flags\n"); | |
1902 | |
1903 } | |
1904 | |
1905 extern "C" void demux_close_mkv(demuxer_t *demuxer) { | |
1906 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *)demuxer->priv; | |
1907 | |
1908 free_mkv_demuxer(mkv_d); | |
1909 | |
1910 #ifdef USE_ICONV | |
1911 subcp_close(); | |
1912 #endif | |
1913 } | |
1914 | |
1915 extern "C" int demux_mkv_control(demuxer_t *demuxer, int cmd, void *arg) { | |
1916 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *)demuxer->priv; | |
1917 | |
1918 switch (cmd) { | |
1919 case DEMUXER_CTRL_GET_TIME_LENGTH: | |
1920 if (mkv_d->duration == -1.0) | |
1921 return DEMUXER_CTRL_DONTKNOW; | |
1922 | |
1923 *((unsigned long *)arg) = (unsigned long)mkv_d->duration; | |
1924 return DEMUXER_CTRL_OK; | |
1925 | |
1926 case DEMUXER_CTRL_GET_PERCENT_POS: | |
1927 if (mkv_d->duration == -1.0) { | |
1928 if (demuxer->movi_start == demuxer->movi_end) | |
1929 return DEMUXER_CTRL_DONTKNOW; | |
1930 | |
1931 *((int *)arg) = | |
1932 (int)((demuxer->filepos - demuxer->movi_start) / | |
1933 ((demuxer->movi_end - demuxer->movi_start) / 100)); | |
1934 return DEMUXER_CTRL_OK; | |
1935 } | |
1936 | |
1937 *((int *)arg) = (int)(100 * mkv_d->last_pts / mkv_d->duration); | |
1938 return DEMUXER_CTRL_OK; | |
1939 | |
1940 default: | |
1941 return DEMUXER_CTRL_NOTIMPL; | |
1942 } | |
1943 } | |
1944 | |
1945 #endif /* HAVE_MATROSKA */ |