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','a',' ')) &&
  65         (type != MAKEFOURCC('M','4','B',' ')) &&
  66         (type != MAKEFOURCC('m','p','4','2')) &&
  67         (type != MAKEFOURCC('3','g','p','6')) &&
  68         (type != MAKEFOURCC('q','t',' ',' ')) &&
  69         (type != MAKEFOURCC('i','s','o','m')))
  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     bool got_codec_data = false;
 176
 177     /* version */
 178     stream_read_uint8(qtmovie->stream);
 179     size_remaining -= 1;
 180     /* flags */
 181     stream_read_uint8(qtmovie->stream);
 182     stream_read_uint8(qtmovie->stream);
 183     stream_read_uint8(qtmovie->stream);
 184     size_remaining -= 3;
 185
 186     numentries = stream_read_uint32(qtmovie->stream);
 187     size_remaining -= 4;
 188
 189     /* if (numentries != 1)
 190     {
 191         DEBUGF("only expecting one entry in sample description atom!\n");
 192         return false;
 193     } */
 194
 195     for (i = 0; i < numentries; i++)
 196     {
 197         uint32_t entry_size;
 198
 199         uint32_t entry_remaining;
 200
 201         entry_size = stream_read_uint32(qtmovie->stream);
 202         qtmovie->res->format = stream_read_uint32(qtmovie->stream);
 203         DEBUGF("format: %c%c%c%c\n",SPLITFOURCC(qtmovie->res->format));
 204         entry_remaining = entry_size;
 205         entry_remaining -= 8;
 206
 207         /* sound info: */
 208
 209         /* reserved + data reference index + sound version + reserved */
 210         stream_skip(qtmovie->stream, 6 + 2 + 2 + 6);
 211         entry_remaining -= 6 + 2 + 2 + 6;
 212
 213         qtmovie->res->num_channels = stream_read_uint16(qtmovie->stream);
 214         qtmovie->res->sound_sample_size = stream_read_uint16(qtmovie->stream);
 215         entry_remaining -= 4;
 216
 217         /* packet size */
 218         stream_skip(qtmovie->stream, 2);
 219         qtmovie->res->sound_sample_rate = stream_read_uint32(qtmovie->stream);
 220         /* reserved size */
 221         stream_skip(qtmovie->stream, 2);
 222         entry_remaining -= 8;
 223
 224         /* remaining is codec data */
 225
 226         if ((qtmovie->res->format==MAKEFOURCC('a','l','a','c'))) {
 227           if (qtmovie->stream->ci->id3->codectype!=AFMT_MP4_ALAC) {
 228                return false;
 229           }
 230
 231           /* 12 = audio format atom, 8 = padding */
 232           qtmovie->res->codecdata_len = entry_remaining + 12 + 8;
 233           if (qtmovie->res->codecdata_len > MAX_CODECDATA_SIZE)
 234           {
 235               DEBUGF("codecdata too large (%d) in stsd\n",
 236                       (int)qtmovie->res->codecdata_len);
 237               return false;
 238           }
 239
 240           memset(qtmovie->res->codecdata, 0, qtmovie->res->codecdata_len);
 241           /* audio format atom */
 242 #if 0
 243           /* The ALAC decoder skips these bytes, so there is no need to store them,
 244              and this code isn't endian/alignment safe */
 245           ((unsigned int*)qtmovie->res->codecdata)[0] = 0x0c000000;
 246           ((unsigned int*)qtmovie->res->codecdata)[1] = MAKEFOURCC('a','m','r','f');
 247           ((unsigned int*)qtmovie->res->codecdata)[2] = MAKEFOURCC('c','a','l','a');
 248 #endif
 249
 250           stream_read(qtmovie->stream,
 251                   entry_remaining,
 252                   ((char*)qtmovie->res->codecdata) + 12);
 253           entry_remaining -= entry_remaining;
 254           got_codec_data = true;
 255
 256           if (entry_remaining)
 257               stream_skip(qtmovie->stream, entry_remaining);
 258
 259         } else if (qtmovie->res->format==MAKEFOURCC('m','p','4','a')) {
 260           if (qtmovie->stream->ci->id3->codectype!=AFMT_MP4_AAC &&
 261               qtmovie->stream->ci->id3->codectype!=AFMT_MP4_AAC_HE) {
 262                return false;
 263           }
 264
 265           size_t sub_chunk_len;
 266           fourcc_t sub_chunk_id;
 267
 268           sub_chunk_len = stream_read_uint32(qtmovie->stream);
 269           if (sub_chunk_len <= 1 || sub_chunk_len > entry_remaining)
 270           {
 271               DEBUGF("strange size (%lu) for chunk inside mp4a\n",
 272                      (unsigned long)sub_chunk_len);
 273               return false;
 274           }
 275
 276           sub_chunk_id = stream_read_uint32(qtmovie->stream);
 277
 278           if (sub_chunk_id != MAKEFOURCC('e','s','d','s'))
 279           {
 280               DEBUGF("Expected esds chunk inside mp4a, found %c%c%c%c\n",SPLITFOURCC(sub_chunk_id));
 281               return false;
 282           }
 283
 284           j=qtmovie->stream->ci->curpos+sub_chunk_len-8;
 285           if (read_chunk_esds(qtmovie,sub_chunk_len)) {
 286              if (j!=qtmovie->stream->ci->curpos) {
 287                DEBUGF("curpos=%ld, j=%d - Skipping %ld bytes\n",qtmovie->stream->ci->curpos,j,j-qtmovie->stream->ci->curpos);
 288                stream_skip(qtmovie->stream,j-qtmovie->stream->ci->curpos);
 289              }
 290              got_codec_data = true;
 291              entry_remaining-=sub_chunk_len;
 292           } else {
 293               DEBUGF("Error reading esds\n");
 294               return false;
 295           }
 296
 297           DEBUGF("entry_remaining=%ld\n",(long)entry_remaining);
 298           stream_skip(qtmovie->stream,entry_remaining);
 299
 300         } else if (qtmovie->res->format==MAKEFOURCC('f','r','e','e')) {
 301             /* Skip "filler" atom */
 302             stream_skip(qtmovie->stream,entry_remaining);
 303         } else {
 304             DEBUGF("expecting 'alac', 'mp4a' or 'free' data format, got %c%c%c%c\n",
 305                  SPLITFOURCC(qtmovie->res->format));
 306             return false;
 307         }
 308     }
 309     return got_codec_data;
 310 }
 311
 312 static bool read_chunk_stts(qtmovie_t *qtmovie, size_t chunk_len)
 313 {
 314     unsigned int i;
 315     uint32_t numentries;
 316     size_t size_remaining = chunk_len - 8;
 317
 318     /* version */
 319     stream_read_uint8(qtmovie->stream);
 320     size_remaining -= 1;
 321     /* flags */
 322     stream_read_uint8(qtmovie->stream);
 323     stream_read_uint8(qtmovie->stream);
 324     stream_read_uint8(qtmovie->stream);
 325     size_remaining -= 3;
 326
 327     numentries = stream_read_uint32(qtmovie->stream);
 328     size_remaining -= 4;
 329
 330     qtmovie->res->num_time_to_samples = numentries;
 331     qtmovie->res->time_to_sample = malloc(numentries * sizeof(*qtmovie->res->time_to_sample));
 332
 333     if (!qtmovie->res->time_to_sample)
 334     {
 335         DEBUGF("stts too large\n");
 336         return false;
 337     }
 338
 339     for (i = 0; i < numentries; i++)
 340     {
 341         qtmovie->res->time_to_sample[i].sample_count = stream_read_uint32(qtmovie->stream);
 342         qtmovie->res->time_to_sample[i].sample_duration = stream_read_uint32(qtmovie->stream);
 343         size_remaining -= 8;
 344     }
 345
 346     if (size_remaining)
 347     {
 348         DEBUGF("ehm, size remianing?\n");
 349         stream_skip(qtmovie->stream, size_remaining);
 350     }
 351
 352     return true;
 353 }
 354
 355 static bool read_chunk_stsz(qtmovie_t *qtmovie, size_t chunk_len)
 356 {
 357     size_t size_remaining = chunk_len - 8;
 358
 359     /* version */
 360     stream_read_uint8(qtmovie->stream);
 361     size_remaining -= 1;
 362     /* flags */
 363     stream_read_uint8(qtmovie->stream);
 364     stream_read_uint8(qtmovie->stream);
 365     stream_read_uint8(qtmovie->stream);
 366     size_remaining -= 3;
 367
 368     /* default sample size */
 369     if (stream_read_uint32(qtmovie->stream) != 0)
 370     {
 371         DEBUGF("i was expecting variable samples sizes\n");
 372         stream_read_uint32(qtmovie->stream);
 373         size_remaining -= 4;
 374         return true;
 375     }
 376     size_remaining -= 4;
 377
 378     qtmovie->res->num_sample_byte_sizes = stream_read_uint32(qtmovie->stream);
 379     size_remaining -= 4;
 380
 381     if (size_remaining)
 382     {
 383         stream_skip(qtmovie->stream, size_remaining);
 384     }
 385
 386     return true;
 387 }
 388
 389 static bool read_chunk_stsc(qtmovie_t *qtmovie, size_t chunk_len)
 390 {
 391     unsigned int i;
 392     uint32_t numentries;
 393     size_t size_remaining = chunk_len - 8;
 394
 395     /* version + flags */
 396     stream_read_uint32(qtmovie->stream);
 397     size_remaining -= 4;
 398
 399     numentries = stream_read_uint32(qtmovie->stream);
 400     size_remaining -= 4;
 401
 402     qtmovie->res->num_sample_to_chunks = numentries;
 403     qtmovie->res->sample_to_chunk = malloc(numentries * sizeof(sample_to_chunk_t));
 404
 405     if (!qtmovie->res->sample_to_chunk)
 406     {
 407         DEBUGF("stsc too large\n");
 408         return false;
 409     }
 410
 411     for (i = 0; i < numentries; i++)
 412     {
 413         qtmovie->res->sample_to_chunk[i].first_chunk =
 414             stream_read_uint32(qtmovie->stream);
 415         qtmovie->res->sample_to_chunk[i].num_samples =
 416             stream_read_uint32(qtmovie->stream);
 417         stream_read_uint32(qtmovie->stream);
 418         size_remaining -= 12;
 419     }
 420
 421     if (size_remaining)
 422     {
 423         DEBUGF("ehm, size remianing?\n");
 424         stream_skip(qtmovie->stream, size_remaining);
 425     }
 426
 427     return true;
 428 }
 429
 430 static bool read_chunk_stco(qtmovie_t *qtmovie, size_t chunk_len)
 431 {
 432     uint32_t i, k, old_i;
 433     uint32_t numentries;
 434     uint32_t idx = 0;
 435     uint32_t frame;
 436     uint32_t offset;
 437     uint32_t old_first;
 438     uint32_t new_first;
 439     uint32_t old_frame;
 440     size_t size_remaining = chunk_len - 8;
 441
 442     /* version + flags */
 443     stream_read_uint32(qtmovie->stream);
 444     size_remaining -= 4;
 445
 446     numentries = stream_read_uint32(qtmovie->stream);
 447     size_remaining -= 4;
 448
 449     qtmovie->res->num_lookup_table = numentries;
 450     qtmovie->res->lookup_table = malloc(numentries * sizeof(*qtmovie->res->lookup_table));
 451
 452     if (!qtmovie->res->lookup_table)
 453     {
 454         DEBUGF("stco too large to allocate lookup_table[]\n");
 455         return false;
 456     }
 457
 458     /* read first offset */
 459     offset = stream_read_uint32(qtmovie->stream);
 460     size_remaining -= 4;
 461
 462     /* Build up lookup table. The lookup table contains the sample index and
 463      * byte position in the file for each chunk. This table is used to seek
 464      * and resume (see m4a_seek() and m4a_seek_raw() in libm4a/m4a.c) and
 465      * to skip empty chunks (see m4a_check_sample_offset() in codecs/aac.c and
 466      * libm4a/m4a.c).
 467      * The seek/resume precision is lower than using sample_byte_size[] and
 468      * depends on numentries. Typically the resolution is ~1/10 of all frames
 469      * which equals about 1/4-1/2 seconds. The loss of seek precision is
 470      * accepted to be able to avoid allocation of the large sample_byte_size[]
 471      * table. This reduces the memory consumption by a factor of 2 or even
 472      * more. */
 473     i = 1;
 474     old_i = 1;
 475     frame = 0;
 476     old_first = qtmovie->res->sample_to_chunk[0].first_chunk;
 477     old_frame = qtmovie->res->sample_to_chunk[0].num_samples;
 478     new_first = qtmovie->res->sample_to_chunk[1].first_chunk;
 479     for (k = 1; k < numentries; ++k)
 480     {
 481         for (; i < qtmovie->res->num_sample_to_chunks; ++i)
 482         {
 483             if (i > old_i)
 484             {
 485                 /* Only access sample_to_chunk[] if new data is required. */
 486                 old_first = qtmovie->res->sample_to_chunk[i-1].first_chunk;
 487                 old_frame = qtmovie->res->sample_to_chunk[i-1].num_samples;
 488                 new_first = qtmovie->res->sample_to_chunk[i  ].first_chunk;
 489                 old_i = i;
 490             }
 491
 492             if (new_first > k)
 493                 break;
 494
 495             frame += (new_first - old_first) * old_frame;
 496         }
 497         frame += (k - old_first) * old_frame;
 498
 499         qtmovie->res->lookup_table[idx].sample = frame;
 500         qtmovie->res->lookup_table[idx].offset = offset;
 501         idx++;
 502
 503         frame -= (k - old_first) * old_frame;
 504
 505         offset = stream_read_uint32(qtmovie->stream);
 506         size_remaining -= 4;
 507     }
 508     /* zero-terminate the lookup table */
 509     qtmovie->res->lookup_table[idx].sample = 0;
 510     qtmovie->res->lookup_table[idx].offset = 0;
 511
 512     if (size_remaining)
 513     {
 514         DEBUGF("ehm, size remianing?\n");
 515         stream_skip(qtmovie->stream, size_remaining);
 516     }
 517
 518     return true;
 519 }
 520
 521 static bool read_chunk_stbl(qtmovie_t *qtmovie, size_t chunk_len)
 522 {
 523     size_t size_remaining = chunk_len - 8;
 524
 525     while (size_remaining)
 526     {
 527         size_t sub_chunk_len;
 528         fourcc_t sub_chunk_id;
 529
 530         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 531         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 532         {
 533             DEBUGF("strange size (%lu) for chunk inside stbl\n",
 534                    (unsigned long)sub_chunk_len);
 535             return false;
 536         }
 537
 538         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 539
 540         switch (sub_chunk_id)
 541         {
 542         case MAKEFOURCC('s','t','s','d'):
 543             if (!read_chunk_stsd(qtmovie, sub_chunk_len)) {
 544                return false;
 545             }
 546             break;
 547         case MAKEFOURCC('s','t','t','s'):
 548             if (!read_chunk_stts(qtmovie, sub_chunk_len))
 549             {
 550                return false;
 551             }
 552             break;
 553         case MAKEFOURCC('s','t','s','z'):
 554             if (!read_chunk_stsz(qtmovie, sub_chunk_len))
 555             {
 556                return false;
 557             }
 558             break;
 559         case MAKEFOURCC('s','t','s','c'):
 560             if (!read_chunk_stsc(qtmovie, sub_chunk_len))
 561             {
 562                return false;
 563             }
 564             break;
 565         case MAKEFOURCC('s','t','c','o'):
 566             if (!read_chunk_stco(qtmovie, sub_chunk_len))
 567             {
 568                return false;
 569             }
 570             break;
 571         default:
 572             /*DEBUGF("(stbl) unknown chunk id: %c%c%c%c\n",
 573                    SPLITFOURCC(sub_chunk_id));*/
 574             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 575         }
 576
 577         size_remaining -= sub_chunk_len;
 578     }
 579     return true;
 580 }
 581
 582 static bool read_chunk_minf(qtmovie_t *qtmovie, size_t chunk_len)
 583 {
 584     size_t size_remaining = chunk_len - 8;
 585     uint32_t i;
 586
 587     /* Check for smhd, only kind of minf we care about */
 588
 589     if ((i = stream_read_uint32(qtmovie->stream)) != 16)
 590     {
 591         DEBUGF("unexpected size in media info: %ld\n", (long)i);
 592         stream_skip(qtmovie->stream, size_remaining-4);
 593         return true;
 594     }
 595
 596     if (stream_read_uint32(qtmovie->stream) != MAKEFOURCC('s','m','h','d'))
 597     {
 598         DEBUGF("not a sound header! can't handle this.\n");
 599         return false;
 600     }
 601
 602     /* now skip the rest of the atom */
 603     stream_skip(qtmovie->stream, 16 - 8);
 604     size_remaining -= 16;
 605
 606     while (size_remaining)
 607     {
 608         size_t sub_chunk_len;
 609         fourcc_t sub_chunk_id;
 610
 611         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 612
 613         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 614         {
 615             DEBUGF("strange size (%lu) for chunk inside minf\n",
 616                    (unsigned long)sub_chunk_len);
 617             return false;
 618         }
 619
 620         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 621
 622         switch (sub_chunk_id)
 623         {
 624         case MAKEFOURCC('s','t','b','l'):
 625             if (!read_chunk_stbl(qtmovie, sub_chunk_len)) {
 626                 return false;
 627             }
 628             break;
 629         default:
 630             /*DEBUGF("(minf) unknown chunk id: %c%c%c%c\n",
 631                    SPLITFOURCC(sub_chunk_id));*/
 632             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 633             break;
 634         }
 635
 636         size_remaining -= sub_chunk_len;
 637     }
 638     return true;
 639 }
 640
 641 static bool read_chunk_mdia(qtmovie_t *qtmovie, size_t chunk_len)
 642 {
 643     size_t size_remaining = chunk_len - 8;
 644
 645     while (size_remaining)
 646     {
 647         size_t sub_chunk_len;
 648         fourcc_t sub_chunk_id;
 649
 650         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 651         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 652         {
 653             DEBUGF("strange size (%lu) for chunk inside mdia\n",
 654                    (unsigned long)sub_chunk_len);
 655             return false;
 656         }
 657
 658         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 659
 660         switch (sub_chunk_id)
 661         {
 662         case MAKEFOURCC('m','i','n','f'):
 663             if (!read_chunk_minf(qtmovie, sub_chunk_len)) {
 664                return false;
 665             }
 666             break;
 667         default:
 668             /*DEBUGF("(mdia) unknown chunk id: %c%c%c%c\n",
 669                    SPLITFOURCC(sub_chunk_id));*/
 670             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 671             break;
 672         }
 673
 674         size_remaining -= sub_chunk_len;
 675     }
 676     return true;
 677 }
 678
 679 /* 'trak' - a movie track - contains other atoms */
 680 static bool read_chunk_trak(qtmovie_t *qtmovie, size_t chunk_len)
 681 {
 682     size_t size_remaining = chunk_len - 8;
 683
 684     while (size_remaining)
 685     {
 686         size_t sub_chunk_len;
 687         fourcc_t sub_chunk_id;
 688
 689         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 690         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 691         {
 692             DEBUGF("strange size (%lu) for chunk inside trak\n",
 693                    (unsigned long)sub_chunk_len);
 694             return false;
 695         }
 696
 697         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 698
 699         switch (sub_chunk_id)
 700         {
 701         case MAKEFOURCC('m','d','i','a'):
 702             if (!read_chunk_mdia(qtmovie, sub_chunk_len)) {
 703                return false;
 704             }
 705             break;
 706         default:
 707             /*DEBUGF("(trak) unknown chunk id: %c%c%c%c\n",
 708                     SPLITFOURCC(sub_chunk_id));*/
 709             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 710             break;
 711         }
 712
 713         size_remaining -= sub_chunk_len;
 714     }
 715     return true;
 716 }
 717
 718 /* 'moov' movie atom - contains other atoms */
 719 static bool read_chunk_moov(qtmovie_t *qtmovie, size_t chunk_len)
 720 {
 721     size_t size_remaining = chunk_len - 8;
 722
 723     while (size_remaining)
 724     {
 725         size_t sub_chunk_len;
 726         fourcc_t sub_chunk_id;
 727
 728         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 729         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 730         {
 731             DEBUGF("strange size (%lu) for chunk inside moov\n",
 732                    (unsigned long)sub_chunk_len);
 733             return false;
 734         }
 735
 736         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 737
 738         switch (sub_chunk_id)
 739         {
 740         case MAKEFOURCC('t','r','a','k'):
 741             if (!read_chunk_trak(qtmovie, sub_chunk_len)) {
 742                return false;
 743             }
 744             break;
 745         default:
 746             /*DEBUGF("(moov) unknown chunk id: %c%c%c%c\n",
 747                     SPLITFOURCC(sub_chunk_id));*/
 748             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 749             break;
 750         }
 751
 752         size_remaining -= sub_chunk_len;
 753     }
 754     return true;
 755 }
 756
 757 static void read_chunk_mdat(qtmovie_t *qtmovie, size_t chunk_len)
 758 {
 759     size_t size_remaining = chunk_len - 8;
 760
 761     qtmovie->res->mdat_len = size_remaining;
 762 }
 763
 764 int qtmovie_read(stream_t *file, demux_res_t *demux_res)
 765 {
 766     qtmovie_t qtmovie;
 767
 768     /* construct the stream */
 769     qtmovie.stream = file;
 770     qtmovie.res = demux_res;
 771
 772     /* read the chunks */
 773     while (1)
 774     {
 775         size_t chunk_len;
 776         fourcc_t chunk_id;
 777
 778         chunk_len = stream_read_uint32(qtmovie.stream);
 779         if (stream_eof(qtmovie.stream))
 780         {
 781             if(qtmovie.res->mdat_offset == 0 || qtmovie.res->format == 0)
 782                 return 0;
 783             stream_seek(qtmovie.stream, qtmovie.res->mdat_offset);
 784             return 1;
 785         }
 786
 787         if (chunk_len == 1)
 788         {
 789             //DEBUGF("need 64bit support\n");
 790             return 0;
 791         }
 792         chunk_id = stream_read_uint32(qtmovie.stream);
 793
 794         //DEBUGF("Found a chunk %c%c%c%c, length=%d\n",SPLITFOURCC(chunk_id),chunk_len);
 795         switch (chunk_id)
 796         {
 797         case MAKEFOURCC('f','t','y','p'):
 798             read_chunk_ftyp(&qtmovie, chunk_len);
 799             break;
 800         case MAKEFOURCC('m','o','o','v'):
 801             if (!read_chunk_moov(&qtmovie, chunk_len)) {
 802                return 0;
 803             }
 804             break;
 805         case MAKEFOURCC('m','d','a','t'):
 806             /* There can be empty mdats before the real one. If so, skip them */
 807             if (chunk_len == 8)
 808                 break;
 809             read_chunk_mdat(&qtmovie, chunk_len);
 810             qtmovie.res->mdat_offset=stream_tell(qtmovie.stream);
 811             /* If we've already seen the format, assume there's nothing
 812                interesting after the mdat chunk (the file is "streamable").
 813                This avoids having to seek, which might cause rebuffering. */
 814             if(qtmovie.res->format > 0)
 815                 return 1;
 816             stream_skip(qtmovie.stream, chunk_len - 8);
 817             break;
 818
 819             /*  these following atoms can be skipped !!!! */
 820         case MAKEFOURCC('f','r','e','e'):
 821             stream_skip(qtmovie.stream, chunk_len - 8);
 822             break;
 823         default:
 824             //DEBUGF("(top) unknown chunk id: %c%c%c%c\n",SPLITFOURCC(chunk_id));
 825             return 0;
 826         }
 827
 828     }
 829     return 0;
 830 }
 831
 832