src/add-ons/media/plugins/mp4_reader/libMP4/MP4Parser.cpp

   1 /*
   2  * Copyright (c) 2005, David McPaul
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without modification,
   6  * are permitted provided that the following conditions are met:
   7  *
   8  *  * Redistributions of source code must retain the above copyright notice,
   9  *    this list of conditions and the following disclaimer.
  10  *  * Redistributions in binary form must reproduce the above copyright notice,
  11  *    this list of conditions and the following disclaimer in the documentation
  12  *    and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  18  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  19  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  21  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  22  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  23  * OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26
  27 #include "MP4Parser.h"
  28
  29 #include <stdio.h>
  30
  31 #include <DataIO.h>
  32 #include <MediaFormats.h>
  33 #include <SupportKit.h>
  34
  35 #include <zlib.h>
  36
  37 #include "BitParser.h"
  38
  39
  40 AtomBase *
  41 GetAtom(BPositionIO *pStream)
  42 {
  43         uint32 aAtomType;
  44         uint32 aAtomSize;
  45         uint64 aRealAtomSize;
  46         off_t aStreamOffset;
  47
  48         aStreamOffset = pStream->Position();
  49
  50         // Get Size uint32
  51         pStream->Read(&aAtomSize,4);
  52         aAtomSize = B_BENDIAN_TO_HOST_INT32(aAtomSize);
  53         // Get Type uint32
  54         pStream->Read(&aAtomType,4);
  55         aAtomType = B_BENDIAN_TO_HOST_INT32(aAtomType);
  56         // Check for extended size
  57         if (aAtomSize == 1) {
  58                 // Handle extended size
  59                 pStream->Read(&aRealAtomSize,4);
  60                 aRealAtomSize = B_BENDIAN_TO_HOST_INT64(aRealAtomSize);
  61         } else if (aAtomSize == 0) {
  62                 // aAtomSize extends to end of file.
  63                 // TODO this is broken
  64                 aRealAtomSize = 0;
  65         } else {
  66                 aRealAtomSize = aAtomSize;
  67         }
  68
  69         if (aAtomType == uint32('moov'))
  70                 return new MOOVAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
  71
  72         if (aAtomType == uint32('mvhd'))
  73                 return new MVHDAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
  74
  75         if (aAtomType == uint32('trak'))
  76                 return new TRAKAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
  77
  78         if (aAtomType == uint32('tkhd'))
  79                 return new TKHDAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
  80
  81         if (aAtomType == uint32('free'))
  82                 return new FREEAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
  83
  84         if (aAtomType == uint32('skip'))
  85                 return new SKIPAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
  86
  87         if (aAtomType == uint32('wide'))
  88                 return new WIDEAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
  89
  90         if (aAtomType == uint32('mdat'))
  91                 return new MDATAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
  92
  93         if (aAtomType == uint32('mdia'))
  94                 return new MDIAAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
  95
  96         if (aAtomType == uint32('mdhd'))
  97                 return new MDHDAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
  98
  99         if (aAtomType == uint32('hdlr'))
 100                 return new HDLRAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 101
 102         if (aAtomType == uint32('minf'))
 103                 return new MINFAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 104
 105         if (aAtomType == uint32('vmhd'))
 106                 return new VMHDAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 107
 108         if (aAtomType == uint32('smhd'))
 109                 return new SMHDAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 110
 111         if (aAtomType == uint32('dinf'))
 112                 return new DINFAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 113
 114         if (aAtomType == uint32('stbl'))
 115                 return new STBLAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 116
 117         if (aAtomType == uint32('stsd'))
 118                 return new STSDAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 119
 120         if (aAtomType == uint32('tmcd'))
 121                 return new TMCDAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 122
 123         if (aAtomType == uint32('stts'))
 124                 return new STTSAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 125
 126         if (aAtomType == uint32('pnot'))
 127                 return new PNOTAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 128
 129         if (aAtomType == uint32('stsc'))
 130                 return new STSCAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 131
 132         if (aAtomType == uint32('stco'))
 133                 return new STCOAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 134
 135         if (aAtomType == uint32('stss'))
 136                 return new STSSAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 137
 138         if (aAtomType == uint32('ctts'))
 139                 return new CTTSAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 140
 141         if (aAtomType == uint32('stsz'))
 142                 return new STSZAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 143
 144         if (aAtomType == uint32('stz2'))
 145                 return new STZ2Atom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 146
 147         if (aAtomType == uint32('ftyp'))
 148                 return new FTYPAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 149
 150         if (aAtomType == uint32('cmov'))
 151                 return new CMOVAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 152
 153         if (aAtomType == uint32('dcom'))
 154                 return new DCOMAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 155
 156         if (aAtomType == uint32('cmvd'))
 157                 return new CMVDAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 158
 159         if (aAtomType == uint32('esds'))
 160                 return new ESDSAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 161
 162         if (aAtomType == uint32('alac'))
 163                 return new ALACAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 164
 165         if (aAtomType == uint32('wave'))
 166                 return new WAVEAtom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 167
 168         if (aAtomType == uint32('dac3'))
 169                 return new DAC3Atom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 170
 171         if (aAtomType == uint32('dec3'))
 172                 return new DEC3Atom(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 173
 174         if (aAtomType == uint32('avcC'))
 175                 return new DecoderConfigAtom(pStream, aStreamOffset, aAtomType,
 176                         aRealAtomSize);
 177
 178         return new AtomBase(pStream, aStreamOffset, aAtomType, aRealAtomSize);
 179 }
 180
 181
 182 MOOVAtom::MOOVAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
 183         uint64 pAtomSize) : AtomContainer(pStream, pStreamOffset, pAtomType,
 184         pAtomSize)
 185 {
 186         theMVHDAtom = NULL;
 187 }
 188
 189
 190 MOOVAtom::~MOOVAtom()
 191 {
 192         theMVHDAtom = NULL;
 193 }
 194
 195
 196 void
 197 MOOVAtom::OnProcessMetaData()
 198 {
 199 }
 200
 201 const char *
 202 MOOVAtom::OnGetAtomName()
 203 {
 204         return "MPEG-4 Movie";
 205 }
 206
 207
 208 CMOVAtom::CMOVAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
 209         uint64 pAtomSize) : AtomContainer(pStream, pStreamOffset, pAtomType,
 210         pAtomSize)
 211 {
 212         theUncompressedStream = NULL;
 213 }
 214
 215
 216 CMOVAtom::~CMOVAtom()
 217 {
 218 }
 219
 220
 221 BPositionIO *
 222 CMOVAtom::OnGetStream()
 223 {
 224         // Use the decompressed stream instead of file stream
 225         if (theUncompressedStream)
 226                 return theUncompressedStream;
 227
 228         return theStream;
 229 }
 230
 231
 232 void
 233 CMOVAtom::OnProcessMetaData()
 234 {
 235         BMallocIO *theUncompressedData;
 236         uint8 *outBuffer;
 237         CMVDAtom *aCMVDAtom = NULL;
 238         uint32  compressionID = 0;
 239         uint64  descBytesLeft;
 240         uint32  Size;
 241
 242         descBytesLeft = GetAtomSize();
 243
 244         // Check for Compression Type
 245         while (descBytesLeft > 0) {
 246                 AtomBase *aAtomBase = GetAtom(theStream);
 247
 248                 aAtomBase->OnProcessMetaData();
 249
 250                 if (aAtomBase->GetAtomSize() > 0) {
 251                         descBytesLeft = descBytesLeft - aAtomBase->GetAtomSize();
 252                 } else {
 253                         printf("Invalid Atom found when reading Compressed Headers\n");
 254                         descBytesLeft = 0;
 255                 }
 256
 257                 if (dynamic_cast<DCOMAtom *>(aAtomBase)) {
 258                         // DCOM atom
 259                         compressionID = dynamic_cast<DCOMAtom *>(aAtomBase)->GetCompressionID();
 260                         delete aAtomBase;
 261                 } else {
 262                         if (dynamic_cast<CMVDAtom *>(aAtomBase)) {
 263                                 // CMVD atom
 264                                 aCMVDAtom = dynamic_cast<CMVDAtom *>(aAtomBase);
 265                                 descBytesLeft = 0;
 266                         }
 267                 }
 268         }
 269
 270         // Decompress data
 271         if (compressionID == 'zlib') {
 272                 Size = aCMVDAtom->GetUncompressedSize();
 273
 274                 outBuffer = (uint8 *)(malloc(Size));
 275
 276                 printf("Decompressing %ld bytes to %ld bytes\n",aCMVDAtom->GetBufferSize(),Size);
 277                 int result = uncompress(outBuffer, &Size, aCMVDAtom->GetCompressedData(), aCMVDAtom->GetBufferSize());
 278
 279                 if (result != Z_OK) {
 280                         printf("Failed to decompress headers uncompress returned ");
 281                         switch (result) {
 282                                 case Z_MEM_ERROR:
 283                                         DEBUGGER("Lack of Memory Error\n");
 284                                         break;
 285                                 case Z_BUF_ERROR:
 286                                         DEBUGGER("Lack of Output buffer space Error\n");
 287                                         break;
 288                                 case Z_DATA_ERROR:
 289                                         DEBUGGER("Input Data is corrupt or not a compressed set Error\n");
 290                                         break;
 291                         }
 292                 }
 293
 294                 // Copy uncompressed data into BMAllocIO
 295                 theUncompressedData = new BMallocIO();
 296                 theUncompressedData->SetSize(Size);
 297                 theUncompressedData->WriteAt(0L,outBuffer,Size);
 298
 299                 free(outBuffer);
 300                 delete aCMVDAtom;
 301
 302                 // reset position on BMAllocIO
 303                 theUncompressedData->Seek(SEEK_SET,0L);
 304                 // Assign to Stream
 305                 theUncompressedStream = theUncompressedData;
 306
 307                 // All subsequent reads should use theUncompressedStream
 308         }
 309
 310 }
 311
 312
 313 void
 314 CMOVAtom::OnChildProcessingComplete()
 315 {
 316         // revert back to file stream once all children have finished
 317         if (theUncompressedStream) {
 318                 delete theUncompressedStream;
 319         }
 320         theUncompressedStream = NULL;
 321 }
 322
 323
 324 const char *
 325 CMOVAtom::OnGetAtomName()
 326 {
 327         return "Compressed MPEG-4 Movie";
 328 }
 329
 330
 331 DCOMAtom::DCOMAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
 332         uint64 pAtomSize)
 333         :
 334         AtomBase(pStream, pStreamOffset, pAtomType, pAtomSize)
 335 {
 336 }
 337
 338
 339 DCOMAtom::~DCOMAtom()
 340 {
 341 }
 342
 343
 344 void
 345 DCOMAtom::OnProcessMetaData()
 346 {
 347         Read(&compressionID);
 348 }
 349
 350
 351 const char *
 352 DCOMAtom::OnGetAtomName()
 353 {
 354         return "Decompression Atom";
 355 }
 356
 357
 358 CMVDAtom::CMVDAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
 359         uint64 pAtomSize)
 360         :
 361         AtomBase(pStream, pStreamOffset, pAtomType, pAtomSize)
 362 {
 363         Buffer = NULL;
 364         UncompressedSize = 0;
 365         BufferSize = 0;
 366 }
 367
 368
 369 CMVDAtom::~CMVDAtom()
 370 {
 371         if (Buffer)
 372                 free(Buffer);
 373 }
 374
 375
 376 void
 377 CMVDAtom::OnProcessMetaData()
 378 {
 379         Read(&UncompressedSize);
 380
 381         if (UncompressedSize > 0) {
 382                 BufferSize = GetBytesRemaining();
 383                 Buffer = (uint8 *)(malloc(BufferSize));
 384                 Read(Buffer,BufferSize);
 385         }
 386 }
 387
 388
 389 const char *
 390 CMVDAtom::OnGetAtomName()
 391 {
 392         return "Compressed Movie Data";
 393 }
 394
 395
 396 MVHDAtom::MVHDAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
 397         uint64 pAtomSize)
 398         :
 399         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
 400 {
 401 }
 402
 403
 404 MVHDAtom::~MVHDAtom()
 405 {
 406 }
 407
 408
 409 void
 410 MVHDAtom::OnProcessMetaData()
 411 {
 412         FullAtom::OnProcessMetaData();
 413
 414         if (GetVersion() == 0) {
 415                 mvhdV0 aHeader;
 416
 417                 Read(&aHeader.CreationTime);
 418                 Read(&aHeader.ModificationTime);
 419                 Read(&aHeader.TimeScale);
 420                 Read(&aHeader.Duration);
 421                 Read(&aHeader.PreferredRate);
 422                 Read(&aHeader.PreferredVolume);
 423                 Read(&aHeader.Reserved1);
 424                 Read(&aHeader.Reserved2[0]);
 425                 Read(&aHeader.Reserved2[1]);
 426                 for (uint32 i=0;i<9;i++) {
 427                         Read(&aHeader.Matrix[i]);
 428                 }
 429                 for (uint32 j=0;j<6;j++) {
 430                         Read(&aHeader.pre_defined[j]);
 431                 }
 432                 Read(&aHeader.NextTrackID);
 433
 434                 // Upconvert to V1 header
 435                 theHeader.CreationTime = (uint64)(aHeader.CreationTime);
 436                 theHeader.ModificationTime = (uint64)(aHeader.ModificationTime);
 437                 theHeader.TimeScale = aHeader.TimeScale;
 438                 theHeader.Duration = (uint64)(aHeader.Duration);
 439                 theHeader.PreferredRate = aHeader.PreferredRate;
 440                 theHeader.PreferredVolume = aHeader.PreferredVolume;
 441                 theHeader.NextTrackID = aHeader.NextTrackID;
 442         }
 443
 444         if (GetVersion() == 1) {
 445                 // Read direct into V1 Header
 446                 Read(&theHeader.CreationTime);
 447                 Read(&theHeader.ModificationTime);
 448                 Read(&theHeader.TimeScale);
 449                 Read(&theHeader.Duration);
 450                 Read(&theHeader.PreferredRate);
 451                 Read(&theHeader.PreferredVolume);
 452                 Read(&theHeader.Reserved1);
 453                 Read(&theHeader.Reserved2[0]);
 454                 Read(&theHeader.Reserved2[1]);
 455                 for (uint32 i=0;i<9;i++) {
 456                         Read(&theHeader.Matrix[i]);
 457                 }
 458                 for (uint32 j=0;j<6;j++) {
 459                         Read(&theHeader.pre_defined[j]);
 460                 }
 461                 Read(&theHeader.NextTrackID);
 462         }
 463 }
 464
 465
 466 const char *
 467 MVHDAtom::OnGetAtomName()
 468 {
 469         return "MPEG-4 Movie Header";
 470 }
 471
 472
 473 MVHDAtom *
 474 MOOVAtom::GetMVHDAtom()
 475 {
 476         AtomBase *aAtomBase;
 477
 478         if (theMVHDAtom == NULL) {
 479                 aAtomBase = GetChildAtom(uint32('mvhd'));
 480                 theMVHDAtom = dynamic_cast<MVHDAtom *>(aAtomBase);
 481         }
 482
 483         // Assert(theMVHDAtom != NULL,"Movie has no movie header atom");
 484         return theMVHDAtom;
 485 }
 486
 487
 488 STTSAtom::STTSAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
 489         uint64 pAtomSize)
 490         :
 491         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
 492 {
 493         theHeader.NoEntries = 0;
 494         SUMDurations = 0;
 495         SUMCounts = 0;
 496 }
 497
 498
 499 STTSAtom::~STTSAtom()
 500 {
 501         for (uint32 i=0;i<theHeader.NoEntries;i++) {
 502                 delete theTimeToSampleArray[i];
 503                 theTimeToSampleArray[i] = NULL;
 504         }
 505 }
 506
 507
 508 void
 509 STTSAtom::OnProcessMetaData()
 510 {
 511         TimeToSample    *aTimeToSample;
 512
 513         FullAtom::OnProcessMetaData();
 514
 515         ReadArrayHeader(&theHeader);
 516
 517         for (uint32 i=0;i<theHeader.NoEntries;i++) {
 518                 aTimeToSample = new TimeToSample;
 519
 520                 Read(&aTimeToSample->Count);
 521                 Read(&aTimeToSample->Duration);
 522
 523                 theTimeToSampleArray[i] = aTimeToSample;
 524                 SUMDurations += (theTimeToSampleArray[i]->Duration
 525                         * theTimeToSampleArray[i]->Count);
 526                 SUMCounts += theTimeToSampleArray[i]->Count;
 527         }
 528 }
 529
 530
 531 const char *
 532 STTSAtom::OnGetAtomName()
 533 {
 534         return "Time to Sample Atom";
 535 }
 536
 537
 538 uint32
 539 STTSAtom::GetSampleForTime(bigtime_t pTime)
 540 {
 541         // Sample for time is this calc, how does STTS help us?
 542         return uint32((pTime * FrameRate + 50) / 1000000.0);
 543
 544 // TODO this is too slow.  PreCalc when loading this?
 545 /*      bigtime_t TotalDuration = 0;
 546         uint64 TotalCount = 0;
 547
 548         for (uint32 i=0;i<theHeader.NoEntries;i++) {
 549                 TotalDuration += (theTimeToSampleArray[i]->Duration
 550                         * theTimeToSampleArray[i]->Count);
 551                 TotalCount += theTimeToSampleArray[i]->Count;
 552                 if ((TotalDuration * 44100) > pTime) {
 553                         return uint32((pTime * FrameRate + 50) / 1000000.0);
 554                 }
 555         }
 556
 557         return 0;
 558 */
 559 }
 560
 561
 562 uint32
 563 STTSAtom::GetSampleForFrame(uint32 pFrame)
 564 {
 565         // Convert frame to time and call GetSampleForTime()
 566         return pFrame;
 567 }
 568
 569
 570 CTTSAtom::CTTSAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
 571         uint64 pAtomSize)
 572         :
 573         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
 574 {
 575         theHeader.NoEntries = 0;
 576 }
 577
 578
 579 CTTSAtom::~CTTSAtom()
 580 {
 581         for (uint32 i=0;i<theHeader.NoEntries;i++) {
 582                 delete theCompTimeToSampleArray[i];
 583                 theCompTimeToSampleArray[i] = NULL;
 584         }
 585 }
 586
 587
 588 void
 589 CTTSAtom::OnProcessMetaData()
 590 {
 591         CompTimeToSample* aCompTimeToSample;
 592
 593         FullAtom::OnProcessMetaData();
 594
 595         ReadArrayHeader(&theHeader);
 596
 597         for (uint32 i=0;i<theHeader.NoEntries;i++) {
 598                 aCompTimeToSample = new CompTimeToSample;
 599
 600                 Read(&aCompTimeToSample->Count);
 601                 Read(&aCompTimeToSample->Offset);
 602
 603                 theCompTimeToSampleArray[i] = aCompTimeToSample;
 604         }
 605 }
 606
 607
 608 const char *
 609 CTTSAtom::OnGetAtomName()
 610 {
 611         return "Composition Time to Sample Atom";
 612 }
 613
 614
 615 STSCAtom::STSCAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
 616         uint64 pAtomSize)
 617         :
 618         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
 619 {
 620         theHeader.NoEntries = 0;
 621 }
 622
 623
 624 STSCAtom::~STSCAtom()
 625 {
 626         for (uint32 i=0;i<theHeader.NoEntries;i++) {
 627                 delete theSampleToChunkArray[i];
 628                 theSampleToChunkArray[i] = NULL;
 629         }
 630 }
 631
 632
 633 void
 634 STSCAtom::OnProcessMetaData()
 635 {
 636         SampleToChunk   *aSampleToChunk;
 637
 638         FullAtom::OnProcessMetaData();
 639
 640         ReadArrayHeader(&theHeader);
 641
 642         uint32  TotalPrevSamples = 0;
 643
 644         for (uint32 i=0;i<theHeader.NoEntries;i++) {
 645                 aSampleToChunk = new SampleToChunk;
 646
 647                 Read(&aSampleToChunk->FirstChunk);
 648                 Read(&aSampleToChunk->SamplesPerChunk);
 649                 Read(&aSampleToChunk->SampleDescriptionID);
 650
 651                 if (i > 0) {
 652                         TotalPrevSamples = TotalPrevSamples + (aSampleToChunk->FirstChunk - theSampleToChunkArray[i-1]->FirstChunk) * theSampleToChunkArray[i-1]->SamplesPerChunk;
 653                         aSampleToChunk->TotalPrevSamples = TotalPrevSamples;
 654                 } else {
 655                         aSampleToChunk->TotalPrevSamples = 0;
 656                 }
 657
 658                 theSampleToChunkArray.push_back(aSampleToChunk);
 659         }
 660 }
 661
 662
 663 const char *
 664 STSCAtom::OnGetAtomName()
 665 {
 666         return "Sample to Chunk Atom";
 667 }
 668
 669
 670 uint32
 671 STSCAtom::GetNoSamplesInChunk(uint32 pChunkID)
 672 {
 673         for (uint32 i=0;i<theHeader.NoEntries;i++) {
 674                 if (theSampleToChunkArray[i]->FirstChunk > pChunkID) {
 675                         return theSampleToChunkArray[i-1]->SamplesPerChunk;
 676                 }
 677         }
 678
 679         return theSampleToChunkArray[theHeader.NoEntries-1]->SamplesPerChunk;
 680 }
 681
 682
 683 uint32
 684 STSCAtom::GetFirstSampleInChunk(uint32 pChunkID)
 685 {
 686         uint32 Diff;
 687
 688         for (uint32 i=0;i<theHeader.NoEntries;i++) {
 689                 if (theSampleToChunkArray[i]->FirstChunk > pChunkID) {
 690                         Diff = pChunkID - theSampleToChunkArray[i-1]->FirstChunk;
 691                         return ((Diff * theSampleToChunkArray[i-1]->SamplesPerChunk)
 692                                 + theSampleToChunkArray[i-1]->TotalPrevSamples);
 693                 }
 694         }
 695
 696         Diff = pChunkID - theSampleToChunkArray[theHeader.NoEntries-1]->FirstChunk;
 697         return Diff * theSampleToChunkArray[theHeader.NoEntries-1]->SamplesPerChunk
 698                 + theSampleToChunkArray[theHeader.NoEntries-1]->TotalPrevSamples;
 699 }
 700
 701
 702 uint32
 703 STSCAtom::GetChunkForSample(uint32 pSample, uint32 *pOffsetInChunk)
 704 {
 705         uint32 ChunkID = 0;
 706
 707         for (int32 i=theHeader.NoEntries-1;i>=0;i--) {
 708                 if (pSample >= theSampleToChunkArray[i]->TotalPrevSamples) {
 709                         // Found chunk now calculate offset
 710                         ChunkID = ((pSample - theSampleToChunkArray[i]->TotalPrevSamples)
 711                                 / theSampleToChunkArray[i]->SamplesPerChunk)
 712                                 + theSampleToChunkArray[i]->FirstChunk;
 713
 714                         *pOffsetInChunk = (pSample - theSampleToChunkArray[i]->TotalPrevSamples) % theSampleToChunkArray[i]->SamplesPerChunk;
 715
 716                         return ChunkID;
 717                 }
 718         }
 719
 720         *pOffsetInChunk = 0;
 721         return theSampleToChunkArray[theHeader.NoEntries-1]->FirstChunk;
 722 }
 723
 724
 725 STSSAtom::STSSAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
 726         uint64 pAtomSize)
 727         :
 728         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
 729 {
 730         theHeader.NoEntries = 0;
 731 }
 732
 733
 734 STSSAtom::~STSSAtom()
 735 {
 736         for (uint32 i=0;i<theHeader.NoEntries;i++) {
 737                 delete theSyncSampleArray[i];
 738                 theSyncSampleArray[i] = NULL;
 739         }
 740 }
 741
 742
 743 void
 744 STSSAtom::OnProcessMetaData()
 745 {
 746         SyncSample      *aSyncSample;
 747
 748         FullAtom::OnProcessMetaData();
 749
 750         ReadArrayHeader(&theHeader);
 751
 752         for (uint32 i=0;i<theHeader.NoEntries;i++) {
 753                 aSyncSample = new SyncSample;
 754
 755                 Read(&aSyncSample->SyncSampleNo);
 756                 aSyncSample->SyncSampleNo--; // First frame is 0 for haiku
 757
 758                 theSyncSampleArray.push_back(aSyncSample);
 759         }
 760 }
 761
 762
 763 const char *
 764 STSSAtom::OnGetAtomName()
 765 {
 766         return "Sync Sample Atom";
 767 }
 768
 769
 770 bool
 771 STSSAtom::IsSyncSample(uint32 pSampleNo)
 772 {
 773
 774         for (uint32 i=0;i<theHeader.NoEntries;i++) {
 775                 if (theSyncSampleArray[i]->SyncSampleNo == pSampleNo) {
 776                         return true;
 777                 }
 778
 779                 if (pSampleNo < theSyncSampleArray[i]->SyncSampleNo) {
 780                         return false;
 781                 }
 782         }
 783
 784         return false;
 785 }
 786
 787
 788 STSZAtom::STSZAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
 789         uint64 pAtomSize)
 790         :
 791         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
 792 {
 793         SampleCount = 0;
 794 }
 795
 796
 797 STSZAtom::~STSZAtom()
 798 {
 799         for (uint32 i=0;i<SampleCount;i++) {
 800                 delete theSampleSizeArray[i];
 801                 theSampleSizeArray[i] = NULL;
 802         }
 803 }
 804
 805
 806 void
 807 STSZAtom::OnProcessMetaData()
 808 {
 809         FullAtom::OnProcessMetaData();
 810
 811         Read(&SampleSize);
 812         Read(&SampleCount);
 813
 814         // If the sample size is constant there is no array and NoEntries seems to
 815         // contain bad values
 816         if (SampleSize == 0) {
 817                 SampleSizePtr   aSampleSizePtr;
 818
 819                 for (uint32 i=0;i<SampleCount;i++) {
 820                         aSampleSizePtr = new SampleSizeEntry;
 821
 822                         Read(&aSampleSizePtr->EntrySize);
 823
 824                         theSampleSizeArray.push_back(aSampleSizePtr);
 825                 }
 826         }
 827 }
 828
 829
 830 const char *
 831 STSZAtom::OnGetAtomName()
 832 {
 833         return "Sample Size Atom";
 834 }
 835
 836
 837 uint32
 838 STSZAtom::GetSizeForSample(uint32 pSampleNo)
 839 {
 840         if (SampleSize > 0) {
 841                 // All samples are the same size
 842                 return SampleSize;
 843         }
 844
 845         if (pSampleNo < SampleCount) {
 846                 // Sample Array indexed by SampleNo
 847                 return theSampleSizeArray[pSampleNo]->EntrySize;
 848         }
 849
 850         printf("SampleNo %ld is outside SampleSize Array\n", pSampleNo);
 851         return 0;
 852 }
 853
 854
 855 bool
 856 STSZAtom::IsSingleSampleSize()
 857 {
 858         return (SampleSize > 0);
 859 }
 860
 861
 862 STZ2Atom::STZ2Atom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
 863         uint64 pAtomSize)
 864         :
 865         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
 866 {
 867         SampleCount = 0;
 868 }
 869
 870
 871 STZ2Atom::~STZ2Atom()
 872 {
 873         for (uint32 i=0;i<SampleCount;i++) {
 874                 delete theSampleSizeArray[i];
 875                 theSampleSizeArray[i] = NULL;
 876         }
 877 }
 878
 879
 880 void
 881 STZ2Atom::OnProcessMetaData()
 882 {
 883         FullAtom::OnProcessMetaData();
 884
 885         uint8   reserved;
 886         Read(&reserved);
 887         Read(&reserved);
 888         Read(&reserved);
 889
 890         Read(&FieldSize);
 891         Read(&SampleCount);
 892
 893         SampleSizePtr   aSampleSizePtr;
 894         uint8   EntrySize8;
 895         uint16  EntrySize16;
 896
 897         for (uint32 i=0;i<SampleCount;i++) {
 898                 aSampleSizePtr = new SampleSizeEntry;
 899
 900                 switch (FieldSize) {
 901                         case 4:
 902                                 Read(&EntrySize8);
 903                                 // 2 values per byte
 904                                 aSampleSizePtr->EntrySize = (uint32)(EntrySize8);
 905                                 break;
 906                         case 8:
 907                                 Read(&EntrySize8);
 908                                 // 1 value per byte
 909                                 aSampleSizePtr->EntrySize = (uint32)(EntrySize8);
 910                                 break;
 911                         case 16:
 912                                 Read(&EntrySize16);
 913                                 // 1 value per 2 bytes
 914                                 aSampleSizePtr->EntrySize = (uint32)(EntrySize16);
 915                                 break;
 916                 }
 917
 918                 theSampleSizeArray.push_back(aSampleSizePtr);
 919         }
 920 }
 921
 922
 923 const char *
 924 STZ2Atom::OnGetAtomName()
 925 {
 926         return "Compressed Sample Size Atom";
 927 }
 928
 929
 930 uint32
 931 STZ2Atom::GetSizeForSample(uint32 pSampleNo)
 932 {
 933         // THIS CODE NEEDS SOME TESTING, never seen a STZ2 atom
 934
 935         uint32  index;
 936
 937         switch (FieldSize) {
 938                 case 4:
 939                         // 2 entries per array entry so Divide by 2
 940                         index = pSampleNo / 2;
 941                         if (index * 2 == pSampleNo) {
 942                                 // even so return low nibble
 943                                 return theSampleSizeArray[pSampleNo]->EntrySize && 0x0000000f;
 944                         } else {
 945                                 // odd so return high nibble
 946                                 return theSampleSizeArray[pSampleNo]->EntrySize && 0x000000f0;
 947                         }
 948                         break;
 949                 case 8:
 950                         return theSampleSizeArray[pSampleNo]->EntrySize;
 951                         break;
 952                 case 16:
 953                         return theSampleSizeArray[pSampleNo]->EntrySize;
 954                         break;
 955         }
 956
 957         // Sample Array indexed by SampleNo
 958         return theSampleSizeArray[pSampleNo]->EntrySize;
 959 }
 960
 961
 962 bool
 963 STZ2Atom::IsSingleSampleSize()
 964 {
 965         return false;
 966 }
 967
 968
 969 STCOAtom::STCOAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
 970         uint64 pAtomSize)
 971         :
 972         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
 973 {
 974         theHeader.NoEntries = 0;
 975 }
 976
 977
 978 STCOAtom::~STCOAtom()
 979 {
 980         for (uint32 i=0;i<theHeader.NoEntries;i++) {
 981                 delete theChunkToOffsetArray[i];
 982                 theChunkToOffsetArray[i] = NULL;
 983         }
 984 }
 985
 986
 987 uint64
 988 STCOAtom::OnGetChunkOffset()
 989 {
 990         uint32 Offset;
 991
 992         Read(&Offset);
 993
 994         // Upconvert to uint64
 995         return uint64(Offset);
 996 }
 997
 998
 999 void
