blob: 770f08fa43daa054a4b9ae1e0dae25f49d53bbbc [file] [log] [blame]
/*
* 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 - 2004. 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.
*
* Portions created by Adnecto d.o.o. are
* Copyright (C) Adnecto d.o.o. 2005. All Rights Reserved
*
* Contributor(s):
* Dave Mackie dmackie@cisco.com
* Alix Marchandise-Franquet alix@cisco.com
* Ximpo Group Ltd. mp4v2@ximpo.com
* Danijel Kopcinovic danijel.kopcinovic@adnecto.net
*/
#include "src/impl.h"
namespace mp4v2 { namespace impl {
///////////////////////////////////////////////////////////////////////////////
MP4AtomInfo::MP4AtomInfo(const char* name, bool mandatory, bool onlyOne)
{
m_name = name;
m_mandatory = mandatory;
m_onlyOne = onlyOne;
m_count = 0;
}
MP4Atom::MP4Atom(MP4File& file, const char* type)
: m_File(file)
{
SetType(type);
m_unknownType = false;
m_start = 0;
m_end = 0;
m_largesizeMode = false;
m_size = 0;
m_pParentAtom = NULL;
m_depth = 0xFF;
}
MP4Atom::~MP4Atom()
{
uint32_t i;
for (i = 0; i < m_pProperties.Size(); i++) {
delete m_pProperties[i];
}
for (i = 0; i < m_pChildAtomInfos.Size(); i++) {
delete m_pChildAtomInfos[i];
}
for (i = 0; i < m_pChildAtoms.Size(); i++) {
delete m_pChildAtoms[i];
}
}
MP4Atom* MP4Atom::CreateAtom( MP4File &file, MP4Atom* parent, const char* type )
{
MP4Atom* atom = factory( file, parent, type );
ASSERT( atom );
return atom;
}
// generate a skeletal self
void MP4Atom::Generate()
{
uint32_t i;
// for all properties
for (i = 0; i < m_pProperties.Size(); i++) {
// ask it to self generate
m_pProperties[i]->Generate();
}
// for all mandatory, single child atom types
for (i = 0; i < m_pChildAtomInfos.Size(); i++) {
if (m_pChildAtomInfos[i]->m_mandatory
&& m_pChildAtomInfos[i]->m_onlyOne) {
// create the mandatory, single child atom
MP4Atom* pChildAtom =
CreateAtom(m_File, this, m_pChildAtomInfos[i]->m_name);
AddChildAtom(pChildAtom);
// and ask it to self generate
pChildAtom->Generate();
}
}
}
MP4Atom* MP4Atom::ReadAtom(MP4File& file, MP4Atom* pParentAtom)
{
uint8_t hdrSize = 8;
uint8_t extendedType[16];
uint64_t pos = file.GetPosition();
log.verbose1f("\"%s\": pos = 0x%" PRIx64, file.GetFilename().c_str(), pos);
uint64_t dataSize = file.ReadUInt32();
char type[5];
file.ReadBytes((uint8_t*)&type[0], 4);
type[4] = '\0';
// extended size
const bool largesizeMode = (dataSize == 1);
if (dataSize == 1) {
dataSize = file.ReadUInt64();
hdrSize += 8;
file.Check64BitStatus(type);
}
// extended type
if (ATOMID(type) == ATOMID("uuid")) {
file.ReadBytes(extendedType, sizeof(extendedType));
hdrSize += sizeof(extendedType);
}
if (dataSize == 0) {
// extends to EOF
dataSize = file.GetSize() - pos;
}
dataSize -= hdrSize;
log.verbose1f("\"%s\": type = \"%s\" data-size = %" PRIu64 " (0x%" PRIx64 ") hdr %u",
file.GetFilename().c_str(), type, dataSize, dataSize, hdrSize);
if (pos + hdrSize + dataSize > pParentAtom->GetEnd()) {
log.errorf("%s: \"%s\": invalid atom size, extends outside parent atom - skipping to end of \"%s\" \"%s\" %" PRIu64 " vs %" PRIu64,
__FUNCTION__, file.GetFilename().c_str(), pParentAtom->GetType(), type,
pos + hdrSize + dataSize,
pParentAtom->GetEnd());
log.verbose1f("\"%s\": parent %s (%" PRIu64 ") pos %" PRIu64 " hdr %d data %" PRIu64 " sum %" PRIu64,
file.GetFilename().c_str(), pParentAtom->GetType(),
pParentAtom->GetEnd(),
pos,
hdrSize,
dataSize,
pos + hdrSize + dataSize);
// skip to end of atom
dataSize = pParentAtom->GetEnd() - pos - hdrSize;
}
MP4Atom* pAtom = CreateAtom(file, pParentAtom, type);
// pAtom->SetFile(pFile);
pAtom->SetStart(pos);
pAtom->SetEnd(pos + hdrSize + dataSize);
pAtom->SetLargesizeMode(largesizeMode);
pAtom->SetSize(dataSize);
if (ATOMID(type) == ATOMID("uuid")) {
pAtom->SetExtendedType(extendedType);
}
if (pAtom->IsUnknownType()) {
if (!IsReasonableType(pAtom->GetType())) {
log.warningf("%s: \"%s\": atom type %s is suspect", __FUNCTION__, file.GetFilename().c_str(),
pAtom->GetType());
} else {
log.verbose1f("\"%s\": Info: atom type %s is unknown", file.GetFilename().c_str(),
pAtom->GetType());
}
if (dataSize > 0) {
pAtom->AddProperty(
new MP4BytesProperty(*pAtom, "data", dataSize));
}
}
pAtom->SetParentAtom(pParentAtom);
try {
pAtom->Read();
}
catch (Exception* x) {
// delete atom and rethrow so we don't leak memory.
delete pAtom;
throw x;
}
return pAtom;
}
bool MP4Atom::IsReasonableType(const char* type)
{
// Unwound this. Pricy when called a lot.
if( isalnum((unsigned char) type[0])) {
if( isalnum((unsigned char) type[1])) {
if( isalnum((unsigned char) type[2])) {
if( isalnum((unsigned char) type[3]) || type[3] == ' ' ) {
return true;
}
}
}
}
return false;
}
// generic read
void MP4Atom::Read()
{
if (ATOMID(m_type) != 0 && m_size > 1000000) {
log.verbose1f("%s: \"%s\": %s atom size %" PRIu64 " is suspect", __FUNCTION__,
m_File.GetFilename().c_str(), m_type, m_size);
}
ReadProperties();
// read child atoms, if we expect there to be some
if (m_pChildAtomInfos.Size() > 0) {
ReadChildAtoms();
}
Skip(); // to end of atom
}
void MP4Atom::Skip()
{
if (m_File.GetPosition() != m_end) {
log.verbose1f("\"%s\": Skip: %" PRIu64 " bytes",
m_File.GetFilename().c_str(), m_end - m_File.GetPosition());
}
m_File.SetPosition(m_end);
}
MP4Atom* MP4Atom::FindAtom(const char* name)
{
if (!IsMe(name)) {
return NULL;
}
if (!IsRootAtom()) {
log.verbose1f("\"%s\": FindAtom: matched %s",
GetFile().GetFilename().c_str(), name);
name = MP4NameAfterFirst(name);
// I'm the sought after atom
if (name == NULL) {
return this;
}
}
// else it's one of my children
return FindChildAtom(name);
}
bool MP4Atom::FindProperty(const char *name,
MP4Property** ppProperty, uint32_t* pIndex)
{
if (!IsMe(name)) {
return false;
}
if (!IsRootAtom()) {
log.verbose1f("\"%s\": FindProperty: matched %s",
GetFile().GetFilename().c_str(), name);
name = MP4NameAfterFirst(name);
// no property name given
if (name == NULL) {
return false;
}
}
return FindContainedProperty(name, ppProperty, pIndex);
}
bool MP4Atom::IsMe(const char* name)
{
if (name == NULL) {
return false;
}
// root atom always matches
if (!strcmp(m_type, "")) {
return true;
}
// check if our atom name is specified as the first component
if (!MP4NameFirstMatches(m_type, name)) {
return false;
}
return true;
}
MP4Atom* MP4Atom::FindChildAtom(const char* name)
{
uint32_t atomIndex = 0;
// get the index if we have one, e.g. moov.trak[2].mdia...
(void)MP4NameFirstIndex(name, &atomIndex);
// need to get to the index'th child atom of the right type
for (uint32_t i = 0; i < m_pChildAtoms.Size(); i++) {
if (MP4NameFirstMatches(m_pChildAtoms[i]->GetType(), name)) {
if (atomIndex == 0) {
// this is the one, ask it to match
return m_pChildAtoms[i]->FindAtom(name);
}
atomIndex--;
}
}
return NULL;
}
bool MP4Atom::FindContainedProperty(const char *name,
MP4Property** ppProperty, uint32_t* pIndex)
{
uint32_t numProperties = m_pProperties.Size();
uint32_t i;
// check all of our properties
for (i = 0; i < numProperties; i++) {
if (m_pProperties[i]->FindProperty(name, ppProperty, pIndex)) {
return true;
}
}
// not one of our properties,
// presumably one of our children's properties
// check child atoms...
// check if we have an index, e.g. trak[2].mdia...
uint32_t atomIndex = 0;
(void)MP4NameFirstIndex(name, &atomIndex);
// need to get to the index'th child atom of the right type
for (i = 0; i < m_pChildAtoms.Size(); i++) {
if (MP4NameFirstMatches(m_pChildAtoms[i]->GetType(), name)) {
if (atomIndex == 0) {
// this is the one, ask it to match
return m_pChildAtoms[i]->FindProperty(name, ppProperty, pIndex);
}
atomIndex--;
}
}
log.verbose1f("\"%s\": FindProperty: no match for %s",
GetFile().GetFilename().c_str(), name);
return false;
}
void MP4Atom::ReadProperties(uint32_t startIndex, uint32_t count)
{
uint32_t numProperties = min(count, m_pProperties.Size() - startIndex);
// read any properties of the atom
for (uint32_t i = startIndex; i < startIndex + numProperties; i++) {
m_pProperties[i]->Read(m_File);
if (m_File.GetPosition() > m_end) {
log.verbose1f("ReadProperties: insufficient data for property: %s pos 0x%" PRIx64 " atom end 0x%" PRIx64,
m_pProperties[i]->GetName(),
m_File.GetPosition(), m_end);
ostringstream oss;
oss << "atom '" << GetType() << "' is too small; overrun at property: " << m_pProperties[i]->GetName();
throw new Exception( oss.str().c_str(), __FILE__, __LINE__, __FUNCTION__ );
}
MP4LogLevel thisVerbosity =
(m_pProperties[i]->GetType() == TableProperty) ?
MP4_LOG_VERBOSE2 : MP4_LOG_VERBOSE1;
if (log.verbosity >= thisVerbosity) {
// log.printf(thisVerbosity,"Read: ");
m_pProperties[i]->Dump(0, true);
}
}
}
void MP4Atom::ReadChildAtoms()
{
bool this_is_udta = ATOMID(m_type) == ATOMID("udta");
log.verbose1f("\"%s\": of %s", m_File.GetFilename().c_str(), m_type[0] ? m_type : "root");
for (uint64_t position = m_File.GetPosition();
position < m_end;
position = m_File.GetPosition()) {
// make sure that we have enough to read at least 8 bytes
// size and type.
if (m_end - position < 2 * sizeof(uint32_t)) {
// if we're reading udta, it's okay to have 4 bytes of 0
if (this_is_udta &&
m_end - position == sizeof(uint32_t)) {
uint32_t mbz = m_File.ReadUInt32();
if (mbz != 0) {
log.warningf("%s: \"%s\": In udta atom, end value is not zero %x", __FUNCTION__,
m_File.GetFilename().c_str(), mbz);
}
continue;
}
// otherwise, output a warning, but don't care
log.warningf("%s: \"%s\": In %s atom, extra %" PRId64 " bytes at end of atom", __FUNCTION__,
m_File.GetFilename().c_str(), m_type, (m_end - position));
for (uint64_t ix = 0; ix < m_end - position; ix++) {
(void)m_File.ReadUInt8();
}
continue;
}
MP4Atom* pChildAtom = MP4Atom::ReadAtom(m_File, this);
AddChildAtom(pChildAtom);
MP4AtomInfo* pChildAtomInfo = FindAtomInfo(pChildAtom->GetType());
// if child atom is of known type
// but not expected here print warning
if (pChildAtomInfo == NULL && !pChildAtom->IsUnknownType()) {
log.verbose1f("%s: \"%s\": In atom %s unexpected child atom %s", __FUNCTION__,
m_File.GetFilename().c_str(), GetType(), pChildAtom->GetType());
}
// if child atoms should have just one instance
// and this is more than one, print warning
if (pChildAtomInfo) {
pChildAtomInfo->m_count++;
if (pChildAtomInfo->m_onlyOne && pChildAtomInfo->m_count > 1) {
log.warningf("%s: \"%s\": In atom %s multiple child atoms %s", __FUNCTION__,
m_File.GetFilename().c_str(), GetType(), pChildAtom->GetType());
}
}
}
// if mandatory child atom doesn't exist, print warning
uint32_t numAtomInfo = m_pChildAtomInfos.Size();
for (uint32_t i = 0; i < numAtomInfo; i++) {
if (m_pChildAtomInfos[i]->m_mandatory
&& m_pChildAtomInfos[i]->m_count == 0) {
log.warningf("%s: \"%s\": In atom %s missing child atom %s", __FUNCTION__,
m_File.GetFilename().c_str(), GetType(), m_pChildAtomInfos[i]->m_name);
}
}
log.verbose1f("\"%s\": finished %s", m_File.GetFilename().c_str(), m_type);
}
MP4AtomInfo* MP4Atom::FindAtomInfo(const char* name)
{
uint32_t numAtomInfo = m_pChildAtomInfos.Size();
for (uint32_t i = 0; i < numAtomInfo; i++) {
if (ATOMID(m_pChildAtomInfos[i]->m_name) == ATOMID(name)) {
return m_pChildAtomInfos[i];
}
}
return NULL;
}
// generic write
void MP4Atom::Write()
{
BeginWrite();
WriteProperties();
WriteChildAtoms();
FinishWrite();
}
void MP4Atom::Rewrite()
{
if (!m_end) {
// This atom hasn't been written yet...
return;
}
uint64_t fPos = m_File.GetPosition();
m_File.SetPosition(GetStart());
Write();
m_File.SetPosition(fPos);
}
void MP4Atom::BeginWrite(bool use64)
{
m_start = m_File.GetPosition();
//use64 = m_File.Use64Bits();
if (use64) {
m_File.WriteUInt32(1);
} else {
m_File.WriteUInt32(0);
}
m_File.WriteBytes((uint8_t*)&m_type[0], 4);
if (use64) {
m_File.WriteUInt64(0);
}
if (ATOMID(m_type) == ATOMID("uuid")) {
m_File.WriteBytes(m_extendedType, sizeof(m_extendedType));
}
}
void MP4Atom::FinishWrite(bool use64)
{
m_end = m_File.GetPosition();
m_size = (m_end - m_start);
log.verbose1f("end: type %s %" PRIu64 " %" PRIu64 " size %" PRIu64,
m_type,m_start, m_end, m_size);
//use64 = m_File.Use64Bits();
if (use64) {
m_File.SetPosition(m_start + 8);
m_File.WriteUInt64(m_size);
} else {
ASSERT(m_size <= (uint64_t)0xFFFFFFFF);
m_File.SetPosition(m_start);
m_File.WriteUInt32(m_size);
}
m_File.SetPosition(m_end);
// adjust size to just reflect data portion of atom
m_size -= (use64 ? 16 : 8);
if (ATOMID(m_type) == ATOMID("uuid")) {
m_size -= sizeof(m_extendedType);
}
}
void MP4Atom::WriteProperties(uint32_t startIndex, uint32_t count)
{
uint32_t numProperties = min(count, m_pProperties.Size() - startIndex);
log.verbose1f("Write: \"%s\": type %s", m_File.GetFilename().c_str(), m_type);
for (uint32_t i = startIndex; i < startIndex + numProperties; i++) {
m_pProperties[i]->Write(m_File);
MP4LogLevel thisVerbosity =
(m_pProperties[i]->GetType() == TableProperty) ?
MP4_LOG_VERBOSE2 : MP4_LOG_VERBOSE1;
if (log.verbosity >= thisVerbosity) {
log.printf(thisVerbosity,"Write: ");
m_pProperties[i]->Dump(0, false);
}
}
}
void MP4Atom::WriteChildAtoms()
{
uint32_t size = m_pChildAtoms.Size();
for (uint32_t i = 0; i < size; i++) {
m_pChildAtoms[i]->Write();
}
log.verbose1f("Write: \"%s\": finished %s", m_File.GetFilename().c_str(), m_type);
}
void MP4Atom::AddProperty(MP4Property* pProperty)
{
ASSERT(pProperty);
m_pProperties.Add(pProperty);
}
void MP4Atom::AddVersionAndFlags()
{
AddProperty(new MP4Integer8Property(*this, "version"));
AddProperty(new MP4Integer24Property(*this, "flags"));
}
void MP4Atom::AddReserved(MP4Atom& parentAtom, const char* name, uint32_t size)
{
MP4BytesProperty* pReserved = new MP4BytesProperty(parentAtom, name, size);
pReserved->SetReadOnly();
AddProperty(pReserved);
}
void MP4Atom::ExpectChildAtom(const char* name, bool mandatory, bool onlyOne)
{
m_pChildAtomInfos.Add(new MP4AtomInfo(name, mandatory, onlyOne));
}
uint8_t MP4Atom::GetVersion()
{
if (strcmp("version", m_pProperties[0]->GetName())) {
return 0;
}
return ((MP4Integer8Property*)m_pProperties[0])->GetValue();
}
void MP4Atom::SetVersion(uint8_t version)
{
if (strcmp("version", m_pProperties[0]->GetName())) {
return;
}
((MP4Integer8Property*)m_pProperties[0])->SetValue(version);
}
uint32_t MP4Atom::GetFlags()
{
if (strcmp("flags", m_pProperties[1]->GetName())) {
return 0;
}
return ((MP4Integer24Property*)m_pProperties[1])->GetValue();
}
void MP4Atom::SetFlags(uint32_t flags)
{
if (strcmp("flags", m_pProperties[1]->GetName())) {
return;
}
((MP4Integer24Property*)m_pProperties[1])->SetValue(flags);
}
void MP4Atom::Dump(uint8_t indent, bool dumpImplicits)
{
if ( m_type[0] != '\0' ) {
// create list of ancestors
std::list<string> tlist;
for( MP4Atom* atom = this; atom; atom = atom->GetParentAtom() ) {
const char* const type = atom->GetType();
if( type && type[0] != '\0' )
tlist.push_front( type );
}
// create contextual atom-name
string can;
const std::list<string>::iterator ie = tlist.end();
for( std::list<string>::iterator it = tlist.begin(); it != ie; it++ )
can += *it + '.';
if( can.length() )
can.resize( can.length() - 1 );
log.dump(indent, MP4_LOG_VERBOSE1, "\"%s\": type %s (%s)",
GetFile().GetFilename().c_str(),
m_type, can.c_str() );
}
uint32_t i;
uint32_t size;
// dump our properties
size = m_pProperties.Size();
for (i = 0; i < size; i++) {
/* skip details of tables unless we're told to be verbose */
if (m_pProperties[i]->GetType() == TableProperty
&& (log.verbosity < MP4_LOG_VERBOSE2)) {
log.dump(indent + 1, MP4_LOG_VERBOSE1, "\"%s\": <table entries suppressed>",
GetFile().GetFilename().c_str() );
continue;
}
m_pProperties[i]->Dump(indent + 1, dumpImplicits);
}
// dump our children
size = m_pChildAtoms.Size();
for (i = 0; i < size; i++) {
m_pChildAtoms[i]->Dump(indent + 1, dumpImplicits);
}
}
uint8_t MP4Atom::GetDepth()
{
if (m_depth < 0xFF) {
return m_depth;
}
MP4Atom *pAtom = this;
m_depth = 0;
while ((pAtom = pAtom->GetParentAtom()) != NULL) {
m_depth++;
ASSERT(m_depth < 255);
}
return m_depth;
}
bool MP4Atom::GetLargesizeMode()
{
return m_largesizeMode;
}
void MP4Atom::SetLargesizeMode( bool mode )
{
m_largesizeMode = mode;
}
bool
MP4Atom::descendsFrom( MP4Atom* parent, const char* type )
{
const uint32_t id = ATOMID( type );
for( MP4Atom* atom = parent; atom; atom = atom->GetParentAtom() ) {
if( id == ATOMID(atom->GetType()) )
return true;
}
return false;
}
// UDTA child atom types to be constructed as MP4UdtaElementAtom.
// List gleaned from QTFF 2007-09-04.
static const char* const UDTA_ELEMENTS[] = {
"\xA9" "arg",
"\xA9" "ark",
"\xA9" "cok",
"\xA9" "com",
"\xA9" "cpy",
"\xA9" "day",
"\xA9" "dir",
"\xA9" "ed1",
"\xA9" "ed2",
"\xA9" "ed3",
"\xA9" "ed4",
"\xA9" "ed5",
"\xA9" "ed6",
"\xA9" "ed7",
"\xA9" "ed8",
"\xA9" "ed9",
"\xA9" "fmt",
"\xA9" "inf",
"\xA9" "isr",
"\xA9" "lab",
"\xA9" "lal",
"\xA9" "mak",
"\xA9" "nak",
"\xA9" "nam",
"\xA9" "pdk",
"\xA9" "phg",
"\xA9" "prd",
"\xA9" "prf",
"\xA9" "prk",
"\xA9" "prl",
"\xA9" "req",
"\xA9" "snk",
"\xA9" "snm",
"\xA9" "src",
"\xA9" "swf",
"\xA9" "swk",
"\xA9" "swr",
"\xA9" "wrt",
"Allf",
"name",
"LOOP",
"ptv ",
"SelO",
"WLOC",
NULL // must be last
};
MP4Atom*
MP4Atom::factory( MP4File &file, MP4Atom* parent, const char* type )
{
// type may be NULL only in case of root-atom
if( !type )
return new MP4RootAtom(file);
// construct atoms which are context-savvy
if( parent ) {
const char* const ptype = parent->GetType();
if( descendsFrom( parent, "ilst" )) {
if( ATOMID( ptype ) == ATOMID( "ilst" ))
return new MP4ItemAtom( file, type );
if( ATOMID( type ) == ATOMID( "data" ))
return new MP4DataAtom(file);
if( ATOMID( ptype ) == ATOMID( "----" )) {
if( ATOMID( type ) == ATOMID( "mean" ))
return new MP4MeanAtom(file);
if( ATOMID( type ) == ATOMID( "name" ))
return new MP4NameAtom(file);
}
}
else if( ATOMID( ptype ) == ATOMID( "meta" )) {
if( ATOMID( type ) == ATOMID( "hdlr" ))
return new MP4ItmfHdlrAtom(file);
}
else if( ATOMID( ptype ) == ATOMID( "udta" )) {
if( ATOMID( type ) == ATOMID( "hnti" ))
return new MP4HntiAtom(file);
if( ATOMID( type ) == ATOMID( "hinf" ))
return new MP4HinfAtom(file);
for( const char* const* p = UDTA_ELEMENTS; *p; p++ )
if( !strcmp( type, *p ))
return new MP4UdtaElementAtom( file, type );
}
}
// no-context construction (old-style)
switch( (uint8_t)type[0] ) {
case 'S':
if( ATOMID(type) == ATOMID("SVQ3") )
return new MP4VideoAtom( file, type );
if( ATOMID(type) == ATOMID("SMI ") )
return new MP4SmiAtom(file);
break;
case 'a':
if( ATOMID(type) == ATOMID("avc1") )
return new MP4Avc1Atom(file);
if( ATOMID(type) == ATOMID("ac-3") )
return new MP4Ac3Atom(file);
if( ATOMID(type) == ATOMID("avcC") )
return new MP4AvcCAtom(file);
if( ATOMID(type) == ATOMID("alis") )
return new MP4UrlAtom( file, type );
if( ATOMID(type) == ATOMID("alaw") )
return new MP4SoundAtom( file, type );
if( ATOMID(type) == ATOMID("alac") )
return new MP4SoundAtom( file, type );
break;
case 'c':
if( ATOMID(type) == ATOMID("camm") )
return new MP4CammAtom(file);
if( ATOMID(type) == ATOMID("chap") )
return new MP4TrefTypeAtom( file, type );
if( ATOMID(type) == ATOMID("chpl") )
return new MP4ChplAtom(file);
if( ATOMID(type) == ATOMID("colr") )
return new MP4ColrAtom(file);
break;
case 'd':
if( ATOMID(type) == ATOMID("d263") )
return new MP4D263Atom(file);
if( ATOMID(type) == ATOMID("damr") )
return new MP4DamrAtom(file);
if( ATOMID(type) == ATOMID("dref") )
return new MP4DrefAtom(file);
if( ATOMID(type) == ATOMID("dpnd") )
return new MP4TrefTypeAtom( file, type );
if( ATOMID(type) == ATOMID("dac3") )
return new MP4DAc3Atom(file);
break;
case 'e':
if( ATOMID(type) == ATOMID("elst") )
return new MP4ElstAtom(file);
if( ATOMID(type) == ATOMID("enca") )
return new MP4EncaAtom(file);
if( ATOMID(type) == ATOMID("encv") )
return new MP4EncvAtom(file);
break;
case 'f':
if( ATOMID(type) == ATOMID("free") )
return new MP4FreeAtom(file);
if( ATOMID(type) == ATOMID("ftyp") )
return new MP4FtypAtom(file);
if( ATOMID(type) == ATOMID("ftab") )
return new MP4FtabAtom(file);
break;
case 'g':
if( ATOMID(type) == ATOMID("gmin") )
return new MP4GminAtom(file);
break;
case 'h':
if( ATOMID(type) == ATOMID("hdlr") )
return new MP4HdlrAtom(file);
if( ATOMID(type) == ATOMID("hint") )
return new MP4TrefTypeAtom( file, type );
if( ATOMID(type) == ATOMID("h263") )
return new MP4VideoAtom( file, type );
if( ATOMID(type) == ATOMID("href") )
return new MP4HrefAtom(file);
break;
case 'i':
if( ATOMID(type) == ATOMID("ipir") )
return new MP4TrefTypeAtom( file, type );
if( ATOMID(type) == ATOMID("ima4") )
return new MP4SoundAtom( file, type );
break;
case 'j':
if( ATOMID(type) == ATOMID("jpeg") )
return new MP4VideoAtom(file, "jpeg");
break;
case 'm':
if( ATOMID(type) == ATOMID("mdhd") )
return new MP4MdhdAtom(file);
if( ATOMID(type) == ATOMID("mvhd") )
return new MP4MvhdAtom(file);
if( ATOMID(type) == ATOMID("mdat") )
return new MP4MdatAtom(file);
if( ATOMID(type) == ATOMID("mpod") )
return new MP4TrefTypeAtom( file, type );
if( ATOMID(type) == ATOMID("mp4a") )
return new MP4SoundAtom( file, type );
if( ATOMID(type) == ATOMID("mp4s") )
return new MP4Mp4sAtom(file);
if( ATOMID(type) == ATOMID("mp4v") )
return new MP4Mp4vAtom(file);
break;
case 'n':
if( ATOMID(type) == ATOMID("nmhd") )
return new MP4NmhdAtom(file);
break;
case 'o':
if( ATOMID(type) == ATOMID("ohdr") )
return new MP4OhdrAtom(file);
break;
case 'p':
if( ATOMID(type) == ATOMID("pasp") )
return new MP4PaspAtom(file);
break;
case 'r':
if( ATOMID(type) == ATOMID("rtp ") )
return new MP4RtpAtom(file);
if( ATOMID(type) == ATOMID("raw ") )
return new MP4VideoAtom( file, type );
break;
case 's':
if( ATOMID(type) == ATOMID("s263") )
return new MP4S263Atom(file);
if( ATOMID(type) == ATOMID("samr") )
return new MP4AmrAtom( file, type );
if( ATOMID(type) == ATOMID("sawb") )
return new MP4AmrAtom( file, type );
if( ATOMID(type) == ATOMID("sdtp") )
return new MP4SdtpAtom(file);
if( ATOMID(type) == ATOMID("stbl") )
return new MP4StblAtom(file);
if( ATOMID(type) == ATOMID("stsd") )
return new MP4StsdAtom(file);
if( ATOMID(type) == ATOMID("stsz") )
return new MP4StszAtom(file);
if( ATOMID(type) == ATOMID("stsc") )
return new MP4StscAtom(file);
if( ATOMID(type) == ATOMID("stz2") )
return new MP4Stz2Atom(file);
if( ATOMID(type) == ATOMID("stdp") )
return new MP4StdpAtom(file);
if( ATOMID(type) == ATOMID("sdp ") )
return new MP4SdpAtom(file);
if( ATOMID(type) == ATOMID("sync") )
return new MP4TrefTypeAtom( file, type );
if( ATOMID(type) == ATOMID("skip") )
return new MP4FreeAtom( file, type );
if (ATOMID(type) == ATOMID("sowt") )
return new MP4SoundAtom( file, type );
break;
case 't':
if( ATOMID(type) == ATOMID("text") )
return new MP4TextAtom(file);
if( ATOMID(type) == ATOMID("tx3g") )
return new MP4Tx3gAtom(file);
if( ATOMID(type) == ATOMID("tkhd") )
return new MP4TkhdAtom(file);
if( ATOMID(type) == ATOMID("tfhd") )
return new MP4TfhdAtom(file);
if( ATOMID(type) == ATOMID("trun") )
return new MP4TrunAtom(file);
if( ATOMID(type) == ATOMID("twos") )
return new MP4SoundAtom( file, type );
break;
case 'u':
if( ATOMID(type) == ATOMID("udta") )
return new MP4UdtaAtom(file);
if( ATOMID(type) == ATOMID("url ") )
return new MP4UrlAtom(file);
if( ATOMID(type) == ATOMID("urn ") )
return new MP4UrnAtom(file);
if( ATOMID(type) == ATOMID("ulaw") )
return new MP4SoundAtom( file, type );
break;
case 'v':
if( ATOMID(type) == ATOMID("vmhd") )
return new MP4VmhdAtom(file);
break;
case 'y':
if( ATOMID(type) == ATOMID("yuv2") )
return new MP4VideoAtom( file, type );
break;
default:
break;
}
// default to MP4StandardAtom implementation
return new MP4StandardAtom( file, type );
}
///////////////////////////////////////////////////////////////////////////////
}} // namespace mp4v2::impl