isma.cpp

完整的RTP RTSP代码库

	  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;
	}
}