← Back to branch summary

~ubuntu-branches/debian/sid/mplayer/sid

« back to all changes in this revision

Viewing changes to libmpdemux/demux_mkv.c

  • Committer: Bazaar Package Importer
  • Author(s): A Mennucc1
  • Date: 2009-03-23 10:05:45 UTC
  • mfrom: (4.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090323100545-x8h79obawnnte7kk
Tags: 1.0~rc2+svn20090303-5
debian/control : move docbook-xml,docbook-xsl,xsltproc from 
Build-Depends-Indep to Build-Depends, since they are needed to run
configure

Show diffs side-by-side

added added

removed removed

Lines of Context:
libmpdemux/demux_mkv.c
22
22
#include "mp_msg.h"
23
23
#include "help_mp.h"
24
24
 
 
25
#include "vobsub.h"
25
26
#include "subreader.h"
26
27
#include "libvo/sub.h"
27
28
 
30
31
 
31
32
#include "libavutil/common.h"
32
33
 
33
 
#ifdef USE_QTX_CODECS
 
34
#ifdef CONFIG_QTX_CODECS
34
35
#include "loader/qtx/qtxsdk/components.h"
35
36
#endif
36
37
 
37
 
#ifdef HAVE_ZLIB
 
38
#if CONFIG_ZLIB
38
39
#include <zlib.h>
39
40
#endif
40
41
 
41
 
#ifdef USE_LIBAVUTIL_SO
42
 
#include <ffmpeg/lzo.h>
43
 
#include <ffmpeg/intreadwrite.h>
44
 
#else
45
42
#include "libavutil/lzo.h"
46
43
#include "libavutil/intreadwrite.h"
47
 
#endif
48
44
#include "libavutil/avstring.h"
49
45
 
50
 
static unsigned char sipr_swaps[38][2]={
 
46
static const unsigned char sipr_swaps[38][2]={
51
47
    {0,63},{1,22},{2,44},{3,90},{5,81},{7,31},{8,86},{9,58},{10,36},{12,68},
52
48
    {13,39},{14,73},{15,53},{16,69},{17,57},{19,88},{20,34},{21,71},{24,46},
53
49
    {25,94},{26,54},{28,75},{29,50},{32,70},{33,92},{35,74},{38,85},{40,56},
58
54
#define SIPR_FLAVORS 4
59
55
#define ATRC_FLAVORS 8
60
56
#define COOK_FLAVORS 34
61
 
static int sipr_fl2bps[SIPR_FLAVORS] = {813, 1062, 625, 2000};
62
 
static int atrc_fl2bps[ATRC_FLAVORS] = {8269, 11714, 13092, 16538, 18260, 22050, 33075, 44100};
63
 
static int cook_fl2bps[COOK_FLAVORS] = {1000, 1378, 2024, 2584, 4005, 5513, 8010, 4005, 750, 2498,
64
 
                                        4048, 5513, 8010, 11973, 8010, 2584, 4005, 2067, 2584, 2584,
65
 
                                        4005, 4005, 5513, 5513, 8010, 12059, 1550, 8010, 12059, 5513,
66
 
                                        12016, 16408, 22911, 33506};
 
57
static const int sipr_fl2bps[SIPR_FLAVORS] = {813, 1062, 625, 2000};
 
58
static const int atrc_fl2bps[ATRC_FLAVORS] =
 
59
    {8269, 11714, 13092, 16538, 18260, 22050, 33075, 44100};
 
60
static const int cook_fl2bps[COOK_FLAVORS] =
 
61
    { 1000,  1378,  2024,  2584, 4005,  5513, 8010, 4005,   750, 2498,
 
62
      4048,  5513,  8010, 11973, 8010,  2584, 4005, 2067,  2584, 2584,
 
63
      4005,  4005,  5513,  5513, 8010, 12059, 1550, 8010, 12059, 5513,
 
64
     12016, 16408, 22911, 33506};
67
65
 
68
66
typedef struct
69
67
{
100
98
 
101
99
  /* stuff for realmedia */
102
100
  int realmedia;
103
 
  int rv_kf_base, rv_kf_pts;
 
101
  int64_t rv_kf_base;
 
102
  int rv_kf_pts;
104
103
  float rv_pts;  /* previous video timestamp */
105
104
  float ra_pts;  /* previous audio timestamp */
106
105
 
142
141
  uint64_t timecode, filepos;
143
142
} mkv_index_t;
144
143
 
145
 
typedef struct mkv_attachment
146
 
{
147
 
  char* name;
148
 
  char* mime;
149
 
  uint64_t uid;
150
 
  void* data;
151
 
  unsigned int data_size;
152
 
} mkv_attachment_t;
153
 
 
154
144
typedef struct mkv_demuxer
155
145
{
156
146
  off_t segment_start;
185
175
  
186
176
  int last_aid;
187
177
  int audio_tracks[MAX_A_STREAMS];
188
 
  
189
 
  mkv_attachment_t *attachments;
190
 
  int num_attachments;
191
178
} mkv_demuxer_t;
192
179
 
193
180
#define REALHEADER_SIZE    16
224
211
  return NULL;
225
212
}
226
213
 
227
 
static mkv_track_t *
228
 
demux_mkv_find_track_by_language (mkv_demuxer_t *d, char *language, int type)
229
 
{
230
 
  int i, len;
231
 
  
232
 
  language += strspn(language,",");
233
 
  while((len = strcspn(language,",")) > 0)
234
 
    {
235
 
      for (i=0; i < d->num_tracks; i++)
236
 
        if (d->tracks[i] != NULL && d->tracks[i]->language != NULL &&
237
 
            d->tracks[i]->type == type &&
238
 
            !strncmp(d->tracks[i]->language, language, len))
239
 
          return d->tracks[i];
240
 
      language += len;
241
 
      language += strspn(language,",");
242
 
    }
243
 
  
244
 
  return NULL;
245
 
}
246
 
 
247
214
static void
248
215
add_cluster_position (mkv_demuxer_t *mkv_d, uint64_t position)
249
216
{
289
256
    return 11;
290
257
}
291
258
 
292
 
 
293
 
static int
294
 
vobsub_parse_size (sh_sub_t *sh, const char *start)
295
 
{
296
 
  if (sscanf(&start[6], "%dx%d", &sh->width, &sh->height) == 2)
297
 
    {
298
 
      mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] VobSub size: %ux%u\n",
299
 
             sh->width, sh->height);
300
 
      return 1;
301
 
    }
302
 
  return 0;
303
 
}
304
 
 
305
 
