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