1 /* ------------------------------------------------------------------ 2 * Copyright (C) 1998-2009 PacketVideo 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 13 * express or implied. 14 * See the License for the specific language governing permissions 15 * and limitations under the License. 16 * ------------------------------------------------------------------- 17 */ 18 /*********************************************************************************/ 19 /* ------------------------------------------------------------------- */ 20 /* MPEG-4 Mpeg4File Class */ 21 /* ------------------------------------------------------------------- */ 22 /*********************************************************************************/ 23 /* 24 The Mpeg4File Class is the class that will construct and maintain all the 25 mecessary data structures to be able to render a valid MP4 file to disk. 26 Format. 27 */ 28 29 30 #ifndef MPEG4FILE_H_INCLUDED 31 #define MPEG4FILE_H_INCLUDED 32 33 #ifndef OSCL_FILE_IO_H_INCLUDED 34 #include "oscl_file_io.h" 35 #endif 36 #ifndef IMPEG4FILE_H_INCLUDED 37 #include "impeg4file.h" 38 #endif 39 #ifndef PARENTABLE_H_INCLUDED 40 #include "parentable.h" 41 #endif 42 #ifndef USERDATAATOM_H_INCLUDED 43 #include "userdataatom.h" 44 #endif 45 #ifndef MOVIEATOM_H_INCLUDED 46 #include "movieatom.h" 47 #endif 48 #ifndef MEDIADATAATOM_H_INCLUDED 49 #include "mediadataatom.h" 50 #endif 51 #ifndef ATOMDEFS_H_INCLUDED 52 #include "atomdefs.h" 53 #endif 54 #ifndef FILETYPEATOM_H_INCLUDED 55 #include "filetypeatom.h" 56 #endif 57 #ifndef COPYRIGHTATOM_H_INCLUDED 58 #include "copyrightatom.h" 59 #endif 60 61 #ifndef OSCL_MEDIA_DATA_H_INCLUDED 62 #include "oscl_media_data.h" 63 #endif 64 #ifndef PV_GAU_H_INCLUDED 65 #include "pv_gau.h" 66 #endif 67 68 #ifndef OMA2BOXES_H_INCLUDED 69 #include "oma2boxes.h" 70 #endif 71 #ifndef ATOMDEFS_H_INCLUDED 72 #include "atomdefs.h" 73 #endif 74 75 #ifndef OSCL_UTF8CONV_H_INCLUDED 76 #include "oscl_utf8conv.h" 77 #endif 78 79 #ifndef MOVIEFRAGMENTATOM_H_INCLUDED 80 #include "moviefragmentatom.h" 81 #endif 82 83 #ifndef MOVIEFRAGMENTRANDOMACCESSATOM_H_INCLUDED 84 #include "moviefragmentrandomaccess.h" 85 #endif 86 87 #ifndef MEDIA_CLOCK_CONVERTOR_H_INCLUDED 88 #include "media_clock_converter.h" 89 #endif 90 91 #ifndef PV_ID3_PARCOM_H_INCLUDED 92 #include "pv_id3_parcom.h" 93 #endif 94 95 #define ID3V1_STR_MAX_SIZE 64 96 97 class AVCSampleEntry; 98 99 class Mpeg4File : public IMpeg4File, public Parentable 100 { 101 102 public: 103 Mpeg4File(MP4_FF_FILE *fp, 104 OSCL_wString& filename, 105 uint32 parsingMode = 0); // Stream-in Constructor 106 virtual ~Mpeg4File(); 107 108 int32 updateFileSize(uint32 filesize) 109 { 110 if (_pmovieAtom != NULL) 111 { 112 return _pmovieAtom->updateFileSize(filesize); 113 } 114 return DEFAULT_ERROR; 115 } 116 117 int32 getNextMediaSample(uint32 id, uint8 *buf, uint32 &size, uint32 &index, uint32 &SampleOffset) 118 { 119 if (_pmovieAtom == NULL) 120 { 121 return READ_MOVIE_ATOM_FAILED; 122 } 123 return _pmovieAtom->getNextMediaSample(id, buf, size, index, SampleOffset); 124 } 125 126 MP4_ERROR_CODE getKeyMediaSampleNumAt(uint32 aTrackId, 127 uint32 aKeySampleNum, 128 GAU *pgau); 129 130 uint32 getNumKeyFrames(uint32 trackid) 131 { 132 if (_pmovieAtom != NULL) 133 { 134 return _pmovieAtom->getNumKeyFrames(trackid); 135 } 136 else 137 { 138 return 0; 139 } 140 } 141 142 int32 getPrevKeyMediaSample(uint32 inputtimestamp, 143 uint32 &aKeySampleNum, 144 uint32 id, 145 uint32 *n, 146 GAU *pgau) 147 { 148 if (_pmovieAtom == NULL) 149 { 150 return READ_MOVIE_ATOM_FAILED; 151 } 152 return _pmovieAtom->getPrevKeyMediaSample(inputtimestamp, aKeySampleNum, id, n, pgau); 153 } 154 155 int32 getNextKeyMediaSample(uint32 inputtimestamp, 156 uint32 &aKeySampleNum, 157 uint32 id, 158 uint32 *n, 159 GAU *pgau) 160 { 161 if (_pmovieAtom == NULL) 162 { 163 return READ_MOVIE_ATOM_FAILED; 164 } 165 return _pmovieAtom->getNextKeyMediaSample(inputtimestamp, aKeySampleNum, id, n, pgau); 166 } 167 168 int32 getMediaSample(uint32 id, uint32 sampleNumber, uint8 *buf, int32 &size, uint32 &index, uint32 &SampleOffset) 169 { 170 if (_pmovieAtom == NULL) 171 { 172 return READ_MOVIE_ATOM_FAILED; 173 } 174 return _pmovieAtom->getMediaSample(id, sampleNumber, buf, size, index, SampleOffset); 175 } 176 177 int32 getOffsetByTime(uint32 id, uint32 ts, int32* sampleFileOffset , uint32 jitterbuffertimeinmillisec); 178 179 180 uint32 getMediaTimestampForCurrentSample(uint32 id) 181 { 182 if (_pmovieAtom != NULL) 183 { 184 return _pmovieAtom->getTimestampForCurrentSample(id); 185 } 186 else 187 { 188 return 0; 189 } 190 } 191 192 int32 getTimestampForRandomAccessPoints(uint32 id, uint32 *num, uint32 *tsBuf, uint32* numBuf, uint32 *offsetBuf); 193 194 195 int32 getTimestampForRandomAccessPointsBeforeAfter(uint32 id, uint32 ts, uint32 *tsBuf, uint32* numBuf, 196 uint32& numsamplestoget, 197 uint32 howManyKeySamples); 198 199 200 //Return MPEG VOL header information 201 virtual uint8* getTrackDecoderSpecificInfoContent(uint32 id); 202 virtual uint32 getTrackDecoderSpecificInfoSize(uint32 id); 203 uint32 getTimestampForSampleNumber(uint32 id, uint32 sampleNumber) ; 204 int32 getSampleSizeAt(uint32 id, int32 sampleNum) ; 205 206 virtual DecoderSpecificInfo* getTrackDecoderSpecificInfoAtSDI(uint32 trackID, uint32 index); 207 208 virtual void resetPlayback(); 209 210 uint32 repositionFromMoof(uint32 time, uint32 trackID); 211 212 void resetAllMovieFragments(); 213 214 215 virtual uint32 resetPlayback(uint32 time, uint16 numTracks, uint32 *trackList, bool bResetToIFrame); 216 217 virtual int32 queryRepositionTime(uint32 time, 218 uint16 numTracks, 219 uint32 *trackList, 220 bool bResetToIFrame, 221 bool bBeforeRequestedTime); 222 223 virtual int32 querySyncFrameBeforeTime(uint32 time, uint16 numTracks, uint32 *trackList) 224 { 225 if (_pmovieAtom == NULL) 226 { 227 return READ_MOVIE_ATOM_FAILED; 228 } 229 return _pmovieAtom->querySyncFrameBeforeTime(time, numTracks, trackList); 230 } 231 232 // pvmm 233 virtual OSCL_wString& getPVTitle(MP4FFParserOriginalCharEnc &charType) ; 234 virtual OSCL_wString& getPVAuthor(MP4FFParserOriginalCharEnc &charType) ; 235 virtual OSCL_wString& getPVDescription(MP4FFParserOriginalCharEnc &charType) ; 236 virtual OSCL_wString& getPVRating(MP4FFParserOriginalCharEnc &charType) ; 237 virtual OSCL_wString& getPVCopyright(MP4FFParserOriginalCharEnc &charType) ; 238 virtual OSCL_wString& getPVVersion(MP4FFParserOriginalCharEnc &charType) ; 239 virtual OSCL_wHeapString<OsclMemAllocator> getCreationDate(MP4FFParserOriginalCharEnc &charType) ; 240 241 // from 'ftyp' atom 242 uint32 getCompatibiltyMajorBrand() 243 { 244 if (_pFileTypeAtom != NULL) 245 { 246 return _pFileTypeAtom->getMajorBrand(); 247 } 248 else 249 { 250 return 0; 251 } 252 } 253 254 uint32 getCompatibiltyMajorBrandVersion() 255 { 256 if (_pFileTypeAtom != NULL) 257 { 258 return _pFileTypeAtom->getMajorBrandVersion(); 259 } 260 else 261 { 262 return 0; 263 } 264 } 265 266 Oscl_Vector<uint32, OsclMemAllocator> *getCompatibiltyList() 267 { 268 if (_pFileTypeAtom != NULL) 269 { 270 return _pFileTypeAtom->getCompatibleBrand(); 271 } 272 else 273 { 274 return NULL; 275 } 276 } 277 278 // From Movie 279 int32 getNumTracks() 280 { 281 if (_pmovieAtom != NULL) 282 { 283 return _pmovieAtom->getNumTracks(); 284 } 285 else 286 { 287 return 0; 288 } 289 } 290 291 int32 getTrackIDList(uint32 *ids, int size) 292 { 293 if (_pmovieAtom != NULL) 294 { 295 return _pmovieAtom->getTrackIDList(ids, size); 296 } 297 else 298 { 299 return 0; 300 } 301 } 302 303 uint32 getTrackWholeIDList(uint32 *ids) 304 { 305 if (_pmovieAtom != NULL) 306 { 307 return _pmovieAtom->getTrackWholeIDList(ids); 308 } 309 else 310 { 311 return 0; 312 } 313 } 314 315 316 // RETRIEVAL METHODS 317 // Methods to get the sample rate (i.e. timescales) for the streams and 318 // the overall Mpeg-4 presentation 319 virtual uint64 getMovieDuration() const; 320 virtual uint64 getMovieFragmentDuration() const; 321 virtual uint32 getMovieTimescale() const; 322 323 // From TrackHeader 324 uint64 getTrackDuration(uint32 id); 325 326 // From TrackReference 327 uint32 trackDependsOn(uint32 id); 328 329 // From MediaHeader 330 uint64 getTrackMediaDurationForMovie(uint32 id); 331 332 // From MediaHeader 333 uint64 getTrackMediaDuration(uint32 id); 334 uint32 getTrackMediaTimescale(uint32 id); 335 uint16 getTrackLangCode(uint32 id); 336 337 // From Handler 338 uint32 getTrackMediaType(uint32 id); 339 340 // From SampleDescription 341 int32 getTrackNumSampleEntries(uint32 id); 342 343 void getTrackMIMEType(uint32 id, OSCL_String& aMimeType); // Based on OTI value 344 345 int32 getTrackMaxBufferSizeDB(uint32 id); 346 int32 getTrackAverageBitrate(uint32 id); 347 348 //From PASP atom 349 uint32 getHspacing(uint32 id); 350 uint32 getVspacing(uint32 id); 351 352 353 354 // MPEG4 header retrieval methods 355 int32 getFileType() const 356 { 357 return _fileType; 358 } 359 int32 getScalability() const 360 { 361 return _scalability; 362 } 363 int32 parseMFRA(); 364 365 virtual int32 peekNextBundledAccessUnits(const uint32 trackID, 366 uint32 *n, 367 MediaMetaInfo *mInfo); 368 369 virtual int32 getNextBundledAccessUnits(const uint32 trackID, uint32 *n, GAU *pgau); 370 MovieFragmentAtom *getMovieFragmentForTrackId(uint32 id); 371 372 uint32 getSampleCountInTrack(uint32 id); 373 374 375 int16 getLayer(uint32 trackid) 376 { 377 return _pmovieAtom->getLayer(trackid); 378 } 379 uint16 getAlternateGroup(uint32 trackid) 380 { 381 return _pmovieAtom->getAlternateGroup(trackid); 382 } 383 int32 getVideoFrameHeight(uint32 trackid) 384 { 385 return _pmovieAtom->getTrackHeight(trackid); 386 } 387 388 int32 getVideoFrameWidth(uint32 trackid) 389 { 390 return _pmovieAtom->getTrackWidth(trackid); 391 } 392 393 int32 getTextTrackWidth(uint32 trackid) 394 { 395 return _pmovieAtom->getTextTrackWidth(trackid); 396 } 397 int32 getTextTrackHeight(uint32 trackid) 398 { 399 return _pmovieAtom->getTextTrackHeight(trackid); 400 } 401 int32 getTextTrackXOffset(uint32 trackid) 402 { 403 return _pmovieAtom->getTextTrackXOffset(trackid); 404 } 405 int32 getTextTrackYOffset(uint32 trackid) 406 { 407 return _pmovieAtom->getTextTrackYOffset(trackid); 408 } 409 410 SampleEntry *getTextSampleEntryAt(uint32 trackid, uint32 index) 411 { 412 if (_pmovieAtom != NULL) 413 { 414 return (_pmovieAtom->getTextSampleEntryAt(trackid, index)); 415 } 416 else 417 { 418 return NULL; 419 } 420 } 421 422 virtual bool IsMobileMP4(); 423 424 OSCL_wString& convertModificationTime(uint32 time); 425 426 //Metadata Retrieval Functions 427 428 virtual PVMFStatus populateMetadataVectors(); 429 430 //Title Retrieval Functions 431 virtual uint32 getNumTitle(); 432 virtual PVMFStatus getTitle(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); 433 virtual PVMFStatus populateTitleVector(); 434 435 //Author Retrieval Functions 436 virtual uint32 getNumAuthor(); 437 virtual PVMFStatus getAuthor(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); 438 virtual PVMFStatus populateAuthorVector(); 439 440 //Album Retrieval Functions 441 virtual uint32 getNumAlbum(); 442 virtual PVMFStatus getAlbum(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); 443 virtual PVMFStatus populateAlbumVector(); 444 445 //Artist Retrieval Functions 446 virtual uint32 getNumArtist(); 447 virtual PVMFStatus getArtist(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); 448 virtual PVMFStatus populateArtistVector(); 449 450 //Genre Retrieval Functions 451 virtual uint32 getNumGenre(); 452 virtual PVMFStatus getGenre(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); 453 virtual PVMFStatus populateGenreVector(); 454 455 //Year Retrieval Functions 456 virtual uint32 getNumYear(); 457 virtual PVMFStatus getYear(uint32 index, uint32& aVal); 458 virtual PVMFStatus populateYearVector(); 459 460 //Copyright Retrieval Functions 461 virtual uint32 getNumCopyright(); 462 virtual PVMFStatus getCopyright(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); 463 virtual PVMFStatus populateCopyrightVector(); 464 465 //Comment Retrieval Functions 466 virtual uint32 getNumComment(); 467 virtual PVMFStatus getComment(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); 468 virtual PVMFStatus populateCommentVector(); 469 470 //Description Retrieval Functions 471 virtual uint32 getNumDescription(); 472 virtual PVMFStatus getDescription(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); 473 virtual PVMFStatus populateDescriptionVector(); 474 475 //Rating Retrieval Functions 476 virtual uint32 getNumRating(); 477 virtual PVMFStatus getRating(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); 478 virtual PVMFStatus populateRatingVector(); 479 480 481 uint16 getAssetInfoTitleLangCode(int32 index) const 482 { 483 return (_pmovieAtom->getAssetInfoTitleLangCode(index)); 484 } 485 OSCL_wString& getAssetInfoTitleNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const 486 { 487 return (_pmovieAtom->getAssetInfoTitleNotice(charType, index)); 488 } 489 uint16 getAssetInfoDescLangCode(int32 index) const 490 { 491 return (_pmovieAtom->getAssetInfoDescLangCode(index)); 492 } 493 OSCL_wString& getAssetInfoDescNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const 494 { 495 return (_pmovieAtom->getAssetInfoDescNotice(charType, index)); 496 } 497 OSCL_wString& getCopyRightString(MP4FFParserOriginalCharEnc &charType, int32 index) 498 { 499 return (_pmovieAtom->getCopyRightString(charType, index)); 500 } 501 uint16 getCopyRightLanguageCode(int32 index) 502 { 503 return (_pmovieAtom->getCopyRightLanguageCode(index)); 504 } 505 uint16 getAssetInfoPerformerLangCode(int32 index) const 506 { 507 return (_pmovieAtom->getAssetInfoPerformerLangCode(index)); 508 } 509 OSCL_wString& getAssetInfoPerformerNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const 510 { 511 return (_pmovieAtom->getAssetInfoPerformerNotice(charType, index)); 512 } 513 uint16 getAssetInfoAuthorLangCode(int32 index) const 514 { 515 return (_pmovieAtom->getAssetInfoAuthorLangCode(index)); 516 } 517 OSCL_wString& getAssetInfoAuthorNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const 518 { 519 return (_pmovieAtom->getAssetInfoAuthorNotice(charType, index)); 520 } 521 uint16 getAssetInfoGenreLangCode(int32 index) const 522 { 523 return (_pmovieAtom->getAssetInfoGenreLangCode(index)); 524 } 525 OSCL_wString& getAssetInfoGenreNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const 526 { 527 return (_pmovieAtom->getAssetInfoGenreNotice(charType, index)); 528 } 529 uint32 getAssetInfoRatingCriteria(int32 index) const 530 { 531 return (_pmovieAtom->getAssetInfoRatingCriteria(index)); 532 } 533 uint32 getAssetInfoRatingEntity(int32 index) const 534 { 535 return (_pmovieAtom->getAssetInfoRatingEntity(index)); 536 } 537 uint16 getAssetInfoRatingLangCode(int32 index) const 538 { 539 return (_pmovieAtom->getAssetInfoRatingLangCode(index)); 540 } 541 OSCL_wString& getAssetInfoRatingNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const 542 { 543 return (_pmovieAtom->getAssetInfoRatingNotice(charType, index)); 544 } 545 uint32 getAssetInfoClassificationEntity(int32 index) const 546 { 547 return (_pmovieAtom->getAssetInfoClassificationEntity(index)); 548 } 549 uint16 getAssetInfoClassificationTable(int32 index) const 550 { 551 return (_pmovieAtom->getAssetInfoClassificationTable(index)); 552 } 553 uint16 getAssetInfoClassificationLangCode(int32 index) const 554 { 555 return (_pmovieAtom->getAssetInfoClassificationLangCode(index)); 556 } 557 OSCL_wString& getAssetInfoClassificationNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const 558 { 559 return (_pmovieAtom->getAssetInfoClassificationNotice(charType, index)); 560 } 561 uint16 getAssetInfoNumKeyWords(int32 index) const 562 { 563 return (_pmovieAtom->getAssetInfoNumKeyWords(index)); 564 } 565 uint16 getAssetInfoKeyWordLangCode(int32 index) const 566 { 567 return (_pmovieAtom->getAssetInfoKeyWordLangCode(index)); 568 } 569 OSCL_wString& getAssetInfoKeyWord(int32 atomIndex, int32 keyWordIndex) const 570 { 571 return (_pmovieAtom->getAssetInfoKeyWord(atomIndex, keyWordIndex)); 572 } 573 574 int32 getNumAssetInfoTitleAtoms() 575 { 576 if (_pmovieAtom != NULL) 577 { 578 return (_pmovieAtom->getNumAssetInfoTitleAtoms()); 579 } 580 else 581 { 582 return 0; 583 } 584 } 585 int32 getNumAssetInfoDescAtoms() 586 { 587 if (_pmovieAtom != NULL) 588 { 589 return (_pmovieAtom->getNumAssetInfoDescAtoms()); 590 } 591 else 592 { 593 return 0; 594 } 595 } 596 int32 getNumCopyRightAtoms() 597 { 598 if (_pmovieAtom != NULL) 599 { 600 return (_pmovieAtom->getNumCopyRightAtoms()); 601 } 602 else 603 { 604 return 0; 605 } 606 } 607 int32 getNumAssetInfoPerformerAtoms() 608 { 609 if (_pmovieAtom != NULL) 610 { 611 return (_pmovieAtom->getNumAssetInfoPerformerAtoms()); 612 } 613 else 614 { 615 return 0; 616 } 617 } 618 int32 getNumAssetInfoAuthorAtoms() 619 { 620 if (_pmovieAtom != NULL) 621 { 622 return (_pmovieAtom->getNumAssetInfoAuthorAtoms()); 623 } 624 else 625 { 626 return 0; 627 } 628 } 629 int32 getNumAssetInfoGenreAtoms() 630 { 631 if (_pmovieAtom != NULL) 632 { 633 return (_pmovieAtom->getNumAssetInfoGenreAtoms()); 634 } 635 else 636 { 637 return 0; 638 } 639 } 640 int32 getNumAssetInfoRatingAtoms() 641 { 642 if (_pmovieAtom != NULL) 643 { 644 return (_pmovieAtom->getNumAssetInfoRatingAtoms()); 645 } 646 else 647 { 648 return 0; 649 } 650 } 651 int32 getNumAssetInfoClassificationAtoms() 652 { 653 if (_pmovieAtom != NULL) 654 { 655 return (_pmovieAtom->getNumAssetInfoClassificationAtoms()); 656 } 657 else 658 { 659 return 0; 660 } 661 } 662 int32 getNumAssetInfoKeyWordAtoms() 663 { 664 if (_pmovieAtom != NULL) 665 { 666 return (_pmovieAtom->getNumAssetInfoKeyWordAtoms()); 667 } 668 else 669 { 670 return 0; 671 } 672 } 673 int32 getNumAssetInfoLocationAtoms() 674 { 675 if (_pmovieAtom != NULL) 676 { 677 return (_pmovieAtom->getNumAssetInfoLocationAtoms()); 678 } 679 else 680 { 681 return 0; 682 } 683 } 684 685 int32 getNumAssetInfoAlbumAtoms() 686 { 687 if (_pmovieAtom != NULL) 688 { 689 return (_pmovieAtom->getNumAssetInfoAlbumAtoms()); 690 } 691 else 692 { 693 return 0; 694 } 695 } 696 697 int32 getNumAssetInfoRecordingYearAtoms() 698 { 699 if (_pmovieAtom != NULL) 700 { 701 return (_pmovieAtom->getNumAssetInfoRecordingYearAtoms()); 702 } 703 else 704 { 705 return 0; 706 } 707 } 708 PvmfAssetInfo3GPPLocationStruct *getAssetInfoLocationStruct(int32 index = 0) const 709 { 710 if (_pmovieAtom != NULL) 711 { 712 return (_pmovieAtom->getAssetInfoLocationStruct(index)); 713 } 714 else 715 { 716 return NULL; 717 } 718 } 719 uint16 getAssetInfoAlbumLangCode(int32 index) 720 { 721 if (_pmovieAtom != NULL) 722 { 723 return (_pmovieAtom->getAssetInfoAlbumLangCode(index)); 724 } 725 else 726 { 727 return 0; 728 } 729 } 730 OSCL_wString& getAssetInfoAlbumNotice(MP4FFParserOriginalCharEnc &charType, int32 index) 731 { 732 if (_pmovieAtom != NULL) 733 { 734 return (_pmovieAtom->getAssetInfoAlbumNotice(charType, index)); 735 } 736 else 737 { 738 return _emptyString; 739 } 740 } 741 uint8 getAssetInfoAlbumTrackNumber(int32 index) 742 { 743 if (_pmovieAtom != NULL) 744 { 745 return (_pmovieAtom->getAssetInfoAlbumTrackNumber(index)); 746 } 747 else 748 { 749 return 0; 750 } 751 } 752 uint16 getAssetInfoRecordingYear(int32 index) 753 { 754 if (_pmovieAtom != NULL) 755 { 756 return (_pmovieAtom->getAssetInfoRecordingYear(index)); 757 } 758 else 759 { 760 return 0; 761 } 762 } 763 764 int32 getNumAMRFramesPerSample(uint32 trackID) 765 { 766 if (_pmovieAtom != NULL) 767 { 768 return (_pmovieAtom->getNumAMRFramesPerSample(trackID)); 769 } 770 else 771 { 772 return 0; 773 } 774 } 775 776 uint8 parseBufferAndGetNumAMRFrames(uint8* buffer, uint32 size); 777 778 779 MP4_ERROR_CODE getMaxTrackTimeStamp(uint32 trackID, 780 uint32 fileSize, 781 uint32& timeStamp) 782 { 783 if (_pmovieAtom != NULL) 784 { 785 return (_pmovieAtom->getMaxTrackTimeStamp(trackID, 786 fileSize, 787 timeStamp)); 788 } 789 else 790 { 791 return DEFAULT_ERROR; 792 } 793 } 794 795 MP4_ERROR_CODE getSampleNumberClosestToTimeStamp(uint32 trackID, 796 uint32 &sampleNumber, 797 uint32 timeStamp, 798 uint32 sampleOffset = 0) 799 { 800 if (_pmovieAtom != NULL) 801 { 802 return 803 (_pmovieAtom->getSampleNumberClosestToTimeStamp(trackID, 804 sampleNumber, 805 timeStamp, 806 sampleOffset)); 807 } 808 else 809 { 810 return (READ_FAILED); 811 } 812 } 813 814 AVCSampleEntry* getAVCSampleEntry(uint32 trackID, uint32 index) 815 { 816 if (_pmovieAtom != NULL) 817 { 818 return (_pmovieAtom->getAVCSampleEntry(trackID, index)); 819 } 820 return (NULL); 821 } 822 823 uint32 getAVCNALLengthSize(uint32 trackID, uint32 index) 824 { 825 if (_pmovieAtom != NULL) 826 { 827 return (_pmovieAtom->getAVCNALLengthSize(trackID, index)); 828 } 829 return 0; 830 } 831 832 uint32 getNumAVCSampleEntries(uint32 trackID) 833 { 834 if (_pmovieAtom != NULL) 835 { 836 return (_pmovieAtom->getNumAVCSampleEntries(trackID)); 837 } 838 return 0; 839 } 840 841 void ResetVideoTrackPresentFlag(void) 842 { 843 _oVideoTrackPresent = false; 844 } 845 846 uint32 getTrackLevelOMA2DRMInfoSize(uint32 trackID); 847 uint8* getTrackLevelOMA2DRMInfo(uint32 trackID); 848 849 MP4_ERROR_CODE RequestReadCapacityNotification(PvmiDataStreamObserver& aObserver, 850 uint32 aFileOffset, 851 OsclAny* aContextData = NULL); 852 853 MP4_ERROR_CODE CancelNotificationSync(); 854 855 MP4_ERROR_CODE GetCurrentFileSize(uint32& aFileSize); 856 857 int32 getTrackTSStartOffset(uint32& aTSOffset, uint32 aTrackID) 858 { 859 if (_pmovieAtom != NULL) 860 { 861 return (_pmovieAtom->getTrackTSStartOffset(aTSOffset, aTrackID)); 862 } 863 else 864 { 865 return READ_FAILED; 866 } 867 } 868 869 870 OSCL_wHeapString<OsclMemAllocator> getITunesArtist() const 871 { 872 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 873 if (_pmovieAtom != NULL) 874 { 875 return _pmovieAtom->getITunesArtist(); 876 877 } 878 else 879 return temp; 880 } 881 882 OSCL_wHeapString<OsclMemAllocator> getITunesAlbumArtist() const 883 { 884 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 885 if (_pmovieAtom != NULL) 886 { 887 return _pmovieAtom->getITunesAlbumArtist(); 888 889 } 890 else 891 return temp; 892 } 893 894 OSCL_wHeapString<OsclMemAllocator> getITunesTitle() const 895 { 896 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 897 if (_pmovieAtom != NULL) 898 { 899 return _pmovieAtom->getITunesTitle(); 900 901 } 902 else 903 return temp; 904 905 } 906 907 OSCL_wHeapString<OsclMemAllocator> getITunesTrackSubTitle() const 908 { 909 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 910 if (_pmovieAtom != NULL) 911 { 912 return _pmovieAtom->getITunesTrackSubTitle(); 913 914 } 915 else 916 return temp; 917 918 } 919 920 921 OSCL_wHeapString<OsclMemAllocator> getITunesAlbum() const 922 { 923 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 924 925 if (_pmovieAtom != NULL) 926 { 927 return _pmovieAtom->getITunesAlbum(); 928 } 929 else 930 return temp; 931 } 932 933 // Gnre ** Starts ** 934 uint16 getITunesGnreID() const 935 { 936 if (_pmovieAtom != NULL) 937 { 938 939 if (_pmovieAtom->getITunesGnreVersion() == INTEGER_GENRE) 940 { 941 return _pmovieAtom->getITunesGnreID(); 942 } 943 else 944 return 0; 945 } 946 else 947 return 0; 948 } 949 950 951 OSCL_wHeapString<OsclMemAllocator> getITunesGnreString() const 952 { 953 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 954 955 if (_pmovieAtom != NULL) 956 { 957 958 if (_pmovieAtom->getITunesGnreVersion() == STRING_GENRE) 959 { 960 return _pmovieAtom->getITunesGnreString(); 961 } 962 else 963 return temp; 964 } 965 else 966 return temp; 967 } 968 969 //This function will tell the type of Genre-- 970 GnreVersion getITunesGnreVersion() const 971 { 972 if (_pmovieAtom != NULL) 973 { 974 return _pmovieAtom->getITunesGnreVersion(); 975 } 976 else 977 return INTEGER_GENRE; 978 979 } 980 // Gnre ** Ends ** 981 982 983 // Returns the 4-byte YEAR when the song was recorded 984 OSCL_wHeapString<OsclMemAllocator> getITunesYear() const 985 { 986 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 987 988 if (_pmovieAtom != NULL) 989 { 990 991 return _pmovieAtom->getITunesYear(); 992 } 993 else 994 return temp; 995 } 996 997 998 OSCL_wHeapString<OsclMemAllocator> getITunesTool() const 999 { 1000 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 1001 1002 if (_pmovieAtom != NULL) 1003 { 1004 1005 return _pmovieAtom->getITunesTool(); 1006 } 1007 else 1008 return temp; 1009 } 1010 1011 OSCL_wHeapString<OsclMemAllocator> getITunesEncodedBy() const 1012 { 1013 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 1014 1015 if (_pmovieAtom != NULL) 1016 { 1017 1018 return _pmovieAtom->getITunesEncodedBy(); 1019 } 1020 else 1021 return temp; 1022 } 1023 1024 OSCL_wHeapString<OsclMemAllocator> getITunesWriter() const 1025 { 1026 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 1027 1028 if (_pmovieAtom != NULL) 1029 { 1030 1031 return _pmovieAtom->getITunesWriter(); 1032 } 1033 else 1034 return temp; 1035 } 1036 1037 OSCL_wHeapString<OsclMemAllocator> getITunesGroupData() const 1038 { 1039 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 1040 1041 if (_pmovieAtom != NULL) 1042 { 1043 1044 return _pmovieAtom->getITunesGroup(); 1045 } 1046 else 1047 return temp; 1048 } 1049 1050 OSCL_wHeapString<OsclMemAllocator> getITunesComment() const 1051 { 1052 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 1053 1054 if (_pmovieAtom != NULL) 1055 { 1056 1057 return _pmovieAtom->getITunesComment(); 1058 } 1059 else 1060 return temp; 1061 } 1062 1063 OSCL_wHeapString<OsclMemAllocator> getITunesCopyright() const 1064 { 1065 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 1066 1067 if (_pmovieAtom != NULL) 1068 { 1069 1070 return _pmovieAtom->getITunesCopyright(); 1071 } 1072 else 1073 return temp; 1074 } 1075 1076 OSCL_wHeapString<OsclMemAllocator> getITunesDescription() const 1077 { 1078 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 1079 1080 if (_pmovieAtom != NULL) 1081 { 1082 1083 return _pmovieAtom->getITunesDescription(); 1084 } 1085 else 1086 return temp; 1087 } 1088 1089 uint16 getITunesThisTrackNo() const 1090 { 1091 if (_pmovieAtom != NULL) 1092 { 1093 1094 return _pmovieAtom->getITunesThisTrackNo(); 1095 } 1096 else 1097 return 0; 1098 } 1099 1100 uint16 getITunesTotalTracks() const 1101 { 1102 if (_pmovieAtom != NULL) 1103 { 1104 1105 return _pmovieAtom->getITunesTotalTracks(); 1106 } 1107 else 1108 return 0; 1109 } 1110 1111 bool IsITunesCompilationPart() const 1112 { 1113 if (_pmovieAtom != NULL) 1114 { 1115 1116 return _pmovieAtom->IsITunesCompilationPart(); 1117 } 1118 else 1119 return false; 1120 } 1121 1122 bool IsITunesContentRating() const 1123 { 1124 if (_pmovieAtom != NULL) 1125 { 1126 1127 return _pmovieAtom->IsITunesContentRating(); 1128 } 1129 else 1130 return false; 1131 } 1132 1133 uint16 getITunesBeatsPerMinute() const 1134 { 1135 if (_pmovieAtom != NULL) 1136 { 1137 return _pmovieAtom->getITunesBeatsPerMinute(); 1138 1139 } 1140 else 1141 return 0; 1142 } 1143 1144 1145 PvmfApicStruct* getITunesImageData() const 1146 { 1147 if (_pmovieAtom) 1148 return _pmovieAtom ->getITunesImageData(); 1149 else 1150 return NULL; 1151 } 1152 1153 uint16 getITunesThisDiskNo() const 1154 { 1155 if (_pmovieAtom != NULL) 1156 { 1157 1158 return _pmovieAtom->getITunesThisDiskNo(); 1159 1160 } 1161 else 1162 return 0; 1163 } 1164 1165 uint16 getITunesTotalDisks() const 1166 { 1167 if (_pmovieAtom != NULL) 1168 { 1169 1170 return _pmovieAtom->getITunesTotalDisks(); 1171 } 1172 else 1173 return 0; 1174 } 1175 1176 1177 OSCL_wHeapString<OsclMemAllocator> getITunesNormalizationData() const 1178 { 1179 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 1180 1181 if (_pmovieAtom != NULL) 1182 { 1183 return _pmovieAtom->getITunesNormalizationData(); 1184 1185 } 1186 else 1187 return temp; 1188 1189 } 1190 1191 OSCL_wHeapString<OsclMemAllocator> getITunesCDIdentifierData(uint8 index) 1192 { 1193 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 1194 1195 if (_pmovieAtom != NULL) 1196 { 1197 return _pmovieAtom->getITunesCDIdentifierData(index); 1198 1199 } 1200 else 1201 return temp; 1202 } 1203 1204 1205 uint8 getITunesTotalCDIdentifierData() const 1206 { 1207 1208 if (_pmovieAtom != NULL) 1209 return _pmovieAtom->getITunesTotalCDIdentifierData(); 1210 else 1211 return 0; 1212 } 1213 1214 1215 OSCL_wHeapString<OsclMemAllocator> getITunesCDTrackNumberData() const 1216 { 1217 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 1218 1219 if (_pmovieAtom != NULL) 1220 { 1221 return _pmovieAtom->getITunesCDTrackNumberData(); 1222 1223 } 1224 else 1225 return temp; 1226 1227 } 1228 1229 OSCL_wHeapString<OsclMemAllocator> getITunesCDDB1Data() const 1230 { 1231 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 1232 1233 if (_pmovieAtom != NULL) 1234 { 1235 return _pmovieAtom->getITunesCDDB1Data(); 1236 1237 } 1238 else 1239 return temp; 1240 1241 } 1242 1243 OSCL_wHeapString<OsclMemAllocator> getITunesLyrics() const 1244 { 1245 OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); 1246 1247 if (_pmovieAtom != NULL) 1248 { 1249 1250 return _pmovieAtom->getITunesLyrics(); 1251 } 1252 else 1253 return temp; 1254 } 1255 1256 // For DRM Atom. 1257 bool IsTFRAPresentForTrack(uint32 TrackId, bool oVideoAudioTextTrack); 1258 1259 /* 1260 This function has been modified to check the entry count in TFRA for all tracks are equal. 1261 The code change is under macro DISABLE_REPOS_ON_CLIPS_HAVING_UNEQUAL_TFRA_ENTRY_COUNT 1262 */ 1263 bool IsTFRAPresentForAllTrack(uint32 numTracks, uint32 *trackList); 1264 1265 1266 bool IsMovieFragmentsPresent() const 1267 { 1268 return _isMovieFragmentsPresent; 1269 } 1270 uint32 GetByteOffsetToStartOfAudioFrames(); 1271 void GetID3MetaData(PvmiKvpSharedPtrVector &id3Frames); 1272 bool IsID3Frame(const OSCL_String& frameType); 1273 void GetID3Frame(const OSCL_String& aFrameType, PvmiKvpSharedPtrVector& aFrame); 1274 PVID3Version GetID3Version() const; 1275 void parseID3Header(MP4_FF_FILE * aFile); 1276 1277 uint32 getContentType(); 1278 bool CreateDataStreamSessionForExternalDownload(OSCL_wString& aFilename, 1279 PVMFCPMPluginAccessInterfaceFactory* aCPMAccessFactory, 1280 OsclFileHandle* aHandle, 1281 Oscl_FileServer* aFileServSession); 1282 void DestroyDataStreamForExternalDownload(); 1283 1284 1285 private: 1286 void ReserveMemoryForLangCodeVector(Oscl_Vector<uint16, OsclMemAllocator> &iLangCode, int32 capacity, int32 &leavecode); 1287 void ReserveMemoryForValuesVector(Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> &iValues, int32 capacity, int32 &leavecode); 1288 OSCL_wHeapString<OsclMemAllocator> _emptyString; 1289 UserDataAtom *_puserDataAtom; 1290 FileTypeAtom *_pFileTypeAtom; 1291 MovieAtom *_pmovieAtom; 1292 MovieFragmentAtom *_pMovieFragmentAtom; 1293 PVID3ParCom* _pID3Parser; 1294 1295 Oscl_Vector<TrackAtom*, OsclMemAllocator> *_pTrackAtomVec; 1296 1297 int32 _scalability; 1298 int32 _fileType; 1299 1300 // From DecoderConfigDescriptor 1301 DecoderSpecificInfo *getTrackDecoderSpecificInfo(uint32 id); 1302 1303 bool _oPVContent; 1304 bool _oPVContentDownloadable; 1305 1306 MP4_FF_FILE *_commonFilePtr; 1307 1308 bool _isMovieFragmentsPresent; 1309 uint32 _pointerMovieAtomEnd; 1310 MP4_FF_FILE *_movieFragmentFilePtr; 1311 Oscl_Vector<MovieFragmentAtom*, OsclMemAllocator> *_pMovieFragmentAtomVec; 1312 Oscl_Vector<MovieFragmentRandomAccessAtom*, OsclMemAllocator> *_pMovieFragmentRandomAccessAtomVec; 1313 MfraOffsetAtom *_pMfraOffsetAtom; 1314 uint32 _ptrMoofEnds; 1315 uint32 _parsing_mode; 1316 uint32 _movieFragmentIdx[256]; 1317 uint32 _peekMovieFragmentIdx[256]; 1318 TrackDurationContainer *_pTrackDurationContainer; 1319 Oscl_Vector<TrackExtendsAtom*, OsclMemAllocator> *_pTrackExtendsAtomVec; 1320 Oscl_Vector<uint32, OsclMemAllocator> *_pMoofOffsetVec; 1321 void populateTrackDurationVec(); 1322 MP4_FF_FILE tempfptr; 1323 1324 PVLogger *iLogger, *iStateVarLogger, *iParsedDataLogger; 1325 bool oMfraFound; 1326 bool parseMoofCompletely; 1327 bool moofParsingCompleted; 1328 uint32 moofType; 1329 uint32 moofSize; 1330 uint32 moofCount; 1331 uint32 moofPtrPos; 1332 uint32 currMoofNum; 1333 bool _oVideoTrackPresent; 1334 uint32 _movieFragmentSeqIdx[256]; 1335 uint32 _peekMovieFragmentSeqIdx[256]; 1336 bool isResetPlayBackCalled; 1337 uint32 countOfTrunsParsed; 1338 1339 //Master Title List 1340 Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> titleValues; 1341 Oscl_Vector<uint16, OsclMemAllocator> iTitleLangCode; 1342 Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iTitleCharType; 1343 1344 //Master Author List 1345 Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> authorValues; 1346 Oscl_Vector<uint16, OsclMemAllocator> iAuthorLangCode; 1347 Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iAuthorCharType; 1348 1349 //Master Album List 1350 Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> albumValues; 1351 Oscl_Vector<uint16, OsclMemAllocator> iAlbumLangCode; 1352 Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iAlbumCharType; 1353 1354 //Master Artist List 1355 Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> artistValues; 1356 Oscl_Vector<uint16, OsclMemAllocator> iArtistLangCode; 1357 Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iArtistCharType; 1358 1359 //Master Genre List 1360 Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> genreValues; 1361 Oscl_Vector<uint16, OsclMemAllocator> iGenreLangCode; 1362 Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iGenreCharType; 1363 1364 //Master Year List 1365 Oscl_Vector<uint32, OsclMemAllocator> yearValues; 1366 1367 //Master Copyright List 1368 Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> copyrightValues; 1369 Oscl_Vector<uint16, OsclMemAllocator> iCopyrightLangCode; 1370 Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iCopyrightCharType; 1371 1372 //Master Comment List 1373 Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> commentValues; 1374 Oscl_Vector<uint16, OsclMemAllocator> iCommentLangCode; 1375 Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iCommentCharType; 1376 1377 //Master Description List 1378 Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> descriptionValues; 1379 Oscl_Vector<uint16, OsclMemAllocator> iDescriptionLangCode; 1380 Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iDescriptionCharType; 1381 1382 //Master Rating List 1383 Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> ratingValues; 1384 Oscl_Vector<uint16, OsclMemAllocator> iRatingLangCode; 1385 Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iRatingCharType; 1386 1387 oscl_wchar _id3v1Title[ID3V1_STR_MAX_SIZE]; 1388 oscl_wchar _id3v1Album[ID3V1_STR_MAX_SIZE]; 1389 oscl_wchar _id3v1Artist[ID3V1_STR_MAX_SIZE]; 1390 oscl_wchar _id3v1Comment[ID3V1_STR_MAX_SIZE]; 1391 uint32 _id3v1Year; 1392 uint32 _fileSize; 1393 1394 }; 1395 1396 #endif // MPEG4FILE_H_INCLUDED 1397 1398 1399 1400