static int
306
 
vobsub_parse_palette (sh_sub_t *sh, const char *start)
307
 
{
308
 
  int i, r, g, b, y, u, v, tmp;
309
 
 
310
 
  start += 8;
311
 
  while (isspace(*start))
312
 
    start++;
313
 
  for (i = 0; i < 16; i++)
314
 
    {
315
 
      if (sscanf(start, "%06x", &tmp) != 1)
316
 
        break;
317
 
      r = tmp >> 16 & 0xff;
318
 
      g = tmp >> 8 & 0xff;
319
 
      b = tmp & 0xff;
320
 
      y = av_clip_uint8( 0.1494  * r + 0.6061 * g + 0.2445 * b);
321
 
      u = av_clip_uint8( 0.6066  * r - 0.4322 * g - 0.1744 * b + 128);
322
 
      v = av_clip_uint8(-0.08435 * r - 0.3422 * g + 0.4266 * b + 128);
323
 
      sh->palette[i] = y << 16 | u << 8 | v;
324
 
      start += 6;
325
 
      while ((*start == ',') || isspace(*start))
326
 
        start++;
327
 
    }
328
 
  if (i == 16)
329
 
    {
330
 
      mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] VobSub palette: %06x,%06x,"
331
 
             "%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,"
332
 
             "%06x,%06x,%06x\n", sh->palette[0],
333
 
             sh->palette[1], sh->palette[2],
334
 
             sh->palette[3], sh->palette[4],
335
 
             sh->palette[5], sh->palette[6],
336
 
             sh->palette[7], sh->palette[8],
337
 
             sh->palette[9], sh->palette[10],
338
 
             sh->palette[11], sh->palette[12],
339
 
             sh->palette[13], sh->palette[14],
340
 
             sh->palette[15]);
341
 
      sh->has_palette = 1;
342
 
      return 2;
343
 
    }
344
 
  return 0;
345
 
}
346
 
 
347
 
static int
348
 
vobsub_parse_custom_colors (sh_sub_t *sh, const char *start)
349
 
{
350
 
  int use_custom_colors, i;
351
 
 
352
 
  use_custom_colors = 0;
353
 
  start += 14;
354
 
  while (isspace(*start))
355
 
    start++;
356
 
   if (!strncasecmp(start, "ON", 2) || (*start == '1'))
357
 
     use_custom_colors = 1;
358
 
   else if (!strncasecmp(start, "OFF", 3) || (*start == '0'))
359
 
     use_custom_colors = 0;
360
 
   mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] VobSub custom colors: %s\n",
361
 
          use_custom_colors ? "ON" : "OFF");
362
 
   if ((start = strstr(start, "colors:")) != NULL)
363
 
     {
364
 
       start += 7;
365
 
       while (isspace(*start))
366
 
         start++;
367
 
       for (i = 0; i < 4; i++)
368
 
         {
369
 
           if (sscanf(start, "%06x", &sh->colors[i]) != 1)
370
 
             break;
371
 
           start += 6;
372
 
           while ((*start == ',') || isspace(*start))
373
 
             start++;
374
 
         }
375
 
       if (i == 4)
376
 
         {
377
 
           sh->custom_colors = 4;
378
 
           mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] VobSub colors: %06x,"
379
 
                  "%06x,%06x,%06x\n", sh->colors[0],
380
 
                  sh->colors[1], sh->colors[2],
381
 
                  sh->colors[3]);
382
 
         }
383
 
     }
384
 
   if (!use_custom_colors)
385
 
     sh->custom_colors = 0;
386
 
   return 4;
387
 
}
388
 
 
389
 
static int
390
 
vobsub_parse_forced_subs (sh_sub_t *sh, const char *start)
391
 
{
392
 
  start += 12;
393
 
  while (isspace(*start))
394
 
    start++;
395
 
  if (!strncasecmp(start, "on", 2) || (*start == '1'))
396
 
    sh->forced_subs_only = 1;
397
 
  else if (!strncasecmp(start, "off", 3) || (*start == '0'))
398
 
    sh->forced_subs_only = 0;
399
 
  else
400
 
    return 0;
401
 
  mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] VobSub forced subs: %d\n",
402
 
         sh->forced_subs_only);
403
 
  return 8;
