apps/codecs/libm4a/demux.c

   1 /*
   2  * ALAC (Apple Lossless Audio Codec) decoder
   3  * Copyright (c) 2005 David Hammerton
   4  * All rights reserved.
   5  *
   6  * This is the quicktime container demuxer.
   7  *
   8  * http://crazney.net/programs/itunes/alac.html
   9  *
  10  * Permission is hereby granted, free of charge, to any person
  11  * obtaining a copy of this software and associated documentation
  12  * files (the "Software"), to deal in the Software without
  13  * restriction, including without limitation the rights to use,
  14  * copy, modify, merge, publish, distribute, sublicense, and/or
  15  * sell copies of the Software, and to permit persons to whom the
  16  * Software is furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be
  19  * included in all copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  23  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  25  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  26  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  27  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  28  * OTHER DEALINGS IN THE SOFTWARE.
  29  *
  30  */
  31
  32 #include <string.h>
  33 #include <inttypes.h>
  34 #include <stdlib.h>
  35
  36 #include "codeclib.h"
  37
  38 #include "m4a.h"
  39
  40 #undef DEBUGF
  41 #if defined(DEBUG)
  42 #define DEBUGF qtmovie->stream->ci->debugf
  43 #else
  44 #define DEBUGF(...)
  45 #endif
  46
  47 typedef struct
  48 {
  49     stream_t *stream;
  50     demux_res_t *res;
  51 } qtmovie_t;
  52
  53
  54 /* chunk handlers */
  55 static void read_chunk_ftyp(qtmovie_t *qtmovie, size_t chunk_len)
  56 {
  57     fourcc_t type;
  58     uint32_t minor_ver;
  59     size_t size_remaining = chunk_len - 8;
  60
  61     type = stream_read_uint32(qtmovie->stream);
  62     size_remaining-=4;
  63     if ((type != MAKEFOURCC('M','4','A',' ')) &&
  64         (type != MAKEFOURCC('M','4','B',' ')) &&
  65         (type != MAKEFOURCC('m','p','4','2')) &&
  66         (type != MAKEFOURCC('3','g','p','6')) &&
  67         (type != MAKEFOURCC('q','t',' ',' ')) &&
  68         (type != MAKEFOURCC('i','s','o','m')))
  69     {
  70         DEBUGF("not M4A file\n");
  71         return;
  72     }
  73     minor_ver = stream_read_uint32(qtmovie->stream);
  74     size_remaining-=4;
  75
  76     /* compatible brands */
  77     while (size_remaining)
  78     {
  79         /* unused */
  80         /*fourcc_t cbrand =*/ stream_read_uint32(qtmovie->stream);
  81         size_remaining-=4;
  82     }
  83 }
  84
  85 static uint32_t mp4ff_read_mp4_descr_length(stream_t* stream)
  86 {
  87     uint8_t b;
  88     uint8_t numBytes = 0;
  89     uint32_t length = 0;
  90
  91     do
  92     {
  93         b = stream_read_uint8(stream);
  94         numBytes++;
  95         length = (length << 7) | (b & 0x7F);
  96     } while ((b & 0x80) && numBytes < 4);
  97
  98     return length;
  99 }
 100
 101 /* The following function is based on mp4ff */
 102 static bool read_chunk_esds(qtmovie_t *qtmovie, size_t chunk_len)
 103 {
 104     uint8_t tag;
 105     uint32_t temp;
 106     int audioType;
 107     int32_t maxBitrate;
 108     int32_t avgBitrate;
 109
 110     (void)chunk_len;
 111     /* version and flags */
 112     temp=stream_read_uint32(qtmovie->stream);
 113
 114     /* get and verify ES_DescrTag */
 115     tag = stream_read_uint8(qtmovie->stream);
 116     if (tag == 0x03)
 117     {
 118         /* read length */
 119         if (mp4ff_read_mp4_descr_length(qtmovie->stream) < 5 + 15)
 120         {
 121             return false;
 122         }
 123         /* skip 3 bytes */
 124         stream_skip(qtmovie->stream,3);
 125     } else {
 126         /* skip 2 bytes */
 127         stream_skip(qtmovie->stream,2);
 128     }
 129
 130     /* get and verify DecoderConfigDescrTab */
 131     if (stream_read_uint8(qtmovie->stream) != 0x04)
 132     {
 133         return false;
 134     }
 135
 136     /* read length */
 137     temp = mp4ff_read_mp4_descr_length(qtmovie->stream);
 138     if (temp < 13) return false;
 139
 140     audioType = stream_read_uint8(qtmovie->stream);
 141     temp=stream_read_int32(qtmovie->stream);//0x15000414 ????
 142     maxBitrate = stream_read_int32(qtmovie->stream);
 143     avgBitrate = stream_read_int32(qtmovie->stream);
 144     DEBUGF("audioType=%d, maxBitrate=%ld, avgBitrate=%ld\n",audioType,
 145            (long)maxBitrate,(long)avgBitrate);
 146
 147     /* get and verify DecSpecificInfoTag */
 148     if (stream_read_uint8(qtmovie->stream) != 0x05)
 149     {
 150         return false;
 151     }
 152
 153     /* read length */
 154     qtmovie->res->codecdata_len = mp4ff_read_mp4_descr_length(qtmovie->stream);
 155     if (qtmovie->res->codecdata_len > MAX_CODECDATA_SIZE)
 156     {
 157         DEBUGF("codecdata too large (%d) in esds\n",
 158                (int)qtmovie->res->codecdata_len);
 159         return false;
 160     }
 161
 162     stream_read(qtmovie->stream, qtmovie->res->codecdata_len, qtmovie->res->codecdata);
 163
 164     /* will skip the remainder of the atom */
 165     return true;
 166 }
 167
 168 static bool read_chunk_stsd(qtmovie_t *qtmovie, size_t chunk_len)
 169 {
 170     unsigned int i;
 171     int j;
 172     uint32_t numentries;
 173     size_t size_remaining = chunk_len - 8;
 174
 175     /* version */
 176     stream_read_uint8(qtmovie->stream);
 177     size_remaining -= 1;
 178     /* flags */
 179     stream_read_uint8(qtmovie->stream);
 180     stream_read_uint8(qtmovie->stream);
 181     stream_read_uint8(qtmovie->stream);
 182     size_remaining -= 3;
 183
 184     numentries = stream_read_uint32(qtmovie->stream);
 185     size_remaining -= 4;
 186
 187     if (numentries != 1)
 188     {
 189         DEBUGF("only expecting one entry in sample description atom!\n");
 190         return false;
 191     }
 192
 193     for (i = 0; i < numentries; i++)
 194     {
 195         uint32_t entry_size;
 196
 197         uint32_t entry_remaining;
 198
 199         entry_size = stream_read_uint32(qtmovie->stream);
 200         qtmovie->res->format = stream_read_uint32(qtmovie->stream);
 201         DEBUGF("format: %c%c%c%c\n",SPLITFOURCC(qtmovie->res->format));
 202         entry_remaining = entry_size;
 203         entry_remaining -= 8;
 204
 205         /* sound info: */
 206
 207         /* reserved + data reference index + sound version + reserved */
 208         stream_skip(qtmovie->stream, 6 + 2 + 2 + 6);
 209         entry_remaining -= 6 + 2 + 2 + 6;
 210
 211         qtmovie->res->num_channels = stream_read_uint16(qtmovie->stream);
 212         qtmovie->res->sound_sample_size = stream_read_uint16(qtmovie->stream);
 213         entry_remaining -= 4;
 214
 215         /* packet size */
 216         stream_skip(qtmovie->stream, 2);
 217         qtmovie->res->sound_sample_rate = stream_read_uint32(qtmovie->stream);
 218         /* reserved size */
 219         stream_skip(qtmovie->stream, 2);
 220         entry_remaining -= 8;
 221
 222         /* remaining is codec data */
 223
 224         if ((qtmovie->res->format==MAKEFOURCC('a','l','a','c'))) {
 225           if (qtmovie->stream->ci->id3->codectype!=AFMT_MP4_ALAC) {
 226                return false;
 227           }
 228
 229           /* 12 = audio format atom, 8 = padding */
 230           qtmovie->res->codecdata_len = entry_remaining + 12 + 8;
 231           if (qtmovie->res->codecdata_len > MAX_CODECDATA_SIZE)
 232           {
 233               DEBUGF("codecdata too large (%d) in stsd\n",
 234                       (int)qtmovie->res->codecdata_len);
 235               return false;
 236           }
 237
 238           memset(qtmovie->res->codecdata, 0, qtmovie->res->codecdata_len);
 239           /* audio format atom */
 240 #if 0
 241           /* The ALAC decoder skips these bytes, so there is no need to store them,
 242              and this code isn't endian/alignment safe */
 243           ((unsigned int*)qtmovie->res->codecdata)[0] = 0x0c000000;
 244           ((unsigned int*)qtmovie->res->codecdata)[1] = MAKEFOURCC('a','m','r','f');
 245           ((unsigned int*)qtmovie->res->codecdata)[2] = MAKEFOURCC('c','a','l','a');
 246 #endif
 247
 248           stream_read(qtmovie->stream,
 249                   entry_remaining,
 250                   ((char*)qtmovie->res->codecdata) + 12);
 251           entry_remaining -= entry_remaining;
 252
 253           if (entry_remaining)
 254               stream_skip(qtmovie->stream, entry_remaining);
 255
 256         } else if (qtmovie->res->format==MAKEFOURCC('m','p','4','a')) {
 257           if (qtmovie->stream->ci->id3->codectype!=AFMT_MP4_AAC) {
 258                return false;
 259           }
 260
 261           size_t sub_chunk_len;
 262           fourcc_t sub_chunk_id;
 263
 264           sub_chunk_len = stream_read_uint32(qtmovie->stream);
 265           if (sub_chunk_len <= 1 || sub_chunk_len > entry_remaining)
 266           {
 267               DEBUGF("strange size (%lu) for chunk inside mp4a\n",
 268                      (unsigned long)sub_chunk_len);
 269               return false;
 270           }
 271
 272           sub_chunk_id = stream_read_uint32(qtmovie->stream);
 273
 274           if (sub_chunk_id != MAKEFOURCC('e','s','d','s'))
 275           {
 276               DEBUGF("Expected esds chunk inside mp4a, found %c%c%c%c\n",SPLITFOURCC(sub_chunk_id));
 277               return false;
 278           }
 279
 280           j=qtmovie->stream->ci->curpos+sub_chunk_len-8;
 281           if (read_chunk_esds(qtmovie,sub_chunk_len)) {
 282              if (j!=qtmovie->stream->ci->curpos) {
 283                DEBUGF("curpos=%ld, j=%d - Skipping %ld bytes\n",qtmovie->stream->ci->curpos,j,j-qtmovie->stream->ci->curpos);
 284                stream_skip(qtmovie->stream,j-qtmovie->stream->ci->curpos);
 285              }
 286              entry_remaining-=sub_chunk_len;
 287           } else {
 288               DEBUGF("Error reading esds\n");
 289               return false;
 290           }
 291
 292           DEBUGF("entry_remaining=%ld\n",(long)entry_remaining);
 293           stream_skip(qtmovie->stream,entry_remaining);
 294
 295         } else {
 296             DEBUGF("expecting 'alac' or 'mp4a' data format, got %c%c%c%c\n",
 297                  SPLITFOURCC(qtmovie->res->format));
 298             return false;
 299         }
 300     }
 301     return true;
 302 }
 303
 304 static bool read_chunk_stts(qtmovie_t *qtmovie, size_t chunk_len)
 305 {
 306     unsigned int i;
 307     uint32_t numentries;
 308     size_t size_remaining = chunk_len - 8;
 309
 310     /* version */
 311     stream_read_uint8(qtmovie->stream);
 312     size_remaining -= 1;
 313     /* flags */
 314     stream_read_uint8(qtmovie->stream);
 315     stream_read_uint8(qtmovie->stream);
 316     stream_read_uint8(qtmovie->stream);
 317     size_remaining -= 3;
 318
 319     numentries = stream_read_uint32(qtmovie->stream);
 320     size_remaining -= 4;
 321
 322     qtmovie->res->num_time_to_samples = numentries;
 323     qtmovie->res->time_to_sample = malloc(numentries * sizeof(*qtmovie->res->time_to_sample));
 324
 325     if (!qtmovie->res->time_to_sample)
 326     {
 327         DEBUGF("stts too large\n");
 328         return false;
 329     }
 330
 331     for (i = 0; i < numentries; i++)
 332     {
 333         qtmovie->res->time_to_sample[i].sample_count = stream_read_uint32(qtmovie->stream);
 334         qtmovie->res->time_to_sample[i].sample_duration = stream_read_uint32(qtmovie->stream);
 335         size_remaining -= 8;
 336     }
 337
 338     if (size_remaining)
 339     {
 340         DEBUGF("ehm, size remianing?\n");
 341         stream_skip(qtmovie->stream, size_remaining);
 342     }
 343
 344     return true;
 345 }
 346
 347 static bool read_chunk_stsz(qtmovie_t *qtmovie, size_t chunk_len)
 348 {
 349     unsigned int i;
 350     uint32_t numentries;
 351     size_t size_remaining = chunk_len - 8;
 352
 353     /* version */
 354     stream_read_uint8(qtmovie->stream);
 355     size_remaining -= 1;
 356     /* flags */
 357     stream_read_uint8(qtmovie->stream);
 358     stream_read_uint8(qtmovie->stream);
 359     stream_read_uint8(qtmovie->stream);
 360     size_remaining -= 3;
 361
 362     /* default sample size */
 363     if (stream_read_uint32(qtmovie->stream) != 0)
 364     {
 365         DEBUGF("i was expecting variable samples sizes\n");
 366         stream_read_uint32(qtmovie->stream);
 367         size_remaining -= 4;
 368         return true;
 369     }
 370     size_remaining -= 4;
 371
 372     numentries = stream_read_uint32(qtmovie->stream);
 373     size_remaining -= 4;
 374
 375     qtmovie->res->num_sample_byte_sizes = numentries;
 376     qtmovie->res->sample_byte_size = malloc(numentries * sizeof(*qtmovie->res->sample_byte_size));
 377
 378     if (!qtmovie->res->sample_byte_size)
 379     {
 380         DEBUGF("stsz too large\n");
 381         return false;
 382     }
 383
 384     for (i = 0; i < numentries; i++)
 385     {
 386         uint32_t v = stream_read_uint32(qtmovie->stream);
 387
 388         if (v > 0x0000ffff)
 389         {
 390             DEBUGF("stsz[%d] > 65 kB (%ld)\n", i, (long)v);
 391             return false;
 392         }
 393
 394         qtmovie->res->sample_byte_size[i] = v;
 395         size_remaining -= 4;
 396     }
 397
 398     if (size_remaining)
 399     {
 400         DEBUGF("ehm, size remianing?\n");
 401         stream_skip(qtmovie->stream, size_remaining);
 402     }
 403
 404     return true;
 405 }
 406
 407 static bool read_chunk_stsc(qtmovie_t *qtmovie, size_t chunk_len)
 408 {
 409     unsigned int i;
 410     uint32_t numentries;
 411     size_t size_remaining = chunk_len - 8;
 412
 413     /* version + flags */
 414     stream_read_uint32(qtmovie->stream);
 415     size_remaining -= 4;
 416
 417     numentries = stream_read_uint32(qtmovie->stream);
 418     size_remaining -= 4;
 419
 420     qtmovie->res->num_sample_to_chunks = numentries;
 421     qtmovie->res->sample_to_chunk = malloc(numentries *
 422         sizeof(*qtmovie->res->sample_to_chunk));
 423
 424     if (!qtmovie->res->sample_to_chunk)
 425     {
 426         DEBUGF("stsc too large\n");
 427         return false;
 428     }
 429
 430     for (i = 0; i < numentries; i++)
 431     {
 432         qtmovie->res->sample_to_chunk[i].first_chunk =
 433             stream_read_uint32(qtmovie->stream);
 434         qtmovie->res->sample_to_chunk[i].num_samples =
 435             stream_read_uint32(qtmovie->stream);
 436         stream_read_uint32(qtmovie->stream);
 437         size_remaining -= 12;
 438     }
 439
 440     if (size_remaining)
 441     {
 442         DEBUGF("ehm, size remianing?\n");
 443         stream_skip(qtmovie->stream, size_remaining);
 444     }
 445
 446     return true;
 447 }
 448
 449 static bool read_chunk_stco(qtmovie_t *qtmovie, size_t chunk_len)
 450 {
 451     unsigned int i;
 452     uint32_t numentries;
 453     size_t size_remaining = chunk_len - 8;
 454
 455     /* version + flags */
 456     stream_read_uint32(qtmovie->stream);
 457     size_remaining -= 4;
 458
 459     numentries = stream_read_uint32(qtmovie->stream);
 460     size_remaining -= 4;
 461
 462     qtmovie->res->num_chunk_offsets = numentries;
 463     qtmovie->res->chunk_offset = malloc(numentries *
 464         sizeof(*qtmovie->res->chunk_offset));
 465
 466     if (!qtmovie->res->chunk_offset)
 467     {
 468         DEBUGF("stco too large\n");
 469         return false;
 470     }
 471
 472     for (i = 0; i < numentries; i++)
 473     {
 474         qtmovie->res->chunk_offset[i] = stream_read_uint32(qtmovie->stream);
 475         size_remaining -= 4;
 476     }
 477
 478     if (size_remaining)
 479     {
 480         DEBUGF("ehm, size remianing?\n");
 481         stream_skip(qtmovie->stream, size_remaining);
 482     }
 483
 484     return true;
 485 }
 486
 487 static bool read_chunk_stbl(qtmovie_t *qtmovie, size_t chunk_len)
 488 {
 489     size_t size_remaining = chunk_len - 8;
 490
 491     while (size_remaining)
 492     {
 493         size_t sub_chunk_len;
 494         fourcc_t sub_chunk_id;
 495
 496         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 497         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 498         {
 499             DEBUGF("strange size (%lu) for chunk inside stbl\n",
 500                    (unsigned long)sub_chunk_len);
 501             return false;
 502         }
 503
 504         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 505
 506         switch (sub_chunk_id)
 507         {
 508         case MAKEFOURCC('s','t','s','d'):
 509             if (!read_chunk_stsd(qtmovie, sub_chunk_len)) {
 510                return false;
 511             }
 512             break;
 513         case MAKEFOURCC('s','t','t','s'):
 514             if (!read_chunk_stts(qtmovie, sub_chunk_len))
 515             {
 516                return false;
 517             }
 518             break;
 519         case MAKEFOURCC('s','t','s','z'):
 520             if (!read_chunk_stsz(qtmovie, sub_chunk_len))
 521             {
 522                return false;
 523             }
 524             break;
 525         case MAKEFOURCC('s','t','s','c'):
 526             if (!read_chunk_stsc(qtmovie, sub_chunk_len))
 527             {
 528                return false;
 529             }
 530             break;
 531         case MAKEFOURCC('s','t','c','o'):
 532             if (!read_chunk_stco(qtmovie, sub_chunk_len))
 533             {
 534                return false;
 535             }
 536             break;
 537         default:
 538             /*DEBUGF("(stbl) unknown chunk id: %c%c%c%c\n",
 539                    SPLITFOURCC(sub_chunk_id));*/
 540             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 541         }
 542
 543         size_remaining -= sub_chunk_len;
 544     }
 545     return true;
 546 }
 547
 548 static bool read_chunk_minf(qtmovie_t *qtmovie, size_t chunk_len)
 549 {
 550     size_t size_remaining = chunk_len - 8;
 551     uint32_t i;
 552
 553     /* Check for smhd, only kind of minf we care about */
 554
 555     if ((i = stream_read_uint32(qtmovie->stream)) != 16)
 556     {
 557         DEBUGF("unexpected size in media info: %ld\n", (long)i);
 558         stream_skip(qtmovie->stream, size_remaining-4);
 559         return true;
 560     }
 561
 562     if (stream_read_uint32(qtmovie->stream) != MAKEFOURCC('s','m','h','d'))
 563     {
 564         DEBUGF("not a sound header! can't handle this.\n");
 565         return false;
 566     }
 567
 568     /* now skip the rest of the atom */
 569     stream_skip(qtmovie->stream, 16 - 8);
 570     size_remaining -= 16;
 571
 572     while (size_remaining)
 573     {
 574         size_t sub_chunk_len;
 575         fourcc_t sub_chunk_id;
 576
 577         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 578
 579         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 580         {
 581             DEBUGF("strange size (%lu) for chunk inside minf\n",
 582                    (unsigned long)sub_chunk_len);
 583             return false;
 584         }
 585
 586         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 587
 588         switch (sub_chunk_id)
 589         {
 590         case MAKEFOURCC('s','t','b','l'):
 591             if (!read_chunk_stbl(qtmovie, sub_chunk_len)) {
 592                 return false;
 593             }
 594             break;
 595         default:
 596             /*DEBUGF("(minf) unknown chunk id: %c%c%c%c\n",
 597                    SPLITFOURCC(sub_chunk_id));*/
 598             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 599             break;
 600         }
 601
 602         size_remaining -= sub_chunk_len;
 603     }
 604     return true;
 605 }
 606
 607 static bool read_chunk_mdia(qtmovie_t *qtmovie, size_t chunk_len)
 608 {
 609     size_t size_remaining = chunk_len - 8;
 610
 611     while (size_remaining)
 612     {
 613         size_t sub_chunk_len;
 614         fourcc_t sub_chunk_id;
 615
 616         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 617         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 618         {
 619             DEBUGF("strange size (%lu) for chunk inside mdia\n",
 620                    (unsigned long)sub_chunk_len);
 621             return false;
 622         }
 623
 624         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 625
 626         switch (sub_chunk_id)
 627         {
 628         case MAKEFOURCC('m','i','n','f'):
 629             if (!read_chunk_minf(qtmovie, sub_chunk_len)) {
 630                return false;
 631             }
 632             break;
 633         default:
 634             /*DEBUGF("(mdia) unknown chunk id: %c%c%c%c\n",
 635                    SPLITFOURCC(sub_chunk_id));*/
 636             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 637             break;
 638         }
 639
 640         size_remaining -= sub_chunk_len;
 641     }
 642     return true;
 643 }
 644
 645 /* 'trak' - a movie track - contains other atoms */
 646 static bool read_chunk_trak(qtmovie_t *qtmovie, size_t chunk_len)
 647 {
 648     size_t size_remaining = chunk_len - 8;
 649
 650     while (size_remaining)
 651     {
 652         size_t sub_chunk_len;
 653         fourcc_t sub_chunk_id;
 654
 655         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 656         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 657         {
 658             DEBUGF("strange size (%lu) for chunk inside trak\n",
 659                    (unsigned long)sub_chunk_len);
 660             return false;
 661         }
 662
 663         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 664
 665         switch (sub_chunk_id)
 666         {
 667         case MAKEFOURCC('m','d','i','a'):
 668             if (!read_chunk_mdia(qtmovie, sub_chunk_len)) {
 669                return false;
 670             }
 671             break;
 672         default:
 673             /*DEBUGF("(trak) unknown chunk id: %c%c%c%c\n",
 674                     SPLITFOURCC(sub_chunk_id));*/
 675             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 676             break;
 677         }
 678
 679         size_remaining -= sub_chunk_len;
 680     }
 681     return true;
 682 }
 683
 684 /* 'moov' movie atom - contains other atoms */
 685 static bool read_chunk_moov(qtmovie_t *qtmovie, size_t chunk_len)
 686 {
 687     size_t size_remaining = chunk_len - 8;
 688
 689     while (size_remaining)
 690     {
 691         size_t sub_chunk_len;
 692         fourcc_t sub_chunk_id;
 693
 694         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 695         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 696         {
 697             DEBUGF("strange size (%lu) for chunk inside moov\n",
 698                    (unsigned long)sub_chunk_len);
 699             return false;
 700         }
 701
 702         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 703
 704         switch (sub_chunk_id)
 705         {
 706         case MAKEFOURCC('t','r','a','k'):
 707             if (!read_chunk_trak(qtmovie, sub_chunk_len)) {
 708                return false;
 709             }
 710             break;
 711         default:
 712             /*DEBUGF("(moov) unknown chunk id: %c%c%c%c\n",
 713                     SPLITFOURCC(sub_chunk_id));*/
 714             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 715             break;
 716         }
 717
 718         size_remaining -= sub_chunk_len;
 719     }
 720     return true;
 721 }
 722
 723 static void read_chunk_mdat(qtmovie_t *qtmovie, size_t chunk_len)
 724 {
 725     size_t size_remaining = chunk_len - 8;
 726
 727     qtmovie->res->mdat_len = size_remaining;
 728 }
 729
 730 int qtmovie_read(stream_t *file, demux_res_t *demux_res)
 731 {
 732     qtmovie_t qtmovie;
 733
 734     /* construct the stream */
 735     qtmovie.stream = file;
 736     qtmovie.res = demux_res;
 737
 738     /* read the chunks */
 739     while (1)
 740     {
 741         size_t chunk_len;
 742         fourcc_t chunk_id;
 743
 744         chunk_len = stream_read_uint32(qtmovie.stream);
 745         if (stream_eof(qtmovie.stream))
 746         {
 747             if(qtmovie.res->mdat_offset == 0 || qtmovie.res->format == 0)
 748                 return 0;
 749             stream_seek(qtmovie.stream, qtmovie.res->mdat_offset);
 750             return 1;
 751         }
 752
 753         if (chunk_len == 1)
 754         {
 755             //DEBUGF("need 64bit support\n");
 756             return 0;
 757         }
 758         chunk_id = stream_read_uint32(qtmovie.stream);
 759
 760         //DEBUGF("Found a chunk %c%c%c%c, length=%d\n",SPLITFOURCC(chunk_id),chunk_len);
 761         switch (chunk_id)
 762         {
 763         case MAKEFOURCC('f','t','y','p'):
 764             read_chunk_ftyp(&qtmovie, chunk_len);
 765             break;
 766         case MAKEFOURCC('m','o','o','v'):
 767             if (!read_chunk_moov(&qtmovie, chunk_len)) {
 768                return 0;
 769             }
 770             break;
 771         case MAKEFOURCC('m','d','a','t'):
 772             /* There can be empty mdats before the real one. If so, skip them */
 773             if (chunk_len == 8)
 774                 break;
 775             read_chunk_mdat(&qtmovie, chunk_len);
 776             qtmovie.res->mdat_offset=stream_tell(qtmovie.stream);
 777             /* If we've already seen the format, assume there's nothing
 778                interesting after the mdat chunk (the file is "streamable").
 779                This avoids having to seek, which might cause rebuffering. */
 780             if(qtmovie.res->format > 0)
 781                 return 1;
 782             stream_skip(qtmovie.stream, chunk_len - 8);
 783             break;
 784
 785             /*  these following atoms can be skipped !!!! */
 786         case MAKEFOURCC('f','r','e','e'):
 787             stream_skip(qtmovie.stream, chunk_len - 8);
 788             break;
 789         default:
 790             //DEBUGF("(top) unknown chunk id: %c%c%c%c\n",SPLITFOURCC(chunk_id));
 791             return 0;
 792         }
 793
 794     }
 795     return 0;
 796 }
 797
 798