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