404
 
}
405
 
 
406
259
/** \brief Free cached demux packets
407
260
 *
408
261
 * Reordering the timecodes requires caching of demux packets. This function
432
285
}
433
286
 
434
287
static int
435
 
demux_mkv_parse_idx (mkv_track_t *t)
436
 
{
437
 
  int things_found, last;
438
 
  char *buf, *pos, *start;
439
 
 
440
 
  if ((t->private_data == NULL) || (t->private_size == 0))
441
 
    return 0;
442
 
 
443
 
  things_found = 0;
444
 
  buf = malloc(t->private_size + 1);
445
 
  if (buf == NULL)
446
 
    return 0;
447
 
  memcpy(buf, t->private_data, t->private_size);
448
 
  buf[t->private_size] = 0;
449
 
  t->sh_sub->has_palette = 0;
450
 
 
451
 
  pos = buf;
452
 
  start = buf;
453
 
  last = 0;
454
 
  do
455
 
    {
456
 
      if ((*pos == 0) || (*pos == '\r') || (*pos == '\n'))
457
 
        {
458
 
          if (*pos == 0)
459
 
            last = 1;
460
 
          *pos = 0;
461
 
 
462
 
          if (!strncasecmp(start, "size: ", 6))
463
 
            things_found |= vobsub_parse_size(t->sh_sub, start);
464
 
          else if (!strncasecmp(start, "palette:", 8))
465
 
            things_found |= vobsub_parse_palette(t->sh_sub, start);
466
 
          else if (!strncasecmp(start, "custom colors:", 14))
467
 
            things_found |= vobsub_parse_custom_colors(t->sh_sub, start);
468
 
          else if (!strncasecmp(start, "forced subs:", 12))
469
 
            things_found |= vobsub_parse_forced_subs(t->sh_sub, start);
470
 
 
471
 
          if (last)
472
 
            break;
473
 
          do
474
 
            {
475
 
              pos++;
476
 
            }
477
 
          while ((*pos == '\r') || (*pos == '\n'));
478
 
          start = pos;
479
 
        }
480
 
      else
481
 
        pos++;
482
 
    }
483
 
  while (!last && (*start != 0));
484
 
 
485
 
  free(buf);
486
 
 
487
 
  return (things_found & 3) == 3;
488
 
}
489
 
 
490
 
 
491
 
static int
492
288
demux_mkv_decode (mkv_track_t *track, uint8_t *src, uint8_t **dest,
493
289
                  uint32_t *size, uint32_t type)
494
290
{
504
300
      if (!(track->encodings[i].scope & type))
505
301
        continue;
506
302
 
507
 
#ifdef HAVE_ZLIB
 
303
#if CONFIG_ZLIB
508
304
      if (track->encodings[i].comp_algo == 0)
509
305
        {
510
306
          /* zlib encoded track */
556
352
          while (1)
557
353
            {
558
354
              int srclen = *size;
559
 
              if (dstlen > SIZE_MAX - LZO_OUTPUT_PADDING) goto lzo_fail;
560
 
              *dest = realloc (*dest, dstlen + LZO_OUTPUT_PADDING);
561
 
              result = lzo1x_decode (*dest, &dstlen, src, &srclen);
 
355
              if (dstlen > SIZE_MAX - AV_LZO_OUTPUT_PADDING) goto lzo_fail;
 
356
              *dest = realloc (*dest, dstlen + AV_LZO_OUTPUT_PADDING);
 
357
              result = av_lzo1x_decode (*dest, &dstlen, src, &srclen);
562
358
              if (result == 0)
563
359
                break;
564
 
              if (!(result & LZO_OUTPUT_FULL))
 
360
              if (!(result & AV_LZO_OUTPUT_FULL))
565
361
                {
566
362
lzo_fail:
567
363
                  mp_msg (MSGT_DEMUX, MSGL_WARN,
752
548
                                  MSGTR_MPDEMUX_MKV_UnknownCompression,
753
549
                                  track->tnum, e.comp_algo);
754
550
                        }
755
 
#ifndef HAVE_ZLIB
 
551
#if !CONFIG_ZLIB
756
552
                      else if (e.comp_algo == 0)
757
553
                        {
758
554
                          mp_msg (MSGT_DEMUX, MSGL_WARN,
940
736
 */
941
737
static void
942
738
demux_mkv_free_trackentry(mkv_track_t *track) {
943
 
  if (track->name)
944
 
    free (track->name);
945
 
  if (track->codec_id)
946
 
    free (track->codec_id);
947
 
  if (track->language)
948
 
    free (track->language);
949
 
  if (track->private_data)
950
 
    free (track->private_data);
951
 
  if (track->audio_buf)
952
 
    free (track->audio_buf);
953
 
  if (track->audio_timestamp)
954
 
    free (track->audio_timestamp);
955
 
#ifdef USE_ASS
956
 
  if (track->sh_sub && track->sh_sub->ass_track)
957
 
    ass_free_track (track->sh_sub->ass_track);
958
 
#endif
 
739
  free (track->name);
 
740
  free (track->codec_id);
 
741
  free (track->language);
 
742
  free (track->private_data);
 
743
  free (track->audio_buf);
 
744
  free (track->audio_timestamp);
959
745
  demux_mkv_free_encodings(track->encodings, track->num_encodings);
960
746
  free(track);
961
747
}
1074
860
            // audit: cheap guard against overflows later..
1075
861
            if (num > SIZE_MAX - 1000) return 0;
1076
862
            l = x + num;
1077
 
            track->private_data = malloc (num + LZO_INPUT_PADDING);
 
863
            track->private_data = malloc (num + AV_LZO_INPUT_PADDING);
1078
864
            if (stream_read(s, track->private_data, num) != (int) num)
1079
865
              goto err_out;
1080
866
            track->private_size = num;
1439
1225
static int
1440
1226
demux_mkv_read_attachments (demuxer_t *demuxer)
1441
1227
{
1442
 
  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1443
1228
  stream_t *s = demuxer->stream;
1444
1229
  uint64_t length, l;
1445
1230
  int il;
1457
1242
              int i;
1458
1243
              char* name = NULL;
1459
1244
              char* mime = NULL;
1460
 
              uint64_t uid = 0;
1461
1245
              char* data = NULL;
1462
1246
              int data_size = 0;
1463
1247
 
1466
1250
 
1467
1251
              mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + an attachment...\n");
1468
1252
 
1469
 
              grow_array(&mkv_d->attachments, mkv_d->num_attachments,
1470
 
                         sizeof(*mkv_d->attachments));
1471
 
 
1472
1253
              while (len > 0)
1473
1254
                {
1474
1255
                  uint64_t l;
1492
1273
                        mime);
1493
1274
                      break;
1494
1275
 
1495
 
                    case MATROSKA_ID_FILEUID:
1496
 
                      uid = ebml_read_uint (s, &l);
1497
 
                      break;
1498
 
 
1499
1276
                    case MATROSKA_ID_FILEDATA:
1500
1277
                      {
1501
1278
                        int x;
1521
1298
                  len -= l + il;
1522
1299
                }
1523
1300
 
1524
 
              mkv_d->attachments[mkv_d->num_attachments].name = name;
1525
 
              mkv_d->attachments[mkv_d->num_attachments].mime = mime;
1526
 
              mkv_d->attachments[mkv_d->num_attachments].uid = uid;
1527
 
              mkv_d->attachments[mkv_d->num_attachments].data = data;
1528
 
              mkv_d->attachments[mkv_d->num_attachments].data_size = data_size;
1529
 
              mkv_d->num_attachments ++;
 
1301
              demuxer_add_attachment(demuxer, name, mime, data, data_size);
1530
1302
              mp_msg(MSGT_DEMUX, MSGL_V,
1531
1303
                     "[mkv] Attachment: %s, %s, %u bytes\n",
1532
1304
                     name, mime, data_size);
1533
 
#ifdef USE_ASS
1534
 
              if (ass_library &&
1535
 
                  extract_embedded_fonts && name && data && data_size &&
1536
 
                  mime && (strcmp(mime, "application/x-truetype-font") == 0 ||
1537
 
                  strcmp(mime, "application/x-font") == 0))
1538
 
                ass_add_font(ass_library, name, data, data_size);
1539
 
#endif
1540
1305
              break;
1541
1306
            }
1542
1307
 
1819
1584
          stream_read(demuxer->stream, dst+8, cnt);
1820
1585
          track->realmedia = 1;
1821
1586
 
1822
 
#ifdef USE_QTX_CODECS
 
1587
#ifdef CONFIG_QTX_CODECS
1823
1588
        }
1824
1589
      else if (track->private_size >= sizeof (ImageDescription)
1825
1590
               && !strcmp(track->codec_id, MKV_V_QUICKTIME))
1845
1610
          bih->biPlanes = 1;
1846
1611
          bih->biCompression = idesc->cType;
1847
1612
          ImageDesc = idesc;
1848
 
#endif /* USE_QTX_CODECS */
 
1613
#endif /* CONFIG_QTX_CODECS */
1849
1614
 
1850
1615
        }
1851
1616
      else
1859
1624
              bih = realloc (bih, bih->biSize);
1860
1625
              memcpy (bih + 1, track->private_data, track->private_size);
1861
1626
            }
