/*
 * 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.
 *
 * Contributor(s):
 *      Dave Mackie       dmackie@cisco.com
 *              Alix Marchandise-Franquet alix@cisco.com
 *              Ximpo Group Ltd.                mp4v2@ximpo.com
 */

#include "src/impl.h"

namespace mp4v2 {
namespace impl {

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

static const uint8_t BifsV2Config[3] = {
    0x00, 0x00, 0x60 // IsCommandStream = 1, PixelMetric = 1
};

void MP4File::MakeIsmaCompliant(bool addIsmaComplianceSdp)
{
    ProtectWriteOperation(__FILE__, __LINE__, __FUNCTION__);

    if (m_useIsma) {
        // already done
        return;
    }

    // find first audio and/or video tracks

    MP4TrackId audioTrackId = MP4_INVALID_TRACK_ID;
    try {
        audioTrackId = FindTrackId(0, MP4_AUDIO_TRACK_TYPE);
    }
    catch ( Exception *x ) {
        log.errorf(*x);
        delete x;
    }
    MP4TrackId videoTrackId = MP4_INVALID_TRACK_ID;
    try {
        videoTrackId = FindTrackId(0, MP4_VIDEO_TRACK_TYPE);
    }
    catch (Exception* x) {
        log.errorf(*x);
        delete x;
    }
    if (audioTrackId == MP4_INVALID_TRACK_ID &&
            videoTrackId == MP4_INVALID_TRACK_ID) return;

    const char *audio_media_data_name, *video_media_data_name;
    uint8_t videoProfile = 0xff;
    if (audioTrackId != MP4_INVALID_TRACK_ID) {
        audio_media_data_name = MP4GetTrackMediaDataName(this, audioTrackId);
        if (!(ATOMID(audio_media_data_name) == ATOMID("mp4a") ||
                ATOMID(audio_media_data_name) == ATOMID("enca"))) {
            log.errorf("%s: \"%s\": can't make ISMA compliant when file contains an %s track", 
                       __FUNCTION__, GetFilename().c_str(), audio_media_data_name);
            return;
        }
    }
    //
    // Note - might have to check for avc1 here...
    if (videoTrackId != MP4_INVALID_TRACK_ID) {
        video_media_data_name = MP4GetTrackMediaDataName(this, videoTrackId);
        if (!(ATOMID(video_media_data_name) == ATOMID("mp4v") ||
                ATOMID(video_media_data_name) == ATOMID("encv"))) {
            log.errorf("%s: \"%s\": can't make ISMA compliant when file contains an %s track", __FUNCTION__, 
                       GetFilename().c_str(), video_media_data_name);
            return;
        }
        MP4LogLevel verb = log.verbosity;
        log.setVerbosity(MP4_LOG_NONE);
        videoProfile = MP4GetVideoProfileLevel(this, videoTrackId);
        log.setVerbosity(verb);
    }

    m_useIsma = true;

    uint64_t fileMsDuration = 0;
    fileMsDuration =
        ConvertFromMovieDuration(GetDuration(), MP4_MSECS_TIME_SCALE);

    // delete any existing OD track
    if (m_odTrackId != MP4_INVALID_TRACK_ID) {
        DeleteTrack(m_odTrackId);
    }

    if (m_pRootAtom->FindAtom("moov.iods") == NULL) {
        (void)AddChildAtom("moov", "iods");
    }
    (void)AddODTrack();
    SetODProfileLevel(0xFF);

    if (audioTrackId != MP4_INVALID_TRACK_ID) {
        AddTrackToOd(audioTrackId);
        MP4SetAudioProfileLevel(this, 0xf);
    }
    if (videoTrackId != MP4_INVALID_TRACK_ID) {
        AddTrackToOd(videoTrackId);
        MP4SetVideoProfileLevel(this, videoProfile);
    }

    // delete any existing scene track
    MP4TrackId sceneTrackId = MP4_INVALID_TRACK_ID;
    try {
        sceneTrackId = FindTrackId(0, MP4_SCENE_TRACK_TYPE);
    }
    catch (Exception *x) {
        log.errorf(*x);
        delete x;
    }
    if (sceneTrackId != MP4_INVALID_TRACK_ID) {
        DeleteTrack(sceneTrackId);
    }

    // add scene track
    sceneTrackId = AddSceneTrack();
    SetSceneProfileLevel(0xFF);
    SetGraphicsProfileLevel(0xFF);
    SetTrackIntegerProperty(sceneTrackId,
                            "mdia.minf.stbl.stsd.mp4s.esds.decConfigDescr.objectTypeId",
                            MP4SystemsV2ObjectType);

    SetTrackESConfiguration(sceneTrackId,
                            BifsV2Config, sizeof(BifsV2Config));

    uint8_t* pBytes = NULL;
    uint64_t numBytes = 0;

    // write OD Update Command
    CreateIsmaODUpdateCommandFromFileForFile(
        m_odTrackId,
        audioTrackId,
        videoTrackId,
        &pBytes,
        &numBytes);

    WriteSample(m_odTrackId, pBytes, numBytes, fileMsDuration);

    MP4Free(pBytes);
    pBytes = NULL;

    // write BIFS Scene Replace Command
    CreateIsmaSceneCommand(
        MP4_IS_VALID_TRACK_ID(audioTrackId),
        MP4_IS_VALID_TRACK_ID(videoTrackId),
        &pBytes,
        &numBytes);

    WriteSample(sceneTrackId, pBytes, numBytes, fileMsDuration);

    MP4Free(pBytes);
    pBytes = NULL;

    // add session level sdp
    CreateIsmaIodFromFile(
        m_odTrackId,
        sceneTrackId,
        audioTrackId,
        videoTrackId,
        &pBytes,
        &numBytes);

    char* iodBase64 = MP4ToBase64(pBytes, numBytes);

    uint32_t sdpBufLen = (uint32_t)strlen(iodBase64) + 256;
    uint32_t used;
    char* sdpBuf = (char*)MP4Calloc(sdpBufLen);

    if (addIsmaComplianceSdp) {
        strncpy(sdpBuf, "a=isma-compliance:1,1.0,1\015\012", sdpBufLen);
    }

    used = (uint32_t)strlen(sdpBuf);
    sdpBufLen -= used;
    snprintf(&sdpBuf[used], sdpBufLen,
             "a=mpeg4-iod: \042data:application/mpeg4-iod;base64,%s\042\015\012",
             iodBase64);

    SetSessionSdp(sdpBuf);

    log.verbose1f("\"%s\": IOD SDP = %s", GetFilename().c_str(), sdpBuf);

    MP4Free(iodBase64);
    iodBase64 = NULL;
    MP4Free(pBytes);
    pBytes = NULL;
    MP4Free(sdpBuf);
    sdpBuf = NULL;
}

static void CloneIntegerProperty(
    MP4Descriptor* pDest,
    MP4DescriptorProperty* pSrc,
    const char* name)
{
    MP4IntegerProperty* pGetProperty;
    MP4IntegerProperty* pSetProperty;

    if (!pSrc->FindProperty(name, (MP4Property**)&pGetProperty)) return;
    if (!pDest->FindProperty(name, (MP4Property**)&pSetProperty)) return;
    pSetProperty->SetValue(pGetProperty->GetValue());
}

void MP4File::CreateIsmaIodFromFile(
    MP4TrackId odTrackId,
    MP4TrackId sceneTrackId,
    MP4TrackId audioTrackId,
    MP4TrackId videoTrackId,
    uint8_t** ppBytes,
    uint64_t* pNumBytes)
{
    MP4Atom* pIodsAtom = FindAtom("moov.iods");
    ASSERT(pIodsAtom);
    MP4DescriptorProperty* pSrcIod =
        (MP4DescriptorProperty*)pIodsAtom->GetProperty(2);

    MP4Descriptor* pIod = new MP4IODescriptor(*pIodsAtom);
    pIod->SetTag(MP4IODescrTag);
    pIod->Generate();

    CloneIntegerProperty(pIod, pSrcIod, "objectDescriptorId");
    CloneIntegerProperty(pIod, pSrcIod, "ODProfileLevelId");
    CloneIntegerProperty(pIod, pSrcIod, "sceneProfileLevelId");
    CloneIntegerProperty(pIod, pSrcIod, "audioProfileLevelId");
    CloneIntegerProperty(pIod, pSrcIod, "visualProfileLevelId");
    CloneIntegerProperty(pIod, pSrcIod, "graphicsProfileLevelId");

    // mutate esIds from MP4ESIDIncDescrTag to MP4ESDescrTag
    MP4DescriptorProperty* pEsProperty;
    if (!pIod->FindProperty("esIds", (MP4Property**)&pEsProperty)) return;
    pEsProperty->SetTags(MP4ESDescrTag);

    MP4IntegerProperty* pSetProperty;
    MP4IntegerProperty* pSceneESID;
    MP4IntegerProperty* pOdESID;

    // OD
    MP4Descriptor* pOdEsd =
        pEsProperty->AddDescriptor(MP4ESDescrTag);
    pOdEsd->Generate();

    if (!pOdEsd->FindProperty("ESID", (MP4Property**)&pOdESID)) return;

    // we set the OD ESID to a non-zero unique value
    pOdESID->SetValue(m_odTrackId);

    if (pOdEsd->FindProperty("URLFlag",
                             (MP4Property**)&pSetProperty))
        pSetProperty->SetValue(1);

    uint8_t* pBytes;
    uint64_t numBytes;

    CreateIsmaODUpdateCommandFromFileForStream(
        audioTrackId,
        videoTrackId,
        &pBytes,
        &numBytes);

    log.hexDump(0, MP4_LOG_VERBOSE1, pBytes, numBytes, "\"%s\": OD data",
                GetFilename().c_str() );

    char* odCmdBase64 = MP4ToBase64(pBytes, numBytes);

    uint32_t urlBufLen = (uint32_t)strlen(odCmdBase64) + 64;
    char* urlBuf = (char*)MP4Malloc(urlBufLen);

    snprintf(urlBuf, urlBufLen,
             "data:application/mpeg4-od-au;base64,%s",
             odCmdBase64);

    MP4StringProperty* pUrlProperty;
    if (pOdEsd->FindProperty("URL",
                             (MP4Property**)&pUrlProperty))
        pUrlProperty->SetValue(urlBuf);

    log.verbose1f("\"%s\": OD data URL = \042%s\042", GetFilename().c_str(),
                  urlBuf);

    MP4Free(odCmdBase64);
    odCmdBase64 = NULL;
    MP4Free(pBytes);
    pBytes = NULL;
    MP4Free(urlBuf);
    urlBuf = NULL;

    MP4DescriptorProperty* pSrcDcd = NULL;

    // HACK temporarily point to scene decoder config
    (void)FindProperty(MakeTrackName(odTrackId,
                                     "mdia.minf.stbl.stsd.mp4s.esds.decConfigDescr"),
                       (MP4Property**)&pSrcDcd);
    ASSERT(pSrcDcd);
    MP4Property* pOrgOdEsdProperty =
        pOdEsd->GetProperty(8);
    pOdEsd->SetProperty(8, pSrcDcd);

    // bufferSizeDB needs to be set appropriately
    MP4BitfieldProperty* pBufferSizeProperty = NULL;
    if (pOdEsd->FindProperty("decConfigDescr.bufferSizeDB",
                             (MP4Property**)&pBufferSizeProperty)) {
        ASSERT(pBufferSizeProperty);
        pBufferSizeProperty->SetValue(numBytes);
    }

    // SL config needs to change from 2 (file) to 1 (null)
    if (pOdEsd->FindProperty("slConfigDescr.predefined",
                             (MP4Property**)&pSetProperty))
        pSetProperty->SetValue(1);


    // Scene
    MP4Descriptor* pSceneEsd =
        pEsProperty->AddDescriptor(MP4ESDescrTag);
    pSceneEsd->Generate();

    if (pSceneEsd->FindProperty("ESID",
                                (MP4Property**)&pSceneESID)) {
        // we set the Scene ESID to a non-zero unique value
        pSceneESID->SetValue(sceneTrackId);
    }

    if (pSceneEsd->FindProperty("URLFlag",
                                (MP4Property**)&pSetProperty))
        pSetProperty->SetValue(1);

    CreateIsmaSceneCommand(
        MP4_IS_VALID_TRACK_ID(audioTrackId),
        MP4_IS_VALID_TRACK_ID(videoTrackId),
        &pBytes,
        &numBytes);

    log.hexDump(0, MP4_LOG_VERBOSE1, pBytes, numBytes, "\"%s\": Scene data",
                GetFilename().c_str() );

    char *sceneCmdBase64 = MP4ToBase64(pBytes, numBytes);

    urlBuf = (char*)MP4Malloc(strlen(sceneCmdBase64) + 64);
    snprintf(urlBuf, strlen(sceneCmdBase64) + 64,
             "data:application/mpeg4-bifs-au;base64,%s",
             sceneCmdBase64);

    if (pSceneEsd->FindProperty("URL",
                                (MP4Property**)&pUrlProperty))
        pUrlProperty->SetValue(urlBuf);

    log.verbose1f("\"%s\": Scene data URL = \042%s\042",
                  GetFilename().c_str(), urlBuf);

    MP4Free(sceneCmdBase64);
    sceneCmdBase64 = NULL;
    MP4Free(urlBuf);
    urlBuf = NULL;
    MP4Free(pBytes);
    pBytes = NULL;

    // HACK temporarily point to scene decoder config
    ASSERT(FindProperty(MakeTrackName(sceneTrackId,
                                      "mdia.minf.stbl.stsd.mp4s.esds.decConfigDescr"),
                        (MP4Property**)&pSrcDcd));
    ASSERT(pSrcDcd);
    MP4Property* pOrgSceneEsdProperty =
        pSceneEsd->GetProperty(8);
    pSceneEsd->SetProperty(8, pSrcDcd);

    // bufferSizeDB needs to be set
    pBufferSizeProperty = NULL;
    if (pSceneEsd->FindProperty("decConfigDescr.bufferSizeDB",
                                (MP4Property**)&pBufferSizeProperty)) {
        ASSERT(pBufferSizeProperty);
        pBufferSizeProperty->SetValue(numBytes);
    }

    // SL config needs to change from 2 (file) to 1 (null)
    if (pSceneEsd->FindProperty("slConfigDescr.predefined",
                                (MP4Property**)&pSetProperty))
        pSetProperty->SetValue(1);


    // finally get the whole thing written to a memory
    pIod->WriteToMemory(*this, ppBytes, pNumBytes);


    // now carefully replace esd properties before destroying
    pOdEsd->SetProperty(8, pOrgOdEsdProperty);
    pSceneEsd->SetProperty(8, pOrgSceneEsdProperty);
    pSceneESID->SetValue(0); // restore 0 value
    pOdESID->SetValue(0);

    delete pIod;

    log.hexDump(0, MP4_LOG_VERBOSE1, *ppBytes, *pNumBytes, "\"%s\": IOD data",
                GetFilename().c_str() );
}

void MP4File::CreateIsmaIodFromParams(
    uint8_t videoProfile,
    uint32_t videoBitrate,
    uint8_t* videoConfig,
    uint32_t videoConfigLength,
    uint8_t audioProfile,
    uint32_t audioBitrate,
    uint8_t* audioConfig,
    uint32_t audioConfigLength,
    uint8_t** ppIodBytes,
    uint64_t* pIodNumBytes)
{
    MP4IntegerProperty* pInt;
    uint8_t* pBytes = NULL;
    uint64_t numBytes;

    // Descriptor constructors need a parent atom.  In this
    // case we don't have one so create a dummy one.  This
    // is OK as we only build the descriptor and then dump
    // its contents to a buffer
    MP4Atom     dummyParent(*this);

    // Create the IOD
    MP4Descriptor* pIod = new MP4IODescriptor(dummyParent);
    pIod->SetTag(MP4IODescrTag);
    pIod->Generate();

    // Set audio and video profileLevels
    if (pIod->FindProperty("audioProfileLevelId",
                           (MP4Property**)&pInt))
        pInt->SetValue(audioProfile);

    if (pIod->FindProperty("visualProfileLevelId",
                           (MP4Property**)&pInt))
        pInt->SetValue(videoProfile);

    // Mutate esIds from MP4ESIDIncDescrTag to MP4ESDescrTag
    MP4DescriptorProperty* pEsProperty;
    if (!pIod->FindProperty("esIds", (MP4Property**)&pEsProperty)) return;
    pEsProperty->SetTags(MP4ESDescrTag);

    // Add ES Descriptors

    // Scene
    CreateIsmaSceneCommand(
        (audioProfile != 0xFF),
        (videoProfile != 0xFF),
        &pBytes,
        &numBytes);

    log.hexDump(0, MP4_LOG_VERBOSE1, pBytes, numBytes, "\"%s\": Scene data",
                GetFilename().c_str() );

    char* sceneCmdBase64 = MP4ToBase64(pBytes, numBytes);

    char* urlBuf =
        (char*)MP4Malloc(strlen(sceneCmdBase64) + 64);
    snprintf(urlBuf, strlen(sceneCmdBase64) + 64,
             "data:application/mpeg4-bifs-au;base64,%s",
             sceneCmdBase64);

    log.verbose1f("\"%s\": Scene data URL = \042%s\042", GetFilename().c_str(),
                  urlBuf);

    /* MP4Descriptor* pSceneEsd = */
    CreateESD(
        pEsProperty,
        201,                // esid
        MP4SystemsV2ObjectType,
        MP4SceneDescriptionStreamType,
        numBytes,           // bufferSize
        numBytes * 8,       // bitrate
        BifsV2Config,
        sizeof(BifsV2Config),
        urlBuf);
    MP4Free(urlBuf);
    urlBuf = NULL;

    MP4Free(sceneCmdBase64);
    sceneCmdBase64 = NULL;
    MP4Free(pBytes);
    pBytes = NULL;

    // OD

    // Video
    MP4DescriptorProperty* pVideoEsdProperty =
        new MP4DescriptorProperty(dummyParent);
    pVideoEsdProperty->SetTags(MP4ESDescrTag);

    /* MP4Descriptor* pVideoEsd = */
    CreateESD(
        pVideoEsdProperty,
        20,                 // esid
        MP4_MPEG4_VIDEO_TYPE,
        MP4VisualStreamType,
        videoBitrate / 8,   // bufferSize
        videoBitrate,
        videoConfig,
        videoConfigLength,
        NULL);

    // Audio
    MP4DescriptorProperty* pAudioEsdProperty =
        new MP4DescriptorProperty(dummyParent);
    pAudioEsdProperty->SetTags(MP4ESDescrTag);

    /* MP4Descriptor* pAudioEsd = */
    CreateESD(
        pAudioEsdProperty,
        10,                 // esid
        MP4_MPEG4_AUDIO_TYPE,
        MP4AudioStreamType,
        audioBitrate / 8,   // bufferSize
        audioBitrate,
        audioConfig,
        audioConfigLength,
        NULL);

    CreateIsmaODUpdateCommandForStream(
        pAudioEsdProperty,
        pVideoEsdProperty,
        &pBytes,
        &numBytes);

    // cleanup temporary descriptor properties
    delete pAudioEsdProperty;
    delete pVideoEsdProperty;

    log.hexDump(0, MP4_LOG_VERBOSE1,pBytes, numBytes,"\"%s\": OD data = %" PRIu64 " bytes",
                GetFilename().c_str(), numBytes);

    char* odCmdBase64 = MP4ToBase64(pBytes, numBytes);

    urlBuf = (char*)MP4Malloc(strlen(odCmdBase64) + 64);
    if (urlBuf != NULL) {
        snprintf(urlBuf, strlen(odCmdBase64) + 64,
                 "data:application/mpeg4-od-au;base64,%s",
                 odCmdBase64);

        log.verbose1f("\"%s\": OD data URL = \042%s\042", GetFilename().c_str(), urlBuf);

        /* MP4Descriptor* pOdEsd = */
        CreateESD(
            pEsProperty,
            101,
            MP4SystemsV1ObjectType,
            MP4ObjectDescriptionStreamType,
            numBytes,       // bufferSize
            numBytes * 8,   // bitrate
            NULL,           // config
            0,              // configLength
            urlBuf);

        MP4Free(urlBuf);
        urlBuf = NULL;
    }
    MP4Free(odCmdBase64);
    odCmdBase64 = NULL;
    MP4Free(pBytes);
    pBytes = NULL;

    // finally get the whole thing written to a memory
    pIod->WriteToMemory(*this, ppIodBytes, pIodNumBytes);

    delete pIod;

    log.hexDump(0, MP4_LOG_VERBOSE1, *ppIodBytes, *pIodNumBytes,"\"%s\": IOD data",
                GetFilename().c_str() );
}

void MP4File::CreateESD(
    MP4DescriptorProperty* pEsProperty,
    uint32_t esid,
    uint8_t objectType,
    uint8_t streamType,
    uint32_t bufferSize,
    uint32_t bitrate,
    const uint8_t* pConfig,
    uint32_t configLength,
    char* url)
{
    MP4IntegerProperty* pInt;
    MP4StringProperty* pString;
    MP4BytesProperty* pBytes;
    MP4BitfieldProperty* pBits;

    MP4Descriptor* pEsd =
        pEsProperty->AddDescriptor(MP4ESDescrTag);
    pEsd->Generate();

    if (pEsd->FindProperty("ESID",
                           (MP4Property**)&pInt))
        pInt->SetValue(esid);

    if (pEsd->FindProperty("decConfigDescr.objectTypeId",
                           (MP4Property**)&pInt))
        pInt->SetValue(objectType);

    if (pEsd->FindProperty("decConfigDescr.streamType",
                           (MP4Property**)&pInt))
        pInt->SetValue(streamType);

    if (pEsd->FindProperty("decConfigDescr.bufferSizeDB",
                           (MP4Property**)&pInt))
        pInt->SetValue(bufferSize);

    if (pEsd->FindProperty("decConfigDescr.maxBitrate",
                           (MP4Property**)&pInt))
        pInt->SetValue(bitrate);

    if (pEsd->FindProperty("decConfigDescr.avgBitrate",
                           (MP4Property**)&pInt))
        pInt->SetValue(bitrate);

    MP4DescriptorProperty* pConfigDescrProperty;
    if (pEsd->FindProperty("decConfigDescr.decSpecificInfo",
                           (MP4Property**)&pConfigDescrProperty)) {

        MP4Descriptor* pConfigDescr =
            pConfigDescrProperty->AddDescriptor(MP4DecSpecificDescrTag);
        pConfigDescr->Generate();

        if (pConfigDescrProperty->FindProperty("decSpecificInfo[0].info",
                                               (MP4Property**)&pBytes))
            pBytes->SetValue(pConfig, configLength);
    }

    if (pEsd->FindProperty("slConfigDescr.predefined",
                           (MP4Property**)&pInt))
        // changed 12/5/02 from plugfest to value 0
        pInt->SetValue(0);

    if (pEsd->FindProperty("slConfig.useAccessUnitEndFlag",
                           (MP4Property **)&pBits))
        pBits->SetValue(1);

    if (url) {
        if (pEsd->FindProperty("URLFlag",
                               (MP4Property**)&pInt))
            pInt->SetValue(1);

        if (pEsd->FindProperty("URL",
                               (MP4Property**)&pString))
            pString->SetValue(url);
    }

    //return pEsd;
}

void MP4File::CreateIsmaODUpdateCommandFromFileForFile(
    MP4TrackId odTrackId,
    MP4TrackId audioTrackId,
    MP4TrackId videoTrackId,
    uint8_t** ppBytes,
    uint64_t* pNumBytes)
{
    // Descriptor constructors need a parent atom.  In this
    // case we don't have one so create a dummy one.  This
    // is OK as we only build the descriptor and then dump
    // its contents to a buffer
    MP4Atom     dummyParent(*this);
    MP4Descriptor* pCommand = CreateODCommand(dummyParent, MP4ODUpdateODCommandTag);
    pCommand->Generate();

    for (uint8_t i = 0; i < 2; i++) {
        MP4TrackId trackId;
        uint16_t odId;

        if (i == 0) {
            trackId = audioTrackId;
            odId = 10;
        } else {
            trackId = videoTrackId;
            odId = 20;
        }

        if (trackId == MP4_INVALID_TRACK_ID) {
            continue;
        }

        MP4DescriptorProperty* pOdDescrProperty =
            (MP4DescriptorProperty*)(pCommand->GetProperty(0));

        pOdDescrProperty->SetTags(MP4FileODescrTag);

        MP4Descriptor* pOd =
            pOdDescrProperty->AddDescriptor(MP4FileODescrTag);

        pOd->Generate();

        MP4BitfieldProperty* pOdIdProperty = NULL;
        if (pOd->FindProperty("objectDescriptorId",
                              (MP4Property**)&pOdIdProperty))
            pOdIdProperty->SetValue(odId);

        MP4DescriptorProperty* pEsIdsDescriptorProperty = NULL;
        ASSERT(pOd->FindProperty("esIds",
                                 (MP4Property**)&pEsIdsDescriptorProperty));
        ASSERT(pEsIdsDescriptorProperty);

        pEsIdsDescriptorProperty->SetTags(MP4ESIDRefDescrTag);

        MP4Descriptor *pRefDescriptor =
            pEsIdsDescriptorProperty->AddDescriptor(MP4ESIDRefDescrTag);
        pRefDescriptor->Generate();

        MP4Integer16Property* pRefIndexProperty = NULL;
        ASSERT(pRefDescriptor->FindProperty("refIndex",
                                            (MP4Property**)&pRefIndexProperty));
        ASSERT(pRefIndexProperty);

        uint32_t mpodIndex = FindTrackReference(
                                 MakeTrackName(odTrackId, "tref.mpod"), trackId);
        ASSERT(mpodIndex != 0);

        pRefIndexProperty->SetValue(mpodIndex);
    }

    pCommand->WriteToMemory(*this, ppBytes, pNumBytes);

    delete pCommand;
}

void MP4File::CreateIsmaODUpdateCommandFromFileForStream(
    MP4TrackId audioTrackId,
    MP4TrackId videoTrackId,
    uint8_t** ppBytes,
    uint64_t* pNumBytes)
{
    MP4DescriptorProperty* pAudioEsd = NULL;
    MP4Integer8Property* pAudioSLConfigPredef = NULL;
    MP4BitfieldProperty* pAudioAccessUnitEndFlag = NULL;
    int oldAudioUnitEndFlagValue = 0;
    MP4DescriptorProperty* pVideoEsd = NULL;
    MP4Integer8Property* pVideoSLConfigPredef = NULL;
    MP4BitfieldProperty* pVideoAccessUnitEndFlag = NULL;
    int oldVideoUnitEndFlagValue = 0;
    MP4IntegerProperty* pAudioEsdId = NULL;
    MP4IntegerProperty* pVideoEsdId = NULL;

    if (audioTrackId != MP4_INVALID_TRACK_ID) {
        // changed mp4a to * to handle enca case
        MP4Atom* pEsdsAtom =
            FindAtom(MakeTrackName(audioTrackId,
                                   "mdia.minf.stbl.stsd.*.esds"));
        ASSERT(pEsdsAtom);

        pAudioEsd = (MP4DescriptorProperty*)(pEsdsAtom->GetProperty(2));
        // ESID is 0 for file, stream needs to be non-ze
        ASSERT(pAudioEsd->FindProperty("ESID",
                                       (MP4Property**)&pAudioEsdId));

        ASSERT(pAudioEsdId);
        pAudioEsdId->SetValue(audioTrackId);

        // SL config needs to change from 2 (file) to 1 (null)
        if (pAudioEsd->FindProperty("slConfigDescr.predefined",
                                    (MP4Property**)&pAudioSLConfigPredef)) {
            ASSERT(pAudioSLConfigPredef);
            pAudioSLConfigPredef->SetValue(0);
        }

        if (pAudioEsd->FindProperty("slConfigDescr.useAccessUnitEndFlag",
                                    (MP4Property **)&pAudioAccessUnitEndFlag)) {
            oldAudioUnitEndFlagValue =
                pAudioAccessUnitEndFlag->GetValue();
            pAudioAccessUnitEndFlag->SetValue(1);
        }
    }

    if (videoTrackId != MP4_INVALID_TRACK_ID) {
        // changed mp4v to * to handle encv case
        MP4Atom* pEsdsAtom =
            FindAtom(MakeTrackName(videoTrackId,
                                   "mdia.minf.stbl.stsd.*.esds"));
        ASSERT(pEsdsAtom);

        pVideoEsd = (MP4DescriptorProperty*)(pEsdsAtom->GetProperty(2));
        ASSERT(pVideoEsd->FindProperty("ESID",
                                       (MP4Property**)&pVideoEsdId));

        ASSERT(pVideoEsdId);
        pVideoEsdId->SetValue(videoTrackId);

        // SL config needs to change from 2 (file) to 1 (null)
        ASSERT(pVideoEsd->FindProperty("slConfigDescr.predefined",
                                       (MP4Property **)&pVideoSLConfigPredef));
        ASSERT(pVideoSLConfigPredef);
        pVideoSLConfigPredef->SetValue(0);

        if (pVideoEsd->FindProperty("slConfigDescr.useAccessUnitEndFlag",
                                    (MP4Property **)&pVideoAccessUnitEndFlag)) {
            oldVideoUnitEndFlagValue =
                pVideoAccessUnitEndFlag->GetValue();
            pVideoAccessUnitEndFlag->SetValue(1);
        }
    }

    CreateIsmaODUpdateCommandForStream(
        pAudioEsd, pVideoEsd, ppBytes, pNumBytes);
    log.hexDump(0, MP4_LOG_VERBOSE1, *ppBytes, *pNumBytes,
                "\"%s\": After CreateImsaODUpdateCommandForStream len %" PRIu64,
                GetFilename().c_str(), *pNumBytes);

    // return SL config values to 2 (file)
    // return ESID values to 0
    if (pAudioSLConfigPredef) {
        pAudioSLConfigPredef->SetValue(2);
    }
    if (pAudioEsdId) {
        pAudioEsdId->SetValue(0);
    }
    if (pAudioAccessUnitEndFlag) {
        pAudioAccessUnitEndFlag->SetValue(oldAudioUnitEndFlagValue );
    }
    if (pVideoEsdId) {
        pVideoEsdId->SetValue(0);
    }
    if (pVideoSLConfigPredef) {
        pVideoSLConfigPredef->SetValue(2);
    }
    if (pVideoAccessUnitEndFlag) {
        pVideoAccessUnitEndFlag->SetValue(oldVideoUnitEndFlagValue );
    }
}

void MP4File::CreateIsmaODUpdateCommandForStream(
    MP4DescriptorProperty* pAudioEsdProperty,
    MP4DescriptorProperty* pVideoEsdProperty,
    uint8_t** ppBytes,
    uint64_t* pNumBytes)
{
    MP4Descriptor* pAudioOd = NULL;
    MP4Descriptor* pVideoOd = NULL;

    // Descriptor constructors need a parent atom.  In this
    // case we don't have one so create a dummy one.  This
    // is OK as we only build the descriptor and then dump
    // its contents to a buffer
    MP4Atom     dummyParent(*this);
    MP4Descriptor* pCommand =
        CreateODCommand(dummyParent, MP4ODUpdateODCommandTag);
    pCommand->Generate();

    for (uint8_t i = 0; i < 2; i++) {
        uint16_t odId;
        MP4DescriptorProperty* pEsdProperty = NULL;

        if (i == 0) {
            odId = 10;
            pEsdProperty = pAudioEsdProperty;
        } else {
            odId = 20;
            pEsdProperty = pVideoEsdProperty;
        }

        if (pEsdProperty == NULL) {
            continue;
        }

        MP4DescriptorProperty* pOdDescrProperty =
            (MP4DescriptorProperty*)(pCommand->GetProperty(0));

        pOdDescrProperty->SetTags(MP4ODescrTag);

        MP4Descriptor* pOd =
            pOdDescrProperty->AddDescriptor(MP4ODescrTag);
        pOd->Generate();

        if (i == 0) {
            pAudioOd = pOd;
        } else {
            pVideoOd = pOd;
        }

        MP4BitfieldProperty* pOdIdProperty = NULL;
        if (pOd->FindProperty("objectDescriptorId",
                              (MP4Property**)&pOdIdProperty)) {
            pOdIdProperty->SetValue(odId);
        }

        delete (MP4DescriptorProperty*)pOd->GetProperty(4);
        pOd->SetProperty(4, pEsdProperty);
    }

    // serialize OD command
    pCommand->WriteToMemory(*this, ppBytes, pNumBytes);

    // detach from esd descriptor params
    if (pAudioOd) {
        pAudioOd->SetProperty(4, NULL);
    }
    if (pVideoOd) {
        pVideoOd->SetProperty(4, NULL);
    }

    // then destroy
    delete pCommand;
}

void MP4File::CreateIsmaSceneCommand(
    bool hasAudio,
    bool hasVideo,
    uint8_t** ppBytes,
    uint64_t* pNumBytes)
{
    // from ISMA 1.0 Tech Spec Appendix E
    static const uint8_t bifsAudioOnly[] = {
        0xC0, 0x10, 0x12,
        0x81, 0x30, 0x2A, 0x05, 0x6D, 0xC0
    };
    static const uint8_t bifsVideoOnly[] = {
        0xC0, 0x10, 0x12,
        0x61, 0x04,
        0x1F, 0xC0, 0x00, 0x00,
        0x1F, 0xC0, 0x00, 0x00,
        0x44, 0x28, 0x22, 0x82, 0x9F, 0x80
    };
    static const uint8_t bifsAudioVideo[] = {
        0xC0, 0x10, 0x12,
        0x81, 0x30, 0x2A, 0x05, 0x6D, 0x26,
        0x10, 0x41, 0xFC, 0x00, 0x00, 0x01, 0xFC, 0x00, 0x00,
        0x04, 0x42, 0x82, 0x28, 0x29, 0xF8
    };

    if (hasAudio && hasVideo) {
        *pNumBytes = sizeof(bifsAudioVideo);
        *ppBytes = (uint8_t*)MP4Malloc(*pNumBytes);
        memcpy(*ppBytes, bifsAudioVideo, sizeof(bifsAudioVideo));

    } else if (hasAudio) {
        *pNumBytes = sizeof(bifsAudioOnly);
        *ppBytes = (uint8_t*)MP4Malloc(*pNumBytes);
        memcpy(*ppBytes, bifsAudioOnly, sizeof(bifsAudioOnly));

    } else if (hasVideo) {
        *pNumBytes = sizeof(bifsVideoOnly);
        *ppBytes = (uint8_t*)MP4Malloc(*pNumBytes);
        memcpy(*ppBytes, bifsVideoOnly, sizeof(bifsVideoOnly));
    } else {
        *pNumBytes = 0;
        *ppBytes = NULL;
    }
}

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

}
} // namespace mp4v2::impl