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;
 433     uint32_t numentries;
 434     int32_t idx = 0;
 435     int32_t frame;
 436     int32_t offset;
 437     int32_t old_first;
 438     int32_t new_first;
 439     int32_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     frame = 0;
 475     old_frame = qtmovie->res->sample_to_chunk[0].num_samples;
 476     old_first = qtmovie->res->sample_to_chunk[0].first_chunk;
 477     for (k = 1; k < numentries; ++k)
 478     {
 479         for (; i < qtmovie->res->num_sample_to_chunks; ++i)
 480         {
 481             old_frame = qtmovie->res->sample_to_chunk[i-1].num_samples;
 482             old_first = qtmovie->res->sample_to_chunk[i-1].first_chunk;
 483             new_first = qtmovie->res->sample_to_chunk[i  ].first_chunk;
 484
 485             if (qtmovie->res->sample_to_chunk[i].first_chunk > k)
 486                 break;
 487
 488             frame += (new_first - old_first) * old_frame;
 489         }
 490         frame += (k - old_first) * old_frame;
 491
 492         qtmovie->res->lookup_table[idx].sample = frame;
 493         qtmovie->res->lookup_table[idx].offset = offset;
 494         idx++;
 495
 496         frame -= (k - old_first) * old_frame;
 497
 498         offset = stream_read_uint32(qtmovie->stream);
 499         size_remaining -= 4;
 500     }
 501
 502     if (size_remaining)
 503     {
 504         DEBUGF("ehm, size remianing?\n");
 505         stream_skip(qtmovie->stream, size_remaining);
 506     }
 507
 508     return true;
 509 }
 510
 511 static bool read_chunk_stbl(qtmovie_t *qtmovie, size_t chunk_len)
 512 {
 513     size_t size_remaining = chunk_len - 8;
 514
 515     while (size_remaining)
 516     {
 517         size_t sub_chunk_len;
 518         fourcc_t sub_chunk_id;
 519
 520         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 521         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 522         {
 523             DEBUGF("strange size (%lu) for chunk inside stbl\n",
 524                    (unsigned long)sub_chunk_len);
 525             return false;
 526         }
 527
 528         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 529
 530         switch (sub_chunk_id)
 531         {
 532         case MAKEFOURCC('s','t','s','d'):
 533             if (!read_chunk_stsd(qtmovie, sub_chunk_len)) {
 534                return false;
 535             }
 536             break;
 537         case MAKEFOURCC('s','t','t','s'):
 538             if (!read_chunk_stts(qtmovie, sub_chunk_len))
 539             {
 540                return false;
 541             }
 542             break;
 543         case MAKEFOURCC('s','t','s','z'):
 544             if (!read_chunk_stsz(qtmovie, sub_chunk_len))
 545             {
 546                return false;
 547             }
 548             break;
 549         case MAKEFOURCC('s','t','s','c'):
 550             if (!read_chunk_stsc(qtmovie, sub_chunk_len))
 551             {
 552                return false;
 553             }
 554             break;
 555         case MAKEFOURCC('s','t','c','o'):
 556             if (!read_chunk_stco(qtmovie, sub_chunk_len))
 557             {
 558                return false;
 559             }
 560             break;
 561         default:
 562             /*DEBUGF("(stbl) unknown chunk id: %c%c%c%c\n",
 563                    SPLITFOURCC(sub_chunk_id));*/
 564             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 565         }
 566
 567         size_remaining -= sub_chunk_len;
 568     }
 569     return true;
 570 }
 571
 572 static bool read_chunk_minf(qtmovie_t *qtmovie, size_t chunk_len)
 573 {
 574     size_t size_remaining = chunk_len - 8;
 575     uint32_t i;
 576
 577     /* Check for smhd, only kind of minf we care about */
 578
 579     if ((i = stream_read_uint32(qtmovie->stream)) != 16)
 580     {
 581         DEBUGF("unexpected size in media info: %ld\n", (long)i);
 582         stream_skip(qtmovie->stream, size_remaining-4);
 583         return true;
 584     }
 585
 586     if (stream_read_uint32(qtmovie->stream) != MAKEFOURCC('s','m','h','d'))
 587     {
 588         DEBUGF("not a sound header! can't handle this.\n");
 589         return false;
 590     }
 591
 592     /* now skip the rest of the atom */
 593     stream_skip(qtmovie->stream, 16 - 8);
 594     size_remaining -= 16;
 595
 596     while (size_remaining)
 597     {
 598         size_t sub_chunk_len;
 599         fourcc_t sub_chunk_id;
 600
 601         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 602
 603         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 604         {
 605             DEBUGF("strange size (%lu) for chunk inside minf\n",
 606                    (unsigned long)sub_chunk_len);
 607             return false;
 608         }
 609
 610         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 611
 612         switch (sub_chunk_id)
 613         {
 614         case MAKEFOURCC('s','t','b','l'):
 615             if (!read_chunk_stbl(qtmovie, sub_chunk_len)) {
 616                 return false;
 617             }
 618             break;
 619         default:
 620             /*DEBUGF("(minf) unknown chunk id: %c%c%c%c\n",
 621                    SPLITFOURCC(sub_chunk_id));*/
 622             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 623             break;
 624         }
 625
 626         size_remaining -= sub_chunk_len;
 627     }
 628     return true;
 629 }
 630
 631 static bool read_chunk_mdia(qtmovie_t *qtmovie, size_t chunk_len)
 632 {
 633     size_t size_remaining = chunk_len - 8;
 634
 635     while (size_remaining)
 636     {
 637         size_t sub_chunk_len;
 638         fourcc_t sub_chunk_id;
 639
 640         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 641         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 642         {
 643             DEBUGF("strange size (%lu) for chunk inside mdia\n",
 644                    (unsigned long)sub_chunk_len);
 645             return false;
 646         }
 647
 648         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 649
 650         switch (sub_chunk_id)
 651         {
 652         case MAKEFOURCC('m','i','n','f'):
 653             if (!read_chunk_minf(qtmovie, sub_chunk_len)) {
 654                return false;
 655             }
 656             break;
 657         default:
 658             /*DEBUGF("(mdia) unknown chunk id: %c%c%c%c\n",
 659                    SPLITFOURCC(sub_chunk_id));*/
 660             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 661             break;
 662         }
 663
 664         size_remaining -= sub_chunk_len;
 665     }
 666     return true;
 667 }
 668
 669 /* 'trak' - a movie track - contains other atoms */
 670 static bool read_chunk_trak(qtmovie_t *qtmovie, size_t chunk_len)
 671 {
 672     size_t size_remaining = chunk_len - 8;
 673
 674     while (size_remaining)
 675     {
 676         size_t sub_chunk_len;
 677         fourcc_t sub_chunk_id;
 678
 679         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 680         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 681         {
 682             DEBUGF("strange size (%lu) for chunk inside trak\n",
 683                    (unsigned long)sub_chunk_len);
 684             return false;
 685         }
 686
 687         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 688
 689         switch (sub_chunk_id)
 690         {
 691         case MAKEFOURCC('m','d','i','a'):
 692             if (!read_chunk_mdia(qtmovie, sub_chunk_len)) {
 693                return false;
 694             }
 695             break;
 696         default:
 697             /*DEBUGF("(trak) unknown chunk id: %c%c%c%c\n",
 698                     SPLITFOURCC(sub_chunk_id));*/
 699             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 700             break;
 701         }
 702
 703         size_remaining -= sub_chunk_len;
 704     }
 705     return true;
 706 }
 707
 708 /* 'moov' movie atom - contains other atoms */
 709 static bool read_chunk_moov(qtmovie_t *qtmovie, size_t chunk_len)
 710 {
 711     size_t size_remaining = chunk_len - 8;
 712
 713     while (size_remaining)
 714     {
 715         size_t sub_chunk_len;
 716         fourcc_t sub_chunk_id;
 717
 718         sub_chunk_len = stream_read_uint32(qtmovie->stream);
 719         if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
 720         {
 721             DEBUGF("strange size (%lu) for chunk inside moov\n",
 722                    (unsigned long)sub_chunk_len);
 723             return false;
 724         }
 725
 726         sub_chunk_id = stream_read_uint32(qtmovie->stream);
 727
 728         switch (sub_chunk_id)
 729         {
 730         case MAKEFOURCC('t','r','a','k'):
 731             if (!read_chunk_trak(qtmovie, sub_chunk_len)) {
 732                return false;
 733             }
 734             break;
 735         default:
 736             /*DEBUGF("(moov) unknown chunk id: %c%c%c%c\n",
 737                     SPLITFOURCC(sub_chunk_id));*/
 738             stream_skip(qtmovie->stream, sub_chunk_len - 8);
 739             break;
 740         }
 741
 742         size_remaining -= sub_chunk_len;
 743     }
 744     return true;
 745 }
 746
 747 static void read_chunk_mdat(qtmovie_t *qtmovie, size_t chunk_len)
 748 {
 749     size_t size_remaining = chunk_len - 8;
 750
 751     qtmovie->res->mdat_len = size_remaining;
 752 }
 753
 754 int qtmovie_read(stream_t *file, demux_res_t *demux_res)
 755 {
 756     qtmovie_t qtmovie;
 757
 758     /* construct the stream */
 759     qtmovie.stream = file;
 760     qtmovie.res = demux_res;
 761
 762     /* read the chunks */
 763     while (1)
 764     {
 765         size_t chunk_len;
 766         fourcc_t chunk_id;
 767
 768         chunk_len = stream_read_uint32(qtmovie.stream);
 769         if (stream_eof(qtmovie.stream))
 770         {
 771             if(qtmovie.res->mdat_offset == 0 || qtmovie.res->format == 0)
 772                 return 0;
 773             stream_seek(qtmovie.stream, qtmovie.res->mdat_offset);
 774             return 1;
 775         }
 776
 777         if (chunk_len == 1)
 778         {
 779             //DEBUGF("need 64bit support\n");
 780             return 0;
 781         }
 782         chunk_id = stream_read_uint32(qtmovie.stream);
 783
 784         //DEBUGF("Found a chunk %c%c%c%c, length=%d\n",SPLITFOURCC(chunk_id),chunk_len);
 785         switch (chunk_id)
 786         {
 787         case MAKEFOURCC('f','t','y','p'):
 788             read_chunk_ftyp(&qtmovie, chunk_len);
 789             break;
 790         case MAKEFOURCC('m','o','o','v'):
 791             if (!read_chunk_moov(&qtmovie, chunk_len)) {
 792                return 0;
 793             }
 794             break;
 795         case MAKEFOURCC('m','d','a','t'):
 796             /* There can be empty mdats before the real one. If so, skip them */
 797             if (chunk_len == 8)
 798                 break;
 799             read_chunk_mdat(&qtmovie, chunk_len);
 800             qtmovie.res->mdat_offset=stream_tell(qtmovie.stream);
 801             /* If we've already seen the format, assume there's nothing
 802                interesting after the mdat chunk (the file is "streamable").
 803                This avoids having to seek, which might cause rebuffering. */
 804             if(qtmovie.res->format > 0)
 805                 return 1;
 806             stream_skip(qtmovie.stream, chunk_len - 8);
 807             break;
 808
 809             /*  these following atoms can be skipped !!!! */
 810         case MAKEFOURCC('f','r','e','e'):
 811             stream_skip(qtmovie.stream, chunk_len - 8);
 812             break;
 813         default:
 814             //DEBUGF("(top) unknown chunk id: %c%c%c%c\n",SPLITFOURCC(chunk_id));
 815             return 0;
 816         }
 817
 818     }
 819     return 0;
 820 }
 821
 822