1862
 
          track->reorder_timecodes = !correct_pts;
 
1627
          track->reorder_timecodes = user_correct_pts == 0;
1863
1628
          if (!vi->id) {
1864
1629
              mp_msg (MSGT_DEMUX,MSGL_WARN, MSGTR_MPDEMUX_MKV_UnknownCodecID,
1865
1630
                      track->codec_id, track->tnum);
1910
1675
  if(!sh_a) return 1;
1911
1676
  mkv_d->audio_tracks[mkv_d->last_aid] = track->tnum;
1912
1677
 
 
1678
  if (track->language && (strcmp(track->language, "und") != 0))
 
1679
    sh_a->lang = strdup(track->language);
 
1680
  sh_a->default_track = track->default_track;
1913
1681
  sh_a->ds = demuxer->audio;
1914
1682
  sh_a->wf = malloc (sizeof (WAVEFORMATEX));
1915
1683
  if (track->ms_compat && (track->private_size >= sizeof(WAVEFORMATEX)))
1966
1734
        track->a_formattag = mmioFOURCC('Q', 'D', 'M', 'C');
1967
1735
      else if (!strcmp(track->codec_id, MKV_A_QDMC2))
1968
1736
        track->a_formattag = mmioFOURCC('Q', 'D', 'M', '2');
 
1737
      else if (!strcmp(track->codec_id, MKV_A_WAVPACK))
 
1738
        track->a_formattag = mmioFOURCC('W', 'V', 'P', 'K');
1969
1739
      else if (!strcmp(track->codec_id, MKV_A_FLAC))
1970
1740
        {
1971
1741
          if (track->private_data == NULL || track->private_size == 0)
2205
1975
      dp->flags = 0;
2206
1976
      ds_add_packet (demuxer->audio, dp);
2207
1977
    }
 
1978
  else if (track->a_formattag == mmioFOURCC('W', 'V', 'P', 'K'))
 
1979
    {  /* do nothing, still works */  }
2208
1980
  else if (!track->ms_compat || (track->private_size < sizeof(WAVEFORMATEX)))
2209
1981
    {
2210
1982
      free_sh_audio(demuxer, track->tnum);
2214
1986
  return 0;
2215
1987
}
2216
1988
 
2217
 
/** \brief Parse the private data for VobSub subtitle tracks.
2218
 
 
2219
 
  This function tries to parse the private data for all VobSub tracks.
2220
 
  The private data contains the normal text from the original .idx file.
2221
 
  Things like the palette, subtitle dimensions and custom colors are
2222
 
  stored here.
2223
 
 
2224
 
  \param demuxer The generic demuxer.
2225
 
*/
2226
 
static void
2227
 
demux_mkv_parse_vobsub_data (demuxer_t *demuxer)
2228
 
{
2229
 
  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2230
 
  mkv_track_t *track;
2231
 
  int i, m, size;
2232
 
  uint8_t *buffer;
2233
 
 
2234
 
  for (i = 0; i < mkv_d->num_tracks; i++)
2235
 
    {
2236
 
      track = mkv_d->tracks[i];
2237
 
      if ((track->type != MATROSKA_TRACK_SUBTITLE) ||
2238
 
          (track->subtitle_type != MATROSKA_SUBTYPE_VOBSUB))
2239
 
        continue;
2240
 
 
2241
 
      size = track->private_size;
2242
 
      m = demux_mkv_decode (track,track->private_data,&buffer,&size,2);
2243
 
      if (buffer && m)
2244
 
        {
2245
 
          free (track->private_data);
2246
 
          track->private_data = buffer;
2247
 
          track->private_size = size;
2248
 
        }
2249
 
      if (!demux_mkv_parse_idx (track))
2250
 
        {
2251
 
          free (track->private_data);
2252
 
          track->private_data = NULL;
2253
 
          track->private_size = 0;
2254
 
        }
2255
 
    }
2256
 
}
2257
 
 
2258
 
/** \brief Parse the private data for SSA/ASS subtitle tracks.
2259
 
 
2260
 
  This function tries to parse the private data for all SSA/ASS tracks.
2261
 
  The private data contains the normal text from the original script,
2262
 
  from the start to the beginning of 'Events' section, including '[Events]' line.
2263
 
 
2264
 
  \param demuxer The generic demuxer.
2265
 
*/
2266
 
#ifdef USE_ASS
2267
 
static void
2268
 
demux_mkv_parse_ass_data (demuxer_t *demuxer)
2269
 
{
2270
 
  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2271
 
  mkv_track_t *track;
2272
 
  int i, m, size;
2273
 
  uint8_t *buffer;
2274
 
 
2275
 
  for (i = 0; i < mkv_d->num_tracks; i++)
2276
 
    {
2277
 
      track = mkv_d->tracks[i];
2278
 
      if (track->type != MATROSKA_TRACK_SUBTITLE ||
2279
 
          track->subtitle_type == MATROSKA_SUBTYPE_VOBSUB)
2280
 
        continue;
2281
 
 
2282
 
      if (track->subtitle_type == MATROSKA_SUBTYPE_SSA)
2283
 
        {
2284
 
          track->sh_sub->ass_track = ass_new_track(ass_library);
2285
 
          size = track->private_size;
2286
 
          m = demux_mkv_decode (track,track->private_data,&buffer,&size,2);
2287
 
          if (buffer && m)
2288
 
            {
2289
 
              free (track->private_data);
2290
 
              track->private_data = buffer;
2291
 
              track->private_size = size;
2292
 
            }
2293
 
          ass_process_codec_private(track->sh_sub->ass_track, track->private_data, track->private_size);
2294
 
        }
2295
 
    }
2296
 
}
2297
 
#endif
2298
 
 
2299
1989
static int
2300
1990
demux_mkv_open_sub (demuxer_t *demuxer, mkv_track_t *track, int sid)
2301
1991
{
2302
1992
  if (track->subtitle_type != MATROSKA_SUBTYPE_UNKNOWN)
2303
1993
    {
 
1994
      int size, m;
 
1995
      uint8_t *buffer;
2304
1996
      sh_sub_t *sh = new_sh_sub_sid(demuxer, track->tnum, sid);
2305
1997
      track->sh_sub = sh;
2306
1998
      sh->type = 't';
2308
2000
        sh->type = 'v';
2309
2001
      if (track->subtitle_type == MATROSKA_SUBTYPE_SSA)
2310
2002
        sh->type = 'a';
 
2003
      size = track->private_size;
 
2004
      m = demux_mkv_decode (track,track->private_data,&buffer,&size,2);
 
2005
      if (buffer && m)
 
2006
        {
 
2007
          free (track->private_data);
 
2008
          track->private_data = buffer;
 
2009
          track->private_size = size;
 
2010
        }
 
2011
      sh->extradata=malloc(track->private_size);
 
2012
      memcpy (sh->extradata, track->private_data,
 
2013
              track->private_size);
 
2014
      sh->extradata_len = track->private_size;
 
2015
      if (track->language && (strcmp(track->language, "und") != 0))
 
2016
        sh->lang = strdup(track->language);
 
2017
      sh->default_track = track->default_track;
2311
2018
    }
2312
2019
  else
2313
2020
    {
2321
2028
 
2322
2029
static void demux_mkv_seek (demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags);
2323
2030
 
2324
 
/** \brief Given a matroska track number and type, find the id that mplayer would ask for.
2325
 
 *  \param d The demuxer for which the subtitle id should be returned.
2326
 
 *  \param num The matroska track number we are looking up.
2327
 
 *  \param type The track type.
2328
 
 */
2329
 
static int demux_mkv_reverse_id(mkv_demuxer_t *d, int num, int type)
2330
 
{
2331
 
  int i, id;
2332
 
  
2333
 
  for (i=0, id=0; i < d->num_tracks; i++)
2334
 
    if (d->tracks[i] != NULL && d->tracks[i]->type == type) {
2335
 
      if (d->tracks[i]->tnum == num)
2336
 
        return id;
2337
 
      id++;
2338
 
    }
2339
 
  
2340
 
  return -1;
2341
 
}
2342
 
 
2343
2031
static int
2344
2032
demux_mkv_open (demuxer_t *demuxer)
2345
2033
{
2489
2177
 
2490
2178
  /* select audio track */
2491
2179
  track = NULL;
2492
 
  if (demuxer->audio->id == -1)  /* automatically select an audio track */
2493
 
    {
2494
 
      /* check if the user specified an audio language */
2495
 
      if (audio_lang != NULL)
2496
 
        track = demux_mkv_find_track_by_language(mkv_d, audio_lang,
2497
 
                                                 MATROSKA_TRACK_AUDIO);
2498
 
      if (track == NULL)
2499
 
        /* no audio language specified, or language not found */
2500
 
        /* search for an audio track that has the 'default' flag set */
2501
 
        for (i=0; i < mkv_d->num_tracks; i++)
2502
 
          if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO
2503
 
              && mkv_d->tracks[i]->default_track)
2504
 
            {
2505
 
              track = mkv_d->tracks[i];
2506
 
              break;
2507
 
            }
2508
 
 
2509
 
      if (track == NULL)
2510
 
        /* no track has the 'default' flag set */
2511
 
        /* let's take the first audio track */
2512
 
        for (i=0; i < mkv_d->num_tracks; i++)
2513
 
          if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO)
2514
 
            {
2515
 
              track = mkv_d->tracks[i];
2516
 
              break;
2517
 
            }
2518
 
    }
2519
 
  else if (demuxer->audio->id != -2)  /* -2 = no audio at all */
2520
 
    track = demux_mkv_find_track_by_num (mkv_d, demuxer->audio->id,
2521
 
                                         MATROSKA_TRACK_AUDIO);
 
2180
  if (track == NULL)
 
2181
    /* search for an audio track that has the 'default' flag set */
 
2182
    for (i=0; i < mkv_d->num_tracks; i++)
 
2183
      if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO
 
2184
          && mkv_d->tracks[i]->default_track)
 
2185
        {
 
2186
          track = mkv_d->tracks[i];
 
2187
          break;
 
2188
        }
 
2189
 
 
2190
  if (track == NULL)
 
2191
    /* no track has the 'default' flag set */
 
2192
    /* let's take the first audio track */
 
2193
    for (i=0; i < mkv_d->num_tracks; i++)
 
2194
      if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO)
 
