| /* |
| * The contents of this file are subject to the Mozilla Public |
| * License Version 1.1 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at http://www.mozilla.org/MPL/ |
| * |
| * Software distributed under the License is distributed on an "AS |
| * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * rights and limitations under the License. |
| * |
| * The Original Code is MPEG4IP. |
| * |
| * The Initial Developer of the Original Code is Cisco Systems Inc. |
| * Portions created by Cisco Systems Inc. are |
| * Copyright (C) Cisco Systems Inc. 2001 - 2005. All Rights Reserved. |
| * |
| * 3GPP features implementation is based on 3GPP's TS26.234-v5.60, |
| * and was contributed by Ximpo Group Ltd. |
| * |
| * Portions created by Ximpo Group Ltd. are |
| * Copyright (C) Ximpo Group Ltd. 2003, 2004. All Rights Reserved. |
| * |
| * Contributor(s): |
| * Dave Mackie dmackie@cisco.com |
| * Alix Marchandise-Franquet alix@cisco.com |
| * Ximpo Group Ltd. mp4v2@ximpo.com |
| * Bill May wmay@cisco.com |
| */ |
| |
| #include "src/impl.h" |
| |
| namespace mp4v2 { namespace impl { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| MP4File::MP4File( ) : |
| m_file ( NULL ) |
| , m_fileOriginalSize ( 0 ) |
| , m_createFlags ( 0 ) |
| { |
| this->Init(); |
| } |
| |
| /** |
| * Initialize member variables (shared among constructors) |
| */ |
| void MP4File::Init() |
| { |
| m_pRootAtom = NULL; |
| m_odTrackId = MP4_INVALID_TRACK_ID; |
| |
| m_useIsma = false; |
| |
| m_pModificationProperty = NULL; |
| m_pTimeScaleProperty = NULL; |
| m_pDurationProperty = NULL; |
| |
| m_memoryBuffer = NULL; |
| m_memoryBufferSize = 0; |
| m_memoryBufferPosition = 0; |
| |
| m_numReadBits = 0; |
| m_bufReadBits = 0; |
| m_numWriteBits = 0; |
| m_bufWriteBits = 0; |
| m_editName = NULL; |
| m_trakName[0] = '\0'; |
| } |
| |
| MP4File::~MP4File() |
| { |
| delete m_pRootAtom; |
| for( uint32_t i = 0; i < m_pTracks.Size(); i++ ) |
| delete m_pTracks[i]; |
| MP4Free( m_memoryBuffer ); // just in case |
| CHECK_AND_FREE( m_editName ); |
| delete m_file; |
| } |
| |
| const std::string & |
| MP4File::GetFilename() const |
| { |
| // No one should call this unless Read, etc. has |
| // succeeded and m_file exists since this method really |
| // only exists for the public API. This helps us |
| // guarantee that MP4GetFilename always returns a valid |
| // string given a valid MP4FileHandle |
| ASSERT(m_file); |
| return m_file->name; |
| } |
| |
| void MP4File::Read( const char* name, const MP4FileProvider* provider ) |
| { |
| Open( name, File::MODE_READ, provider ); |
| ReadFromFile(); |
| CacheProperties(); |
| } |
| |
| void MP4File::Create( const char* fileName, |
| uint32_t flags, |
| const MP4FileProvider* provider, |
| int add_ftyp, |
| int add_iods, |
| char* majorBrand, |
| uint32_t minorVersion, |
| char** supportedBrands, |
| uint32_t supportedBrandsCount ) |
| { |
| m_createFlags = flags; |
| Open( fileName, File::MODE_CREATE, provider ); |
| |
| // generate a skeletal atom tree |
| m_pRootAtom = MP4Atom::CreateAtom(*this, NULL, NULL); |
| m_pRootAtom->Generate(); |
| |
| if (add_ftyp != 0) { |
| MakeFtypAtom(majorBrand, minorVersion, |
| supportedBrands, supportedBrandsCount); |
| } |
| |
| CacheProperties(); |
| |
| // create mdat, and insert it after ftyp, and before moov |
| (void)InsertChildAtom(m_pRootAtom, "mdat", |
| add_ftyp != 0 ? 1 : 0); |
| |
| // start writing |
| m_pRootAtom->BeginWrite(); |
| if (add_iods != 0) { |
| (void)AddChildAtom("moov", "iods"); |
| } |
| } |
| |
| bool MP4File::Use64Bits (const char *atomName) |
| { |
| uint32_t atomid = ATOMID(atomName); |
| if (atomid == ATOMID("mdat") || atomid == ATOMID("stbl")) { |
| return (m_createFlags & MP4_CREATE_64BIT_DATA) == MP4_CREATE_64BIT_DATA; |
| } |
| if (atomid == ATOMID("mvhd") || |
| atomid == ATOMID("tkhd") || |
| atomid == ATOMID("mdhd")) { |
| return (m_createFlags & MP4_CREATE_64BIT_TIME) == MP4_CREATE_64BIT_TIME; |
| } |
| return false; |
| } |
| |
| void MP4File::Check64BitStatus (const char *atomName) |
| { |
| uint32_t atomid = ATOMID(atomName); |
| |
| if (atomid == ATOMID("mdat") || atomid == ATOMID("stbl")) { |
| m_createFlags |= MP4_CREATE_64BIT_DATA; |
| } else if (atomid == ATOMID("mvhd") || |
| atomid == ATOMID("tkhd") || |
| atomid == ATOMID("mdhd")) { |
| m_createFlags |= MP4_CREATE_64BIT_TIME; |
| } |
| } |
| |
| |
| bool MP4File::Modify( const char* fileName ) |
| { |
| Open( fileName, File::MODE_MODIFY, NULL ); |
| ReadFromFile(); |
| |
| // find the moov atom |
| MP4Atom* pMoovAtom = m_pRootAtom->FindAtom("moov"); |
| uint32_t numAtoms; |
| |
| if (pMoovAtom == NULL) { |
| // there isn't one, odd but we can still proceed |
| log.warningf("%s: \"%s\": no moov atom, can't modify", |
| __FUNCTION__, GetFilename().c_str()); |
| return false; |
| //pMoovAtom = AddChildAtom(m_pRootAtom, "moov"); |
| } else { |
| numAtoms = m_pRootAtom->GetNumberOfChildAtoms(); |
| |
| // work backwards thru the top level atoms |
| int32_t i; |
| bool lastAtomIsMoov = true; |
| MP4Atom* pLastAtom = NULL; |
| |
| for (i = numAtoms - 1; i >= 0; i--) { |
| MP4Atom* pAtom = m_pRootAtom->GetChildAtom(i); |
| const char* type = pAtom->GetType(); |
| |
| // get rid of any trailing free or skips |
| if (!strcmp(type, "free") || !strcmp(type, "skip")) { |
| m_pRootAtom->DeleteChildAtom(pAtom); |
| continue; |
| } |
| |
| if (strcmp(type, "moov")) { |
| if (pLastAtom == NULL) { |
| pLastAtom = pAtom; |
| lastAtomIsMoov = false; |
| } |
| continue; |
| } |
| |
| // now at moov atom |
| |
| // multiple moov atoms?!? |
| if (pAtom != pMoovAtom) { |
| throw new Exception( |
| "Badly formed mp4 file, multiple moov atoms", |
| __FILE__,__LINE__,__FUNCTION__); |
| } |
| |
| if (lastAtomIsMoov) { |
| // position to start of moov atom, |
| // effectively truncating file |
| // prior to adding new mdat |
| SetPosition(pMoovAtom->GetStart()); |
| |
| } else { // last atom isn't moov |
| // need to place a free atom |
| MP4Atom* pFreeAtom = MP4Atom::CreateAtom(*this, NULL, "free"); |
| |
| // in existing position of the moov atom |
| m_pRootAtom->InsertChildAtom(pFreeAtom, i); |
| m_pRootAtom->DeleteChildAtom(pMoovAtom); |
| m_pRootAtom->AddChildAtom(pMoovAtom); |
| |
| // write free atom to disk |
| SetPosition(pMoovAtom->GetStart()); |
| pFreeAtom->SetSize(pMoovAtom->GetSize()); |
| pFreeAtom->Write(); |
| |
| // finally set our file position to the end of the last atom |
| SetPosition(pLastAtom->GetEnd()); |
| } |
| |
| break; |
| } |
| ASSERT(i != -1); |
| } |
| |
| CacheProperties(); // of moov atom |
| |
| numAtoms = m_pRootAtom->GetNumberOfChildAtoms(); |
| |
| // insert another mdat prior to moov atom (the last atom) |
| MP4Atom* pMdatAtom = InsertChildAtom(m_pRootAtom, "mdat", numAtoms - 1); |
| |
| // start writing new mdat |
| pMdatAtom->BeginWrite(Use64Bits("mdat")); |
| return true; |
| } |
| |
| void MP4File::Optimize( const char* srcFileName, const char* dstFileName ) |
| { |
| File* src = NULL; |
| File* dst = NULL; |
| |
| // compute destination filename |
| string dname; |
| if( dstFileName ) { |
| dname = dstFileName; |
| } else { |
| // No destination given, so let's kludge together a temporary file. |
| // We'll try to create it in the same directory as the srcFileName, since |
| // it's more likely that directory is writable. In the absence of that, |
| // we'll create it in "./", which is the default pathnameTemp() provides. |
| string s(srcFileName); |
| size_t pos = s.find_last_of("\\/"); |
| const char *d; |
| if (pos == string::npos) { |
| d = "."; |
| } else { |
| s = s.substr(0, pos); |
| d = s.c_str(); |
| } |
| FileSystem::pathnameTemp( dname, d, "tmp", ".mp4" ); |
| } |
| |
| try { |
| // file source to optimize |
| Open( srcFileName, File::MODE_READ, NULL ); |
| ReadFromFile(); |
| CacheProperties(); // of moov atom |
| |
| src = m_file; |
| m_file = NULL; |
| |
| // optimized file destination |
| Open( dname.c_str(), File::MODE_CREATE, NULL ); |
| dst = m_file; |
| |
| SetIntegerProperty( "moov.mvhd.modificationTime", MP4GetAbsTimestamp() ); |
| |
| // writing meta info in the optimal order |
| ((MP4RootAtom*)m_pRootAtom)->BeginOptimalWrite(); |
| |
| // write data in optimal order |
| RewriteMdat( *src, *dst ); |
| |
| // finish writing |
| ((MP4RootAtom*)m_pRootAtom)->FinishOptimalWrite(); |
| |
| } |
| catch (...) { |
| // cleanup and rethrow. Without this, we'd leak memory and an open file handle(s). |
| if(src == NULL && dst == NULL) |
| delete m_file;// We didn't make it far enough to have m_file go to src or dst. |
| |
| m_file = NULL; |
| delete dst; |
| delete src; |
| throw; |
| } |
| |
| // cleanup |
| delete dst; |
| delete src; |
| m_file = NULL; |
| |
| // move temporary file into place |
| if( !dstFileName ) |
| Rename( dname.c_str(), srcFileName ); |
| } |
| |
| void MP4File::RewriteMdat( File& src, File& dst ) |
| { |
| uint32_t numTracks = m_pTracks.Size(); |
| |
| MP4ChunkId* chunkIds = new MP4ChunkId[numTracks]; |
| MP4ChunkId* maxChunkIds = new MP4ChunkId[numTracks]; |
| MP4Timestamp* nextChunkTimes = new MP4Timestamp[numTracks]; |
| |
| for( uint32_t i = 0; i < numTracks; i++ ) { |
| chunkIds[i] = 1; |
| maxChunkIds[i] = m_pTracks[i]->GetNumberOfChunks(); |
| nextChunkTimes[i] = MP4_INVALID_TIMESTAMP; |
| } |
| |
| for( ;; ) { |
| uint32_t nextTrackIndex = (uint32_t)-1; |
| MP4Timestamp nextTime = MP4_INVALID_TIMESTAMP; |
| |
| for( uint32_t i = 0; i < numTracks; i++ ) { |
| if( chunkIds[i] > maxChunkIds[i] ) |
| continue; |
| |
| if( nextChunkTimes[i] == MP4_INVALID_TIMESTAMP ) { |
| MP4Timestamp chunkTime = m_pTracks[i]->GetChunkTime( chunkIds[i] ); |
| nextChunkTimes[i] = MP4ConvertTime( chunkTime, m_pTracks[i]->GetTimeScale(), GetTimeScale() ); |
| } |
| |
| // time is not earliest so far |
| if( nextChunkTimes[i] > nextTime ) |
| continue; |
| |
| // prefer hint tracks to media tracks if times are equal |
| if( nextChunkTimes[i] == nextTime && strcmp( m_pTracks[i]->GetType(), MP4_HINT_TRACK_TYPE )) |
| continue; |
| |
| // this is our current choice of tracks |
| nextTime = nextChunkTimes[i]; |
| nextTrackIndex = i; |
| } |
| |
| if( nextTrackIndex == (uint32_t)-1 ) |
| break; |
| |
| uint8_t* pChunk; |
| uint32_t chunkSize; |
| |
| // point into original mp4 file for read chunk call |
| m_file = &src; |
| m_pTracks[nextTrackIndex]->ReadChunk( chunkIds[nextTrackIndex], &pChunk, &chunkSize ); |
| |
| // point back at the new mp4 file for write chunk |
| m_file = &dst; |
| m_pTracks[nextTrackIndex]->RewriteChunk( chunkIds[nextTrackIndex], pChunk, chunkSize ); |
| |
| MP4Free( pChunk ); |
| |
| chunkIds[nextTrackIndex]++; |
| nextChunkTimes[nextTrackIndex] = MP4_INVALID_TIMESTAMP; |
| } |
| |
| delete [] chunkIds; |
| delete [] maxChunkIds; |
| delete [] nextChunkTimes; |
| } |
| |
| void MP4File::Open( const char* name, File::Mode mode, const MP4FileProvider* provider ) |
| { |
| ASSERT( !m_file ); |
| |
| m_file = new File( name, mode, provider ? new io::CustomFileProvider( *provider ) : NULL ); |
| if( m_file->open() ) { |
| ostringstream msg; |
| msg << "open(" << name << ") failed"; |
| throw new Exception( msg.str(), __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| switch( mode ) { |
| case File::MODE_READ: |
| case File::MODE_MODIFY: |
| m_fileOriginalSize = m_file->size; |
| break; |
| |
| case File::MODE_CREATE: |
| default: |
| m_fileOriginalSize = 0; |
| break; |
| } |
| } |
| |
| void MP4File::ReadFromFile() |
| { |
| // ensure we start at beginning of file |
| SetPosition(0); |
| |
| // create a new root atom |
| ASSERT(m_pRootAtom == NULL); |
| m_pRootAtom = MP4Atom::CreateAtom(*this, NULL, NULL); |
| |
| uint64_t fileSize = GetSize(); |
| |
| m_pRootAtom->SetStart(0); |
| m_pRootAtom->SetSize(fileSize); |
| m_pRootAtom->SetEnd(fileSize); |
| |
| m_pRootAtom->Read(); |
| |
| // create MP4Track's for any tracks in the file |
| GenerateTracks(); |
| } |
| |
| void MP4File::GenerateTracks() |
| { |
| uint32_t trackIndex = 0; |
| |
| while (true) { |
| char trackName[32]; |
| snprintf(trackName, sizeof(trackName), "moov.trak[%u]", trackIndex); |
| |
| // find next trak atom |
| MP4Atom* pTrakAtom = m_pRootAtom->FindAtom(trackName); |
| |
| // done, no more trak atoms |
| if (pTrakAtom == NULL) { |
| break; |
| } |
| |
| // find track id property |
| MP4Integer32Property* pTrackIdProperty = NULL; |
| (void)pTrakAtom->FindProperty( |
| "trak.tkhd.trackId", |
| (MP4Property**)&pTrackIdProperty); |
| |
| // find track type property |
| MP4StringProperty* pTypeProperty = NULL; |
| (void)pTrakAtom->FindProperty( |
| "trak.mdia.hdlr.handlerType", |
| (MP4Property**)&pTypeProperty); |
| |
| // ensure we have the basics properties |
| if (pTrackIdProperty && pTypeProperty) { |
| |
| m_trakIds.Add(pTrackIdProperty->GetValue()); |
| |
| MP4Track* pTrack = NULL; |
| try { |
| if (!strcmp(pTypeProperty->GetValue(), MP4_HINT_TRACK_TYPE)) { |
| pTrack = new MP4RtpHintTrack(*this, *pTrakAtom); |
| } else { |
| pTrack = new MP4Track(*this, *pTrakAtom); |
| } |
| m_pTracks.Add(pTrack); |
| } |
| catch( Exception* x ) { |
| log.errorf(*x); |
| delete x; |
| } |
| |
| // remember when we encounter the OD track |
| if (pTrack && !strcmp(pTrack->GetType(), MP4_OD_TRACK_TYPE)) { |
| if (m_odTrackId == MP4_INVALID_TRACK_ID) { |
| m_odTrackId = pTrackIdProperty->GetValue(); |
| } else { |
| log.warningf("%s: \"%s\": multiple OD tracks present", |
| __FUNCTION__, GetFilename().c_str() ); |
| } |
| } |
| } else { |
| m_trakIds.Add(0); |
| } |
| |
| trackIndex++; |
| } |
| } |
| |
| void MP4File::CacheProperties() |
| { |
| FindIntegerProperty("moov.mvhd.modificationTime", |
| (MP4Property**)&m_pModificationProperty); |
| |
| FindIntegerProperty("moov.mvhd.timeScale", |
| (MP4Property**)&m_pTimeScaleProperty); |
| |
| FindIntegerProperty("moov.mvhd.duration", |
| (MP4Property**)&m_pDurationProperty); |
| } |
| |
| void MP4File::BeginWrite() |
| { |
| m_pRootAtom->BeginWrite(); |
| } |
| |
| void MP4File::FinishWrite(uint32_t options) |
| { |
| // remove empty moov.udta.meta.ilst |
| { |
| MP4Atom* ilst = FindAtom( "moov.udta.meta.ilst" ); |
| if( ilst ) { |
| if( ilst->GetNumberOfChildAtoms() == 0 ) { |
| ilst->GetParentAtom()->DeleteChildAtom( ilst ); |
| delete ilst; |
| } |
| } |
| } |
| |
| // remove empty moov.udta.meta |
| { |
| MP4Atom* meta = FindAtom( "moov.udta.meta" ); |
| if( meta ) { |
| if( meta->GetNumberOfChildAtoms() == 0 ) { |
| meta->GetParentAtom()->DeleteChildAtom( meta ); |
| delete meta; |
| } |
| else if( meta->GetNumberOfChildAtoms() == 1 ) { |
| if( ATOMID( meta->GetChildAtom( 0 )->GetType() ) == ATOMID( "hdlr" )) { |
| meta->GetParentAtom()->DeleteChildAtom( meta ); |
| delete meta; |
| } |
| } |
| } |
| } |
| |
| // remove empty moov.udta.name |
| { |
| MP4Atom* name = FindAtom( "moov.udta.name" ); |
| if( name ) { |
| unsigned char *val = NULL; |
| uint32_t valSize = 0; |
| GetBytesProperty("moov.udta.name.value", (uint8_t**)&val, &valSize); |
| if( valSize == 0 ) { |
| name->GetParentAtom()->DeleteChildAtom( name ); |
| delete name; |
| } |
| } |
| } |
| |
| // remove empty moov.udta |
| { |
| MP4Atom* udta = FindAtom( "moov.udta" ); |
| if( udta ) { |
| if( udta->GetNumberOfChildAtoms() == 0 ) { |
| udta->GetParentAtom()->DeleteChildAtom( udta ); |
| delete udta; |
| } |
| } |
| } |
| |
| // for all tracks, flush chunking buffers |
| for( uint32_t i = 0; i < m_pTracks.Size(); i++ ) { |
| ASSERT( m_pTracks[i] ); |
| m_pTracks[i]->FinishWrite(options); |
| } |
| |
| // ask root atom to write |
| m_pRootAtom->FinishWrite(); |
| |
| // finished all writes, if position < size then file has shrunk and |
| // we mark remaining bytes as free atom; otherwise trailing garbage remains. |
| if( GetPosition() < GetSize() ) { |
| MP4RootAtom* root = (MP4RootAtom*)FindAtom( "" ); |
| ASSERT( root ); |
| |
| // compute size of free atom; always has 8 bytes of overhead |
| uint64_t size = GetSize() - GetPosition(); |
| if( size < 8 ) |
| size = 0; |
| else |
| size -= 8; |
| |
| MP4FreeAtom* freeAtom = (MP4FreeAtom*)MP4Atom::CreateAtom( *this, NULL, "free" ); |
| ASSERT( freeAtom ); |
| freeAtom->SetSize( size ); |
| root->AddChildAtom( freeAtom ); |
| freeAtom->Write(); |
| } |
| } |
| |
| void MP4File::UpdateDuration(MP4Duration duration) |
| { |
| MP4Duration currentDuration = GetDuration(); |
| if (duration > currentDuration) { |
| SetDuration(duration); |
| } |
| } |
| |
| void MP4File::Dump( bool dumpImplicits ) |
| { |
| log.dump(0, MP4_LOG_VERBOSE1, "\"%s\": Dumping meta-information...", m_file->name.c_str() ); |
| m_pRootAtom->Dump( 0, dumpImplicits); |
| } |
| |
| void MP4File::Close(uint32_t options) |
| { |
| if( IsWriteMode() ) { |
| SetIntegerProperty( "moov.mvhd.modificationTime", MP4GetAbsTimestamp() ); |
| FinishWrite(options); |
| } |
| |
| delete m_file; |
| m_file = NULL; |
| } |
| |
| void MP4File::Rename(const char* oldFileName, const char* newFileName) |
| { |
| if( FileSystem::rename( oldFileName, newFileName )) |
| throw new PlatformException( sys::getLastErrorStr(), sys::getLastError(), __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| |
| void MP4File::ProtectWriteOperation(const char* file, |
| int line, |
| const char* func ) |
| { |
| if( !IsWriteMode() ) |
| throw new Exception( "operation not permitted in read mode", file, line, func ); |
| } |
| |
| MP4Track* MP4File::GetTrack(MP4TrackId trackId) |
| { |
| return m_pTracks[FindTrackIndex(trackId)]; |
| } |
| |
| MP4Atom* MP4File::FindAtom(const char* name) |
| { |
| MP4Atom* pAtom = NULL; |
| if (!name || !strcmp(name, "")) { |
| pAtom = m_pRootAtom; |
| } else { |
| pAtom = m_pRootAtom->FindAtom(name); |
| } |
| return pAtom; |
| } |
| |
| MP4Atom* MP4File::AddChildAtom( |
| const char* parentName, |
| const char* childName) |
| { |
| return AddChildAtom(FindAtom(parentName), childName); |
| } |
| |
| MP4Atom* MP4File::AddChildAtom( |
| MP4Atom* pParentAtom, |
| const char* childName) |
| { |
| return InsertChildAtom(pParentAtom, childName, |
| pParentAtom->GetNumberOfChildAtoms()); |
| } |
| |
| MP4Atom* MP4File::InsertChildAtom( |
| const char* parentName, |
| const char* childName, |
| uint32_t index) |
| { |
| return InsertChildAtom(FindAtom(parentName), childName, index); |
| } |
| |
| MP4Atom* MP4File::InsertChildAtom( |
| MP4Atom* pParentAtom, |
| const char* childName, |
| uint32_t index) |
| { |
| MP4Atom* pChildAtom = MP4Atom::CreateAtom(*this, pParentAtom, childName); |
| |
| ASSERT(pParentAtom); |
| pParentAtom->InsertChildAtom(pChildAtom, index); |
| |
| pChildAtom->Generate(); |
| |
| return pChildAtom; |
| } |
| |
| MP4Atom* MP4File::AddDescendantAtoms( |
| const char* ancestorName, |
| const char* descendantNames) |
| { |
| return AddDescendantAtoms(FindAtom(ancestorName), descendantNames); |
| } |
| |
| MP4Atom* MP4File::AddDescendantAtoms( |
| MP4Atom* pAncestorAtom, const char* descendantNames) |
| { |
| ASSERT(pAncestorAtom); |
| |
| MP4Atom* pParentAtom = pAncestorAtom; |
| MP4Atom* pChildAtom = NULL; |
| |
| while (true) { |
| char* childName = MP4NameFirst(descendantNames); |
| |
| if (childName == NULL) { |
| break; |
| } |
| |
| descendantNames = MP4NameAfterFirst(descendantNames); |
| |
| pChildAtom = pParentAtom->FindChildAtom(childName); |
| |
| if (pChildAtom == NULL) { |
| pChildAtom = AddChildAtom(pParentAtom, childName); |
| } |
| |
| pParentAtom = pChildAtom; |
| |
| MP4Free(childName); |
| } |
| |
| return pChildAtom; |
| } |
| |
| bool MP4File::FindProperty(const char* name, |
| MP4Property** ppProperty, uint32_t* pIndex) |
| { |
| if( pIndex ) |
| *pIndex = 0; // set the default answer for index |
| return m_pRootAtom->FindProperty(name, ppProperty, pIndex); |
| } |
| |
| void MP4File::FindIntegerProperty(const char* name, |
| MP4Property** ppProperty, uint32_t* pIndex) |
| { |
| if (!FindProperty(name, ppProperty, pIndex)) { |
| ostringstream msg; |
| msg << "no such property - " << name; |
| throw new Exception(msg.str(), __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| switch ((*ppProperty)->GetType()) { |
| case Integer8Property: |
| case Integer16Property: |
| case Integer24Property: |
| case Integer32Property: |
| case Integer64Property: |
| break; |
| default: |
| ostringstream msg; |
| msg << "type mismatch - property " << name << " type " << (*ppProperty)->GetType(); |
| throw new Exception(msg.str(), __FILE__, __LINE__, __FUNCTION__); |
| } |
| } |
| |
| uint64_t MP4File::GetIntegerProperty(const char* name) |
| { |
| MP4Property* pProperty; |
| uint32_t index; |
| |
| FindIntegerProperty(name, &pProperty, &index); |
| |
| return ((MP4IntegerProperty*)pProperty)->GetValue(index); |
| } |
| |
| void MP4File::SetIntegerProperty(const char* name, uint64_t value) |
| { |
| ProtectWriteOperation(__FILE__, __LINE__, __FUNCTION__); |
| |
| MP4Property* pProperty = NULL; |
| uint32_t index = 0; |
| |
| FindIntegerProperty(name, &pProperty, &index); |
| |
| ((MP4IntegerProperty*)pProperty)->SetValue(value, index); |
| } |
| |
| void MP4File::FindFloatProperty(const char* name, |
| MP4Property** ppProperty, uint32_t* pIndex) |
| { |
| if (!FindProperty(name, ppProperty, pIndex)) { |
| ostringstream msg; |
| msg << "no such property - " << name; |
| throw new Exception(msg.str(), __FILE__, __LINE__, __FUNCTION__); |
| } |
| if ((*ppProperty)->GetType() != Float32Property) { |
| ostringstream msg; |
| msg << "type mismatch - property " << name << " type " << (*ppProperty)->GetType(); |
| throw new Exception(msg.str(), __FILE__, __LINE__, __FUNCTION__); |
| } |
| } |
| |
| float MP4File::GetFloatProperty(const char* name) |
| { |
| MP4Property* pProperty; |
| uint32_t index; |
| |
| FindFloatProperty(name, &pProperty, &index); |
| |
| return ((MP4Float32Property*)pProperty)->GetValue(index); |
| } |
| |
| void MP4File::SetFloatProperty(const char* name, float value) |
| { |
| ProtectWriteOperation(__FILE__, __LINE__, __FUNCTION__); |
| |
| MP4Property* pProperty; |
| uint32_t index; |
| |
| FindFloatProperty(name, &pProperty, &index); |
| |
| ((MP4Float32Property*)pProperty)->SetValue(value, index); |
| } |
| |
| void MP4File::FindStringProperty(const char* name, |
| MP4Property** ppProperty, uint32_t* pIndex) |
| { |
| if (!FindProperty(name, ppProperty, pIndex)) { |
| ostringstream msg; |
| msg << "no such property - " << name; |
| throw new Exception(msg.str(), __FILE__, __LINE__, __FUNCTION__); |
| } |
| if ((*ppProperty)->GetType() != StringProperty) { |
| ostringstream msg; |
| msg << "type mismatch - property " << name << " type " << (*ppProperty)->GetType(); |
| throw new Exception(msg.str(), __FILE__, __LINE__, __FUNCTION__); |
| } |
| } |
| |
| const char* MP4File::GetStringProperty(const char* name) |
| { |
| MP4Property* pProperty; |
| uint32_t index; |
| |
| FindStringProperty(name, &pProperty, &index); |
| |
| return ((MP4StringProperty*)pProperty)->GetValue(index); |
| } |
| |
| void MP4File::SetStringProperty(const char* name, const char* value) |
| { |
| ProtectWriteOperation(__FILE__, __LINE__, __FUNCTION__); |
| |
| MP4Property* pProperty; |
| uint32_t index; |
| |
| FindStringProperty(name, &pProperty, &index); |
| |
| ((MP4StringProperty*)pProperty)->SetValue(value, index); |
| } |
| |
| void MP4File::FindBytesProperty(const char* name, |
| MP4Property** ppProperty, uint32_t* pIndex) |
| { |
| if (!FindProperty(name, ppProperty, pIndex)) { |
| ostringstream msg; |
| msg << "no such property " << name; |
| throw new Exception(msg.str(), __FILE__, __LINE__, __FUNCTION__); |
| } |
| if ((*ppProperty)->GetType() != BytesProperty) { |
| ostringstream msg; |
| msg << "type mismatch - property " << name << " - type " << (*ppProperty)->GetType(); |
| throw new Exception(msg.str(), __FILE__, __LINE__, __FUNCTION__); |
| } |
| } |
| |
| void MP4File::GetBytesProperty(const char* name, |
| uint8_t** ppValue, uint32_t* pValueSize) |
| { |
| MP4Property* pProperty; |
| uint32_t index; |
| |
| FindBytesProperty(name, &pProperty, &index); |
| |
| ((MP4BytesProperty*)pProperty)->GetValue(ppValue, pValueSize, index); |
| } |
| |
| void MP4File::SetBytesProperty(const char* name, |
| const uint8_t* pValue, uint32_t valueSize) |
| { |
| ProtectWriteOperation(__FILE__, __LINE__, __FUNCTION__); |
| |
| MP4Property* pProperty; |
| uint32_t index; |
| |
| FindBytesProperty(name, &pProperty, &index); |
| |
| ((MP4BytesProperty*)pProperty)->SetValue(pValue, valueSize, index); |
| } |
| |
| |
| // track functions |
| |
| MP4TrackId MP4File::AddTrack(const char* type, uint32_t timeScale) |
| { |
| ProtectWriteOperation(__FILE__, __LINE__, __FUNCTION__); |
| |
| // create and add new trak atom |
| MP4Atom* pTrakAtom = AddChildAtom("moov", "trak"); |
| ASSERT(pTrakAtom); |
| |
| // allocate a new track id |
| MP4TrackId trackId = AllocTrackId(); |
| |
| m_trakIds.Add(trackId); |
| |
| // set track id |
| MP4Integer32Property* pInteger32Property = NULL; |
| (void)pTrakAtom->FindProperty("trak.tkhd.trackId", |
| (MP4Property**)&pInteger32Property); |
| ASSERT(pInteger32Property); |
| pInteger32Property->SetValue(trackId); |
| |
| // set track type |
| const char* normType = MP4NormalizeTrackType(type); |
| |
| // sanity check for user defined types |
| if (strlen(normType) > 4) { |
| log.warningf("%s: \"%s\": type truncated to four characters", |
| __FUNCTION__, GetFilename().c_str()); |
| // StringProperty::SetValue() will do the actual truncation |
| } |
| |
| MP4StringProperty* pStringProperty = NULL; |
| (void)pTrakAtom->FindProperty("trak.mdia.hdlr.handlerType", |
| (MP4Property**)&pStringProperty); |
| ASSERT(pStringProperty); |
| pStringProperty->SetValue(normType); |
| |
| // set track time scale |
| pInteger32Property = NULL; |
| (void)pTrakAtom->FindProperty("trak.mdia.mdhd.timeScale", |
| (MP4Property**)&pInteger32Property); |
| ASSERT(pInteger32Property); |
| pInteger32Property->SetValue(timeScale ? timeScale : 1000); |
| |
| // now have enough to create MP4Track object |
| MP4Track* pTrack = NULL; |
| if (!strcmp(normType, MP4_HINT_TRACK_TYPE)) { |
| pTrack = new MP4RtpHintTrack(*this, *pTrakAtom); |
| } else { |
| pTrack = new MP4Track(*this, *pTrakAtom); |
| } |
| m_pTracks.Add(pTrack); |
| |
| // mark non-hint tracks as enabled |
| if (strcmp(normType, MP4_HINT_TRACK_TYPE)) { |
| SetTrackIntegerProperty(trackId, "tkhd.flags", 1); |
| } |
| |
| // mark track as contained in this file |
| // LATER will provide option for external data references |
| AddDataReference(trackId, NULL); |
| |
| return trackId; |
| } |
| |
| void MP4File::AddTrackToIod(MP4TrackId trackId) |
| { |
| MP4DescriptorProperty* pDescriptorProperty = NULL; |
| (void)m_pRootAtom->FindProperty("moov.iods.esIds", |
| (MP4Property**)&pDescriptorProperty); |
| ASSERT(pDescriptorProperty); |
| |
| MP4Descriptor* pDescriptor = |
| pDescriptorProperty->AddDescriptor(MP4ESIDIncDescrTag); |
| ASSERT(pDescriptor); |
| |
| MP4Integer32Property* pIdProperty = NULL; |
| (void)pDescriptor->FindProperty("id", |
| (MP4Property**)&pIdProperty); |
| ASSERT(pIdProperty); |
| |
| pIdProperty->SetValue(trackId); |
| } |
| |
| void MP4File::RemoveTrackFromIod(MP4TrackId trackId, bool shallHaveIods) |
| { |
| MP4DescriptorProperty* pDescriptorProperty = NULL; |
| if (!m_pRootAtom->FindProperty("moov.iods.esIds",(MP4Property**)&pDescriptorProperty) |
| || pDescriptorProperty == NULL) |
| return; |
| |
| for (uint32_t i = 0; i < pDescriptorProperty->GetCount(); i++) { |
| /* static */ |
| char name[32]; |
| snprintf(name, sizeof(name), "esIds[%u].id", i); |
| |
| MP4Integer32Property* pIdProperty = NULL; |
| (void)pDescriptorProperty->FindProperty(name, |
| (MP4Property**)&pIdProperty); |
| // wmay ASSERT(pIdProperty); |
| |
| if (pIdProperty != NULL && |
| pIdProperty->GetValue() == trackId) { |
| pDescriptorProperty->DeleteDescriptor(i); |
| break; |
| } |
| } |
| } |
| |
| void MP4File::AddTrackToOd(MP4TrackId trackId) |
| { |
| if (!m_odTrackId) { |
| return; |
| } |
| |
| AddTrackReference(MakeTrackName(m_odTrackId, "tref.mpod"), trackId); |
| } |
| |
| void MP4File::RemoveTrackFromOd(MP4TrackId trackId) |
| { |
| if (!m_odTrackId) { |
| return; |
| } |
| |
| RemoveTrackReference(MakeTrackName(m_odTrackId, "tref.mpod"), trackId); |
| } |
| |
| /* |
| * Try to obtain the properties of this reference track, if not found then return |
| * NULL in *ppCountProperty and *ppTrackIdProperty. |
| */ |
| void MP4File::GetTrackReferenceProperties(const char* trefName, |
| MP4Property** ppCountProperty, MP4Property** ppTrackIdProperty) |
| { |
| char propName[1024]; |
| |
| snprintf(propName, sizeof(propName), "%s.%s", trefName, "entryCount"); |
| (void)m_pRootAtom->FindProperty(propName, ppCountProperty); |
| |
| snprintf(propName, sizeof(propName), "%s.%s", trefName, "entries.trackId"); |
| (void)m_pRootAtom->FindProperty(propName, ppTrackIdProperty); |
| } |
| |
| void MP4File::AddTrackReference(const char* trefName, MP4TrackId refTrackId) |
| { |
| MP4Integer32Property* pCountProperty = NULL; |
| MP4Integer32Property* pTrackIdProperty = NULL; |
| |
| GetTrackReferenceProperties(trefName, |
| (MP4Property**)&pCountProperty, |
| (MP4Property**)&pTrackIdProperty); |
| |
| if (pCountProperty && pTrackIdProperty) { |
| pTrackIdProperty->AddValue(refTrackId); |
| pCountProperty->IncrementValue(); |
| } |
| } |
| |
| uint32_t MP4File::FindTrackReference(const char* trefName, |
| MP4TrackId refTrackId) |
| { |
| MP4Integer32Property* pCountProperty = NULL; |
| MP4Integer32Property* pTrackIdProperty = NULL; |
| |
| GetTrackReferenceProperties(trefName, |
| (MP4Property**)&pCountProperty, |
| (MP4Property**)&pTrackIdProperty); |
| |
| if (pCountProperty && pTrackIdProperty) { |
| for (uint32_t i = 0; i < pCountProperty->GetValue(); i++) { |
| if (refTrackId == pTrackIdProperty->GetValue(i)) { |
| return i + 1; // N.B. 1 not 0 based index |
| } |
| } |
| } |
| return 0; |
| } |
| |
| void MP4File::RemoveTrackReference(const char* trefName, MP4TrackId refTrackId) |
| { |
| MP4Integer32Property* pCountProperty = NULL; |
| MP4Integer32Property* pTrackIdProperty = NULL; |
| |
| GetTrackReferenceProperties(trefName, |
| (MP4Property**)&pCountProperty, |
| (MP4Property**)&pTrackIdProperty); |
| |
| if (pCountProperty && pTrackIdProperty) { |
| for (uint32_t i = 0; i < pCountProperty->GetValue(); i++) { |
| if (refTrackId == pTrackIdProperty->GetValue(i)) { |
| pTrackIdProperty->DeleteValue(i); |
| pCountProperty->IncrementValue(-1); |
| } |
| } |
| } |
| } |
| |
| void MP4File::AddDataReference(MP4TrackId trackId, const char* url) |
| { |
| MP4Atom* pDrefAtom = |
| FindAtom(MakeTrackName(trackId, "mdia.minf.dinf.dref")); |
| ASSERT(pDrefAtom); |
| |
| MP4Integer32Property* pCountProperty = NULL; |
| (void)pDrefAtom->FindProperty("dref.entryCount", |
| (MP4Property**)&pCountProperty); |
| ASSERT(pCountProperty); |
| pCountProperty->IncrementValue(); |
| |
| MP4Atom* pUrlAtom = AddChildAtom(pDrefAtom, "url "); |
| |
| if (url && url[0] != '\0') { |
| pUrlAtom->SetFlags(pUrlAtom->GetFlags() & 0xFFFFFE); |
| |
| MP4StringProperty* pUrlProperty = NULL; |
| (void)pUrlAtom->FindProperty("url .location", |
| (MP4Property**)&pUrlProperty); |
| ASSERT(pUrlProperty); |
| pUrlProperty->SetValue(url); |
| } else { |
| pUrlAtom->SetFlags(pUrlAtom->GetFlags() | 1); |
| } |
| } |
| |
| MP4TrackId MP4File::AddSystemsTrack(const char* type, uint32_t timeScale) |
| { |
| const char* normType = MP4NormalizeTrackType(type); |
| |
| // TBD if user type, fix name to four chars, and warn |
| |
| MP4TrackId trackId = AddTrack(type, timeScale); |
| |
| (void)InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "nmhd", 0); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), "mp4s"); |
| |
| AddDescendantAtoms(MakeTrackName(trackId, NULL), "udta.name"); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the mp4s atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4s.esds.ESID", |
| 0 |
| ); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4s.esds.decConfigDescr.objectTypeId", |
| MP4SystemsV1ObjectType); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4s.esds.decConfigDescr.streamType", |
| ConvertTrackTypeToStreamType(normType)); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddODTrack() |
| { |
| // until a demonstrated need emerges |
| // we limit ourselves to one object description track |
| if (m_odTrackId != MP4_INVALID_TRACK_ID) { |
| throw new Exception("object description track already exists",__FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| m_odTrackId = AddSystemsTrack(MP4_OD_TRACK_TYPE); |
| |
| AddTrackToIod(m_odTrackId); |
| |
| (void)AddDescendantAtoms(MakeTrackName(m_odTrackId, NULL), "tref.mpod"); |
| |
| return m_odTrackId; |
| } |
| |
| MP4TrackId MP4File::AddSceneTrack() |
| { |
| MP4TrackId trackId = AddSystemsTrack(MP4_SCENE_TRACK_TYPE); |
| |
| AddTrackToIod(trackId); |
| AddTrackToOd(trackId); |
| |
| return trackId; |
| } |
| |
| bool MP4File::ShallHaveIods() |
| { |
| // NULL terminated list of brands which require the IODS atom |
| const char* brandsWithIods[] = { |
| "mp42", |
| "isom", |
| NULL |
| }; |
| |
| MP4FtypAtom* ftyp = (MP4FtypAtom*)m_pRootAtom->FindAtom( "ftyp" ); |
| if( !ftyp ) |
| return false; |
| |
| // check major brand |
| const char* brand = ftyp->majorBrand.GetValue(); |
| for( uint32_t i = 0; brandsWithIods[i] != NULL; i++ ) { |
| if( !strcasecmp( brandsWithIods[i], brand )) |
| return true; |
| } |
| |
| // check compatible brands |
| uint32_t max = ftyp->compatibleBrands.GetCount(); |
| for( uint32_t i = 0; i < max; i++ ) { |
| brand = ftyp->compatibleBrands.GetValue( i ); |
| for( uint32_t j = 0; brandsWithIods[j] != NULL ; j++) { |
| if( !strcasecmp( brandsWithIods[j], brand )) |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| void MP4File::SetAmrVendor( |
| MP4TrackId trackId, |
| uint32_t vendor) |
| { |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.*.damr.vendor", |
| vendor); |
| } |
| |
| void MP4File::SetAmrDecoderVersion( |
| MP4TrackId trackId, |
| uint8_t decoderVersion) |
| { |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.*.damr.decoderVersion", |
| decoderVersion); |
| } |
| |
| void MP4File::SetAmrModeSet( |
| MP4TrackId trackId, |
| uint16_t modeSet) |
| { |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.*.damr.modeSet", |
| modeSet); |
| } |
| uint16_t MP4File::GetAmrModeSet(MP4TrackId trackId) |
| { |
| return GetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.*.damr.modeSet"); |
| } |
| |
| MP4TrackId MP4File::AddAmrAudioTrack( |
| uint32_t timeScale, |
| uint16_t modeSet, |
| uint8_t modeChangePeriod, |
| uint8_t framesPerSample, |
| bool isAmrWB) |
| { |
| |
| uint32_t fixedSampleDuration = (timeScale * 20)/1000; // 20mSec/Sample |
| |
| MP4TrackId trackId = AddTrack(MP4_AUDIO_TRACK_TYPE, timeScale); |
| |
| AddTrackToOd(trackId); |
| |
| SetTrackFloatProperty(trackId, "tkhd.volume", 1.0); |
| |
| (void)InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "smhd", 0); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), isAmrWB ? "sawb" : "samr"); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the mp4a atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.*.timeScale", |
| timeScale); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.*.damr.modeSet", |
| modeSet); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.*.damr.modeChangePeriod", |
| modeChangePeriod); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.*.damr.framesPerSample", |
| framesPerSample); |
| |
| |
| m_pTracks[FindTrackIndex(trackId)]-> |
| SetFixedSampleDuration(fixedSampleDuration); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddULawAudioTrack( uint32_t timeScale) |
| { |
| uint32_t fixedSampleDuration = (timeScale * 20)/1000; // 20mSec/Sample |
| |
| MP4TrackId trackId = AddTrack(MP4_AUDIO_TRACK_TYPE, timeScale); |
| |
| AddTrackToOd(trackId); |
| |
| SetTrackFloatProperty(trackId, "tkhd.volume", 1.0); |
| |
| (void)InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "smhd", 0); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), "ulaw"); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the mp4a atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.ulaw.timeScale", |
| timeScale<<16); |
| |
| m_pTracks[FindTrackIndex(trackId)]->SetFixedSampleDuration(fixedSampleDuration); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddALawAudioTrack( uint32_t timeScale) |
| { |
| uint32_t fixedSampleDuration = (timeScale * 20)/1000; // 20mSec/Sample |
| |
| MP4TrackId trackId = AddTrack(MP4_AUDIO_TRACK_TYPE, timeScale); |
| |
| AddTrackToOd(trackId); |
| |
| SetTrackFloatProperty(trackId, "tkhd.volume", 1.0); |
| |
| (void)InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "smhd", 0); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), "alaw"); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the mp4a atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.alaw.timeScale", |
| timeScale<<16); |
| |
| m_pTracks[FindTrackIndex(trackId)]->SetFixedSampleDuration(fixedSampleDuration); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddAudioTrack( |
| uint32_t timeScale, |
| MP4Duration sampleDuration, |
| uint8_t audioType) |
| { |
| MP4TrackId trackId = AddTrack(MP4_AUDIO_TRACK_TYPE, timeScale); |
| |
| AddTrackToOd(trackId); |
| |
| SetTrackFloatProperty(trackId, "tkhd.volume", 1.0); |
| |
| (void)InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "smhd", 0); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), "mp4a"); |
| |
| AddDescendantAtoms(MakeTrackName(trackId, NULL), "udta.name"); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the mp4a atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4a.timeScale", timeScale << 16); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4a.esds.ESID", |
| 0 |
| ); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4a.esds.decConfigDescr.objectTypeId", |
| audioType); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4a.esds.decConfigDescr.streamType", |
| MP4AudioStreamType); |
| |
| m_pTracks[FindTrackIndex(trackId)]-> |
| SetFixedSampleDuration(sampleDuration); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddAC3AudioTrack( |
| uint32_t samplingRate, |
| uint8_t fscod, |
| uint8_t bsid, |
| uint8_t bsmod, |
| uint8_t acmod, |
| uint8_t lfeon, |
| uint8_t bit_rate_code) |
| { |
| MP4TrackId trackId = AddTrack(MP4_AUDIO_TRACK_TYPE, samplingRate); |
| |
| AddTrackToOd(trackId); |
| |
| SetTrackFloatProperty(trackId, "tkhd.volume", 1.0); |
| |
| InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "smhd", 0); |
| |
| AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), "ac-3"); |
| |
| // Set Ac3 settings |
| MP4Integer16Property* pSampleRateProperty = NULL; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.ac-3.samplingRate"), |
| (MP4Property**)&pSampleRateProperty); |
| if (pSampleRateProperty) { |
| pSampleRateProperty->SetValue(samplingRate); |
| } else { |
| throw new Exception("no ac-3.samplingRate property", __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| MP4BitfieldProperty* pBitfieldProperty = NULL; |
| |
| FindProperty(MakeTrackName(trackId, "mdia.minf.stbl.stsd.ac-3.dac3.fscod"), |
| (MP4Property**)&pBitfieldProperty); |
| if (pBitfieldProperty) { |
| pBitfieldProperty->SetValue(fscod); |
| pBitfieldProperty = NULL; |
| } else { |
| throw new Exception("no dac3.fscod property", __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| FindProperty(MakeTrackName(trackId, "mdia.minf.stbl.stsd.ac-3.dac3.bsid"), |
| (MP4Property**)&pBitfieldProperty); |
| if (pBitfieldProperty) { |
| pBitfieldProperty->SetValue(bsid); |
| pBitfieldProperty = NULL; |
| } else { |
| throw new Exception("no dac3.bsid property", __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| FindProperty(MakeTrackName(trackId, "mdia.minf.stbl.stsd.ac-3.dac3.bsmod"), |
| (MP4Property**)&pBitfieldProperty); |
| if (pBitfieldProperty) { |
| pBitfieldProperty->SetValue(bsmod); |
| pBitfieldProperty = NULL; |
| } else { |
| throw new Exception("no dac3.bsmod property", __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| FindProperty(MakeTrackName(trackId, "mdia.minf.stbl.stsd.ac-3.dac3.acmod"), |
| (MP4Property**)&pBitfieldProperty); |
| if (pBitfieldProperty) { |
| pBitfieldProperty->SetValue(acmod); |
| pBitfieldProperty = NULL; |
| } else { |
| throw new Exception("no dac3.acmod property", __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| FindProperty(MakeTrackName(trackId, "mdia.minf.stbl.stsd.ac-3.dac3.lfeon"), |
| (MP4Property**)&pBitfieldProperty); |
| if (pBitfieldProperty) { |
| pBitfieldProperty->SetValue(lfeon); |
| pBitfieldProperty = NULL; |
| } else { |
| throw new Exception("no dac3.lfeon property", __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| FindProperty(MakeTrackName(trackId, "mdia.minf.stbl.stsd.ac-3.dac3.bit_rate_code"), |
| (MP4Property**)&pBitfieldProperty); |
| if (pBitfieldProperty) { |
| pBitfieldProperty->SetValue(bit_rate_code); |
| pBitfieldProperty = NULL; |
| } else { |
| throw new Exception("no dac3.bit_rate_code property", __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| AddDescendantAtoms(MakeTrackName(trackId, NULL), "udta.name"); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the mp4a atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| m_pTracks[FindTrackIndex(trackId)]-> |
| SetFixedSampleDuration(1536); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddEncAudioTrack(uint32_t timeScale, |
| MP4Duration sampleDuration, |
| uint8_t audioType, |
| uint32_t scheme_type, |
| uint16_t scheme_version, |
| uint8_t key_ind_len, |
| uint8_t iv_len, |
| bool selective_enc, |
| const char *kms_uri, |
| bool use_ismacryp |
| ) |
| { |
| uint32_t original_fmt = 0; |
| |
| MP4TrackId trackId = AddTrack(MP4_AUDIO_TRACK_TYPE, timeScale); |
| |
| AddTrackToOd(trackId); |
| |
| SetTrackFloatProperty(trackId, "tkhd.volume", 1.0); |
| |
| (void)InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "smhd", 0); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), "enca"); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the enca atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty(MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| |
| /* set all the ismacryp-specific values */ |
| // original format is mp4a |
| if (use_ismacryp) { |
| original_fmt = ATOMID("mp4a"); |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.enca.sinf.frma.data-format", |
| original_fmt); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.enca.sinf"), |
| "schm"); |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.enca.sinf"), |
| "schi"); |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.enca.sinf.schi"), |
| "iKMS"); |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.enca.sinf.schi"), |
| "iSFM"); |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.enca.sinf.schm.scheme_type", |
| scheme_type); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.enca.sinf.schm.scheme_version", |
| scheme_version); |
| |
| SetTrackStringProperty(trackId, |
| "mdia.minf.stbl.stsd.enca.sinf.schi.iKMS.kms_URI", |
| kms_uri); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.enca.sinf.schi.iSFM.selective-encryption", |
| selective_enc); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.enca.sinf.schi.iSFM.key-indicator-length", |
| key_ind_len); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.enca.sinf.schi.iSFM.IV-length", |
| iv_len); |
| /* end ismacryp */ |
| } |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.enca.timeScale", timeScale); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.enca.esds.ESID", |
| 0 |
| ); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.enca.esds.decConfigDescr.objectTypeId", |
| audioType); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.enca.esds.decConfigDescr.streamType", |
| MP4AudioStreamType); |
| |
| m_pTracks[FindTrackIndex(trackId)]-> |
| SetFixedSampleDuration(sampleDuration); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddCntlTrackDefault (uint32_t timeScale, |
| MP4Duration sampleDuration, |
| const char *type) |
| { |
| MP4TrackId trackId = AddTrack(MP4_CNTL_TRACK_TYPE, timeScale); |
| |
| (void)InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "nmhd", 0); |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), type); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the mp4v atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsz.sampleSize", sampleDuration); |
| |
| m_pTracks[FindTrackIndex(trackId)]-> |
| SetFixedSampleDuration(sampleDuration); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddHrefTrack (uint32_t timeScale, |
| MP4Duration sampleDuration, |
| const char *base_url) |
| { |
| MP4TrackId trackId = AddCntlTrackDefault(timeScale, sampleDuration, "href"); |
| |
| if (base_url != NULL) { |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.href"), |
| "burl"); |
| SetTrackStringProperty(trackId, "mdia.minf.stbl.stsd.href.burl.base_url", |
| base_url); |
| } |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddVideoTrackDefault( |
| uint32_t timeScale, |
| MP4Duration sampleDuration, |
| uint16_t width, |
| uint16_t height, |
| const char *videoType) |
| { |
| MP4TrackId trackId = AddTrack(MP4_VIDEO_TRACK_TYPE, timeScale); |
| |
| AddTrackToOd(trackId); |
| |
| SetTrackFloatProperty(trackId, "tkhd.width", width); |
| SetTrackFloatProperty(trackId, "tkhd.height", height); |
| |
| (void)InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "vmhd", 0); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), videoType); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the mp4v atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsz.sampleSize", sampleDuration); |
| |
| m_pTracks[FindTrackIndex(trackId)]-> |
| SetFixedSampleDuration(sampleDuration); |
| |
| return trackId; |
| } |
| MP4TrackId MP4File::AddMP4VideoTrack( |
| uint32_t timeScale, |
| MP4Duration sampleDuration, |
| uint16_t width, |
| uint16_t height, |
| uint8_t videoType) |
| { |
| MP4TrackId trackId = AddVideoTrackDefault(timeScale, |
| sampleDuration, |
| width, |
| height, |
| "mp4v"); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4v.width", width); |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4v.height", height); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4v.esds.ESID", |
| 0 |
| ); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4v.esds.decConfigDescr.objectTypeId", |
| videoType); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4v.esds.decConfigDescr.streamType", |
| MP4VisualStreamType); |
| |
| return trackId; |
| } |
| |
| // ismacrypted |
| MP4TrackId MP4File::AddEncVideoTrack(uint32_t timeScale, |
| MP4Duration sampleDuration, |
| uint16_t width, |
| uint16_t height, |
| uint8_t videoType, |
| mp4v2_ismacrypParams *icPp, |
| const char *oFormat |
| ) |
| { |
| uint32_t original_fmt = 0; |
| |
| MP4TrackId trackId = AddVideoTrackDefault(timeScale, |
| sampleDuration, |
| width, |
| height, |
| "encv"); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.encv.width", width); |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.encv.height", height); |
| |
| /* set all the ismacryp-specific values */ |
| |
| original_fmt = ATOMID(oFormat); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.encv.sinf.frma.data-format", |
| original_fmt); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.encv.sinf"), |
| "schm"); |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.encv.sinf"), |
| "schi"); |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.encv.sinf.schi"), |
| "iKMS"); |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.encv.sinf.schi"), |
| "iSFM"); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.encv.sinf.schm.scheme_type", |
| icPp->scheme_type); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.encv.sinf.schm.scheme_version", |
| icPp->scheme_version); |
| |
| SetTrackStringProperty(trackId, |
| "mdia.minf.stbl.stsd.encv.sinf.schi.iKMS.kms_URI", |
| icPp->kms_uri); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.encv.sinf.schi.iSFM.selective-encryption", |
| icPp->selective_enc); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.encv.sinf.schi.iSFM.key-indicator-length", |
| icPp->key_ind_len); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.encv.sinf.schi.iSFM.IV-length", |
| icPp->iv_len); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.encv.esds.ESID", |
| 0 |
| ); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.encv.esds.decConfigDescr.objectTypeId", |
| videoType); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.encv.esds.decConfigDescr.streamType", |
| MP4VisualStreamType); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddH264VideoTrack( |
| uint32_t timeScale, |
| MP4Duration sampleDuration, |
| uint16_t width, |
| uint16_t height, |
| uint8_t AVCProfileIndication, |
| uint8_t profile_compat, |
| uint8_t AVCLevelIndication, |
| uint8_t sampleLenFieldSizeMinusOne) |
| { |
| MP4TrackId trackId = AddVideoTrackDefault(timeScale, |
| sampleDuration, |
| width, |
| height, |
| "avc1"); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.avc1.width", width); |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.avc1.height", height); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.avc1.avcC.AVCProfileIndication", |
| AVCProfileIndication); |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.avc1.avcC.profile_compatibility", |
| profile_compat); |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.avc1.avcC.AVCLevelIndication", |
| AVCLevelIndication); |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.avc1.avcC.lengthSizeMinusOne", |
| sampleLenFieldSizeMinusOne); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddEncH264VideoTrack( |
| uint32_t timeScale, |
| MP4Duration sampleDuration, |
| uint16_t width, |
| uint16_t height, |
| MP4Atom *srcAtom, |
| mp4v2_ismacrypParams *icPp) |
| |
| { |
| |
| uint32_t original_fmt = 0; |
| MP4Atom *avcCAtom; |
| |
| MP4TrackId trackId = AddVideoTrackDefault(timeScale, |
| sampleDuration, |
| width, |
| height, |
| "encv"); |
| |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.encv.width", width); |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.encv.height", height); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.encv"), "avcC"); |
| |
| // create default values |
| avcCAtom = FindAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.encv.avcC")); |
| |
| // export source atom |
| ((MP4AvcCAtom *) srcAtom)->Clone((MP4AvcCAtom *)avcCAtom); |
| |
| /* set all the ismacryp-specific values */ |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.encv.sinf"), "schm"); |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.encv.sinf"), "schi"); |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.encv.sinf.schi"), "iKMS"); |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.encv.sinf.schi"), "iSFM"); |
| |
| // per ismacrypt E&A V1.1 section 9.1.2.1 'avc1' is renamed '264b' |
| // avc1 must not appear as a sample entry name or original format name |
| original_fmt = ATOMID("264b"); |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.encv.sinf.frma.data-format", |
| original_fmt); |
| |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.encv.sinf.schm.scheme_type", |
| icPp->scheme_type); |
| |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.encv.sinf.schm.scheme_version", |
| icPp->scheme_version); |
| |
| SetTrackStringProperty(trackId, "mdia.minf.stbl.stsd.encv.sinf.schi.iKMS.kms_URI", |
| icPp->kms_uri); |
| |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.encv.sinf.schi.iSFM.selective-encryption", |
| icPp->selective_enc); |
| |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.encv.sinf.schi.iSFM.key-indicator-length", |
| icPp->key_ind_len); |
| |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.encv.sinf.schi.iSFM.IV-length", |
| icPp->iv_len); |
| |
| |
| return trackId; |
| } |
| |
| |
| void MP4File::AddH264SequenceParameterSet (MP4TrackId trackId, |
| const uint8_t *pSequence, |
| uint16_t sequenceLen) |
| { |
| const char *format; |
| MP4Atom *avcCAtom; |
| |
| // get 4cc media format - can be avc1 or encv for ismacrypted track |
| format = GetTrackMediaDataName(trackId); |
| |
| if (!strcasecmp(format, "avc1")) |
| avcCAtom = FindAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.avc1.avcC")); |
| else if (!strcasecmp(format, "encv")) |
| avcCAtom = FindAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.encv.avcC")); |
| else |
| // huh? unknown track format |
| return; |
| |
| |
| MP4BitfieldProperty *pCount; |
| MP4Integer16Property *pLength; |
| MP4BytesProperty *pUnit; |
| if ((avcCAtom->FindProperty("avcC.numOfSequenceParameterSets", |
| (MP4Property **)&pCount) == false) || |
| (avcCAtom->FindProperty("avcC.sequenceEntries.sequenceParameterSetLength", |
| (MP4Property **)&pLength) == false) || |
| (avcCAtom->FindProperty("avcC.sequenceEntries.sequenceParameterSetNALUnit", |
| (MP4Property **)&pUnit) == false)) { |
| log.errorf("%s: \"%s\": Could not find avcC properties", |
| __FUNCTION__, GetFilename().c_str() ); |
| return; |
| } |
| uint32_t count = pCount->GetValue(); |
| |
| if (count > 0) { |
| // see if we already exist |
| for (uint32_t index = 0; index < count; index++) { |
| if (pLength->GetValue(index) == sequenceLen) { |
| uint8_t *seq; |
| uint32_t seqlen; |
| pUnit->GetValue(&seq, &seqlen, index); |
| if (memcmp(seq, pSequence, sequenceLen) == 0) { |
| free(seq); |
| return; |
| } |
| free(seq); |
| } |
| } |
| } |
| pLength->AddValue(sequenceLen); |
| pUnit->AddValue(pSequence, sequenceLen); |
| pCount->IncrementValue(); |
| |
| return; |
| } |
| void MP4File::AddH264PictureParameterSet (MP4TrackId trackId, |
| const uint8_t *pPict, |
| uint16_t pictLen) |
| { |
| MP4Atom *avcCAtom = |
| FindAtom(MakeTrackName(trackId, |
| "mdia.minf.stbl.stsd.avc1.avcC")); |
| MP4Integer8Property *pCount; |
| MP4Integer16Property *pLength; |
| MP4BytesProperty *pUnit; |
| if ((avcCAtom->FindProperty("avcC.numOfPictureParameterSets", |
| (MP4Property **)&pCount) == false) || |
| (avcCAtom->FindProperty("avcC.pictureEntries.pictureParameterSetLength", |
| (MP4Property **)&pLength) == false) || |
| (avcCAtom->FindProperty("avcC.pictureEntries.pictureParameterSetNALUnit", |
| (MP4Property **)&pUnit) == false)) { |
| log.errorf("%s: \"%s\": Could not find avcC picture table properties", |
| __FUNCTION__, GetFilename().c_str()); |
| return; |
| } |
| |
| ASSERT(pCount); |
| uint32_t count = pCount->GetValue(); |
| |
| if (count > 0) { |
| // see if we already exist |
| for (uint32_t index = 0; index < count; index++) { |
| if (pLength->GetValue(index) == pictLen) { |
| uint8_t *seq; |
| uint32_t seqlen; |
| pUnit->GetValue(&seq, &seqlen, index); |
| if (memcmp(seq, pPict, pictLen) == 0) { |
| log.verbose1f("\"%s\": picture matches %d", |
| GetFilename().c_str(), index); |
| free(seq); |
| return; |
| } |
| free(seq); |
| } |
| } |
| } |
| pLength->AddValue(pictLen); |
| pUnit->AddValue(pPict, pictLen); |
| pCount->IncrementValue(); |
| log.verbose1f("\"%s\": new picture added %d", GetFilename().c_str(), |
| pCount->GetValue()); |
| |
| return; |
| } |
| void MP4File::SetH263Vendor( |
| MP4TrackId trackId, |
| uint32_t vendor) |
| { |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.s263.d263.vendor", |
| vendor); |
| } |
| |
| void MP4File::SetH263DecoderVersion( |
| MP4TrackId trackId, |
| uint8_t decoderVersion) |
| { |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.s263.d263.decoderVersion", |
| decoderVersion); |
| } |
| |
| void MP4File::SetH263Bitrates( |
| MP4TrackId trackId, |
| uint32_t avgBitrate, |
| uint32_t maxBitrate) |
| { |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.s263.d263.bitr.avgBitrate", |
| avgBitrate); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.s263.d263.bitr.maxBitrate", |
| maxBitrate); |
| |
| } |
| |
| MP4TrackId MP4File::AddH263VideoTrack( |
| uint32_t timeScale, |
| MP4Duration sampleDuration, |
| uint16_t width, |
| uint16_t height, |
| uint8_t h263Level, |
| uint8_t h263Profile, |
| uint32_t avgBitrate, |
| uint32_t maxBitrate) |
| |
| { |
| MP4TrackId trackId = AddVideoTrackDefault(timeScale, |
| sampleDuration, |
| width, |
| height, |
| "s263"); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.s263.width", width); |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.s263.height", height); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.s263.d263.h263Level", h263Level); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.s263.d263.h263Profile", h263Profile); |
| |
| // Add the bitr atom |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.s263.d263"), |
| "bitr"); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.s263.d263.bitr.avgBitrate", avgBitrate); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.s263.d263.bitr.maxBitrate", maxBitrate); |
| |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsz.sampleSize", sampleDuration); |
| |
| return trackId; |
| |
| } |
| |
| MP4TrackId MP4File::AddHintTrack(MP4TrackId refTrackId) |
| { |
| // validate reference track id |
| (void)FindTrackIndex(refTrackId); |
| |
| MP4TrackId trackId = |
| AddTrack(MP4_HINT_TRACK_TYPE, GetTrackTimeScale(refTrackId)); |
| |
| (void)InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "hmhd", 0); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), "rtp "); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the rtp atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.rtp .tims.timeScale", |
| GetTrackTimeScale(trackId)); |
| |
| (void)AddDescendantAtoms(MakeTrackName(trackId, NULL), "tref.hint"); |
| |
| AddTrackReference(MakeTrackName(trackId, "tref.hint"), refTrackId); |
| |
| (void)AddDescendantAtoms(MakeTrackName(trackId, NULL), "udta.hnti.sdp "); |
| |
| (void)AddDescendantAtoms(MakeTrackName(trackId, NULL), "udta.hinf"); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddTextTrack(MP4TrackId refTrackId) |
| { |
| // validate reference track id |
| (void)FindTrackIndex(refTrackId); |
| |
| MP4TrackId trackId = |
| AddTrack(MP4_TEXT_TRACK_TYPE, GetTrackTimeScale(refTrackId)); |
| |
| (void)InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "gmhd", 0); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), "text"); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the text atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddSubtitleTrack(uint32_t timescale, |
| uint16_t width, |
| uint16_t height) |
| { |
| MP4TrackId trackId = |
| AddTrack(MP4_SUBTITLE_TRACK_TYPE, timescale); |
| |
| InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "nmhd", 0); |
| |
| AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), "tx3g"); |
| |
| SetTrackFloatProperty(trackId, "tkhd.width", width); |
| SetTrackFloatProperty(trackId, "tkhd.height", height); |
| |
| // Hardcoded crap... add the ftab atom and add one font entry |
| MP4Atom* pFtabAtom = AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.tx3g"), "ftab"); |
| |
| ((MP4Integer16Property*)pFtabAtom->GetProperty(0))->IncrementValue(); |
| |
| MP4Integer16Property* pfontID = (MP4Integer16Property*)((MP4TableProperty*)pFtabAtom->GetProperty(1))->GetProperty(0); |
| pfontID->AddValue(1); |
| |
| MP4StringProperty* pName = (MP4StringProperty*)((MP4TableProperty*)pFtabAtom->GetProperty(1))->GetProperty(1); |
| pName->AddValue("Arial"); |
| |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.tx3g.fontID", 1); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the tx3g atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddSubpicTrack(uint32_t timescale, |
| uint16_t width, |
| uint16_t height) |
| { |
| MP4TrackId trackId = |
| AddTrack(MP4_SUBPIC_TRACK_TYPE, timescale); |
| |
| InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "nmhd", 0); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), "mp4s"); |
| |
| SetTrackFloatProperty(trackId, "tkhd.width", width); |
| SetTrackFloatProperty(trackId, "tkhd.height", height); |
| SetTrackIntegerProperty(trackId, "tkhd.layer", 0); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the mp4s atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4s.esds.ESID", |
| 0 |
| ); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4s.esds.decConfigDescr.objectTypeId", |
| MP4SubpicObjectType); |
| |
| SetTrackIntegerProperty(trackId, |
| "mdia.minf.stbl.stsd.mp4s.esds.decConfigDescr.streamType", |
| MP4NeroSubpicStreamType); |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddChapterTextTrack(MP4TrackId refTrackId, uint32_t timescale) |
| { |
| // validate reference track id |
| (void)FindTrackIndex(refTrackId); |
| |
| if (0 == timescale) |
| { |
| timescale = GetTrackTimeScale(refTrackId); |
| } |
| |
| MP4TrackId trackId = AddTrack(MP4_TEXT_TRACK_TYPE, timescale); |
| |
| (void)InsertChildAtom(MakeTrackName(trackId, "mdia.minf"), "gmhd", 0); |
| |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd"), "text"); |
| |
| // stsd is a unique beast in that it has a count of the number |
| // of child atoms that needs to be incremented after we add the text atom |
| MP4Integer32Property* pStsdCountProperty; |
| FindIntegerProperty( |
| MakeTrackName(trackId, "mdia.minf.stbl.stsd.entryCount"), |
| (MP4Property**)&pStsdCountProperty); |
| pStsdCountProperty->IncrementValue(); |
| |
| // add a "text" atom to the generic media header |
| // this is different to the stsd "text" atom added above |
| // truth be told, it's not clear what this second "text" atom does, |
| // but all iTunes Store movies (with chapter markers) have it, |
| // as do all movies with chapter tracks made by hand in QuickTime Pro |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.gmhd"), "text"); |
| |
| // disable the chapter text track |
| // it won't display anyway, as it has zero display size, |
| // but nonetheless it's good to disable it |
| // the track still operates as a chapter track when disabled |
| MP4Atom *pTkhdAtom = FindAtom(MakeTrackName(trackId, "tkhd")); |
| if (pTkhdAtom) { |
| pTkhdAtom->SetFlags(0xE); |
| } |
| |
| // add a "chapter" track reference to our reference track, |
| // pointing to this new chapter track |
| (void)AddDescendantAtoms(MakeTrackName(refTrackId, NULL), "tref.chap"); |
| AddTrackReference(MakeTrackName(refTrackId, "tref.chap"), trackId); |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddPixelAspectRatio(MP4TrackId trackId, uint32_t hSpacing, uint32_t vSpacing) |
| { |
| // validate reference track id |
| (void)FindTrackIndex(trackId); |
| const char *format = GetTrackMediaDataName (trackId); |
| |
| if (!strcasecmp(format, "avc1")) |
| { |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.avc1"), "pasp"); |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.avc1.pasp.hSpacing", hSpacing); |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.avc1.pasp.vSpacing", vSpacing); |
| } |
| else if (!strcasecmp(format, "mp4v")) |
| { |
| (void)AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.mp4v"), "pasp"); |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.mp4v.pasp.hSpacing", hSpacing); |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.mp4v.pasp.vSpacing", vSpacing); |
| } |
| |
| return trackId; |
| } |
| |
| MP4TrackId MP4File::AddColr(MP4TrackId trackId, |
| uint16_t primariesIndex, |
| uint16_t transferFunctionIndex, |
| uint16_t matrixIndex) |
| { |
| // validate reference track id |
| (void)FindTrackIndex(trackId); |
| const char *format = GetTrackMediaDataName (trackId); |
| |
| if (!strcasecmp(format, "avc1")) |
| { |
| AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.avc1"), "colr"); |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.avc1.colr.primariesIndex", primariesIndex); |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.avc1.colr.transferFunctionIndex", transferFunctionIndex); |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.avc1.colr.matrixIndex", matrixIndex); |
| } |
| else if (!strcasecmp(format, "mp4v")) |
| { |
| AddChildAtom(MakeTrackName(trackId, "mdia.minf.stbl.stsd.mp4v"), "colr"); |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.mp4v.colr.primariesIndex", primariesIndex); |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.mp4v.colr.transferFunctionIndex", transferFunctionIndex); |
| SetTrackIntegerProperty(trackId, "mdia.minf.stbl.stsd.mp4v.colr.matrixIndex", matrixIndex); |
| } |
| |
| return trackId; |
| } |
| |
| |
| void MP4File::AddChapter(MP4TrackId chapterTrackId, MP4Duration chapterDuration, const char *chapterTitle) |
| { |
| if (MP4_INVALID_TRACK_ID == chapterTrackId) |
| { |
| throw new Exception("No chapter track given",__FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| uint32_t sampleLength = 0; |
| uint8_t sample[1040] = {0}; |
| int textLen = 0; |
| char *text = (char *)&(sample[2]); |
| |
| if(chapterTitle != NULL) |
| { |
| textLen = min((uint32_t)strlen(chapterTitle), (uint32_t)MP4V2_CHAPTER_TITLE_MAX); |
| if (0 < textLen) |
| { |
| strncpy(text, chapterTitle, textLen); |
| } |
| } |
| else |
| { |
| MP4Track * pChapterTrack = GetTrack(chapterTrackId); |
| snprintf( text, 1023, "Chapter %03d", pChapterTrack->GetNumberOfSamples() + 1 ); |
| textLen = (uint32_t)strlen(text); |
| } |
| |
| sampleLength = textLen + 2 + 12; // Account for text length code and other marker |
| |
| // 2-byte length marker |
| sample[0] = (textLen >> 8) & 0xff; |
| sample[1] = textLen & 0xff; |
| |
| int x = 2 + textLen; |
| |
| // Modifier Length Marker |
| sample[x] = 0x00; |
| sample[x+1] = 0x00; |
| sample[x+2] = 0x00; |
| sample[x+3] = 0x0C; |
| |
| // Modifier Type Code |
| sample[x+4] = 'e'; |
| sample[x+5] = 'n'; |
| sample[x+6] = 'c'; |
| sample[x+7] = 'd'; |
| |
| // Modifier Value |
| sample[x+8] = 0x00; |
| sample[x+9] = 0x00; |
| sample[x+10] = (256 >> 8) & 0xff; |
| sample[x+11] = 256 & 0xff; |
| |
| WriteSample(chapterTrackId, sample, sampleLength, chapterDuration); |
| } |
| |
| void MP4File::AddNeroChapter(MP4Timestamp chapterStart, const char * chapterTitle) |
| { |
| MP4Atom * pChpl = FindAtom("moov.udta.chpl"); |
| if (!pChpl) |
| { |
| pChpl = AddDescendantAtoms("", "moov.udta.chpl"); |
| } |
| |
| MP4Integer32Property * pCount = (MP4Integer32Property*)pChpl->GetProperty(3); |
| pCount->IncrementValue(); |
| |
| char buffer[256]; |
| |
| if (0 == chapterTitle) |
| { |
| snprintf( buffer, 255, "Chapter %03d", pCount->GetValue() ); |
| } |
| else |
| { |
| int len = min((uint32_t)strlen(chapterTitle), (uint32_t)255); |
| strncpy( buffer, chapterTitle, len ); |
| buffer[len] = 0; |
| } |
| |
| MP4TableProperty * pTable; |
| if (pChpl->FindProperty("chpl.chapters", (MP4Property **)&pTable)) |
| { |
| MP4Integer64Property * pStartTime = (MP4Integer64Property *) pTable->GetProperty(0); |
| MP4StringProperty * pName = (MP4StringProperty *) pTable->GetProperty(1); |
| if (pStartTime && pTable) |
| { |
| pStartTime->AddValue(chapterStart); |
| pName->AddValue(buffer); |
| } |
| } |
| } |
| |
| MP4TrackId MP4File::FindChapterReferenceTrack(MP4TrackId chapterTrackId, char * trackName, int trackNameSize) |
| { |
| for (uint32_t i = 0; i < m_pTracks.Size(); i++) |
| { |
| if( MP4_IS_VIDEO_TRACK_TYPE( m_pTracks[i]->GetType() ) || |
| MP4_IS_AUDIO_TRACK_TYPE( m_pTracks[i]->GetType() ) ) |
| { |
| MP4TrackId refTrackId = m_pTracks[i]->GetId(); |
| char *name = MakeTrackName(refTrackId, "tref.chap"); |
| if( FindTrackReference( name, chapterTrackId ) ) |
| { |
| if( 0 != trackName ) |
| { |
| int nameLen = min((uint32_t)strlen(name), (uint32_t)trackNameSize); |
| strncpy(trackName, name, nameLen); |
| trackName[nameLen] = 0; |
| } |
| |
| return m_pTracks[i]->GetId(); |
| } |
| } |
| } |
| |
| return MP4_INVALID_TRACK_ID; |
| } |
| |
| MP4TrackId MP4File::FindChapterTrack(char * trackName, int trackNameSize) |
| { |
| for (uint32_t i = 0; i < m_pTracks.Size(); i++) |
| { |
| if( !strcasecmp(MP4_TEXT_TRACK_TYPE, m_pTracks[i]->GetType()) ) |
| { |
| MP4TrackId refTrackId = FindChapterReferenceTrack(m_pTracks[i]->GetId(), trackName, trackNameSize); |
| if (MP4_INVALID_TRACK_ID != refTrackId) |
| { |
| return m_pTracks[i]->GetId(); |
| } |
| } |
| } |
| |
| return MP4_INVALID_TRACK_ID; |
| } |
| |
| MP4ChapterType MP4File::DeleteChapters(MP4ChapterType chapterType, MP4TrackId chapterTrackId) |
| { |
| MP4ChapterType deletedType = MP4ChapterTypeNone; |
| |
| if (MP4ChapterTypeAny == chapterType || MP4ChapterTypeNero == chapterType) |
| { |
| MP4Atom * pChpl = FindAtom("moov.udta.chpl"); |
| if (pChpl) |
| { |
| MP4Atom * pParent = pChpl->GetParentAtom(); |
| pParent->DeleteChildAtom(pChpl); |
| deletedType = MP4ChapterTypeNero; |
| } |
| } |
| |
| if (MP4ChapterTypeAny == chapterType || MP4ChapterTypeQt == chapterType) |
| { |
| char trackName[128] = {0}; |
| |
| // no text track given, find a suitable |
| if (MP4_INVALID_TRACK_ID == chapterTrackId) |
| { |
| chapterTrackId = FindChapterTrack(trackName, 127); |
| } |
| |
| if (MP4_INVALID_TRACK_ID != chapterTrackId) |
| { |
| FindChapterReferenceTrack(chapterTrackId, trackName, 127); |
| } |
| |
| if (MP4_INVALID_TRACK_ID != chapterTrackId && 0 != trackName[0]) |
| { |
| // remove the reference |
| MP4Atom * pChap = FindAtom( trackName ); |
| if( pChap ) |
| { |
| MP4Atom * pTref = pChap->GetParentAtom(); |
| if( pTref ) |
| { |
| pTref->DeleteChildAtom( pChap ); |
| |
| MP4Atom* pParent = pTref->GetParentAtom(); |
| pParent->DeleteChildAtom( pTref ); |
| } |
| } |
| |
| // remove the chapter track |
| DeleteTrack(chapterTrackId); |
| deletedType = MP4ChapterTypeNone == deletedType ? MP4ChapterTypeQt : MP4ChapterTypeAny; |
| } |
| } |
| return deletedType; |
| } |
| |
| MP4ChapterType MP4File::GetChapters(MP4Chapter_t ** chapterList, uint32_t * chapterCount, MP4ChapterType fromChapterType) |
| { |
| *chapterList = 0; |
| *chapterCount = 0; |
| |
| if (MP4ChapterTypeAny == fromChapterType || MP4ChapterTypeQt == fromChapterType) |
| { |
| uint8_t * sample = 0; |
| uint32_t sampleSize = 0; |
| MP4Timestamp startTime = 0; |
| MP4Duration duration = 0; |
| |
| // get the chapter track |
| MP4TrackId chapterTrackId = FindChapterTrack(); |
| if (MP4_INVALID_TRACK_ID == chapterTrackId) |
| { |
| if (MP4ChapterTypeQt == fromChapterType) |
| { |
| return MP4ChapterTypeNone; |
| } |
| } |
| else |
| { |
| // get infos about the chapters |
| MP4Track * pChapterTrack = GetTrack(chapterTrackId); |
| uint32_t counter = pChapterTrack->GetNumberOfSamples(); |
| |
| if (0 < counter) |
| { |
| uint32_t timescale = pChapterTrack->GetTimeScale(); |
| MP4Chapter_t * chapters = (MP4Chapter_t*)MP4Malloc(sizeof(MP4Chapter_t) * counter); |
| |
| // process all chapter sample |
| for (uint32_t i = 0; i < counter; ++i) |
| { |
| // get the sample corresponding to the starttime |
| MP4SampleId sampleId = pChapterTrack->GetSampleIdFromTime(startTime + duration, true); |
| pChapterTrack->ReadSample(sampleId, &sample, &sampleSize); |
| |
| // get the starttime and duration |
| pChapterTrack->GetSampleTimes(sampleId, &startTime, &duration); |
| |
| // we know that sample+2 contains the title (sample[0] and sample[1] is the length) |
| const char * title = (const char *)&(sample[2]); |
| int titleLen = min((uint32_t)((sample[0] << 8) | sample[1]), (uint32_t)MP4V2_CHAPTER_TITLE_MAX); |
| strncpy(chapters[i].title, title, titleLen); |
| chapters[i].title[titleLen] = 0; |
| |
| // write the duration (in milliseconds) |
| chapters[i].duration = MP4ConvertTime(duration, timescale, MP4_MILLISECONDS_TIME_SCALE); |
| |
| // we're done with this sample |
| MP4Free(sample); |
| sample = 0; |
| } |
| |
| *chapterList = chapters; |
| *chapterCount = counter; |
| |
| // we got chapters so we are done |
| return MP4ChapterTypeQt; |
| } |
| } |
| } |
| |
| if (MP4ChapterTypeAny == fromChapterType || MP4ChapterTypeNero == fromChapterType) |
| { |
| MP4Atom * pChpl = FindAtom("moov.udta.chpl"); |
| if (!pChpl) |
| { |
| return MP4ChapterTypeNone; |
| } |
| |
| MP4Integer32Property * pCounter = 0; |
| if (!pChpl->FindProperty("chpl.chaptercount", (MP4Property **)&pCounter)) |
| { |
| log.warningf("%s: \"%s\": Nero chapter count does not exist", |
| __FUNCTION__, GetFilename().c_str()); |
| return MP4ChapterTypeNone; |
| } |
| |
| uint32_t counter = pCounter->GetValue(); |
| if (0 == counter) |
| { |
| log.warningf("%s: \"%s\": No Nero chapters available", |
| __FUNCTION__, GetFilename().c_str()); |
| return MP4ChapterTypeNone; |
| } |
| |
| MP4TableProperty * pTable = 0; |
| MP4Integer64Property * pStartTime = 0; |
| MP4StringProperty * pName = 0; |
| MP4Duration chapterDurationSum = 0; |
| const char * name = 0; |
| |
| if (!pChpl->FindProperty("chpl.chapters", (MP4Property **)&pTable)) |
| { |
| log.warningf("%s: \"%s\": Nero chapter list does not exist", |
| __FUNCTION__, GetFilename().c_str()); |
| return MP4ChapterTypeNone; |
| } |
| |
| if (0 == (pStartTime = (MP4Integer64Property *) pTable->GetProperty(0))) |
| { |
| log.warningf("%s: \"%s\": List of Chapter starttimes does not exist", |
| __FUNCTION__, GetFilename().c_str()); |
| return MP4ChapterTypeNone; |
| } |
| if (0 == (pName = (MP4StringProperty *) pTable->GetProperty(1))) |
| { |
| log.warningf("%s: \"%s\": List of Chapter titles does not exist", |
| __FUNCTION__, GetFilename().c_str()); |
| return MP4ChapterTypeNone; |
| } |
| |
| MP4Chapter_t * chapters = (MP4Chapter_t*)MP4Malloc(sizeof(MP4Chapter_t) * counter); |
| |
| // get the name of the first chapter |
| name = pName->GetValue(); |
| |
| // process remaining chapters |
| uint32_t i, j; |
| for (i = 0, j = 1; i < counter; ++i, ++j) |
| { |
| // insert the chapter title |
| uint32_t len = min((uint32_t)strlen(name), (uint32_t)MP4V2_CHAPTER_TITLE_MAX); |
| strncpy(chapters[i].title, name, len); |
| chapters[i].title[len] = 0; |
| |
| // calculate the duration |
| MP4Duration duration = 0; |
| if (j < counter) |
| { |
| duration = MP4ConvertTime(pStartTime->GetValue(j), |
| (MP4_NANOSECONDS_TIME_SCALE / 100), |
| MP4_MILLISECONDS_TIME_SCALE) - chapterDurationSum; |
| |
| // now get the name of the chapter (to be written next) |
| name = pName->GetValue(j); |
| } |
| else |
| { |
| // last chapter |
| duration = MP4ConvertTime(GetDuration(), GetTimeScale(), MP4_MILLISECONDS_TIME_SCALE) - chapterDurationSum; |
| } |
| |
| // sum up the chapter duration |
| chapterDurationSum += duration; |
| |
| // insert the chapter duration |
| chapters[i].duration = duration; |
| } |
| |
| *chapterList = chapters; |
| *chapterCount = counter; |
| |
| return MP4ChapterTypeNero; |
| } |
| |
| return MP4ChapterTypeNone; |
| } |
| |
| MP4ChapterType MP4File::SetChapters(MP4Chapter_t * chapterList, uint32_t chapterCount, MP4ChapterType toChapterType) |
| { |
| MP4ChapterType setType = MP4ChapterTypeNone; |
| |
| // first remove any existing chapters |
| DeleteChapters(toChapterType, MP4_INVALID_TRACK_ID); |
| |
| if( MP4ChapterTypeAny == toChapterType || MP4ChapterTypeNero == toChapterType ) |
| { |
| MP4Duration duration = 0; |
| for( uint32_t i = 0; i < chapterCount; ++i ) |
| { |
| AddNeroChapter(duration, chapterList[i].title); |
| duration += 10 * MP4_MILLISECONDS_TIME_SCALE * chapterList[i].duration; |
| } |
| |
| setType = MP4ChapterTypeNero; |
| } |
| |
| if (MP4ChapterTypeAny == toChapterType || MP4ChapterTypeQt == toChapterType) |
| { |
| // find the first video or audio track |
| MP4TrackId refTrack = MP4_INVALID_TRACK_ID; |
| for( uint32_t i = 0; i < m_pTracks.Size(); i++ ) |
| { |
| if( MP4_IS_VIDEO_TRACK_TYPE( m_pTracks[i]->GetType() ) || |
| MP4_IS_AUDIO_TRACK_TYPE( m_pTracks[i]->GetType() ) ) |
| { |
| refTrack = m_pTracks[i]->GetId(); |
| break; |
| } |
| } |
| |
| if( refTrack == MP4_INVALID_TRACK_ID ) |
| { |
| return setType; |
| } |
| |
| // create the chapter track |
| MP4TrackId chapterTrack = AddChapterTextTrack(refTrack, MP4_MILLISECONDS_TIME_SCALE); |
| |
| for( uint32_t i = 0 ; i < chapterCount; ++i ) |
| { |
| // create and write the chapter track sample |
| AddChapter( chapterTrack, chapterList[i].duration, chapterList[i].title ); |
| } |
| |
| setType = MP4ChapterTypeNone == setType ? MP4ChapterTypeQt : MP4ChapterTypeAny; |
| } |
| |
| return setType; |
| } |
| |
| MP4ChapterType MP4File::ConvertChapters(MP4ChapterType toChapterType) |
| { |
| MP4ChapterType sourceType = MP4ChapterTypeNone; |
| const char* errMsg = 0; |
| |
| if( MP4ChapterTypeQt == toChapterType ) |
| { |
| sourceType = MP4ChapterTypeNero; |
| errMsg = "Could not find Nero chapter markers"; |
| } |
| else if( MP4ChapterTypeNero == toChapterType ) |
| { |
| sourceType = MP4ChapterTypeQt; |
| errMsg = "Could not find QuickTime chapter markers"; |
| } |
| else |
| { |
| return MP4ChapterTypeNone; |
| } |
| |
| MP4Chapter_t * chapters = 0; |
| uint32_t chapterCount = 0; |
| |
| GetChapters(&chapters, &chapterCount, sourceType); |
| if (0 == chapterCount) |
| { |
| log.warningf("%s: \"%s\": %s", __FUNCTION__, GetFilename().c_str(), |
| errMsg); |
| return MP4ChapterTypeNone; |
| } |
| |
| SetChapters(chapters, chapterCount, toChapterType); |
| |
| MP4Free(chapters); |
| |
| return toChapterType; |
| } |
| |
| void MP4File::ChangeMovieTimeScale(uint32_t timescale) |
| { |
| uint32_t origTimeScale = GetTimeScale(); |
| if (timescale == origTimeScale) { |
| // already done |
| return; |
| } |
| |
| MP4Duration movieDuration = GetDuration(); |
| |
| // set movie header timescale and duration |
| SetTimeScale(timescale); |
| SetDuration(MP4ConvertTime(movieDuration, origTimeScale, timescale)); |
| |
| // set track header duration (calculated with movie header timescale) |
| uint32_t trackCount = GetNumberOfTracks(); |
| for (uint32_t i = 0; i < trackCount; ++i) |
| { |
| MP4Track * track = GetTrack(FindTrackId(i)); |
| MP4Atom & trackAtom = track->GetTrakAtom(); |
| MP4IntegerProperty * duration; |
| |
| if (trackAtom.FindProperty("trak.tkhd.duration", (MP4Property**)&duration)) |
| { |
| duration->SetValue(MP4ConvertTime(duration->GetValue(), origTimeScale, timescale)); |
| } |
| } |
| } |
| |
| void MP4File::DeleteTrack(MP4TrackId trackId) |
| { |
| ProtectWriteOperation(__FILE__, __LINE__, __FUNCTION__); |
| |
| uint32_t trakIndex = FindTrakAtomIndex(trackId); |
| uint16_t trackIndex = FindTrackIndex(trackId); |
| MP4Track* pTrack = m_pTracks[trackIndex]; |
| |
| MP4Atom& trakAtom = pTrack->GetTrakAtom(); |
| |
| MP4Atom* pMoovAtom = FindAtom("moov"); |
| ASSERT(pMoovAtom); |
| |
| RemoveTrackFromIod(trackId, ShallHaveIods()); |
| RemoveTrackFromOd(trackId); |
| |
| if (trackId == m_odTrackId) { |
| m_odTrackId = 0; |
| } |
| |
| pMoovAtom->DeleteChildAtom(&trakAtom); |
| |
| m_trakIds.Delete(trakIndex); |
| |
| m_pTracks.Delete(trackIndex); |
| |
| delete pTrack; |
| delete &trakAtom; |
| } |
| |
| uint32_t MP4File::GetNumberOfTracks(const char* type, uint8_t subType) |
| { |
| if (type == NULL) { |
| return m_pTracks.Size(); |
| } |
| |
| uint32_t typeSeen = 0; |
| const char* normType = MP4NormalizeTrackType(type); |
| |
| for (uint32_t i = 0; i < m_pTracks.Size(); i++) { |
| if (!strcmp(normType, m_pTracks[i]->GetType())) { |
| if (subType) { |
| if (strcmp(normType, MP4_AUDIO_TRACK_TYPE) == 0) { |
| if (subType != GetTrackEsdsObjectTypeId(m_pTracks[i]->GetId())) { |
| continue; |
| } |
| } else if (strcmp(normType, MP4_VIDEO_TRACK_TYPE)) { |
| if (subType != GetTrackEsdsObjectTypeId(m_pTracks[i]->GetId())) { |
| continue; |
| } |
| } |
| // else unknown subtype, ignore it |
| } |
| typeSeen++; |
| } |
| } |
| return typeSeen; |
| } |
| |
| MP4TrackId MP4File::AllocTrackId() |
| { |
| MP4TrackId trackId = |
| GetIntegerProperty("moov.mvhd.nextTrackId"); |
| |
| if (trackId <= 0xFFFF) { |
| // check that nextTrackid is correct |
| try { |
| (void)FindTrackIndex(trackId); |
| // ERROR, this trackId is in use |
| } |
| catch (Exception* x) { |
| // OK, this trackId is not in use, proceed |
| delete x; |
| SetIntegerProperty("moov.mvhd.nextTrackId", trackId + 1); |
| return trackId; |
| } |
| } |
| |
| // we need to search for a track id |
| for (trackId = 1; trackId <= 0xFFFF; trackId++) { |
| try { |
| (void)FindTrackIndex(trackId); |
| // KEEP LOOKING, this trackId is in use |
| } |
| catch (Exception* x) { |
| // OK, this trackId is not in use, proceed |
| delete x; |
| return trackId; |
| } |
| } |
| |
| // extreme case where mp4 file has 2^16 tracks in it |
| throw new Exception("too many existing tracks", __FILE__, __LINE__, __FUNCTION__); |
| return MP4_INVALID_TRACK_ID; // to keep MSVC happy |
| } |
| |
| MP4TrackId MP4File::FindTrackId(uint16_t trackIndex, |
| const char* type, uint8_t subType) |
| { |
| if (type == NULL) { |
| return m_pTracks[trackIndex]->GetId(); |
| } |
| |
| uint32_t typeSeen = 0; |
| const char* normType = MP4NormalizeTrackType(type); |
| |
| for (uint32_t i = 0; i < m_pTracks.Size(); i++) { |
| if (!strcmp(normType, m_pTracks[i]->GetType())) { |
| if (subType) { |
| if (strcmp(normType, MP4_AUDIO_TRACK_TYPE) == 0) { |
| if (subType != GetTrackEsdsObjectTypeId(m_pTracks[i]->GetId())) { |
| continue; |
| } |
| } else if (strcmp(normType, MP4_VIDEO_TRACK_TYPE) == 0) { |
| if (subType != GetTrackEsdsObjectTypeId(m_pTracks[i]->GetId())) { |
| continue; |
| } |
| } |
| // else unknown subtype, ignore it |
| } |
| |
| if (trackIndex == typeSeen) { |
| return m_pTracks[i]->GetId(); |
| } |
| |
| typeSeen++; |
| } |
| } |
| |
| ostringstream msg; |
| msg << "Track index doesn't exist - track " << trackIndex << " type " << type; |
| throw new Exception(msg.str(),__FILE__, __LINE__, __FUNCTION__); |
| return MP4_INVALID_TRACK_ID; // satisfy MS compiler |
| } |
| |
| uint16_t MP4File::FindTrackIndex(MP4TrackId trackId) |
| { |
| for (uint32_t i = 0; i < m_pTracks.Size() && i <= 0xFFFF; i++) { |
| if (m_pTracks[i]->GetId() == trackId) { |
| return (uint16_t)i; |
| } |
| } |
| |
| ostringstream msg; |
| msg << "Track id " << trackId << " doesn't exist"; |
| throw new Exception(msg.str(),__FILE__, __LINE__, __FUNCTION__); |
| return (uint16_t)-1; // satisfy MS compiler |
| } |
| |
| uint16_t MP4File::FindTrakAtomIndex(MP4TrackId trackId) |
| { |
| if (trackId) { |
| for (uint32_t i = 0; i < m_trakIds.Size(); i++) { |
| if (m_trakIds[i] == trackId) { |
| return i; |
| } |
| } |
| } |
| |
| ostringstream msg; |
| msg << "Track id " << trackId << " doesn't exist"; |
| throw new Exception(msg.str(),__FILE__, __LINE__, __FUNCTION__); |
| return (uint16_t)-1; // satisfy MS compiler |
| } |
| |
| uint32_t MP4File::GetSampleSize(MP4TrackId trackId, MP4SampleId sampleId) |
| { |
| return m_pTracks[FindTrackIndex(trackId)]->GetSampleSize(sampleId); |
| } |
| |
| uint32_t MP4File::GetTrackMaxSampleSize(MP4TrackId trackId) |
| { |
| return m_pTracks[FindTrackIndex(trackId)]->GetMaxSampleSize(); |
| } |
| |
| MP4SampleId MP4File::GetSampleIdFromTime(MP4TrackId trackId, |
| MP4Timestamp when, bool wantSyncSample) |
| { |
| return m_pTracks[FindTrackIndex(trackId)]-> |
| GetSampleIdFromTime(when, wantSyncSample); |
| } |
| |
| MP4Timestamp MP4File::GetSampleTime( |
| MP4TrackId trackId, MP4SampleId sampleId) |
| { |
| MP4Timestamp timestamp; |
| m_pTracks[FindTrackIndex(trackId)]-> |
| GetSampleTimes(sampleId, ×tamp, NULL); |
| return timestamp; |
| } |
| |
| MP4Duration MP4File::GetSampleDuration( |
| MP4TrackId trackId, MP4SampleId sampleId) |
| { |
| MP4Duration duration; |
| m_pTracks[FindTrackIndex(trackId)]-> |
| GetSampleTimes(sampleId, NULL, &duration); |
| return duration; |
| } |
| |
| MP4Duration MP4File::GetSampleRenderingOffset( |
| MP4TrackId trackId, MP4SampleId sampleId) |
| { |
| return m_pTracks[FindTrackIndex(trackId)]-> |
| GetSampleRenderingOffset(sampleId); |
| } |
| |
| bool MP4File::GetSampleSync(MP4TrackId trackId, MP4SampleId sampleId) |
| { |
| return m_pTracks[FindTrackIndex(trackId)]->IsSyncSample(sampleId); |
| } |
| |
| void MP4File::ReadSample( |
| MP4TrackId trackId, |
| MP4SampleId sampleId, |
| uint8_t** ppBytes, |
| uint32_t* pNumBytes, |
| MP4Timestamp* pStartTime, |
| MP4Duration* pDuration, |
| MP4Duration* pRenderingOffset, |
| bool* pIsSyncSample, |
| bool* hasDependencyFlags, |
| uint32_t* dependencyFlags ) |
| { |
| m_pTracks[FindTrackIndex(trackId)]->ReadSample( |
| sampleId, |
| ppBytes, |
| pNumBytes, |
| pStartTime, |
| pDuration, |
| pRenderingOffset, |
| pIsSyncSample, |
| hasDependencyFlags, |
| dependencyFlags ); |
| } |
| |
| void MP4File::WriteSample( |
| MP4TrackId trackId, |
| const uint8_t* pBytes, |
| uint32_t numBytes, |
| MP4Duration duration, |
| MP4Duration renderingOffset, |
| bool isSyncSample ) |
| { |
| ProtectWriteOperation(__FILE__, __LINE__, __FUNCTION__); |
| m_pTracks[FindTrackIndex(trackId)]->WriteSample( |
| pBytes, numBytes, duration, renderingOffset, isSyncSample ); |
| m_pModificationProperty->SetValue( MP4GetAbsTimestamp() ); |
| } |
| |
| void MP4File::WriteSampleDependency( |
| MP4TrackId trackId, |
| const uint8_t* pBytes, |
| uint32_t numBytes, |
| MP4Duration duration, |
| MP4Duration renderingOffset, |
| bool isSyncSample, |
| uint32_t dependencyFlags ) |
| { |
| ProtectWriteOperation(__FILE__, __LINE__, __FUNCTION__); |
| m_pTracks[FindTrackIndex(trackId)]->WriteSampleDependency( |
| pBytes, numBytes, duration, renderingOffset, isSyncSample, dependencyFlags ); |
| m_pModificationProperty->SetValue( MP4GetAbsTimestamp() ); |
| } |
| |
| void MP4File::SetSampleRenderingOffset(MP4TrackId trackId, |
| MP4SampleId sampleId, MP4Duration renderingOffset) |
| { |
| ProtectWriteOperation(__FILE__, __LINE__, __FUNCTION__); |
| m_pTracks[FindTrackIndex(trackId)]-> |
| SetSampleRenderingOffset(sampleId, renderingOffset); |
| |
| m_pModificationProperty->SetValue(MP4GetAbsTimestamp()); |
| } |
| |
|