1000 STCOAtom::OnProcessMetaData()
1001 {
1002         ChunkToOffset   *aChunkToOffset;
1003
1004         FullAtom::OnProcessMetaData();
1005
1006         ReadArrayHeader(&theHeader);
1007
1008         for (uint32 i=0;i<theHeader.NoEntries;i++) {
1009                 aChunkToOffset = new ChunkToOffset;
1010
1011                 aChunkToOffset->Offset = OnGetChunkOffset();
1012
1013                 theChunkToOffsetArray[i] = aChunkToOffset;
1014         }
1015 }
1016
1017
1018 const char *
1019 STCOAtom::OnGetAtomName()
1020 {
1021         return "Chunk to Offset Atom";
1022 }
1023
1024
1025 uint64
1026 STCOAtom::GetOffsetForChunk(uint32 pChunkIndex)
1027 {
1028         // Chunk Indexes start at 1
1029         if ((pChunkIndex > 0) && (pChunkIndex <= theHeader.NoEntries)) {
1030                 return theChunkToOffsetArray[pChunkIndex - 1]->Offset;
1031         }
1032
1033 #ifdef DEBUG
1034         char msg[100]; sprintf(msg, "Bad Chunk ID %ld / %ld\n", pChunkIndex,
1035                 theHeader.NoEntries);
1036         DEBUGGER(msg);
1037 #endif
1038
1039         TRESPASS();
1040         return 0LL;
1041 }
1042
1043
1044 DecoderConfigAtom::DecoderConfigAtom(BPositionIO *pStream, off_t pStreamOffset,
1045         uint32 pAtomType, uint64 pAtomSize)
1046         :
1047         AtomBase(pStream, pStreamOffset, pAtomType, pAtomSize)
1048 {
1049         theDecoderConfig = NULL;
1050         DecoderConfigSize = 0;
1051 }
1052
1053
1054 DecoderConfigAtom::~DecoderConfigAtom()
1055 {
1056         if (theDecoderConfig) {
1057                 free(theDecoderConfig);
1058         }
1059 }
1060
1061
1062 void DecoderConfigAtom::OnProcessMetaData()
1063 {
1064         DecoderConfigSize = GetBytesRemaining();
1065
1066         theDecoderConfig = (uint8 *)(malloc(DecoderConfigSize));
1067         Read(theDecoderConfig,DecoderConfigSize);
1068 }
1069
1070
1071 uint8 *
1072 DecoderConfigAtom::GetDecoderConfig()
1073 {
1074         return theDecoderConfig;
1075 }
1076
1077
1078 bool
1079 DecoderConfigAtom::SkipTag(uint8 *ESDS, uint8 Tag, uint32 *offset)
1080 {
1081         uint8 byte;
1082
1083         byte = ESDS[(*offset)++];
1084         if (byte == Tag) {
1085                 uint8 numBytes = 0;
1086                 unsigned int length = 0;
1087
1088                 do {
1089                         byte = ESDS[(*offset)++];
1090                         numBytes++;
1091                         length = (length << 7) | (byte & 0x7F);
1092                 } while ((byte & 0x80) && numBytes < 4);
1093         } else {
1094                 // go back Tag not found
1095                 (*offset)--;
1096                 return false;
1097         }
1098
1099         return true;
1100 }
1101
1102
1103 const char *
1104 DecoderConfigAtom::OnGetAtomName()
1105 {
1106         return "Decoder Config Atom - Unknown type";
1107 }
1108
1109
1110 void
1111 DecoderConfigAtom::OverrideAudioDescription(AudioDescription *pAudioDescription)
1112 {
1113         if (pAudioDescription) {
1114                 pAudioDescription->DecoderConfigSize = DecoderConfigSize;
1115                 pAudioDescription->theDecoderConfig = (uint8 *)(malloc(DecoderConfigSize));
1116                 memcpy(pAudioDescription->theDecoderConfig, theDecoderConfig, DecoderConfigSize);
1117                 OnOverrideAudioDescription(pAudioDescription);
1118         }
1119 }
1120
1121
1122 void
1123 DecoderConfigAtom::OverrideVideoDescription(VideoDescription *pVideoDescription)
1124 {
1125         if (pVideoDescription) {
1126                 pVideoDescription->DecoderConfigSize = DecoderConfigSize;
1127                 pVideoDescription->theDecoderConfig = (uint8 *)(malloc(DecoderConfigSize));
1128                 memcpy(pVideoDescription->theDecoderConfig, theDecoderConfig, DecoderConfigSize);
1129                 OnOverrideVideoDescription(pVideoDescription);
1130         }
1131 }
1132
1133
1134 ESDSAtom::ESDSAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1135         uint64 pAtomSize)
1136         :
1137         DecoderConfigAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
1138 {
1139 }
1140
1141
1142 ESDSAtom::~ESDSAtom()
1143 {
1144 }
1145
1146
1147 void
1148 ESDSAtom::OnProcessMetaData()
1149 {
1150         // Read 4 bytes because this is really a FullAtom
1151         uint32 version;
1152         Read(&version);
1153         DecoderConfigAtom::OnProcessMetaData();
1154 }
1155
1156
1157 const char *
1158 ESDSAtom::OnGetAtomName()
1159 {
1160         return "Extended Sample Description Atom";
1161 }
1162
1163
1164 const char * obj_type_names[]=
1165 {
1166         "Unknown",
1167         "Main-AAC",
1168         "LC-AAC",
1169         "SSR-AAC",
1170         "LTP-AAC",
1171         "HE-AAC",
1172         "HE-AAC(disabled)"
1173 };
1174
1175
1176 int aac_sampling_rate[16] =
1177 {
1178         96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
1179         16000, 12000, 11025, 8000, 7350, 0, 0, 0
1180 };
1181
1182
1183 void
1184 ESDSAtom::OnOverrideAudioDescription(AudioDescription *pAudioDescription)
1185 {
1186         // decode for aac and check for HE-AAC which uses a framesize of 2048
1187         // also check for MP3 which has an ESDS
1188         uint32 offset = 0;
1189         BitParser parser;
1190
1191         if (SkipTag(pAudioDescription->theDecoderConfig, 0x03, &offset)) {
1192                 offset += 3;
1193         } else {
1194                 offset += 2;
1195         }
1196
1197         if (SkipTag(pAudioDescription->theDecoderConfig, 0x04, &offset)) {
1198                 parser.Init(&pAudioDescription->theDecoderConfig[offset],
1199                         (pAudioDescription->DecoderConfigSize - offset) * 8);
1200
1201                 ESDSType = parser.GetValue(8);
1202                 StreamType = parser.GetValue(6);
1203                 parser.Skip(2);
1204                 NeededBufferSize = parser.GetValue(24);
1205                 MaxBitRate = parser.GetValue(32);
1206                 AvgBitRate = parser.GetValue(32);
1207
1208                 pAudioDescription->BitRate = AvgBitRate;
1209
1210                 offset+=13;
1211         }
1212
1213         // Find Tag 0x05 that describes the audio format
1214         SkipTag(pAudioDescription->theDecoderConfig, 0x05, &offset);
1215         bool smallFrameSize;
1216         uint32 SampleRate;
1217
1218         // remember where the tag 5 starts
1219         uint32 extendedAudioConfig = offset;
1220
1221         switch (ESDSType) {
1222                 case 64:        // AAC so use AAC Header details to override ESDS values
1223                         parser.Init(&pAudioDescription->theDecoderConfig[offset],
1224                                 (pAudioDescription->DecoderConfigSize - offset) * 8);
1225
1226                         // 5 bits are decoder type
1227                         theAACHeader.objTypeIndex = parser.GetValue(5);
1228                         if (theAACHeader.objTypeIndex == 31) {
1229                                 theAACHeader.objTypeIndex = 32 + parser.GetValue(6);
1230                         }
1231                         // 4 bits are frequency index
1232                         theAACHeader.sampleRateIndex = parser.GetValue(4);
1233                         if (theAACHeader.sampleRateIndex == 15) {
1234                                 // Direct encoding of SampleRate
1235                                 SampleRate = parser.GetValue(24);
1236                         } else {
1237                                 SampleRate = aac_sampling_rate[theAACHeader.sampleRateIndex];
1238                         }
1239
1240                         // 4 bits are channels
1241                         theAACHeader.totalChannels = parser.GetValue(4);
1242                         // 1 bit determines small frame size
1243                         smallFrameSize = (parser.GetValue(1) == 1);
1244
1245                         if (theAACHeader.objTypeIndex < 3) {
1246                                 pAudioDescription->codecSubType = 'mp4a';
1247                                 pAudioDescription->FrameSize = 1024;
1248                                 if (smallFrameSize) {
1249                                         pAudioDescription->FrameSize = 960;
1250                                 }
1251                         } else {
1252                                 pAudioDescription->codecSubType = 'haac';
1253                                 pAudioDescription->FrameSize = 2048;
1254                         }
1255
1256                         // Override STSD
1257                         pAudioDescription->theAudioSampleEntry.SampleRate = SampleRate;
1258                         pAudioDescription->theAudioSampleEntry.ChannelCount =
1259                                 theAACHeader.totalChannels;
1260
1261                         // Reset decoder Config memory
1262                         memcpy(pAudioDescription->theDecoderConfig,
1263                                 &pAudioDescription->theDecoderConfig[extendedAudioConfig],
1264                                 pAudioDescription->DecoderConfigSize - extendedAudioConfig + 1);
1265
1266                         break;
1267
1268                 case 107:       // MP3
1269                         pAudioDescription->codecSubType = '.mp3';
1270
1271                         // Only set this for mp3, we calc it normally
1272                         if (NeededBufferSize > pAudioDescription->BufferSize) {
1273                                 pAudioDescription->BufferSize = NeededBufferSize;
1274                         }
1275
1276                         break;
1277         }
1278 }
1279
1280
1281 void
1282 ESDSAtom::OnOverrideVideoDescription(VideoDescription *pVideoDescription)
1283 {
1284         // Nothing to override
1285 }
1286
1287
1288 ALACAtom::ALACAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1289         uint64 pAtomSize)
1290         :
1291         DecoderConfigAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
1292 {
1293 }
1294
1295
1296 ALACAtom::~ALACAtom()
1297 {
1298 }
1299
1300
1301 void
1302 ALACAtom::OnProcessMetaData()
1303 {
1304         DecoderConfigAtom::OnProcessMetaData();
1305 }
1306
1307
1308 const char *
1309 ALACAtom::OnGetAtomName()
1310 {
1311         return "ALAC Decoder Config Atom";
1312 }
1313
1314
1315 void
1316 ALACAtom::OnOverrideAudioDescription(AudioDescription *pAudioDescription)
1317 {
1318         pAudioDescription->codecSubType = 'alac';
1319         pAudioDescription->FrameSize = 4096;
1320 }
1321
1322
1323 void
1324 ALACAtom::OnOverrideVideoDescription(VideoDescription *pVideoDescription)
1325 {
1326         // Nothing to override
1327 }
1328
1329
1330 WAVEAtom::WAVEAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1331         uint64 pAtomSize)
1332         :
1333         DecoderConfigAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
1334 {
1335 }
1336
1337
1338 WAVEAtom::~WAVEAtom()
1339 {
1340 }
1341
1342
1343 void
1344 WAVEAtom::OnProcessMetaData()
1345 {
1346 }
1347
1348
1349 const char *
1350 WAVEAtom::OnGetAtomName()
1351 {
1352         return "WAVE Decoder Config Atom";
1353 }
1354
1355
1356 void
1357 WAVEAtom::OnOverrideAudioDescription(AudioDescription *pAudioDescription)
1358 {
1359         pAudioDescription->codecSubType = '.mp3';
1360         pAudioDescription->FrameSize = 1;
1361 }
1362
1363
1364 void
1365 WAVEAtom::OnOverrideVideoDescription(VideoDescription *pVideoDescription)
1366 {
1367         // Nothing to override
1368 }
1369
1370
1371 DAC3Atom::DAC3Atom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1372         uint64 pAtomSize)
1373         :
1374         DecoderConfigAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
1375 {
1376 }
1377
1378
1379 DAC3Atom::~DAC3Atom()
1380 {
1381 }
1382
1383
1384 void
1385 DAC3Atom::OnProcessMetaData()
1386 {
1387         DecoderConfigAtom::OnProcessMetaData();
1388 }
1389
1390
1391 void
1392 DAC3Atom::OnOverrideAudioDescription(AudioDescription *pAudioDescription)
1393 {
1394         pAudioDescription->codecSubType = 'dac3';
1395         pAudioDescription->FrameSize = 1536;
1396 }
1397
1398
1399 void
1400 DAC3Atom::OnOverrideVideoDescription(VideoDescription *pVideoDescription)
1401 {
1402         // Nothing to override
1403 }
1404
1405
1406 const char *
1407 DAC3Atom::OnGetAtomName()
1408 {
1409         return "Digital AC3";
1410 }
1411
1412
1413 DEC3Atom::DEC3Atom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1414         uint64 pAtomSize)
1415         :
1416         DecoderConfigAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
1417 {
1418 }
1419
1420
1421 DEC3Atom::~DEC3Atom()
1422 {
1423 }
1424
1425
1426 void
1427 DEC3Atom::OnProcessMetaData()
1428 {
1429         DecoderConfigAtom::OnProcessMetaData();
1430 }
1431
1432
1433 void
1434 DEC3Atom::OnOverrideAudioDescription(AudioDescription *pAudioDescription)
1435 {
1436         pAudioDescription->codecSubType = 'dec3';
1437         pAudioDescription->FrameSize = 1536;
1438 }
1439
1440
1441 void
1442 DEC3Atom::OnOverrideVideoDescription(VideoDescription *pVideoDescription)
1443 {
1444         // Nothing to override
1445 }
1446
1447
1448 const char *
1449 DEC3Atom::OnGetAtomName()
1450 {
1451         return "Digital EAC3";
1452 }
1453
1454
1455 STSDAtom::STSDAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1456         uint64 pAtomSize)
1457         :
1458         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
1459 {
1460         theHeader.NoEntries = 0;
1461         theAudioDescription.codecid = 0;
1462         theAudioDescription.codecSubType = 0;
1463         theAudioDescription.FrameSize = 1;
1464         theAudioDescription.BufferSize = 0;
1465         theAudioDescription.BitRate = 0;
1466         theAudioDescription.theDecoderConfig = NULL;
1467         theVideoDescription.theDecoderConfig = NULL;
1468 }
1469
1470
1471 STSDAtom::~STSDAtom()
1472 {
1473         if (theAudioDescription.theDecoderConfig) {
1474                 free(theAudioDescription.theDecoderConfig);
1475                 theAudioDescription.theDecoderConfig = NULL;
1476         }
1477
1478         if (theVideoDescription.theDecoderConfig) {
1479                 free(theVideoDescription.theDecoderConfig);
1480                 theVideoDescription.theDecoderConfig = NULL;
1481         }
1482 }
1483
1484
1485 uint32
1486 STSDAtom::GetMediaHandlerType()
1487 {
1488         return dynamic_cast<STBLAtom *>(GetParent())->GetMediaHandlerType();
1489 }
1490
1491
1492 void
1493 STSDAtom::ReadDecoderConfig(uint8 **pDecoderConfig, size_t *pDecoderConfigSize,
1494         AudioDescription *pAudioDescription, VideoDescription *pVideoDescription)
1495 {
1496         // Check for a Decoder Config and if it exists copy it back to the caller
1497         // MPEG-4 video/audio use the various decoder config structures to pass
1498         // additional decoder information to the decoder.  The extractor sometimes
1499         // needs to decode the data to work out how to properly construct the
1500         // decoder
1501
1502         // First make sure we have a something
1503         if (GetBytesRemaining() > 0) {
1504                 // Well something is there so read it as an atom
1505                 AtomBase *aAtomBase = GetAtom(theStream);
1506
1507                 aAtomBase->ProcessMetaData();
1508                 printf("%s [%Ld]\n",aAtomBase->GetAtomName(),aAtomBase->GetAtomSize());
1509
1510                 if (dynamic_cast<DecoderConfigAtom *>(aAtomBase)) {
1511                         // DecoderConfig atom good
1512                         DecoderConfigAtom *aDecoderConfigAtom =
1513                                 dynamic_cast<DecoderConfigAtom *>(aAtomBase);
1514                         aDecoderConfigAtom->OverrideAudioDescription(pAudioDescription);
1515                         aDecoderConfigAtom->OverrideVideoDescription(pVideoDescription);
1516
1517                         delete aAtomBase;
1518                 } else {
1519                         // Unknown atom bad
1520                         printf("Unknown atom %s\n",aAtomBase->GetAtomName());
1521                         delete aAtomBase;
1522                 }
1523         }
1524 }
1525
1526
1527 void
1528 STSDAtom::ReadSoundDescription()
1529 {
1530         Read(&theAudioDescription.theAudioSampleEntry.Reserved[1]);
1531         Read(&theAudioDescription.theAudioSampleEntry.Reserved[2]);
1532         Read(&theAudioDescription.theAudioSampleEntry.ChannelCount);
1533         Read(&theAudioDescription.theAudioSampleEntry.SampleSize);
1534         Read(&theAudioDescription.theAudioSampleEntry.pre_defined);
1535         Read(&theAudioDescription.theAudioSampleEntry.reserved);
1536         Read(&theAudioDescription.theAudioSampleEntry.SampleRate);
1537
1538         theAudioDescription.theAudioSampleEntry.SampleRate =
1539                 theAudioDescription.theAudioSampleEntry.SampleRate / 65536;
1540                 // Convert from fixed point decimal to float
1541
1542         ReadDecoderConfig(&theAudioDescription.theDecoderConfig,
1543                 &theAudioDescription.DecoderConfigSize, &theAudioDescription, NULL);
1544 }
1545
1546
1547 void
1548 STSDAtom::ReadVideoDescription()
1549 {
1550         Read(&theVideoDescription.theVideoSampleEntry.pre_defined1);
1551         Read(&theVideoDescription.theVideoSampleEntry.reserved1);
1552         Read(&theVideoDescription.theVideoSampleEntry.pre_defined2[0]);
1553         Read(&theVideoDescription.theVideoSampleEntry.pre_defined2[1]);
1554         Read(&theVideoDescription.theVideoSampleEntry.pre_defined2[2]);
1555         Read(&theVideoDescription.theVideoSampleEntry.Width);
1556         Read(&theVideoDescription.theVideoSampleEntry.Height);
1557         Read(&theVideoDescription.theVideoSampleEntry.HorizontalResolution);
1558         Read(&theVideoDescription.theVideoSampleEntry.VerticalResolution);
1559         Read(&theVideoDescription.theVideoSampleEntry.reserved2);
1560         Read(&theVideoDescription.theVideoSampleEntry.FrameCount);
1561
1562         Read(theVideoDescription.theVideoSampleEntry.CompressorName,32);
1563
1564         // convert from pascal string (first bytes size) to C string (null terminated)
1565         uint8 size = (uint8)(theVideoDescription.theVideoSampleEntry.CompressorName[0]);
1566         if (size > 0 && size < 32) {
1567                 memmove(&theVideoDescription.theVideoSampleEntry.CompressorName[0],
1568                         &theVideoDescription.theVideoSampleEntry.CompressorName[1],size);
1569                 theVideoDescription.theVideoSampleEntry.CompressorName[size] = '\0';
1570                 printf("Compressed using %s\n",
1571                         theVideoDescription.theVideoSampleEntry.CompressorName);
1572         }
1573
1574         Read(&theVideoDescription.theVideoSampleEntry.Depth);
1575         Read(&theVideoDescription.theVideoSampleEntry.pre_defined3);
1576
1577         ReadDecoderConfig(&theVideoDescription.theDecoderConfig, &theVideoDescription.DecoderConfigSize, NULL, &theVideoDescription);
1578 }
1579
1580
1581 void
1582 STSDAtom::OnProcessMetaData()
1583 {
1584         FullAtom::OnProcessMetaData();
1585
1586         ReadArrayHeader(&theHeader);
1587
1588         // This Atom allows for multiple Desc Entries, we don't
1589
1590         // Ok the committee was drunk when they designed this.
1591         // We are actually reading a Atom/Box where the Atom Type is the codec id.
1592         uint32  Size;
1593
1594         Read(&Size);
1595         Read(&codecid);
1596
1597         Read(theSampleEntry.Reserved,6);
1598         Read(&theSampleEntry.DataReference);
1599
1600         switch (GetMediaHandlerType()) {
1601                 case 'soun':
1602                         ReadSoundDescription();
1603                         theAudioDescription.codecid = codecid;
1604                         break;
1605                 case 'vide':
1606                         ReadVideoDescription();
1607                         theVideoDescription.codecid = codecid;
1608                         break;
1609                 case 'hint':
1610                         break;
1611                 default:
1612                         break;
1613         }
1614 }
1615
1616
1617 VideoDescription
1618 STSDAtom::GetAsVideo()
1619 {
1620         // Assert IsVideo
1621         return theVideoDescription;
1622 }
1623
1624
1625 AudioDescription STSDAtom::GetAsAudio()
1626 {
1627         // Assert IsAudio
1628         return theAudioDescription;
1629 }
1630
1631
1632 const char *
1633 STSDAtom::OnGetAtomName()
1634 {
1635         return "Sample Description Atom";
1636 }
1637
1638
1639 TMCDAtom::TMCDAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1640         uint64 pAtomSize)
1641         :
1642         AtomBase(pStream, pStreamOffset, pAtomType, pAtomSize)
1643 {
1644 }
1645
1646
1647 TMCDAtom::~TMCDAtom()
1648 {
1649 }
1650
1651
1652 void
1653 TMCDAtom::OnProcessMetaData()
1654 {
1655 }
1656
1657
1658 const char *
1659 TMCDAtom::OnGetAtomName()
1660 {
1661         return "TimeCode Atom";
1662 }
1663
1664
1665 WIDEAtom::WIDEAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1666         uint64 pAtomSize)
1667         :
1668         AtomBase(pStream, pStreamOffset, pAtomType, pAtomSize)
1669 {
1670 }
1671
1672
1673 WIDEAtom::~WIDEAtom()
1674 {
1675 }
1676
1677
1678 void
1679 WIDEAtom::OnProcessMetaData()
1680 {
1681 }
1682
1683
1684 const char *
1685 WIDEAtom::OnGetAtomName()
1686 {
1687         return "WIDE Atom";
1688 }
1689
1690
1691 FTYPAtom::FTYPAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1692         uint64 pAtomSize)
1693         :
1694         AtomBase(pStream, pStreamOffset, pAtomType, pAtomSize)
1695 {
1696         total_brands = 0;
1697 }
1698
1699
1700 FTYPAtom::~FTYPAtom()
1701 {
1702 }
1703
1704
1705 void
1706 FTYPAtom::OnProcessMetaData()
1707 {
1708         Read(&major_brand);
1709         Read(&minor_version);
1710
1711         total_brands = GetBytesRemaining() / sizeof(uint32);
1712
1713         if (total_brands > 32) {
1714                 total_brands = 32;      // restrict to 32
1715         }
1716
1717         for (uint32 i=0;i<total_brands;i++) {
1718                 Read(&compatable_brands[i]);
1719         }
1720
1721 }
1722
1723
1724 const char *
1725 FTYPAtom::OnGetAtomName()
1726 {
1727         return "File type Atom";
1728 }
1729
1730 bool
1731 FTYPAtom::HasBrand(uint32 brand)
1732 {
1733
1734         if (major_brand == brand) {
1735                 return true;
1736         }
1737
1738         // return true if the specified brand is in the list
1739         for (uint32 i=0;i<total_brands;i++) {
1740                 if (compatable_brands[i] == brand) {
1741                         return true;
1742                 }
1743         }
1744
1745         return false;
1746 }
1747
1748
1749 FREEAtom::FREEAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1750         uint64 pAtomSize)
1751         :
1752         AtomBase(pStream, pStreamOffset, pAtomType, pAtomSize)
1753 {
1754 }
1755
1756
1757 FREEAtom::~FREEAtom()
1758 {
1759 }
1760
1761
1762 void
1763 FREEAtom::OnProcessMetaData()
1764 {
1765 }
1766
1767
1768 const char *
1769 FREEAtom::OnGetAtomName()
1770 {
1771         return "Free Atom";
1772 }
1773
1774
1775 PNOTAtom::PNOTAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1776         uint64 pAtomSize)
1777         :
1778         AtomBase(pStream, pStreamOffset, pAtomType, pAtomSize)
1779 {
1780 }
1781
1782
1783 PNOTAtom::~PNOTAtom()
1784 {
1785 }
1786
1787
1788 void
1789 PNOTAtom::OnProcessMetaData()
1790 {
1791 }
1792
1793
1794 const char *
1795 PNOTAtom::OnGetAtomName()
1796 {
1797         return "Preview Atom";
1798 }
1799
1800
1801 SKIPAtom::SKIPAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1802         uint64 pAtomSize)
1803         :
1804         AtomBase(pStream, pStreamOffset, pAtomType, pAtomSize)
1805 {
1806 }
1807
1808
1809 SKIPAtom::~SKIPAtom()
1810 {
1811 }
1812
1813
1814 void
1815 SKIPAtom::OnProcessMetaData()
1816 {
1817 }
1818
1819
1820 const char *
1821 SKIPAtom::OnGetAtomName()
1822 {
1823         return "Skip Atom";
1824 }
1825
1826
1827 MDATAtom::MDATAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1828         uint64 pAtomSize)
1829         :
1830         AtomBase(pStream, pStreamOffset, pAtomType, pAtomSize)
1831 {
1832 }
1833
1834
1835 MDATAtom::~MDATAtom()
1836 {
1837 }
1838
1839
1840 void
1841 MDATAtom::OnProcessMetaData()
1842 {
1843 }
1844
1845
1846 const char *
1847 MDATAtom::OnGetAtomName()
1848 {
1849         return "Media Data Atom";
1850 }
1851
1852
1853 off_t
1854 MDATAtom::GetEOF()
1855 {
1856         return GetAtomOffset() + GetAtomSize() - 8;
1857 }
1858
1859
1860 MINFAtom::MINFAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1861         uint64 pAtomSize)
1862         :
1863         AtomContainer(pStream, pStreamOffset, pAtomType, pAtomSize)
1864 {
1865 }
1866
1867
1868 MINFAtom::~MINFAtom()
1869 {
1870 }
1871
1872
1873 void
1874 MINFAtom::OnProcessMetaData()
1875 {
1876 }
1877
1878
1879 const char *
1880 MINFAtom::OnGetAtomName()
1881 {
1882         return "MPEG-4 Media Information Atom";
1883 }
1884
1885
1886 uint32
1887 MINFAtom::GetMediaHandlerType()
1888 {
1889         return dynamic_cast<MDIAAtom *>(GetParent())->GetMediaHandlerType();
1890 }
1891
1892
1893 STBLAtom::STBLAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1894         uint64 pAtomSize)
1895         :
1896         AtomContainer(pStream, pStreamOffset, pAtomType, pAtomSize)
1897 {
1898 }
1899
1900
1901 STBLAtom::~STBLAtom()
1902 {
1903 }
1904
1905
1906 void
1907 STBLAtom::OnProcessMetaData()
1908 {
1909 }
1910
1911
1912 const char *
1913 STBLAtom::OnGetAtomName()
1914 {
1915         return "MPEG-4 Sample Table Atom";
1916 }
1917
1918
1919 uint32
1920 STBLAtom::GetMediaHandlerType()
1921 {
1922         return dynamic_cast<MINFAtom *>(GetParent())->GetMediaHandlerType();
1923 }
1924
1925
1926 DINFAtom::DINFAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1927         uint64 pAtomSize)
1928         :
1929         AtomContainer(pStream, pStreamOffset, pAtomType, pAtomSize)
1930 {
1931 }
1932
1933
1934 DINFAtom::~DINFAtom()
1935 {
1936 }
1937
1938
1939 void
1940 DINFAtom::OnProcessMetaData()
1941 {
1942 }
1943
1944
1945 const char *
1946 DINFAtom::OnGetAtomName()
1947 {
1948         return "MPEG-4 Data Information Atom";
1949 }
1950
1951
1952 TKHDAtom::TKHDAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
1953         uint64 pAtomSize)
1954         :
1955         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
1956 {
1957 }
1958
1959
1960 TKHDAtom::~TKHDAtom()
1961 {
1962 }
1963
1964
1965 void
1966 TKHDAtom::OnProcessMetaData()
1967 {
1968
1969         FullAtom::OnProcessMetaData();
1970
1971         if (GetVersion() == 0) {
1972                 tkhdV0 aHeaderV0;
1973
1974                 Read(&aHeaderV0.CreationTime);
1975                 Read(&aHeaderV0.ModificationTime);
1976                 Read(&aHeaderV0.TrackID);
1977                 Read(&aHeaderV0.Reserved1);
1978                 Read(&aHeaderV0.Duration);
1979                 Read(&aHeaderV0.Reserved2[0]);
1980                 Read(&aHeaderV0.Reserved2[1]);
1981                 Read(&aHeaderV0.Layer);
1982                 Read(&aHeaderV0.AlternateGroup);
1983                 Read(&aHeaderV0.Volume);
1984                 Read(&aHeaderV0.Reserved3);
1985
1986                 for (uint32 i=0;i<9;i++) {
1987                         Read(&theHeader.MatrixStructure[i]);
1988                 }
1989
1990                 Read(&aHeaderV0.TrackWidth);
1991                 Read(&aHeaderV0.TrackHeight);
1992
1993                 // upconvert to V1 header
1994                 theHeader.CreationTime = (uint64)(aHeaderV0.CreationTime);
1995                 theHeader.ModificationTime = (uint64)(aHeaderV0.ModificationTime);
1996                 theHeader.TrackID = aHeaderV0.TrackID;
1997                 theHeader.Duration = (uint64)(aHeaderV0.Duration);
1998                 theHeader.Layer = aHeaderV0.Layer;
1999                 theHeader.AlternateGroup = aHeaderV0.AlternateGroup;
2000                 theHeader.Volume = aHeaderV0.Volume;
2001                 theHeader.TrackWidth = aHeaderV0.TrackWidth;
2002                 theHeader.TrackHeight = aHeaderV0.TrackHeight;
2003         } else {
2004                 Read(&theHeader.CreationTime);
2005                 Read(&theHeader.ModificationTime);
2006                 Read(&theHeader.TrackID);
2007                 Read(&theHeader.Reserved1);
2008                 Read(&theHeader.Duration);
2009                 Read(&theHeader.Reserved2[0]);
2010                 Read(&theHeader.Reserved2[1]);
2011                 Read(&theHeader.Layer);
2012                 Read(&theHeader.AlternateGroup);
2013                 Read(&theHeader.Volume);
2014                 Read(&theHeader.Reserved3);
2015
2016                 for (uint32 i=0;i<9;i++)
2017                         Read(&theHeader.MatrixStructure[i]);
2018
2019                 Read(&theHeader.TrackWidth);
2020                 Read(&theHeader.TrackHeight);
2021         }
2022 }
2023
2024
2025 const char *
2026 TKHDAtom::OnGetAtomName()
2027 {
2028         return "MPEG-4 Track Header";
2029 }
2030
2031
2032 MDIAAtom::MDIAAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
2033         uint64 pAtomSize)
2034         :
2035         AtomContainer(pStream, pStreamOffset, pAtomType, pAtomSize)
2036 {
2037 }
2038
2039
2040 MDIAAtom::~MDIAAtom()
2041 {
2042 }
2043
2044
2045 void
2046 MDIAAtom::OnProcessMetaData()
2047 {
2048 }
2049
2050
2051 const char *
2052 MDIAAtom::OnGetAtomName()
2053 {
2054         return "MPEG-4 Media Atom";
2055 }
2056
2057
2058 uint32
2059 MDIAAtom::GetMediaHandlerType()
2060 {
2061         // Get child atom hdlr
2062         HDLRAtom *aHDLRAtom;
2063         aHDLRAtom = dynamic_cast<HDLRAtom *>(GetChildAtom(uint32('hdlr')));
2064
2065         if (aHDLRAtom) {
2066                 return aHDLRAtom->GetMediaHandlerType();
2067         }
2068
2069         return 0;
2070 }
2071
2072
2073 MDHDAtom::MDHDAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
2074         uint64 pAtomSize)
2075         :
2076         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
2077 {
2078 }
2079
2080
2081 MDHDAtom::~MDHDAtom()
2082 {
2083 }
2084
2085
2086 void
2087 MDHDAtom::OnProcessMetaData()
2088 {
2089         FullAtom::OnProcessMetaData();
2090
2091         if (GetVersion() == 0) {
2092                 mdhdV0 aHeader;
2093
2094                 Read(&aHeader.CreationTime);
2095                 Read(&aHeader.ModificationTime);
2096                 Read(&aHeader.TimeScale);
2097                 Read(&aHeader.Duration);
2098                 Read(&aHeader.Language);
2099                 Read(&aHeader.Reserved);
2100
2101                 theHeader.CreationTime = (uint64)(aHeader.CreationTime);
2102                 theHeader.ModificationTime = (uint64)(aHeader.ModificationTime);
2103                 theHeader.TimeScale = aHeader.TimeScale;
2104                 theHeader.Duration = (uint64)(aHeader.Duration);
2105                 theHeader.Language = aHeader.Language;
2106         } else {
2107                 Read(&theHeader.CreationTime);
2108                 Read(&theHeader.ModificationTime);
2109                 Read(&theHeader.TimeScale);
2110                 Read(&theHeader.Duration);
2111                 Read(&theHeader.Language);
2112                 Read(&theHeader.Reserved);
2113         }
2114 }
2115
2116
2117 const char *
2118 MDHDAtom::OnGetAtomName()
2119 {
2120         return "MPEG-4 Media Header";
2121 }
2122
2123
2124 bigtime_t
2125 MDHDAtom::GetDuration()
2126 {
2127         return bigtime_t((theHeader.Duration * 1000000.0) / theHeader.TimeScale);
2128 }
2129
2130
2131 uint32
2132 MDHDAtom::GetTimeScale()
2133 {
2134         return theHeader.TimeScale;
2135 }
2136
2137
2138 HDLRAtom::HDLRAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
2139         uint64 pAtomSize)
2140         :
2141         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
2142 {
2143         name = NULL;
2144 }
2145
2146
2147 HDLRAtom::~HDLRAtom()
2148 {
2149         if (name) {
2150                 free(name);
2151         }
2152 }
2153
2154
2155 void
2156 HDLRAtom::OnProcessMetaData()
2157 {
2158         FullAtom::OnProcessMetaData();
2159
2160         Read(&theHeader.pre_defined);
2161         Read(&theHeader.handler_type);
2162         Read(&theHeader.Reserved[0]);
2163         Read(&theHeader.Reserved[1]);
2164         Read(&theHeader.Reserved[2]);
2165
2166         name = (char *)(malloc(GetBytesRemaining()));
2167
2168         Read(name,GetBytesRemaining());
2169 }
2170
2171
2172 const char *
2173 HDLRAtom::OnGetAtomName()
2174 {
2175         return "MPEG-4 Handler Reference Atom ";
2176 }
2177
2178
2179 bool
2180 HDLRAtom::IsVideoHandler()
2181 {
2182         return (theHeader.handler_type == 'vide');
2183 }
2184
2185
2186 bool
2187 HDLRAtom::IsAudioHandler()
2188 {
2189         return (theHeader.handler_type == 'soun');
2190 }
2191
2192
2193 uint32
2194 HDLRAtom::GetMediaHandlerType()
2195 {
2196         return theHeader.handler_type;
2197 }
2198
2199
2200 VMHDAtom::VMHDAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
2201         uint64 pAtomSize)
2202         :
2203         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
2204 {
2205 }
2206
2207
2208 VMHDAtom::~VMHDAtom()
2209 {
2210 }
2211
2212
2213 void
2214 VMHDAtom::OnProcessMetaData()
2215 {
2216         FullAtom::OnProcessMetaData();
2217
2218         Read(&theHeader.GraphicsMode);
2219         Read(&theHeader.OpColour[0]);
2220         Read(&theHeader.OpColour[1]);
2221         Read(&theHeader.OpColour[2]);
2222 }
2223
2224
2225 const char *
2226 VMHDAtom::OnGetAtomName()
2227 {
2228         return "MPEG-4 Video Media Header";
2229 }
2230
2231
2232 SMHDAtom::SMHDAtom(BPositionIO *pStream, off_t pStreamOffset, uint32 pAtomType,
2233         uint64 pAtomSize)
2234         :
2235         FullAtom(pStream, pStreamOffset, pAtomType, pAtomSize)
2236 {
2237 }
2238
2239
2240 SMHDAtom::~SMHDAtom()
2241 {
2242 }
2243
2244
2245 void
2246 SMHDAtom::OnProcessMetaData()
2247 {
2248         FullAtom::OnProcessMetaData();
2249
2250         Read(&theHeader.Balance);
2251         Read(&theHeader.Reserved);
2252 }
2253
2254
2255 const char *
2256 SMHDAtom::OnGetAtomName()
2257 {
2258         return "MPEG-4 Sound Media Header";
2259 }