2195
        {
 
2196
          track = mkv_d->tracks[i];
 
2197
          break;
 
2198
        }
 
2199
 
2522
2200
  if (track && demuxer->a_streams[track->tnum])
2523
2201
    {
2524
2202
      demuxer->audio->id = track->tnum;
2544
2222
        }
2545
2223
    }
2546
2224
 
2547
 
  demux_mkv_parse_vobsub_data (demuxer);
2548
 
#ifdef USE_ASS
2549
 
  if (ass_enabled)
2550
 
    demux_mkv_parse_ass_data (demuxer);
2551
 
#endif
2552
 
  /* DO NOT automatically select a subtitle track and behave like DVD */
2553
 
  /* playback: only show subtitles if the user explicitely wants them. */
2554
 
  track = NULL;
2555
 
  if (demuxer->sub->id >= 0)
2556
 
    track = demux_mkv_find_track_by_num (mkv_d, demuxer->sub->id,
2557
 
                                         MATROSKA_TRACK_SUBTITLE);
2558
 
  else if (dvdsub_lang != NULL)
2559
 
    track = demux_mkv_find_track_by_language (mkv_d, dvdsub_lang,
2560
 
                                              MATROSKA_TRACK_SUBTITLE);
2561
 
 
2562
 
  if (track)
