/*
 * 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(const char* type)
{
    SetType(type);
    m_unknownType = false;
    m_pFile = NULL;
    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( MP4Atom* parent, const char* type )
{
    MP4Atom* atom = factory( 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(this, m_pChildAtomInfos[i]->m_name);

            AddChildAtom(pChildAtom);

            // and ask it to self generate
            pChildAtom->Generate();
        }
    }
}

MP4Atom* MP4Atom::ReadAtom(MP4File* pFile, MP4Atom* pParentAtom)
{
    uint8_t hdrSize = 8;
    uint8_t extendedType[16];

    uint64_t pos = pFile->GetPosition();

    VERBOSE_READ(pFile->GetVerbosity(),
                 printf("ReadAtom: pos = 0x%" PRIx64 "\n", pos));

    uint64_t dataSize = pFile->ReadUInt32();

    char type[5];
    pFile->ReadBytes((uint8_t*)&type[0], 4);
    type[4] = '\0';

    // extended size
    const bool largesizeMode = (dataSize == 1);
    if (dataSize == 1) {
        dataSize = pFile->ReadUInt64();
        hdrSize += 8;
        pFile->Check64BitStatus(type);
    }

    // extended type
    if (ATOMID(type) == ATOMID("uuid")) {
        pFile->ReadBytes(extendedType, sizeof(extendedType));
        hdrSize += sizeof(extendedType);
    }

    if (dataSize == 0) {
        // extends to EOF
        dataSize = pFile->GetSize() - pos;
    }

    dataSize -= hdrSize;

    VERBOSE_READ(pFile->GetVerbosity(),
                 printf("ReadAtom: type = \"%s\" data-size = %" PRIu64 " (0x%" PRIx64 ") hdr %u\n",
                        type, dataSize, dataSize, hdrSize));

    if (pos + hdrSize + dataSize > pParentAtom->GetEnd()) {
        VERBOSE_ERROR(pFile->GetVerbosity(),
                      printf("ReadAtom: invalid atom size, extends outside parent atom - skipping to end of \"%s\" \"%s\" %" PRIu64 " vs %" PRIu64 "\n",
                             pParentAtom->GetType(), type,
                             pos + hdrSize + dataSize,
                             pParentAtom->GetEnd()));
        VERBOSE_READ(pFile->GetVerbosity(),
                     printf("parent %s (%" PRIu64 ") pos %" PRIu64 " hdr %d data %" PRIu64 " sum %" PRIu64 "\n",
                            pParentAtom->GetType(),
                            pParentAtom->GetEnd(),
                            pos,
                            hdrSize,
                            dataSize,
                            pos + hdrSize + dataSize));
#if 0
        throw new MP4Error("invalid atom size", "ReadAtom");
#else
        // skip to end of atom
        dataSize = pParentAtom->GetEnd() - pos - hdrSize;
#endif
    }

    MP4Atom* pAtom = CreateAtom(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())) {
            VERBOSE_READ(pFile->GetVerbosity(),
                         printf("Warning: atom type %s is suspect\n", pAtom->GetType()));
        } else {
            VERBOSE_READ(pFile->GetVerbosity(),
                         printf("Info: atom type %s is unknown\n", pAtom->GetType()));
        }

        if (dataSize > 0) {
            pAtom->AddProperty(
                new MP4BytesProperty("data", dataSize));
        }
    }

    pAtom->SetParentAtom(pParentAtom);

    try {
    pAtom->Read();
    }
    catch (MP4Error* e) {
        delete pAtom;
        throw e;
    }

    return pAtom;
}

bool MP4Atom::IsReasonableType(const char* type)
{
    for (uint8_t i = 0; i < 4; i++) {
		if (isalnum((unsigned char)type[i])) {
            continue;
        }
        if (i == 3 && type[i] == ' ') {
            continue;
        }
        return false;
    }
    return true;
}

// generic read
void MP4Atom::Read()
{
    ASSERT(m_pFile);

    if (ATOMID(m_type) != 0 && m_size > 1000000) {
        VERBOSE_READ(GetVerbosity(),
                     printf("Warning: %s atom size %" PRIu64 " is suspect\n",
                            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_pFile->GetPosition() != m_end) {
        VERBOSE_READ(m_pFile->GetVerbosity(),
                     printf("Skip: %" PRIu64 " bytes\n", m_end - m_pFile->GetPosition()));
    }
    m_pFile->SetPosition(m_end);
}

MP4Atom* MP4Atom::FindAtom(const char* name)
{
    if (!IsMe(name)) {
        return NULL;
    }

    if (!IsRootAtom()) {
        VERBOSE_FIND(m_pFile->GetVerbosity(),
                     printf("FindAtom: matched %s\n", 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()) {
        VERBOSE_FIND(m_pFile->GetVerbosity(),
                     printf("FindProperty: matched %s\n", 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--;
        }
    }

    VERBOSE_FIND(m_pFile->GetVerbosity(),
                 printf("FindProperty: no match for %s\n", 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_pFile);

        if (m_pFile->GetPosition() > m_end) {
            VERBOSE_READ(GetVerbosity(),
                         printf("ReadProperties: insufficient data for property: %s pos 0x%" PRIx64 " atom end 0x%" PRIx64 "\n",
                                m_pProperties[i]->GetName(),
                                m_pFile->GetPosition(), m_end));

            ostringstream oss;
            oss << "atom '" << GetType() << "' is too small; overrun at property: " << m_pProperties[i]->GetName();
            throw new MP4Error( oss.str().c_str(), "Atom ReadProperties" );
        }

        if (m_pProperties[i]->GetType() == TableProperty) {
            VERBOSE_READ_TABLE(GetVerbosity(),
                               printf("Read: "); m_pProperties[i]->Dump(stdout, 0, true));
        } else if (m_pProperties[i]->GetType() != DescriptorProperty) {
            VERBOSE_READ(GetVerbosity(),
                         printf("Read: "); m_pProperties[i]->Dump(stdout, 0, true));
        }
    }
}

void MP4Atom::ReadChildAtoms()
{
    bool this_is_udta = ATOMID(m_type) == ATOMID("udta");

    VERBOSE_READ(GetVerbosity(),
                 printf("ReadChildAtoms: of %s\n", m_type[0] ? m_type : "root"));
    for (uint64_t position = m_pFile->GetPosition();
            position < m_end;
            position = m_pFile->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_pFile->ReadUInt32();
                if (mbz != 0) {
                    VERBOSE_WARNING(GetVerbosity(),
                                    printf("Error: In udta atom, end value is not zero %x\n",
                                           mbz));
                }
                continue;
            }
            // otherwise, output a warning, but don't care
            VERBOSE_WARNING(GetVerbosity(),
                            printf("Error: In %s atom, extra %" PRId64 " bytes at end of atom\n",
                                   m_type, (m_end - position)));
            for (uint64_t ix = 0; ix < m_end - position; ix++) {
                (void)m_pFile->ReadUInt8();
            }
            continue;
        }
        MP4Atom* pChildAtom = MP4Atom::ReadAtom(m_pFile, 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()) {
            VERBOSE_READ(GetVerbosity(),
                         printf("Warning: In atom %s unexpected child atom %s\n",
                                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) {
                VERBOSE_READ(GetVerbosity(),
                             printf("Warning: In atom %s multiple child atoms %s\n",
                                    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) {
            VERBOSE_READ(GetVerbosity(),
                         printf("Warning: In atom %s missing child atom %s\n",
                                GetType(), m_pChildAtomInfos[i]->m_name));
        }
    }

    VERBOSE_READ(GetVerbosity(),
                 printf("ReadChildAtoms: finished %s\n", 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()
{
    ASSERT(m_pFile);

    BeginWrite();

    WriteProperties();

    WriteChildAtoms();

    FinishWrite();
}

void MP4Atom::Rewrite()
{
    ASSERT(m_pFile);

    if (!m_end) {
        // This atom hasn't been written yet...
        return;
    }

    uint64_t fPos = m_pFile->GetPosition();
    m_pFile->SetPosition(GetStart());
    Write();
    m_pFile->SetPosition(fPos);
}

void MP4Atom::BeginWrite(bool use64)
{
    m_start = m_pFile->GetPosition();
    //use64 = m_pFile->Use64Bits();
    if (use64) {
        m_pFile->WriteUInt32(1);
    } else {
        m_pFile->WriteUInt32(0);
    }
    m_pFile->WriteBytes((uint8_t*)&m_type[0], 4);
    if (use64) {
        m_pFile->WriteUInt64(0);
    }
    if (ATOMID(m_type) == ATOMID("uuid")) {
        m_pFile->WriteBytes(m_extendedType, sizeof(m_extendedType));
    }
}

void MP4Atom::FinishWrite(bool use64)
{
    m_end = m_pFile->GetPosition();
    m_size = (m_end - m_start);
    VERBOSE_WRITE(GetVerbosity(),
                  printf("end: type %s %" PRIu64 " %" PRIu64 " size %" PRIu64 "\n", m_type,
                         m_start, m_end,
                         m_size));
    //use64 = m_pFile->Use64Bits();
    if (use64) {
        m_pFile->SetPosition(m_start + 8);
        m_pFile->WriteUInt64(m_size);
    } else {
        ASSERT(m_size <= (uint64_t)0xFFFFFFFF);
        m_pFile->SetPosition(m_start);
        m_pFile->WriteUInt32(m_size);
    }
    m_pFile->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);

    VERBOSE_WRITE(GetVerbosity(),
                  printf("Write: type %s\n", m_type));

    for (uint32_t i = startIndex; i < startIndex + numProperties; i++) {
        m_pProperties[i]->Write(m_pFile);

        if (m_pProperties[i]->GetType() == TableProperty) {
            VERBOSE_WRITE_TABLE(GetVerbosity(),
                                printf("Write: "); m_pProperties[i]->Dump(stdout, 0, false));
        } else {
            VERBOSE_WRITE(GetVerbosity(),
                          printf("Write: "); m_pProperties[i]->Dump(stdout, 0, false));
        }
    }
}

void MP4Atom::WriteChildAtoms()
{
    uint32_t size = m_pChildAtoms.Size();
    for (uint32_t i = 0; i < size; i++) {
        m_pChildAtoms[i]->Write();
    }

    VERBOSE_WRITE(GetVerbosity(),
                  printf("Write: finished %s\n", m_type));
}

void MP4Atom::AddProperty(MP4Property* pProperty)
{
    ASSERT(pProperty);
    m_pProperties.Add(pProperty);
    pProperty->SetParentAtom(this);
}

void MP4Atom::AddVersionAndFlags()
{
    AddProperty(new MP4Integer8Property("version"));
    AddProperty(new MP4Integer24Property("flags"));
}

void MP4Atom::AddReserved(const char* name, uint32_t size)
{
    MP4BytesProperty* pReserved = new MP4BytesProperty(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(FILE* pFile, uint8_t indent, bool dumpImplicits)
{
    if ( m_type[0] != '\0' ) {
        // create list of ancestors
        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 list<string>::iterator ie = tlist.end();
        for( list<string>::iterator it = tlist.begin(); it != ie; it++ )
            can += *it + '.';
        if( can.length() )
            can.resize( can.length() - 1 );

        Indent( pFile, indent );
        fprintf( pFile, "type %s (%s)\n", m_type, can.c_str() );
        fflush( pFile );
    }

    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
                && !(GetVerbosity() & MP4_DETAILS_TABLE)) {
            Indent(pFile, indent + 1);
            fprintf(pFile, "<table entries suppressed>\n");
            continue;
        }

        m_pProperties[i]->Dump(pFile, indent + 1, dumpImplicits);
    }

    // dump our children
    size = m_pChildAtoms.Size();
    for (i = 0; i < size; i++) {
        m_pChildAtoms[i]->Dump(pFile, indent + 1, dumpImplicits);
    }
}

uint32_t MP4Atom::GetVerbosity()
{
    ASSERT(m_pFile);
    return m_pFile->GetVerbosity();
}

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",
    "hinf",
    "hnti",
    "name",
    "LOOP",
    "ptv ",
    "SelO",
    "WLOC",
    NULL // must be last
};

MP4Atom*
MP4Atom::factory( MP4Atom* parent, const char* type )
{
    // type may be NULL only in case of root-atom
    if( !type )
        return new MP4RootAtom();

    // 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( type );

            if( ATOMID( type ) == ATOMID( "data" ))
                return new MP4DataAtom();

            if( ATOMID( ptype ) == ATOMID( "----" )) {
                if( ATOMID( type ) == ATOMID( "mean" ))
                    return new MP4MeanAtom();
                if( ATOMID( type ) == ATOMID( "name" ))
                    return new MP4NameAtom();
            }
        }
        else if( ATOMID( ptype ) == ATOMID( "udta" )) {
            for( const char* const* p = UDTA_ELEMENTS; *p; p++ )
                if( !strcmp( type, *p ))
                    return new MP4UdtaElementAtom( type );
        }
    }

    // no-context construction (old-style)
    switch( (uint8_t)type[0] ) {
        case 'S':
            if( ATOMID(type) == ATOMID("SVQ3") )
                return new MP4VideoAtom( type );
            if( ATOMID(type) == ATOMID("SMI ") )
                return new MP4SmiAtom();
            break;

        case 'a':
            if( ATOMID(type) == ATOMID("avc1") )
                return new MP4Avc1Atom();
            if( ATOMID(type) == ATOMID("ac-3") )
                return new MP4Ac3Atom();
            if( ATOMID(type) == ATOMID("avcC") )
                return new MP4AvcCAtom();
            if( ATOMID(type) == ATOMID("alis") )
                return new MP4UrlAtom( type );
            if( ATOMID(type) == ATOMID("alaw") )
                return new MP4SoundAtom( type );
            if( ATOMID(type) == ATOMID("alac") )
                return new MP4SoundAtom( type );
            break;

        case 'c':
            if( ATOMID(type) == ATOMID("chap") )
                return new MP4TrefTypeAtom( type );
            if( ATOMID(type) == ATOMID("chpl") )
                return new MP4ChplAtom();
            if( ATOMID(type) == ATOMID("colr") )
                return new MP4ColrAtom();
            break;

        case 'd':
            if( ATOMID(type) == ATOMID("d263") )
                return new MP4D263Atom();
            if( ATOMID(type) == ATOMID("damr") )
                return new MP4DamrAtom();
            if( ATOMID(type) == ATOMID("dref") )
                return new MP4DrefAtom();
            if( ATOMID(type) == ATOMID("dpnd") )
                return new MP4TrefTypeAtom( type );
            if( ATOMID(type) == ATOMID("dac3") )
                return new MP4DAc3Atom();
            break;

        case 'e':
            if( ATOMID(type) == ATOMID("elst") )
                return new MP4ElstAtom();
            if( ATOMID(type) == ATOMID("enca") )
                return new MP4EncaAtom();
            if( ATOMID(type) == ATOMID("encv") )
                return new MP4EncvAtom();
            break;

        case 'f':
            if( ATOMID(type) == ATOMID("free") )
                return new MP4FreeAtom();
            if( ATOMID(type) == ATOMID("ftyp") )
                return new MP4FtypAtom();
            if( ATOMID(type) == ATOMID("ftab") )
                return new MP4FtabAtom();
            break;

        case 'g':
            if( ATOMID(type) == ATOMID("gmin") )
                return new MP4GminAtom();
            break;

        case 'h':
            if( ATOMID(type) == ATOMID("hdlr") )
                return new MP4HdlrAtom();
            if( ATOMID(type) == ATOMID("hint") )
                return new MP4TrefTypeAtom( type );
            if( ATOMID(type) == ATOMID("hnti") )
                return new MP4HntiAtom();
            if( ATOMID(type) == ATOMID("hinf") )
                return new MP4HinfAtom();
            if( ATOMID(type) == ATOMID("h263") )
                return new MP4VideoAtom( type );
            if( ATOMID(type) == ATOMID("href") )
                return new MP4HrefAtom();
            break;

        case 'i':
            if( ATOMID(type) == ATOMID("ipir") )
                return new MP4TrefTypeAtom( type );
            if( ATOMID(type) == ATOMID("ima4") )
                return new MP4SoundAtom( type );
            break;

        case 'j':
            if( ATOMID(type) == ATOMID("jpeg") )
                return new MP4VideoAtom("jpeg");
            break;

        case 'm':
            if( ATOMID(type) == ATOMID("mdhd") )
                return new MP4MdhdAtom();
            if( ATOMID(type) == ATOMID("mvhd") )
                return new MP4MvhdAtom();
            if( ATOMID(type) == ATOMID("mdat") )
                return new MP4MdatAtom();
            if( ATOMID(type) == ATOMID("mpod") )
                return new MP4TrefTypeAtom( type );
            if( ATOMID(type) == ATOMID("mp4a") )
                return new MP4SoundAtom( type );
            if( ATOMID(type) == ATOMID("mp4s") )
                return new MP4Mp4sAtom();
            if( ATOMID(type) == ATOMID("mp4v") )
                return new MP4Mp4vAtom();
            break;

        case 'n':
            if( ATOMID(type) == ATOMID("nmhd") )
                return new MP4NmhdAtom();
            break;

        case 'o':
            if( ATOMID(type) == ATOMID("ohdr") )
                return new MP4OhdrAtom();
            break;

        case 'p':
            if( ATOMID(type) == ATOMID("pasp") )
                return new MP4PaspAtom();
            break;

        case 'r':
            if( ATOMID(type) == ATOMID("rtp ") )
                return new MP4RtpAtom();
            if( ATOMID(type) == ATOMID("raw ") )
                return new MP4VideoAtom( type );
            break;

        case 's':
            if( ATOMID(type) == ATOMID("s263") )
                return new MP4S263Atom();
            if( ATOMID(type) == ATOMID("samr") )
                return new MP4AmrAtom( type );
            if( ATOMID(type) == ATOMID("sawb") )
                return new MP4AmrAtom( type );
            if( ATOMID(type) == ATOMID("sdtp") )
                return new MP4SdtpAtom();
            if( ATOMID(type) == ATOMID("stbl") )
                return new MP4StblAtom();
            if( ATOMID(type) == ATOMID("stsd") )
                return new MP4StsdAtom();
            if( ATOMID(type) == ATOMID("stsz") )
                return new MP4StszAtom();
            if( ATOMID(type) == ATOMID("stsc") )
                return new MP4StscAtom();
            if( ATOMID(type) == ATOMID("stz2") )
                return new MP4Stz2Atom();
            if( ATOMID(type) == ATOMID("stdp") )
                return new MP4StdpAtom();
            if( ATOMID(type) == ATOMID("sdp ") )
                return new MP4SdpAtom();
            if( ATOMID(type) == ATOMID("sync") )
                return new MP4TrefTypeAtom( type );
            if( ATOMID(type) == ATOMID("skip") )
                return new MP4FreeAtom( type );
            if (ATOMID(type) == ATOMID("sowt") )
                return new MP4SoundAtom( type );
            break;

        case 't':
            if( ATOMID(type) == ATOMID("text") )
                return new MP4TextAtom();
            if( ATOMID(type) == ATOMID("tx3g") )
                return new MP4Tx3gAtom();
            if( ATOMID(type) == ATOMID("tkhd") )
                return new MP4TkhdAtom();
            if( ATOMID(type) == ATOMID("tfhd") )
                return new MP4TfhdAtom();
            if( ATOMID(type) == ATOMID("trun") )
                return new MP4TrunAtom();
            if( ATOMID(type) == ATOMID("twos") )
                return new MP4SoundAtom( type );
            break;

        case 'u':
            if( ATOMID(type) == ATOMID("udta") )
                return new MP4UdtaAtom();
            if( ATOMID(type) == ATOMID("url ") )
                return new MP4UrlAtom();
            if( ATOMID(type) == ATOMID("urn ") )
                return new MP4UrnAtom();
            if( ATOMID(type) == ATOMID("ulaw") )
                return new MP4SoundAtom( type );
            break;

        case 'v':
            if( ATOMID(type) == ATOMID("vmhd") )
                return new MP4VmhdAtom();
            break;

        case 'y':
            if( ATOMID(type) == ATOMID("yuv2") )
                return new MP4VideoAtom( type );
            break;

        default:
            break;
    }

    // default to MP4StandardAtom implementation
    return new MP4StandardAtom( type ); 
}

///////////////////////////////////////////////////////////////////////////////

}} // namespace mp4v2::impl