ref: 7915c0a21037e53b0d65b4a0da200836b6939032
dir: /common/mp4v2/isma.cpp/
/*
* 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 "mp4common.h"
static const u_int8_t BifsV2Config[3] = {
0x00, 0x00, 0x60 // IsCommandStream = 1, PixelMetric = 1
};
void MP4File::MakeIsmaCompliant(bool addIsmaComplianceSdp)
{
ProtectWriteOperation("MP4MakeIsmaCompliant");
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 (MP4Error* e) {
delete e;
}
MP4TrackId videoTrackId = MP4_INVALID_TRACK_ID;
try {
videoTrackId = FindTrackId(0, MP4_VIDEO_TRACK_TYPE);
}
catch (MP4Error* e) {
delete e;
}
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"))) {
VERBOSE_ERROR(m_verbosity,
printf("MakeIsmaCompliant:can't make ISMA compliant when file contains an %s track\n", 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"))) {
VERBOSE_ERROR(m_verbosity,
printf("MakeIsmaCompliant:can't make ISMA compliant when file contains an %s track\n", video_media_data_name);
);
return;
}
uint32_t verb = GetVerbosity();
SetVerbosity(verb & ~MP4_DETAILS_ERROR);
videoProfile = MP4GetVideoProfileLevel(this, videoTrackId);
SetVerbosity(verb);
}
m_useIsma = true;
u_int64_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 (MP4Error *e) {
delete e;
}
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));
u_int8_t* pBytes = NULL;
u_int64_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);
uint sdpBufLen = strlen(iodBase64) + 256;
uint used;
char* sdpBuf = (char*)MP4Calloc(sdpBufLen);
if (addIsmaComplianceSdp) {
strncpy(sdpBuf, "a=isma-compliance:1,1.0,1\015\012", sdpBufLen);
}
used = strlen(sdpBuf);
sdpBufLen -= used;
snprintf(&sdpBuf[used], sdpBufLen,
"a=mpeg4-iod: \042data:application/mpeg4-iod;base64,%s\042\015\012",
iodBase64);
SetSessionSdp(sdpBuf);
VERBOSE_ISMA(GetVerbosity(),
printf("IOD SDP = %s\n", 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,
u_int8_t** ppBytes,
u_int64_t* pNumBytes)
{
MP4Descriptor* pIod = new MP4IODescriptor();
pIod->SetTag(MP4IODescrTag);
pIod->Generate();
MP4Atom* pIodsAtom = FindAtom("moov.iods");
ASSERT(pIodsAtom);
MP4DescriptorProperty* pSrcIod =
(MP4DescriptorProperty*)pIodsAtom->GetProperty(2);
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);
u_int8_t* pBytes;
u_int64_t numBytes;
CreateIsmaODUpdateCommandFromFileForStream(
audioTrackId,
videoTrackId,
&pBytes,
&numBytes);
VERBOSE_ISMA(GetVerbosity(),
printf("OD data =\n"); MP4HexDump(pBytes, numBytes));
char* odCmdBase64 = MP4ToBase64(pBytes, numBytes);
uint urlBufLen = 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);
VERBOSE_ISMA(GetVerbosity(),
printf("OD data URL = \042%s\042\n", 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);
VERBOSE_ISMA(GetVerbosity(),
printf("Scene data =\n"); MP4HexDump(pBytes, numBytes));
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);
VERBOSE_ISMA(GetVerbosity(),
printf("Scene data URL = \042%s\042\n", 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;
VERBOSE_ISMA(GetVerbosity(),
printf("IOD data =\n"); MP4HexDump(*ppBytes, *pNumBytes));
}
void MP4File::CreateIsmaIodFromParams(
u_int8_t videoProfile,
u_int32_t videoBitrate,
u_int8_t* videoConfig,
u_int32_t videoConfigLength,
u_int8_t audioProfile,
u_int32_t audioBitrate,
u_int8_t* audioConfig,
u_int32_t audioConfigLength,
u_int8_t** ppIodBytes,
u_int64_t* pIodNumBytes)
{
MP4IntegerProperty* pInt;
u_int8_t* pBytes = NULL;
u_int64_t numBytes;
// Create the IOD
MP4Descriptor* pIod = new MP4IODescriptor();
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);
VERBOSE_ISMA(GetVerbosity(),
printf("Scene data =\n"); MP4HexDump(pBytes, numBytes));
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);
VERBOSE_ISMA(GetVerbosity(),
printf("Scene data URL = \042%s\042\n", 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();
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);
if (urlBuf != NULL) {
snprintf(urlBuf, strlen(odCmdBase64) + 64,
"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(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;
VERBOSE_ISMA(GetVerbosity(),
printf("IOD data =\n"); MP4HexDump(*ppIodBytes, *pIodNumBytes));
}
void 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();
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,
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;
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);
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
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);
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;
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,
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;
}
}