2563
 
          {
2564
 
            mp_msg (MSGT_DEMUX, MSGL_INFO,
2565
 
                    MSGTR_MPDEMUX_MKV_WillDisplaySubtitleTrack, track->tnum);
2566
 
            dvdsub_id = demux_mkv_reverse_id(mkv_d, track->tnum, MATROSKA_TRACK_SUBTITLE);
2567
 
            demuxer->sub->id = track->tnum;
2568
 
            demuxer->sub->sh = demuxer->s_streams[track->tnum];
2569
 
          }
2570
 
  else
2571
 
    demuxer->sub->id = -2;
2572
 
 
2573
2225
  if (demuxer->chapters)
2574
2226
    {
2575
2227
      for (i=0; i < (int)demuxer->num_chapters; i++)
2593
2245
      demuxer->movi_start = s->start_pos;
2594
2246
      demuxer->movi_end = s->end_pos;
2595
2247
      demuxer->seekable = 1;
2596
 
      if (demuxer->chapters && dvd_chapter>1 && dvd_chapter<=demuxer->num_chapters)
2597
 
        {
2598
 
          if (!mkv_d->has_first_tc)
2599
 
            {
2600
 
              mkv_d->first_tc = 0;
2601
 
              mkv_d->has_first_tc = 1;
2602
 
            }
2603
 
          demux_mkv_seek (demuxer,
2604
 
                          demuxer->chapters[dvd_chapter-1].start/1000.0, 0.0, 1);
2605
 
        }
2606
2248
    }
2607
2249
 
2608
2250
  return DEMUXER_TYPE_MATROSKA;
2623
2265
            demux_mkv_free_trackentry(mkv_d->tracks[i]);
2624
2266
          free (mkv_d->tracks);
2625
2267
        }
2626
 
      if (mkv_d->indexes)
2627
 
        free (mkv_d->indexes);
2628
 
      if (mkv_d->cluster_positions)
2629
 
        free (mkv_d->cluster_positions);
2630
 
      if (mkv_d->parsed_cues)
2631
 
        free (mkv_d->parsed_cues);
2632
 
      if (mkv_d->parsed_seekhead)
2633
 
        free (mkv_d->parsed_seekhead);
2634
 
      if (mkv_d->attachments) {
2635
 
        for (i = 0; i < mkv_d->num_attachments; ++i) {
2636
 
          if (mkv_d->attachments[i].name)
2637
 
            free (mkv_d->attachments[i].name);
2638
 
          if (mkv_d->attachments[i].mime)
2639
 
            free (mkv_d->attachments[i].mime);
2640
 
          if (mkv_d->attachments[i].data)
2641
 
            free (mkv_d->attachments[i].data);
2642
 
        }
2643
 
        free (mkv_d->attachments);
2644
 
      }
 
2268
      free (mkv_d->indexes);
 
2269
      free (mkv_d->cluster_positions);
 
2270
      free (mkv_d->parsed_cues);
 
2271
      free (mkv_d->parsed_seekhead);
2645
2272
      free (mkv_d);
2646
2273
    }
2647
2274
}
2737
2364
                 int64_t size, uint64_t block_duration, uint64_t timecode)
2738
2365
{
2739
2366
  demux_packet_t *dp;
2740
 
  char *ptr1;
2741
 
  int i;
2742
2367
 
2743
2368
  if (block_duration == 0)
2744
2369
    {
2747
2372
      return;
2748
2373
    }
2749
2374
 
2750
 
#ifdef USE_ASS
2751
 
  if (ass_enabled && track->subtitle_type == MATROSKA_SUBTYPE_SSA) {
2752
 
    ass_process_chunk(track->sh_sub->ass_track, block, size, (long long)timecode, (long long)block_duration);
2753
 
    return;
2754
 
  }
2755
 
#endif
2756
 
 
2757
 
  ptr1 = block;
2758
 
  if (track->subtitle_type == MATROSKA_SUBTYPE_SSA)
2759
 
    {
2760
 
      /* Find text section. */
2761
 
      for (i=0; i < 8 && *ptr1 != '\0'; ptr1++)
2762
 
        if (*ptr1 == ',')
2763
 
          i++;
2764
 
      if (*ptr1 == '\0')  /* Broken line? */
2765
 
        return;
2766
 
    }
2767
 
 
2768
2375
  sub_utf8 = 1;
2769
 
  size -= ptr1 - block;
2770
2376
  dp = new_demux_packet(size);
2771
 
  memcpy(dp->buffer, ptr1, size);
 
2377
  memcpy(dp->buffer, block, size);
2772
2378
  dp->pts = timecode / 1000.0f;
2773
2379
  dp->endpts = (timecode + block_duration) / 1000.0f;
2774
2380
  ds_add_packet(demuxer->sub, dp);
2775
2381
}
2776
2382
 
