// Write the atom into target file
bool
PVA_FF_MovieExtendsAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP* fp)
{
uint32 rendered = 0;
if (!renderAtomBaseMembers(fp))
{
return false;
}
rendered += getDefaultSize();
// Render the movie extend header atom
if (!_pMehdAtom->renderToFileStream(fp))
{
return false;
}
rendered += getMehdAtom()->getSize();
// render track extend atoms
if (_pTrexAtomVec->size() != 0)
{
for (uint32 ii = 0; ii < _pTrexAtomVec->size(); ii++)
{
if (!((*_pTrexAtomVec)[ii])->renderToFileStream(fp))
{
return false;
}
rendered += ((*_pTrexAtomVec)[ii])->getSize();
}
}
return true;
}
// Recomputes the size of the current atom by checking all contained atoms
void
PVA_FF_MovieExtendsAtom::recomputeSize()
{
int32 size = getDefaultSize(); // From base class
// add size of mehd atom
size += _pMehdAtom->getSize();
// add size of Trex atoms
if (_pTrexAtomVec->size() != 0)
{
for (uint32 ii = 0; ii < _pTrexAtomVec->size(); ii++)
{
size += ((*_pTrexAtomVec)[ii])->getSize();
}
}
_size = size;
// Update the size of the parent atom since this child atom may have changed
if (_pparent != NULL)
{
_pparent->recomputeSize();
}
}
bool
PVA_FF_FileTypeAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP *fp)
{
int32 rendered = 0; // Keep track of number of bytes rendered
// Render PVA_FF_Atom type and size
if (!renderAtomBaseMembers(fp))
{
return false;
}
rendered += getDefaultSize();
if (!PVA_FF_AtomUtils::render32(fp, _Brand))
{
return false;
}
rendered += 4;
if (!PVA_FF_AtomUtils::render32(fp, _Version))
{
return false;
}
rendered += 4;
for (uint32 i = 0; i < _pCompatibleBrandVec->size(); i++)
{
if (!PVA_FF_AtomUtils::render32(fp, (*_pCompatibleBrandVec)[i]))
{
return false;
}
}
return true;
}
bool
PVA_FF_H263DecBitrateAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP *fp)
{
int32 rendered = 0;
if (!renderAtomBaseMembers(fp))
{
return false;
}
rendered += getDefaultSize();
// Render decoder bitrate info payload
if (!PVA_FF_AtomUtils::render32(fp, _avg_bitrate))
{
return false;
}
rendered += 4;
if (!PVA_FF_AtomUtils::render32(fp, _max_bitrate))
{
return false;
}
rendered += 4;
return true;
}
// Rendering the PVA_FF_Atom in proper format (bitlengths, etc.) to an ostream
bool
PVA_FF_ChunkOffsetAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP *fp)
{
int32 rendered = 0;
if (!renderAtomBaseMembers(fp))
{
return false;
}
rendered += getDefaultSize();
if (!PVA_FF_AtomUtils::render32(fp, getEntryCount()))
{
return false;
}
rendered += 4;
if (_pchunkOffsets->size() < getEntryCount())
{
return false;
}
for (uint32 i = 0; i < getEntryCount(); i++)
{
if (!PVA_FF_AtomUtils::render32(fp, (*_pchunkOffsets)[i]))
{
return false;
}
}
rendered += 4 * getEntryCount();
return true;
}
void
PVA_FF_TrackHeaderAtom::recomputeSize()
{
int32 size = getDefaultSize(); // From base class
// Fields that vary depending on the version
if (getVersion() == 0)
{
size += 4; //_creationTime
size += 4; //_modificationTime
size += 4; //_duration
}
else // getVersion() == 1
{
size += 8; //_creationTime
size += 8; //_modificationTime
size += 8; //_duration
}
size += 4; // _trackID;
size += 4; // _reserved1
size += 60; // rest of reserved words
_size = size;
// Update the size of the parent atom since this child atom may have changed
if (_pparent != NULL)
{
_pparent->recomputeSize();
}
}
// recompute size of atom
void
PVA_FF_MovieFragmentAtom::recomputeSize()
{
int32 size = getDefaultSize();
// add size of mfhd atom
size += _pMfhdAtom->getSize();
// add size of Track fragments
if (_pTrafList->size() != 0)
{
for (uint32 ii = 0; ii < _pTrafList->size(); ii++)
{
if (((*_pTrafList)[ii])->getSampleCount() > 0)
{
size += ((*_pTrafList)[ii])->getSize();
}
}
}
_size = size;
// Update the parent atom size
if (_pparent != NULL)
{
_pparent->recomputeSize();
}
}
bool
PVA_FF_EVRCSpecificAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP *fp)
{
int32 rendered = 0;
renderAtomBaseMembers(fp);
rendered += getDefaultSize();
// Render decoder specific info payload
if (!PVA_FF_AtomUtils::render32(fp, _VendorCode))
{
return false;
}
rendered += 4;
if (!PVA_FF_AtomUtils::render8(fp, _encoder_version))
{
return false;
}
rendered += 1;
if (!PVA_FF_AtomUtils::render8(fp, _frames_per_sample))
{
return false;
}
rendered += 1;
return true;
}
bool PVA_FF_AssetInfoGenreAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP *fp)
{
int32 rendered = 0; // Keep track of number of bytes rendered
// Render PVA_FF_Atom type and size
if (!renderAtomBaseMembers(fp))
{
return false;
}
rendered += getDefaultSize();
if (!PVA_FF_AtomUtils::render16(fp, _langCode))
{
return false;
}
rendered += 2;
if (!PVA_FF_AtomUtils::render16(fp, _byteOrderMask))
{
return false;
}
rendered += 2;
if (!PVA_FF_AtomUtils::renderNullTerminatedUnicodeString(fp, _genre))
{
return false;
}
rendered += _genre.get_size() + 1; // 1 for the NULL entry
//recomputeSize();
return true;
}
// Stream-in Constructor
MediaDataAtom::MediaDataAtom(MP4_FF_FILE *fp, OSCL_wString& filename)
: Atom(fp)
{
OSCL_UNUSED_ARG(filename);
if (_success)
{
_type = MEDIA_DATA_ON_DISK;
// Seek past the end of the MEDIA_DATA_ATOM atom
int32 offset = getSize() - getDefaultSize();
int32 filePointer;
filePointer = AtomUtils::getCurrentFilePosition(fp);
if ((filePointer + offset) == fp->_fileSize)
{
// LAST MDAT IN THE FILE
_success = true;
}
AtomUtils::seekFromStart(fp, (filePointer + offset));
}
else
{
_mp4ErrorCode = READ_MEDIA_DATA_ATOM_FAILED;
}
}
// write atom to target file
bool
PVA_FF_TrackFragmentAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP* fp)
{
uint32 rendered = 0;
if (!renderAtomBaseMembers(fp))
{
return false;
}
rendered += getDefaultSize();
// Render the movie fragment header atom
if (!_pTfhdAtom->renderToFileStream(fp))
{
return false;
}
rendered += _pTfhdAtom->getSize();
// render track extend atoms
if (_pTrunList->size() != 0)
{
for (uint32 ii = 0; ii < _pTrunList->size(); ii++)
{
if (!((*_pTrunList)[ii])->renderToFileStream(fp))
{
return false;
}
rendered += ((*_pTrunList)[ii])->getSize();
}
}
return true;
}
// recompute size of atom
void
PVA_FF_TrackFragmentAtom::recomputeSize()
{
int32 size = getDefaultSize();
// add size of tfhd atom
size += _pTfhdAtom->getSize();
// add size of Track run atoms
if (_pTrunList->size() != 0)
{
for (uint32 ii = 0; ii < _pTrunList->size(); ii++)
{
size += ((*_pTrunList)[ii])->getSize();
}
}
_size = size;
// Update the parent atom size
if (_pparent != NULL)
{
_pparent->recomputeSize();
}
}
// write atom in target file
bool
PVA_FF_MovieFragmentRandomAccessAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP* fp)
{
uint32 rendered = 0;
if (!renderAtomBaseMembers(fp))
{
return false;
}
rendered += getDefaultSize();
// render track fragment random access atoms
if (_pTfraList->size() != 0)
{
for (uint32 ii = 0; ii < _pTfraList->size(); ii++)
{
if (!((*_pTfraList)[ii])->renderToFileStream(fp))
{
return false;
}
rendered += ((*_pTfraList)[ii])->getSize();
}
}
// Render the movie fragment random access offset atom
_pMfroAtom->setSize(_size); // before rendering set the size field in MFRO atom
if (!_pMfroAtom->renderToFileStream(fp))
{
return false;
}
rendered += _pMfroAtom->getSize();
return true;
}
// recompute size of atom
void
PVA_FF_MovieFragmentRandomAccessAtom::recomputeSize()
{
int32 size = getDefaultSize();
// add size of mfro atom
size += _pMfroAtom->getSize();
// add size of Tfra list
if (_pTfraList->size() != 0)
{
for (uint32 ii = 0; ii < _pTfraList->size(); ii++)
{
size += ((*_pTfraList)[ii])->getSize();
}
}
_size = size;
// Update the parent atom size
if (_pparent != NULL)
{
_pparent->recomputeSize();
}
}
// Rendering the PVA_FF_Atom in proper format (bitlengths, etc.) to an ostream
bool
PVA_FF_MediaAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP *fp)
{
int32 rendered = 0; // Keep track of number of bytes rendered
// Render PVA_FF_Atom type and size
if (!renderAtomBaseMembers(fp))
{
return false;
}
rendered += getDefaultSize();
// Render all member atoms
if (!_pmediaHeader->renderToFileStream(fp))
{
return false;
}
rendered += _pmediaHeader->getSize();
if (!_phandler->renderToFileStream(fp))
{
return false;
}
rendered += _phandler->getSize();
if (!_pmediaInformation->renderToFileStream(fp))
{
return false;
}
rendered += _pmediaInformation->getSize();
return true;
}
PVContentTypeAtom::PVContentTypeAtom(MP4_FF_FILE *fp, uint32 size, uint32 type)
: Atom(fp, size, type)
{
_success = true;
//Initialize to an undefined value - all content with this atom, ought to contain
//a valid content type
_contentType = 0xFFFFFFFF;
uint32 _count = getDefaultSize();
if (!AtomUtils::read32(fp, _contentType))
{
_success = false;
_mp4ErrorCode = READ_PV_CONTENT_TYPE_ATOM_FAILED;
return;
}
_count += sizeof(_contentType);
while (_count < _size)
{
uint8 data;
if (!AtomUtils::read8(fp, data))
{
_success = false;
_mp4ErrorCode = READ_PV_CONTENT_TYPE_ATOM_FAILED;
return;
}
_count++;
}
}
// Rendering the PVA_FF_Atom in proper format (bitlengths, etc.) to an ostream
bool
PVA_FF_MediaInformationAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP *fp)
{
int32 rendered = 0; // Keep track of number of bytes rendered
// Render PVA_FF_Atom type and size
if (!renderAtomBaseMembers(fp))
{
return false;
}
rendered += getDefaultSize();
// Render the data of the members once they get implemented
if (!_pmediaInformationHeader->renderToFileStream(fp))
{
return false;
}
rendered += _pmediaInformationHeader->getSize();
if (!_pdataInformationAtom->renderToFileStream(fp))
{
return false;
}
rendered += _pdataInformationAtom->getSize();
if (!_psampleTableAtom->renderToFileStream(fp))
{
return false;
}
rendered += _psampleTableAtom->getSize();
return true;
}
bool PVA_FF_AssetInfoKeyWordsAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP *fp)
{
recomputeSize();
int32 rendered = 0; // Keep track of number of bytes rendered
// Render PVA_FF_Atom type and size
if (!renderAtomBaseMembers(fp))
{
return false;
}
rendered += getDefaultSize();
if (!PVA_FF_AtomUtils::render16(fp, _langCode))
{
return false;
}
rendered += 2;
if (!PVA_FF_AtomUtils::render8(fp, _keyWordCnt))
{
return false;
}
rendered += 1;
// calculate size of each object in the structure
for (int i = 0; i < _keyWordCnt; i++)
{
(*_pKeyWordVect)[i]->renderToFileStream(fp);
rendered += (*_pKeyWordVect)[i]->getSizeofStruct();
}
return true;
}
// write atom to the target file
bool
PVA_FF_MovieExtendsHeaderAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP* fp)
{
uint32 rendered = 0;
if (!renderAtomBaseMembers(fp))
{
return false;
}
rendered += getDefaultSize();
// store file offset to modify duration later
_fileOffset = PVA_FF_AtomUtils::getCurrentFilePosition(fp);
if (!PVA_FF_AtomUtils::render32(fp, _fragmentDuration))
{
return false;
}
rendered += 4;
_oRendered = true;
return true;
}
void
PVA_FF_SoundMediaHeaderAtom::recomputeSize()
{
int32 size = getDefaultSize();
size += 4; // for 32 bit reserved
_size = size;
}
void
PVA_FF_VideoMediaHeaderAtom::recomputeSize()
{
int32 size = getDefaultSize();
size += 8; // for 64 bit reserved
_size = size;
}
void
PVA_FF_ProtectionSchemeInfoAtom::recomputeSize()
{
_size = getDefaultSize();
// Original format
_size += _originalFormatAtom.getSize();
}
void
PVA_FF_OriginalFormatAtom::recomputeSize()
{
_size = getDefaultSize();
// Original format
_size += 4;
}
PVA_FF_FileTypeAtom::PVA_FF_FileTypeAtom()
: PVA_FF_Atom(FILE_TYPE_ATOM)
{
_pCompatibleBrandVec = NULL;
_size = getDefaultSize() + 8;
PV_MP4_FF_NEW(fp->auditCB, uint32VecType, (), _pCompatibleBrandVec);
}
void PVA_FF_AssetInfoRecordingYearAtom::recomputeSize()
{
_size = getDefaultSize();
_size += sizeof(_recordingYear);
if (_pparent != NULL)
{
_pparent->recomputeSize();
}
}
uint32_t
AesKeyParamsInfo::checkKeySize(uint32_t size)
{
for (size_t i = 0; i < (sizeof(AES_KEY_SIZES) / sizeof(uint32_t)); i++)
{
if (AES_KEY_SIZES[i] == size)
return size;
}
return getDefaultSize();
}
void
PVA_FF_FileTypeAtom::recomputeSize()
{
_size = getDefaultSize() + 8;
for (uint32 i = 0; i < _pCompatibleBrandVec->size(); i++)
{
_size += 4;
}
}
void
SoGLUpdateAreaElement::init(SoState *)
//
////////////////////////////////////////////////////////////////////////
{
origin = getDefaultOrigin();
size = getDefaultSize();
// Set flag to indicate we are using the default value
isDefault = TRUE;
}
// Constructor
PVA_FF_EditAtom::PVA_FF_EditAtom()
: PVA_FF_Atom(FourCharConstToUint32('e', 'd', 't', 's'))
{
_size = getDefaultSize();
_peditList = NULL;
PV_MP4_FF_NEW(fp->auditCB, PVA_FF_EditListAtom, (), _peditList);
_peditList->setParent(this);
}
void PVA_FF_EditAtom::recomputeSize()
{
_size = getDefaultSize();
_size += _peditList->getSize();
// Update the size of the parent atom since this child atom may have changed
if (_pparent != NULL)
{
_pparent->recomputeSize();
}
}
