///////////////////////////////////////////////////////////////////////////////
//
//  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 MP4v2.
// 
//  The Initial Developer of the Original Code is Kona Blend.
//  Portions created by Kona Blend are Copyright (C) 2008.
//  Portions created by David Byron are Copyright (C) 2011.
//  All Rights Reserved.
//
//  Contributors:
//      Kona Blend, kona8lend@@gmail.com
//      Rouven Wessling, mp4v2@rouvenwessling.de
//      David Byron, dbyron@dbyron.com
//
///////////////////////////////////////////////////////////////////////////////

#include "impl.h"

namespace mp4v2 { namespace impl { namespace itmf {

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

Tags::Tags()
    : hasMetadata(false)
{
}

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

Tags::~Tags()
{
}

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

void
Tags::c_addArtwork( MP4Tags*& tags, MP4TagArtwork& c_artwork )
{
    artwork.resize( artwork.size() + 1 );
    c_setArtwork( tags, (uint32_t)artwork.size() - 1, c_artwork );
    updateArtworkShadow( tags );
}

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

void
Tags::c_alloc( MP4Tags*& tags )
{
    tags = new MP4Tags();
    memset( tags, 0, sizeof(MP4Tags) ); // safe: pure C-struct
    tags->__handle = this;
}

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

void
Tags::c_fetch( MP4Tags*& tags, MP4FileHandle hFile )
{
    MP4Tags& c = *tags;
    MP4File& file = *static_cast<MP4File*>(hFile);

    MP4ItmfItemList* itemList = genericGetItems( file ); // alloc

    hasMetadata = (itemList->size > 0);

    /* create code -> item map.
     * map will only be used for items which do not repeat; we do not care if
     * cover-art is inserted multiple times.
     */
    CodeItemMap cim;
    for( uint32_t i = 0; i < itemList->size; i++ ) {
        MP4ItmfItem& item = itemList->elements[i];
        cim.insert( CodeItemMap::value_type( item.code, &item ));
    }

    fetchString(  cim, CODE_NAME,              name,              c.name );
    fetchString(  cim, CODE_ARTIST,            artist,            c.artist );
    fetchString(  cim, CODE_ALBUMARTIST,       albumArtist,       c.albumArtist );
    fetchString(  cim, CODE_ALBUM,             album,             c.album );
    fetchString(  cim, CODE_GROUPING,          grouping,          c.grouping );
    fetchString(  cim, CODE_COMPOSER,          composer,          c.composer );
    fetchString(  cim, CODE_COMMENTS,          comments,          c.comments );

    fetchString(  cim, CODE_GENRE,             genre,             c.genre );
    fetchGenre(   cim,                         genreType,         c.genreType );

    fetchString(  cim, CODE_RELEASEDATE,       releaseDate,       c.releaseDate );
    fetchTrack(   cim,                         track,             c.track );
    fetchDisk(    cim,                         disk,              c.disk );
    fetchInteger( cim, CODE_TEMPO,             tempo,             c.tempo );
    fetchInteger( cim, CODE_COMPILATION,       compilation,       c.compilation );

    fetchString(  cim, CODE_TVSHOW,            tvShow,            c.tvShow );
    fetchString(  cim, CODE_TVNETWORK,         tvNetwork,         c.tvNetwork );
    fetchString(  cim, CODE_TVEPISODEID,       tvEpisodeID,       c.tvEpisodeID );
    fetchInteger( cim, CODE_TVSEASON,          tvSeason,          c.tvSeason );
    fetchInteger( cim, CODE_TVEPISODE,         tvEpisode,         c.tvEpisode );

    fetchString(  cim, CODE_SORTNAME,          sortName,          c.sortName );
    fetchString(  cim, CODE_SORTARTIST,        sortArtist,        c.sortArtist );
    fetchString(  cim, CODE_SORTALBUMARTIST,   sortAlbumArtist,   c.sortAlbumArtist );
    fetchString(  cim, CODE_SORTALBUM,         sortAlbum,         c.sortAlbum );
    fetchString(  cim, CODE_SORTCOMPOSER,      sortComposer,      c.sortComposer );
    fetchString(  cim, CODE_SORTTVSHOW,        sortTVShow,        c.sortTVShow );

    fetchString(  cim, CODE_DESCRIPTION,       description,       c.description );
    fetchString(  cim, CODE_LONGDESCRIPTION,   longDescription,   c.longDescription );
    fetchString(  cim, CODE_LYRICS,            lyrics,            c.lyrics );

    fetchString(  cim, CODE_COPYRIGHT,         copyright,         c.copyright );
    fetchString(  cim, CODE_ENCODINGTOOL,      encodingTool,      c.encodingTool ); 
    fetchString(  cim, CODE_ENCODEDBY,         encodedBy,         c.encodedBy );
    fetchString(  cim, CODE_PURCHASEDATE,      purchaseDate,      c.purchaseDate );

    fetchInteger( cim, CODE_PODCAST,           podcast,           c.podcast );
    fetchString(  cim, CODE_KEYWORDS,          keywords,          c.keywords );
    fetchString(  cim, CODE_CATEGORY,          category,          c.category );

    fetchInteger( cim, CODE_HDVIDEO,           hdVideo,           c.hdVideo );
    fetchInteger( cim, CODE_MEDIATYPE,         mediaType,         c.mediaType );
    fetchInteger( cim, CODE_CONTENTRATING,     contentRating,     c.contentRating );
    fetchInteger( cim, CODE_GAPLESS,           gapless,           c.gapless );

    fetchString(  cim, CODE_ITUNESACCOUNT,     iTunesAccount,     c.iTunesAccount );
    fetchInteger( cim, CODE_ITUNESACCOUNTTYPE, iTunesAccountType, c.iTunesAccountType );
    fetchInteger( cim, CODE_ITUNESCOUNTRY,     iTunesCountry,     c.iTunesCountry );

    fetchInteger( cim, CODE_CONTENTID,         contentID,         c.contentID );
    fetchInteger( cim, CODE_ARTISTID,          artistID,          c.artistID );
    fetchInteger( cim, CODE_PLAYLISTID,        playlistID,        c.playlistID );
    fetchInteger( cim, CODE_GENREID,           genreID,           c.genreID );
    fetchInteger( cim, CODE_COMPOSERID,        composerID,        c.composerID );
    fetchString(  cim, CODE_XID,               xid,               c.xid );

    genericItemListFree( itemList ); // free

    // fetch full list and overwrite our copy, otherwise clear
    {
        CoverArtBox::ItemList items;
        if( CoverArtBox::list( hFile, items ))
            artwork.clear();
        else
            artwork = items;

        updateArtworkShadow( tags );
    }
}

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

void
Tags::c_free( MP4Tags*& tags )
{
    MP4Tags* c = const_cast<MP4Tags*>(tags);

    delete[] c->artwork;
    delete c;

    tags = NULL;
}

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

void
Tags::c_removeArtwork( MP4Tags*& tags, uint32_t index ) 
{
    if( !(index < artwork.size()) )
        return;

    artwork.erase( artwork.begin() + index );
    updateArtworkShadow( tags );
}

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

void
Tags::c_setArtwork( MP4Tags*& tags, uint32_t index, MP4TagArtwork& c_artwork )
{
    if( !(index < artwork.size()) )
        return;

    CoverArtBox::Item& item = artwork[index];

    switch( c_artwork.type ) {
        case MP4_ART_BMP:
            item.type = BT_BMP;
            break;

        case MP4_ART_GIF:
            item.type = BT_GIF;
            break;

        case MP4_ART_JPEG:
            item.type = BT_JPEG;
            break;

        case MP4_ART_PNG:
            item.type = BT_PNG;
            break;

        case MP4_ART_UNDEFINED:
        default:
            item.type = computeBasicType( c_artwork.data, c_artwork.size );
            break;
    }

    item.buffer   = (uint8_t*)malloc( c_artwork.size );
    item.size     = c_artwork.size;
    item.autofree = true;

    memcpy( item.buffer, c_artwork.data, c_artwork.size );
    updateArtworkShadow( tags );
}

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

void
Tags::c_setInteger( const uint8_t* value, uint8_t& cpp, const uint8_t*& c )
{
    if( !value ) {
        cpp = 0;
        c = NULL;
    }
    else {
        cpp = *value;
        c = &cpp;
    }
}

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

void
Tags::c_setInteger( const uint16_t* value, uint16_t& cpp, const uint16_t*& c )
{
    if( !value ) {
        cpp = 0;
        c = NULL;
    }
    else {
        cpp = *value;
        c = &cpp;
    }
}

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

void
Tags::c_setInteger( const uint32_t* value, uint32_t& cpp, const uint32_t*& c )
{
    if( !value ) {
        cpp = 0;
        c = NULL;
    }
    else {
        cpp = *value;
        c = &cpp;
    }
}

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

void
Tags::c_setInteger( const uint64_t* value, uint64_t& cpp, const uint64_t*& c )
{
    if( !value ) {
        cpp = 0;
        c = NULL;
    }
    else {
        cpp = *value;
        c = &cpp;
    }
}

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

void
Tags::c_setString( const char* value, std::string& cpp, const char*& c )
{
    if( !value ) {
        cpp.clear();
        c = NULL;
    }
    else {
        cpp = value;
        c = cpp.c_str();
    }
}

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

void
Tags::c_setTrack( const MP4TagTrack* value, MP4TagTrack& cpp, const MP4TagTrack*& c )
{
    if( !value ) {
        cpp.index = 0;
        cpp.total = 0;
        c = NULL;
    }
    else {
        cpp.index = value->index;
        cpp.total = value->total;
        c = &cpp;
    }
}

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

void
Tags::c_setDisk( const MP4TagDisk* value, MP4TagDisk& cpp, const MP4TagDisk*& c )
{
    if( !value ) {
        cpp.index = 0;
        cpp.total = 0;
        c = NULL;
    }
    else {
        cpp.index = value->index;
        cpp.total = value->total;
        c = &cpp;
    }
}

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

void
Tags::c_store( MP4Tags*& tags, MP4FileHandle hFile )
{
    MP4Tags& c = *tags;
    MP4File& file = *static_cast<MP4File*>(hFile);
   
    storeString(  file, CODE_NAME,              name,              c.name );
    storeString(  file, CODE_ARTIST,            artist,            c.artist );
    storeString(  file, CODE_ALBUMARTIST,       albumArtist,       c.albumArtist );
    storeString(  file, CODE_ALBUM,             album,             c.album );
    storeString(  file, CODE_GROUPING,          grouping,          c.grouping );
    storeString(  file, CODE_COMPOSER,          composer,          c.composer );
    storeString(  file, CODE_COMMENTS,          comments,          c.comments );

    storeString(  file, CODE_GENRE,             genre,             c.genre );
    storeGenre(   file,                         genreType,         c.genreType );

    storeString(  file, CODE_RELEASEDATE,       releaseDate,       c.releaseDate );
    storeTrack(   file,                         track,             c.track );
    storeDisk(    file,                         disk,              c.disk );
    storeInteger( file, CODE_TEMPO,             tempo,             c.tempo );
    storeInteger( file, CODE_COMPILATION,       compilation,       c.compilation );
    
    storeString(  file, CODE_TVSHOW,            tvShow,            c.tvShow );
    storeString(  file, CODE_TVNETWORK,         tvNetwork,         c.tvNetwork );
    storeString(  file, CODE_TVEPISODEID,       tvEpisodeID,       c.tvEpisodeID );
    storeInteger( file, CODE_TVSEASON,          tvSeason,          c.tvSeason );
    storeInteger( file, CODE_TVEPISODE,         tvEpisode,         c.tvEpisode );
    
    storeString(  file, CODE_SORTNAME,          sortName,          c.sortName );
    storeString(  file, CODE_SORTARTIST,        sortArtist,        c.sortArtist );
    storeString(  file, CODE_SORTALBUMARTIST,   sortAlbumArtist,   c.sortAlbumArtist );
    storeString(  file, CODE_SORTALBUM,         sortAlbum,         c.sortAlbum );
    storeString(  file, CODE_SORTCOMPOSER,      sortComposer,      c.sortComposer );
    storeString(  file, CODE_SORTTVSHOW,        sortTVShow,        c.sortTVShow );

    storeString(  file, CODE_DESCRIPTION,       description,       c.description );
    storeString(  file, CODE_LONGDESCRIPTION,   longDescription,   c.longDescription );
    storeString(  file, CODE_LYRICS,            lyrics,            c.lyrics );

    storeString(  file, CODE_COPYRIGHT,         copyright,         c.copyright );
    storeString(  file, CODE_ENCODINGTOOL,      encodingTool,      c.encodingTool );
    storeString(  file, CODE_ENCODEDBY,         encodedBy,         c.encodedBy );
    storeString(  file, CODE_PURCHASEDATE,      purchaseDate,      c.purchaseDate );

    storeInteger( file, CODE_PODCAST,           podcast,           c.podcast );
    storeString(  file, CODE_KEYWORDS,          keywords,          c.keywords );
    storeString(  file, CODE_CATEGORY,          category,          c.category );

    storeInteger( file, CODE_HDVIDEO,           hdVideo,           c.hdVideo );
    storeInteger( file, CODE_MEDIATYPE,         mediaType,         c.mediaType );
    storeInteger( file, CODE_CONTENTRATING,     contentRating,     c.contentRating );
    storeInteger( file, CODE_GAPLESS,           gapless,           c.gapless );

    storeString(  file, CODE_ITUNESACCOUNT,     iTunesAccount,     c.iTunesAccount );
    storeInteger( file, CODE_ITUNESACCOUNTTYPE, iTunesAccountType, c.iTunesAccountType );
    storeInteger( file, CODE_ITUNESCOUNTRY,     iTunesCountry,     c.iTunesCountry );

    storeInteger( file, CODE_CONTENTID,         contentID,         c.contentID );
    storeInteger( file, CODE_ARTISTID,          artistID,          c.artistID );
    storeInteger( file, CODE_PLAYLISTID,        playlistID,        c.playlistID );
    storeInteger( file, CODE_GENREID,           genreID,           c.genreID );
    storeInteger( file, CODE_COMPOSERID,        composerID,        c.composerID );
    storeString(  file, CODE_XID,               xid,               c.xid );

    // destroy all cover-art then add each
    {
        CoverArtBox::remove( hFile );
        const CoverArtBox::ItemList::size_type max = artwork.size();
        for( CoverArtBox::ItemList::size_type i = 0; i < max; i++ )
            CoverArtBox::add( hFile, artwork[i] );
    }
}

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

void
Tags::fetchGenre( const CodeItemMap& cim, uint16_t& cpp, const uint16_t*& c )
{
    cpp = 0;
    c = NULL;

    CodeItemMap::const_iterator f = cim.find( CODE_GENRETYPE );
    if( f == cim.end() || 0 == f->second->dataList.size )
        return;

    MP4ItmfData& data = f->second->dataList.elements[0];
    if( NULL == data.value )
        return;

    cpp = (uint16_t(data.value[0]) <<  8)
        | (uint16_t(data.value[1])      );

    c = &cpp;
}

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

void
Tags::fetchDisk( const CodeItemMap& cim, MP4TagDisk& cpp, const MP4TagDisk*& c )
{    
    cpp.index = 0;
    cpp.total = 0;
    c = NULL;

    CodeItemMap::const_iterator f = cim.find( CODE_DISK );
    if( f == cim.end() || 0 == f->second->dataList.size )
        return;

    MP4ItmfData& data = f->second->dataList.elements[0];

    if( NULL == data.value )
        return;

    cpp.index = (uint16_t(data.value[2]) <<  8)
              | (uint16_t(data.value[3])      );

    cpp.total = (uint16_t(data.value[4]) <<  8)
              | (uint16_t(data.value[5])      );

    c = &cpp;
}

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

void
Tags::fetchTrack( const CodeItemMap& cim, MP4TagTrack& cpp, const MP4TagTrack*& c )
{    
    cpp.index = 0;
    cpp.total = 0;
    c = NULL;

    CodeItemMap::const_iterator f = cim.find( CODE_TRACK );
    if( f == cim.end() || 0 == f->second->dataList.size )
        return;

    MP4ItmfData& data = f->second->dataList.elements[0];

    if( NULL == data.value )
        return;

    cpp.index = (uint16_t(data.value[2]) <<  8)
              | (uint16_t(data.value[3])      );

    cpp.total = (uint16_t(data.value[4]) <<  8)
              | (uint16_t(data.value[5])      );

    c = &cpp;
}

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

void
Tags::fetchInteger( const CodeItemMap& cim, const std::string& code, uint8_t& cpp, const uint8_t*& c )
{
    cpp = 0;
    c = NULL;

    CodeItemMap::const_iterator f = cim.find( code );
    if( f == cim.end() || 0 == f->second->dataList.size )
        return;

    MP4ItmfData& data = f->second->dataList.elements[0];
    if( NULL == data.value )
        return;

    cpp = data.value[0];
    c = &cpp;
}

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

void
Tags::fetchInteger( const CodeItemMap& cim, const std::string& code, uint16_t& cpp, const uint16_t*& c )
{
    cpp = 0;
    c = NULL;

    CodeItemMap::const_iterator f = cim.find( code );
    if( f == cim.end() || 0 == f->second->dataList.size )
        return;

    MP4ItmfData& data = f->second->dataList.elements[0];

    if( NULL == data.value )
        return;

    cpp = (uint16_t(data.value[0]) <<  8)
        | (uint16_t(data.value[1])      );

    c = &cpp;
}

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

void
Tags::fetchInteger( const CodeItemMap& cim, const std::string& code, uint32_t& cpp, const uint32_t*& c )
{
    cpp = 0;
    c = NULL;

    CodeItemMap::const_iterator f = cim.find( code );
    if( f == cim.end() || 0 == f->second->dataList.size )
        return;

    MP4ItmfData& data = f->second->dataList.elements[0];

    if( NULL == data.value )
        return;

    cpp = (uint32_t(data.value[0]) << 24)
        | (uint32_t(data.value[1]) << 16)
        | (uint32_t(data.value[2]) <<  8)
        | (uint32_t(data.value[3])      );

    c = &cpp;
}

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

void
Tags::fetchInteger( const CodeItemMap& cim, const std::string& code, uint64_t& cpp, const uint64_t*& c )
{
    cpp = 0;
    c = NULL;

    CodeItemMap::const_iterator f = cim.find( code );
    if( f == cim.end() || 0 == f->second->dataList.size )
        return;

    MP4ItmfData& data = f->second->dataList.elements[0];

    if( NULL == data.value )
        return;

    cpp = (uint64_t(data.value[0]) << 56)
        | (uint64_t(data.value[1]) << 48)
        | (uint64_t(data.value[2]) << 40)
        | (uint64_t(data.value[3]) << 32)
        | (uint64_t(data.value[4]) << 24)
        | (uint64_t(data.value[5]) << 16)
        | (uint64_t(data.value[6]) <<  8)
        | (uint64_t(data.value[7])      );

    c = &cpp;
}

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

void
Tags::fetchString( const CodeItemMap& cim, const std::string& code, std::string& cpp, const char*& c )
{
    cpp.clear();
    c = NULL;

    CodeItemMap::const_iterator f = cim.find( code );
    if( f == cim.end() || 0 == f->second->dataList.size )
        return;

    MP4ItmfData& data = f->second->dataList.elements[0];

    if( NULL == data.value )
        return;

    cpp.append( reinterpret_cast<char*>( data.value ), data.valueSize );
    c = cpp.c_str();
}

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

void
Tags::remove( MP4File& file, const std::string& code )
{
    MP4ItmfItemList* itemList = genericGetItemsByCode( file, code ); // alloc

    if( itemList->size )
        genericRemoveItem( file, &itemList->elements[0] );

    genericItemListFree( itemList ); // free
}

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

void
Tags::store( MP4File& file, const std::string& code, MP4ItmfBasicType basicType, const void* buffer, uint32_t size )
{
    // remove existing item
    remove( file, code );

    // add item
    MP4ItmfItem& item = *genericItemAlloc( code, 1 ); // alloc
    MP4ItmfData& data = item.dataList.elements[0];

    data.typeCode = basicType;
    data.valueSize = size;
    data.value = (uint8_t*)malloc( data.valueSize );
    memcpy( data.value, buffer, data.valueSize );

    genericAddItem( file, &item );
    genericItemFree( &item ); // free
}

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

void
Tags::storeGenre( MP4File& file, uint16_t cpp, const uint16_t* c )
{
    if( c ) {
        uint8_t buf[2];

        buf[0] = uint8_t((cpp & 0xff00) >> 8);
        buf[1] = uint8_t((cpp & 0x00ff)     );

        // it's not clear if you must use implicit in these situations and iirc iTunes and other software are not consistent in this regard.
        // many other tags must be integer type yet no issues there. Silly that iTunes insists it must be implict, which is then hardcoded 
        // to interpret as genres anyways.
        store( file, CODE_GENRETYPE, MP4_ITMF_BT_IMPLICIT, buf, sizeof(buf) );
    }
    else {
        remove( file, CODE_GENRETYPE );
    }
}

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

void
Tags::storeDisk( MP4File& file, const MP4TagDisk& cpp, const MP4TagDisk* c )
{
    if( c ) {
        uint8_t buf[6];
        memset( buf, 0, sizeof(buf) );

        buf[2] = uint8_t((cpp.index & 0xff00) >> 8);
        buf[3] = uint8_t((cpp.index & 0x00ff)     );
        buf[4] = uint8_t((cpp.total & 0xff00) >> 8);
        buf[5] = uint8_t((cpp.total & 0x00ff)     );

        store( file, CODE_DISK, MP4_ITMF_BT_IMPLICIT, buf, sizeof(buf) );
    }
    else {
        remove( file, CODE_DISK );
    }
}

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

void
Tags::storeTrack( MP4File& file, const MP4TagTrack& cpp, const MP4TagTrack* c )
{
    if( c ) {
        uint8_t buf[8]; // iTMF spec says 7 but iTunes media is 8
        memset( buf, 0, sizeof(buf) );

        buf[2] = uint8_t((cpp.index & 0xff00) >> 8);
        buf[3] = uint8_t((cpp.index & 0x00ff)     );
        buf[4] = uint8_t((cpp.total & 0xff00) >> 8);
        buf[5] = uint8_t((cpp.total & 0x00ff)     );

        store( file, CODE_TRACK, MP4_ITMF_BT_IMPLICIT, buf, sizeof(buf) );
    }
    else {
        remove( file, CODE_TRACK );
    }
}

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

void
Tags::storeInteger( MP4File& file, const std::string& code, uint8_t cpp, const uint8_t* c )
{
    if( c )
        store( file, code, MP4_ITMF_BT_INTEGER, &cpp, sizeof(cpp) );
    else
        remove( file, code );
}

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

void
Tags::storeInteger( MP4File& file, const std::string& code, uint16_t cpp, const uint16_t* c )
{
    if( c ) {
        uint8_t buf[2];

        buf[0] = uint8_t((cpp & 0xff00) >> 8);
        buf[1] = uint8_t((cpp & 0x00ff)     );

        store( file, code, MP4_ITMF_BT_INTEGER, buf, sizeof(buf) );
    }
    else {
        remove( file, code );
    }
}


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

void
Tags::storeInteger( MP4File& file, const std::string& code, uint32_t cpp, const uint32_t* c )
{
    if( c ) {
        uint8_t buf[4];

        buf[0] = uint8_t((cpp & 0xff000000) >> 24 );
        buf[1] = uint8_t((cpp & 0x00ff0000) >> 16 );
        buf[2] = uint8_t((cpp & 0x0000ff00) >>  8 );
        buf[3] = uint8_t((cpp & 0x000000ff)       );

        store( file, code, MP4_ITMF_BT_INTEGER, buf, sizeof(buf) );
    }
    else {
        remove( file, code );
    }
}

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

void
Tags::storeInteger( MP4File& file, const std::string& code, uint64_t cpp, const uint64_t* c )
{
    if( c ) {
        uint8_t buf[8];

        buf[0] = uint8_t((cpp & 0xff00000000000000LL) >> 56 );
        buf[1] = uint8_t((cpp & 0x00ff000000000000LL) >> 48 );
        buf[2] = uint8_t((cpp & 0x0000ff0000000000LL) >> 40 );
        buf[3] = uint8_t((cpp & 0x000000ff00000000LL) >> 32 );
        buf[4] = uint8_t((cpp & 0x00000000ff000000LL) >> 24 );
        buf[5] = uint8_t((cpp & 0x0000000000ff0000LL) >> 16 );
        buf[6] = uint8_t((cpp & 0x000000000000ff00LL) >>  8 );
        buf[7] = uint8_t((cpp & 0x00000000000000ffLL)       );

        store( file, code, MP4_ITMF_BT_INTEGER, buf, sizeof(buf) );
    }
    else {
        remove( file, code );
    }
}

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

void
Tags::storeString( MP4File& file, const std::string& code, const std::string& cpp, const char* c )
{
    if( c )
        store( file, code, MP4_ITMF_BT_UTF8, cpp.c_str(), (uint32_t)cpp.size() );
    else
        remove( file, code );
}

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

void
Tags::updateArtworkShadow( MP4Tags*& tags )
{
    if( tags->artwork ) {
        delete[] tags->artwork;
        tags->artwork = NULL;
        tags->artworkCount = 0;
    }

    if( artwork.empty() )
        return;

    MP4TagArtwork* const cartwork = new MP4TagArtwork[ artwork.size() ];
    uint32_t max = (uint32_t)artwork.size();

    for( uint32_t i = 0; i < max; i++ ) {
        MP4TagArtwork& a = cartwork[i];
        CoverArtBox::Item& item = artwork[i];

        a.data = item.buffer;
        a.size = item.size;

        switch( item.type ) {
            case BT_BMP:
                a.type = MP4_ART_BMP;
                break;

            case BT_GIF:
                a.type = MP4_ART_GIF;
                break;

            case BT_JPEG:
                a.type = MP4_ART_JPEG;
                break;

            case BT_PNG:
                a.type = MP4_ART_PNG;
                break;

            default:
                a.type = MP4_ART_UNDEFINED;
                break;
        }
    }

    tags->artwork      = cartwork;
    tags->artworkCount = max;
}

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

const std::string Tags::CODE_NAME              = "\xa9" "nam";
const std::string Tags::CODE_ARTIST            = "\xa9" "ART";
const std::string Tags::CODE_ALBUMARTIST       = "aART";
const std::string Tags::CODE_ALBUM             = "\xa9" "alb";
const std::string Tags::CODE_GROUPING          = "\xa9" "grp";
const std::string Tags::CODE_COMPOSER          = "\xa9" "wrt";
const std::string Tags::CODE_COMMENTS          = "\xa9" "cmt";
const std::string Tags::CODE_GENRE             = "\xa9" "gen";
const std::string Tags::CODE_GENRETYPE         = "gnre";
const std::string Tags::CODE_RELEASEDATE       = "\xa9" "day";
const std::string Tags::CODE_TRACK             = "trkn";
const std::string Tags::CODE_DISK              = "disk";
const std::string Tags::CODE_TEMPO             = "tmpo";
const std::string Tags::CODE_COMPILATION       = "cpil";

const std::string Tags::CODE_TVSHOW            = "tvsh";
const std::string Tags::CODE_TVNETWORK         = "tvnn";
const std::string Tags::CODE_TVEPISODEID       = "tven";
const std::string Tags::CODE_TVSEASON          = "tvsn";
const std::string Tags::CODE_TVEPISODE         = "tves";

const std::string Tags::CODE_DESCRIPTION       = "desc";
const std::string Tags::CODE_LONGDESCRIPTION   = "ldes";
const std::string Tags::CODE_LYRICS            = "\xa9" "lyr";

const std::string Tags::CODE_SORTNAME          = "sonm";
const std::string Tags::CODE_SORTARTIST        = "soar";
const std::string Tags::CODE_SORTALBUMARTIST   = "soaa";
const std::string Tags::CODE_SORTALBUM         = "soal";
const std::string Tags::CODE_SORTCOMPOSER      = "soco";
const std::string Tags::CODE_SORTTVSHOW        = "sosn";

const std::string Tags::CODE_COPYRIGHT         = "cprt";
const std::string Tags::CODE_ENCODINGTOOL      = "\xa9" "too";
const std::string Tags::CODE_ENCODEDBY         = "\xa9" "enc";
const std::string Tags::CODE_PURCHASEDATE      = "purd";

const std::string Tags::CODE_PODCAST           = "pcst";
const std::string Tags::CODE_KEYWORDS          = "keyw";
const std::string Tags::CODE_CATEGORY          = "catg";

const std::string Tags::CODE_HDVIDEO           = "hdvd";
const std::string Tags::CODE_MEDIATYPE         = "stik";
const std::string Tags::CODE_CONTENTRATING     = "rtng";
const std::string Tags::CODE_GAPLESS           = "pgap";

const std::string Tags::CODE_ITUNESACCOUNT     = "apID";
const std::string Tags::CODE_ITUNESACCOUNTTYPE = "akID";
const std::string Tags::CODE_ITUNESCOUNTRY     = "sfID";
const std::string Tags::CODE_CONTENTID         = "cnID";
const std::string Tags::CODE_ARTISTID          = "atID";
const std::string Tags::CODE_PLAYLISTID        = "plID";
const std::string Tags::CODE_GENREID           = "geID";
const std::string Tags::CODE_COMPOSERID        = "cmID";
const std::string Tags::CODE_XID               = "xid ";

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

}}} // namespace mp4v2::impl::itmf