2777
 
// Taken from demux_real.c. Thanks to the original developpers :)
2778
 
#define SKIP_BITS(n) buffer <<= n
2779
 
#define SHOW_BITS(n) ((buffer) >> (32 - (n)))
2780
 
 
2781
 
static float real_fix_timestamp(mkv_track_t *track, unsigned char *s,
2782
 
                                int timestamp) {
2783
 
  float v_pts;
2784
 
  uint32_t buffer = (s[0] << 24) + (s[1] << 16) + (s[2] << 8) + s[3];
2785
 
  int kf = timestamp;
2786
 
  int pict_type;
2787
 
  int orig_kf;
2788
 
 
2789
 
  if (!strcmp(track->codec_id, MKV_V_REALV30) ||
2790
 
      !strcmp(track->codec_id, MKV_V_REALV40)) {
2791
 
 
2792
 
    if (!strcmp(track->codec_id, MKV_V_REALV30)) {
2793
 
      SKIP_BITS(3);
2794
 
      pict_type = SHOW_BITS(2);
2795
 
      SKIP_BITS(2 + 7);
2796
 
    }else{
2797
 
      SKIP_BITS(1);
2798
 
      pict_type = SHOW_BITS(2);
2799
 
      SKIP_BITS(2 + 7 + 3);
2800
 
    }
2801
 
    kf = SHOW_BITS(13);         // kf= 2*SHOW_BITS(12);
2802
 
    orig_kf = kf;
2803
 
    if (pict_type <= 1) {
2804
 
      // I frame, sync timestamps:
2805
 
      track->rv_kf_base = timestamp - kf;
2806
 
      mp_msg(MSGT_DEMUX, MSGL_DBG2, "\nTS: base=%08X\n", track->rv_kf_base);
2807
 
      kf = timestamp;
2808
 
    } else {
2809
 
      // P/B frame, merge timestamps:
2810
 
      int tmp = timestamp - track->rv_kf_base;
2811
 
      kf |= tmp & (~0x1fff);    // combine with packet timestamp
2812
 
      if (kf < (tmp - 4096))    // workaround wrap-around problems
2813
 
        kf += 8192;
2814
 
      else if (kf > (tmp + 4096))
2815
 
        kf -= 8192;
2816
 
      kf += track->rv_kf_base;
2817
 
    }
2818
 
    if (pict_type != 3) {       // P || I  frame -> swap timestamps
2819
 
      int tmp = kf;
2820
 
      kf = track->rv_kf_pts;
2821
 
      track->rv_kf_pts = tmp;
2822
 
    }
2823
 
    mp_msg(MSGT_DEMUX, MSGL_DBG2, "\nTS: %08X -> %08X (%04X) %d %02X %02X %02X "
2824
 
           "%02X %5d\n", timestamp, kf, orig_kf, pict_type, s[0], s[1], s[2],
2825
 
           s[3], kf - (int)(1000.0 * track->rv_pts));
2826
 
  }
2827
 
  v_pts = kf * 0.001f;
2828
 
  track->rv_pts = v_pts;
2829
 
 
2830
 
  return v_pts;
2831
 
}
 
2383
double real_fix_timestamp(unsigned char *buf, unsigned int timestamp, unsigned int format, int64_t *kf_base, int *kf_pts, double *pts);
2832
2384
 
