CreateESD(            pEsProperty,            201,                // esid            MP4SystemsV2ObjectType,            MP4SceneDescriptionStreamType,            numBytes,            // bufferSize            numBytes * 8,        // bitrate            BifsV2Config,            sizeof(BifsV2Config),            urlBuf);    MP4Free(sceneCmdBase64);    sceneCmdBase64 = NULL;    MP4Free(urlBuf);    urlBuf = NULL;    MP4Free(pBytes);    pBytes = NULL;    // OD        // Video    MP4DescriptorProperty* pVideoEsdProperty =        new MP4DescriptorProperty();    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();    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;    VERBOSE_ISMA(GetVerbosity(),        printf("OD data = "U64" bytes\n", numBytes); MP4HexDump(pBytes, numBytes));    char* odCmdBase64 = MP4ToBase64(pBytes, numBytes);    urlBuf = (char*)MP4Malloc(strlen(odCmdBase64) + 64);    sprintf(urlBuf,         "data:application/mpeg4-od-au;base64,%s",        odCmdBase64);    VERBOSE_ISMA(GetVerbosity(),        printf("OD data URL = \042%s\042\n", urlBuf));    /* MP4Descriptor* pOdEsd = */        CreateESD(            pEsProperty,            101,            MP4SystemsV1ObjectType,            MP4ObjectDescriptionStreamType,            numBytes,        // bufferSize            numBytes * 8,    // bitrate            NULL,            // config            0,                // configLength            urlBuf);    MP4Free(odCmdBase64);    odCmdBase64 = NULL;    MP4Free(pBytes);    pBytes = NULL;    MP4Free(urlBuf);    urlBuf = NULL;    // finally get the whole thing written to a memory     pIod->WriteToMemory(this, ppIodBytes, pIodNumBytes);    delete pIod;    VERBOSE_ISMA(GetVerbosity(),        printf("IOD data =\n"); MP4HexDump(*ppIodBytes, *pIodNumBytes));}MP4Descriptor* MP4File::CreateESD(    MP4DescriptorProperty* pEsProperty,    u_int32_t esid,    u_int8_t objectType,    u_int8_t streamType,    u_int32_t bufferSize,    u_int32_t bitrate,    const u_int8_t* pConfig,    u_int32_t configLength,    char* url){    MP4IntegerProperty* pInt;    MP4StringProperty* pString;    MP4BytesProperty* pBytes;    MP4BitfieldProperty* pBits;    MP4Descriptor* pEsd =        pEsProperty->AddDescriptor(MP4ESDescrTag);    pEsd->Generate();    pEsd->FindProperty("ESID",         (MP4Property**)&pInt);    pInt->SetValue(esid);    pEsd->FindProperty("decConfigDescr.objectTypeId",         (MP4Property**)&pInt);    pInt->SetValue(objectType);    pEsd->FindProperty("decConfigDescr.streamType",         (MP4Property**)&pInt);    pInt->SetValue(streamType);    pEsd->FindProperty("decConfigDescr.bufferSizeDB",         (MP4Property**)&pInt);    pInt->SetValue(bufferSize);    pEsd->FindProperty("decConfigDescr.maxBitrate",         (MP4Property**)&pInt);    pInt->SetValue(bitrate);    pEsd->FindProperty("decConfigDescr.avgBitrate",         (MP4Property**)&pInt);    pInt->SetValue(bitrate);        MP4DescriptorProperty* pConfigDescrProperty;    pEsd->FindProperty("decConfigDescr.decSpecificInfo",        (MP4Property**)&pConfigDescrProperty);    MP4Descriptor* pConfigDescr =        pConfigDescrProperty->AddDescriptor(MP4DecSpecificDescrTag);    pConfigDescr->Generate();    pConfigDescrProperty->FindProperty("decSpecificInfo[0].info",        (MP4Property**)&pBytes);    pBytes->SetValue(pConfig, configLength);    pEsd->FindProperty("slConfigDescr.predefined",         (MP4Property**)&pInt);    // changed 12/5/02 from plugfest to value 0    pInt->SetValue(0);    pEsd->FindProperty("slConfig.useAccessUnitEndFlag",               (MP4Property **)&pBits);    pBits->SetValue(1);    if (url) {        pEsd->FindProperty("URLFlag",             (MP4Property**)&pInt);        pInt->SetValue(1);        pEsd->FindProperty("URL",             (MP4Property**)&pString);        pString->SetValue(url);    }    return pEsd;}void MP4File::CreateIsmaODUpdateCommandFromFileForFile(    MP4TrackId odTrackId,    MP4TrackId audioTrackId,     MP4TrackId videoTrackId,    u_int8_t** ppBytes,    u_int64_t* pNumBytes){    MP4Descriptor* pCommand = CreateODCommand(MP4ODUpdateODCommandTag);    pCommand->Generate();    for (u_int8_t i = 0; i < 2; i++) {        MP4TrackId trackId;        u_int16_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;        pOd->FindProperty("objectDescriptorId",             (MP4Property**)&pOdIdProperty);        pOdIdProperty->SetValue(odId);        MP4DescriptorProperty* pEsIdsDescriptorProperty = NULL;        pOd->FindProperty("esIds",             (MP4Property**)&pEsIdsDescriptorProperty);        ASSERT(pEsIdsDescriptorProperty);        pEsIdsDescriptorProperty->SetTags(MP4ESIDRefDescrTag);        MP4Descriptor *pRefDescriptor =            pEsIdsDescriptorProperty->AddDescriptor(MP4ESIDRefDescrTag);        pRefDescriptor->Generate();        MP4Integer16Property* pRefIndexProperty = NULL;        pRefDescriptor->FindProperty("refIndex",             (MP4Property**)&pRefIndexProperty);        ASSERT(pRefIndexProperty);        u_int32_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,    u_int8_t** ppBytes,    u_int64_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        pAudioEsd->FindProperty("ESID",                     (MP4Property**)&pAudioEsdId);        ASSERT(pAudioEsdId);        pAudioEsdId->SetValue(audioTrackId);        // SL config needs to change from 2 (file) to 1 (null)        pAudioEsd->FindProperty("slConfigDescr.predefined",             (MP4Property**)&pAudioSLConfigPredef);        ASSERT(pAudioSLConfigPredef);        pAudioSLConfigPredef->SetValue(0);        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));        pVideoEsd->FindProperty("ESID",                     (MP4Property**)&pVideoEsdId);        ASSERT(pVideoEsdId);        pVideoEsdId->SetValue(videoTrackId);        // SL config needs to change from 2 (file) to 1 (null)        pVideoEsd->FindProperty("slConfigDescr.predefined",             (MP4Property**)&pVideoSLConfigPredef);        ASSERT(pVideoSLConfigPredef);        pVideoSLConfigPredef->SetValue(0);        pVideoEsd->FindProperty("slConfigDescr.useAccessUnitEndFlag",                    (MP4Property **)&pVideoAccessUnitEndFlag);        oldVideoUnitEndFlagValue =           pVideoAccessUnitEndFlag->GetValue();        pVideoAccessUnitEndFlag->SetValue(1);    }    CreateIsmaODUpdateCommandForStream(        pAudioEsd, pVideoEsd, ppBytes, pNumBytes);    VERBOSE_ISMA(GetVerbosity(),        printf("After CreateImsaODUpdateCommandForStream len "U64" =\n", *pNumBytes); MP4HexDump(*ppBytes, *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,    u_int8_t** ppBytes,    u_int64_t* pNumBytes){    MP4Descriptor* pAudioOd = NULL;    MP4Descriptor* pVideoOd = NULL;    MP4Descriptor* pCommand =         CreateODCommand(MP4ODUpdateODCommandTag);    pCommand->Generate();    for (u_int8_t i = 0; i < 2; i++) {        u_int16_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;        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,    u_int8_t** ppBytes,    u_int64_t* pNumBytes){    // from ISMA 1.0 Tech Spec Appendix E    static const u_int8_t bifsAudioOnly[] = {        0xC0, 0x10, 0x12,         0x81, 0x30, 0x2A, 0x05, 0x6D, 0xC0    };    static const u_int8_t bifsVideoOnly[] = {        0xC0, 0x10, 0x12,         0x61, 0x04,             0x1F, 0xC0, 0x00, 0x00,             0x1F, 0xC0, 0x00, 0x00,        0x44, 0x28, 0x22, 0x82, 0x9F, 0x80    };    static const u_int8_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 = (u_int8_t*)MP4Malloc(*pNumBytes);        memcpy(*ppBytes, bifsAudioVideo, sizeof(bifsAudioVideo));    } else if (hasAudio) {        *pNumBytes = sizeof(bifsAudioOnly);        *ppBytes = (u_int8_t*)MP4Malloc(*pNumBytes);        memcpy(*ppBytes, bifsAudioOnly, sizeof(bifsAudioOnly));    } else if (hasVideo) {        *pNumBytes = sizeof(bifsVideoOnly);        *ppBytes = (u_int8_t*)MP4Malloc(*pNumBytes);        memcpy(*ppBytes, bifsVideoOnly, sizeof(bifsVideoOnly));    } else {        *pNumBytes = 0;        *ppBytes = NULL;    }}