2833
2385
static void
2834
2386
handle_realvideo (demuxer_t *demuxer, mkv_track_t *track, uint8_t *buffer,
2837
2389
  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2838
2390
  demux_packet_t *dp;
2839
2391
  uint32_t timestamp = mkv_d->last_pts * 1000;
2840
 
  uint32_t *hdr;
2841
 
  uint8_t chunks;
2842
 
  int isize;
2843
 
#ifdef WORDS_BIGENDIAN
2844
 
  uint8_t *p;
2845
 
  int i;
2846
 
#endif
2847
 
 
2848
 
  chunks = *buffer++;
2849
 
  isize = --size - (chunks+1)*8;
2850
 
  dp = new_demux_packet (REALHEADER_SIZE + size);
2851
 
  memcpy (dp->buffer + REALHEADER_SIZE, buffer + (chunks+1)*8, isize);
2852
 
#ifdef WORDS_BIGENDIAN
2853
 
  p = (uint8_t *)(dp->buffer + REALHEADER_SIZE + isize);
2854
 
  for (i = 0; i<(chunks+1)*8; i+=4) {
2855
 
    p[i] = *((uint8_t *)buffer+i+3);
2856
 
    p[i+1] = *((uint8_t *)buffer+i+2);
2857
 
    p[i+2] = *((uint8_t *)buffer+i+1);
2858
 
    p[i+3] = *((uint8_t *)buffer+i);
2859
 
  }
2860
 
#else
2861
 
  memcpy (dp->buffer + REALHEADER_SIZE + isize, buffer, (chunks+1)*8);
2862
 
#endif
2863
 
 
2864
 
  hdr = dp->buffer;
2865
 
  *hdr++ = chunks;                 // number of chunks
2866
 
  *hdr++ = timestamp;              // timestamp from packet header
2867
 
  *hdr++ = isize;                  // length of actual data
2868
 
  *hdr++ = REALHEADER_SIZE + isize;    // offset to chunk offset array
 
2392
 
 
2393
  dp = new_demux_packet (size);
 
2394
  memcpy (dp->buffer, buffer, size);
2869
2395
 
2870
2396
  if (mkv_d->v_skip_to_keyframe)
2871
2397
    {
2874
2400
      track->rv_kf_pts = timestamp;
2875
2401
    }
2876
2402
  else
2877
 
    dp->pts = real_fix_timestamp (track, dp->buffer + REALHEADER_SIZE,
2878
 
                                  timestamp);
 
2403
    dp->pts = real_fix_timestamp (dp->buffer, timestamp,
 
2404
                                  ((sh_video_t*)demuxer->video->sh)->bih->biCompression,
 
2405
                                  &track->rv_kf_base, &track->rv_kf_pts, NULL);
2879
2406
  dp->pos = demuxer->filepos;
2880
2407
  dp->flags = block_bref ? 0 : 0x10;
2881
2408
 
3270
2797
                case MATROSKA_ID_BLOCK:
3271
2798
                  block_length = ebml_read_length (s, &tmp);
3272
2799
                  free(block);
3273
 
                  if (block_length > SIZE_MAX - LZO_INPUT_PADDING) return 0;
3274
 
                  block = malloc (block_length + LZO_INPUT_PADDING);
 
2800
                  if (block_length > SIZE_MAX - AV_LZO_INPUT_PADDING) return 0;
 
2801
                  block = malloc (block_length + AV_LZO_INPUT_PADDING);
3275
2802
                  demuxer->filepos = stream_tell (s);
3276
2803
                  if (stream_read (s,block,block_length) != (int) block_length)
3277
2804
                  {
3388
2915
demux_mkv_seek (demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags)
3389
2916
{
3390
2917
  free_cached_dps (demuxer);
3391
 
  if (!(flags & 2))  /* time in secs */
 
2918
  if (!(flags & SEEK_FACTOR))  /* time in secs */
3392
2919
    {
3393
2920
      mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3394
2921
      stream_t *s = demuxer->stream;
3395
2922
      int64_t target_timecode = 0, diff, min_diff=0xFFFFFFFFFFFFFFFLL;
3396
2923
      int i;
3397
2924
 
3398
 
      if (!(flags & 1))  /* relative seek */
 
2925
      if (!(flags & SEEK_ABSOLUTE))  /* relative seek */
3399
2926
        target_timecode = (int64_t) (mkv_d->last_pts * 1000.0);
3400
2927
      target_timecode += (int64_t)(rel_seek_secs * 1000.0);
3401
2928
      if (target_timecode < 0)
3470
2997
                diff = target_timecode + mkv_d->first_tc -
3471
2998
                       (int64_t) mkv_d->indexes[i].timecode * mkv_d->tc_scale / 1000000.0;
3472
2999
 
3473
 
                if ((flags & 1 || target_timecode <= mkv_d->last_pts*1000)) {
 
3000
                if ((flags & SEEK_ABSOLUTE || target_timecode <= mkv_d->last_pts*1000)) {
3474
3001
                    // Absolute seek or seek backward: find the last index
3475
3002
                    // position before target time
3476
3003
                    if (diff < 0 || diff >= min_diff)
3507
3034
 
3508
3035
      demux_mkv_fill_buffer(demuxer, NULL);
3509
3036
    }
3510
 
  else if ((demuxer->movi_end <= 0) || !(flags & 1))
 
3037
  else if ((demuxer->movi_end <= 0) || !(flags & SEEK_ABSOLUTE))
3511
3038
    mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] seek unsupported flags\n");
3512
3039
  else
3513
3040
    {
3554
3081
  
3555
3082
  switch (cmd)
3556
3083
    {
 
3084
    case DEMUXER_CTRL_CORRECT_PTS:
 
3085
      return DEMUXER_CTRL_OK;
3557
3086
    case DEMUXER_CTRL_GET_TIME_LENGTH:
3558
3087
      if (mkv_d->duration == 0)
3559
3088
        return DEMUXER_CTRL_DONTKNOW;
3594
3123
    }
3595
3124
}
3596
3125
 
3597
 
/** \brief Get the language code for a subtitle track.
3598
 
 
3599
 
  Retrieves the language code for a subtitle track if it is known.
3600
 
  If the language code is "und" then do not copy it ("und" = "undefined").
3601
 
 
3602
 
  \param demuxer The demuxer to work on
3603
 
  \param track_num The subtitle track number to get the language from
3604
 
  \param lang Store the language here
3605
 
  \param maxlen The maximum number of characters to copy into lang
3606
 
*/
3607
 
void
3608
 
demux_mkv_get_sub_lang(demuxer_t *demuxer, int track_num, char *lang,
3609
 
                       int maxlen)
3610
 
{
3611
 
  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3612
 
  mkv_track_t *track = demux_mkv_find_track_by_num (mkv_d, track_num, MATROSKA_TRACK_SUBTITLE);
3613
 
  if (track && track->language && strcmp(track->language, "und"))
3614
 
    av_strlcpy(lang, track->language, maxlen);
3615
 
}
3616
 
 
3617
 
/** \brief Get the language code for an audio track.
3618
 
 
3619
 
  Retrieves the language code for an audio track if it is known.
3620
 
  If the language code is "und" then do not copy it ("und" = "undefined").
3621
 
 
3622
 
  \param demuxer The demuxer to work on
3623
 
  \param track_num The n'th audio track to get the language from
3624
 
  \param lang Store the language here
3625
 
  \param maxlen The maximum number of characters to copy into lang
3626
 
*/
3627
 
void
3628
 
demux_mkv_get_audio_lang(demuxer_t *demuxer, int track_num, char *lang,
3629
 
                       int maxlen)
3630
 
{
3631
 
  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3632
 
  mkv_track_t *track = demux_mkv_find_track_by_num (mkv_d, track_num, MATROSKA_TRACK_AUDIO);
3633
 
  if (track && track->language && strcmp(track->language, "und"))
3634
 
    av_strlcpy(lang, track->language, maxlen);
3635
 
}
3636
 
 
3637
 
 
3638
 
demuxer_desc_t demuxer_desc_matroska = {
 
3126
const demuxer_desc_t demuxer_desc_matroska = {
3639
3127
  "Matroska demuxer",
3640
3128
  "mkv",
3641
3129
  "Matroska",