rmasfdemux.cpp

Sigma SMP8634 Mrua v. 2.8.2.0

/*****************************************
 Copyright © 2001-2003	
 Sigma Designs, Inc. All Rights Reserved
 Proprietary and Confidential
 *****************************************/

#define ALLOW_OS_CODE 1
#include "../include/rmasfdemux.h"

#include "../include/wmdrm.h"
#include "../include/wmdrmopl.h"


extern "C" {
#include "../../asf_demux_push/include/asf_demux.h"
}

#include "../../rmlibcw/include/rmfile.h"

#if 1
  #define ASFDEMUXDBG ENABLE
#else
  #define ASFDEMUXDBG DISABLE
#endif

#if 0
  #define CALLBACKHOOKDBG ENABLE
#else
  #define CALLBACKHOOKDBG DISABLE
#endif

#if 0
  #define CALLBACKDBG ENABLE
#else
  #define CALLBACKDBG DISABLE
#endif


#if 0
  #define TRICKMODEDBG ENABLE
#else
  #define TRICKMODEDBG DISABLE
#endif

#if 1
  #define LOCALDBG ENABLE
#else
  #define LOCALDBG DISABLE
#endif

#if 0
  #define API_DBG ENABLE
#else
  #define API_DBG DISABLE
#endif


RMasfdemux::RMasfdemux ()
	: RMobject ("RMasfdemuxmodule")
{
	unsigned long sizeof_internalstate = asf_demux_state_t_getsize();
	m_asf_demux_state = RMMalloc(sizeof_internalstate*sizeof(RMuint8));
	m_appspecobjcb = 0;
	m_filepropcb = 0;
	m_streambitratepropcb = 0;
	m_videostreampropcb = 0;
	m_audiostreampropcb = 0;
	m_bitratemutexcb = 0;
	m_drmcb = 0;
	m_extdrmcb = 0;
	m_payloadextcb = 0;
	m_signaturecb = 0;
	m_languagecb = 0;
	m_extstreampropcb = 0;
	m_payloadcb = 0;
	m_indexentrycb = 0;
	m_aspectratiocb =0;
	m_isIndexConstructed = FALSE;
	m_packetSize = 0;
	m_header_Object_Size = 0;	
	m_context = NULL;
	m_localContext = (void*)this;
	RMDBGLOG((ENABLE, "demux local context @0x%08X\n", m_localContext));
	m_activeCallbacks = 0;
	m_registeredCallbacks = 0;
	m_localIndex = FALSE;
	m_isThereAnIndex = FALSE;

	m_drmError = 0;
	m_encryptedContent = FALSE;
	m_DRMPreventsPlayback = FALSE;

	m_initentrynum = FALSE;
	m_trickModeDirection = 0;
	m_followingIFramePacket = 0;
	m_followingIFramePacketSize = 0;

	m_preroll = 0;
	m_duration = 0;
	m_lastIFrame = 0;
	m_videoStreamFound = FALSE;
	m_audioStreamFound = FALSE;
	m_isAudioOnly = FALSE;
	m_isFileSeekable = FALSE;
	m_fileSize = 0;
	m_audioBYTERate = 0;
	m_packetCount = 0;
	m_realFileSize = 0;
	m_Broadcast = FALSE;
}

RMasfdemux::~RMasfdemux ()
{
	RMuint32 i;

	// Terminate Windows Media Digital Rights Management
	if (m_encryptedContent == TRUE) {
		RMDBGLOG((ENABLE, "closing WMDRM\n"));
		WMDRM_term();
	}

	if(m_asf_demux_state) 
		RMFree(m_asf_demux_state);

	for (i=0;i<m_numberOfIndex;i++){
		if(m_simpleIndex[i].entry != (typeSimpleIndexEntry*)NULL) {
			RMFree(m_simpleIndex[i].entry);
		}
	}

	if(m_index.specifier != (typeIndexSpecifier *)NULL)
		RMFree(m_index.specifier);

	if(m_index.block != (typedIndexBlock*)NULL) {
		for(i=0;i<m_index.block_count;i++){
			if(m_index.block[i].position != (RMuint64*)NULL)
				RMFree(m_index.block[i].position);
			
			if(m_index.block[i].offset != (RMuint32**)NULL) {
				RMuint8 j;
				for(j=0;i<m_index.block[i].entry_count;j++){
					if(m_index.block[i].offset[j] != (RMuint32*)NULL){
						RMFree(m_index.block[i].offset[j]);
					}
				}
				
				RMFree(m_index.block[i].offset);
			}
		}
		RMFree(m_index.block);
	}

}

void RMasfdemux::SetCallbacks(
			      RMasfdemuxApplicationSpecificObjectCallback appspecobjcb,
			      RMasfdemuxFilePropertiesCallback filepropcb,
			      RMasfdemuxStreamBitratePropertiesCallback streambitratepropcb,
			      RMasfdemuxVideoStreamPropertiesCallback videostreampropcb,
			      RMasfdemuxAudioStreamPropertiesCallback audiostreampropcb,
			      RMasfdemuxBitrateMutualExclusionCallback bitratemutexcb,
			      RMasfdemuxContentEncryptionCallback drmcb,
			      RMasfdemuxExtendedContentEncryptionCallback extdrmcb,
			      RMasfdemuxPayloadExtensionSystemCallback payloadextcb,
			      RMasfdemuxDigitalSignatureCallback signaturecb,
			      RMasfdemuxLanguageListCallback languagecb,
			      RMasfdemuxExtendedStreamPropertiesCallback extstreampropcb,
			      RMasfdemuxPayloadCallback payloadcb,
			      RMasfdemuxSimpleIndexEntryCallback simpleindexentrycb,
			      RMasfdemuxIndexEntryCallback indexentrycb,
			      RMasfdemuxAspectRatioCallback aspectratiocb)

{
	RMDBGLOG((ENABLE, "registering application's callbacks with rmasfdemux:\n"));

	if (appspecobjcb) {
		RMDBGLOG((LOCALDBG, "\tApplicationSpecificObject\n"));
		m_registeredCallbacks |= APP_SPEC_OBJ_CB;
	}

	if (filepropcb) {
		RMDBGLOG((LOCALDBG, "\tFileProperties\n"));
		m_registeredCallbacks |= FILE_PROP_CB;
	}

	if (streambitratepropcb) {
		RMDBGLOG((LOCALDBG, "\tStreamBitrateProperties\n"));
		m_registeredCallbacks |= STREAM_BITRATE_PROP_CB;
	}

	if (videostreampropcb) {
		RMDBGLOG((LOCALDBG, "\tVideoStreamProperties\n"));
		m_registeredCallbacks |= VIDEO_PROP_CB;
	}

	if (audiostreampropcb) {
		RMDBGLOG((LOCALDBG, "\tAudioStreamProperties\n"));
		m_registeredCallbacks |= AUDIO_PROP_CB;
	}

	if (bitratemutexcb) {
		RMDBGLOG((LOCALDBG, "\tBitrateMutualExclusion\n"));
		m_registeredCallbacks |= BITRATE_MUTEX_CB;
	}

	if (drmcb) {
		RMDBGLOG((LOCALDBG, "\tContentEncryption\n"));
		m_registeredCallbacks |= DRM_CB;
	}
	else {
		RMDBGLOG((LOCALDBG, "\tNO ContentEncryption, using default handler to support DRM'ed files\n"));
		drmcb = drmLOCALcb;
		m_registeredCallbacks |= DRM_CB;
	}

	if (extdrmcb) {
		RMDBGLOG((LOCALDBG, "\tExtendedContentEncryption\n"));
		m_registeredCallbacks |= EXT_DRM_CB;
	}
	else {
		RMDBGLOG((LOCALDBG, "\tNO ExtendedContentEncryption, using default handler to support DRM'ed files\n"));
		extdrmcb = extContentEncryptionLOCALcb;
		m_registeredCallbacks |= EXT_DRM_CB;
	}

	if (payloadextcb) {
		RMDBGLOG((LOCALDBG, "\tPayloadExtensionSystem\n"));
		m_registeredCallbacks |= PAYLOAD_EXT_CB;
	}

	if (signaturecb) {
		RMDBGLOG((LOCALDBG, "\tDigitalSignature\n"));
		m_registeredCallbacks |= DIGITAL_SIGNATURE_CB;
	}

	if (languagecb) {
		RMDBGLOG((LOCALDBG, "\tLanguageList\n"));
		m_registeredCallbacks |= LANG_LIST_CB;
	}

	if (extstreampropcb) {
		RMDBGLOG((LOCALDBG, "\tExtendedStreamProperties\n"));
		m_registeredCallbacks |= EXT_PROP_CB;
	}

	if (payloadcb) {
		RMDBGLOG((LOCALDBG, "\tPayload\n"));
		m_registeredCallbacks |= PAYLOAD_CB;
	}

	if (simpleindexentrycb) {
		RMDBGLOG((LOCALDBG, "\tSimpleIndexEntry\n"));
		m_registeredCallbacks |= SIMPLE_INDEX_CB;
	}
	else {
		RMDBGLOG((LOCALDBG, "\tNO SimpleIndexEntry, using default handler to support seeking\n"));
		simpleindexentrycb = simpleIndexLOCALcb;
		m_registeredCallbacks |= SIMPLE_INDEX_CB;
	}

	if (indexentrycb) {
		RMDBGLOG((LOCALDBG, "\tIndexEntry\n"));
		m_registeredCallbacks |= INDEX_CB;
	}
	else {
		RMDBGLOG((LOCALDBG, "\tNO IndexEntry, using default handler to support seeking\n"));
		indexentrycb = indexLOCALcb;
		m_registeredCallbacks |= INDEX_CB;
	}

	if (aspectratiocb) {
		RMDBGLOG((LOCALDBG, "\tAspectRatio\n"));
		m_registeredCallbacks |= ASPECT_RATIO_CB;
	}

	RMDBGLOG((ENABLE, ">>> Registered Callbacks Mask 0x%08X\n", m_registeredCallbacks));

	m_appspecobjcb = appspecobjcb;
	m_filepropcb = filepropcb;
	m_streambitratepropcb = streambitratepropcb;
	m_videostreampropcb = videostreampropcb;
	m_audiostreampropcb = audiostreampropcb;
	m_bitratemutexcb = bitratemutexcb;
	m_drmcb = drmcb;
	m_extdrmcb = extdrmcb;
	m_payloadextcb = payloadextcb;
	m_signaturecb = signaturecb;
	m_languagecb = languagecb;
	m_extstreampropcb = extstreampropcb;
	m_payloadcb = payloadcb;
	m_indexentrycb = indexentrycb;
	m_simpleindexentrycb = simpleindexentrycb;
	m_aspectratiocb = aspectratiocb;

	RegisterCallbacks();

	

	
}

void RMasfdemux::RegisterCallbacks()
{
	
	if(m_asf_demux_state) {

		RMDBGLOG((ENABLE, "registering local callbacks with core parser...\n"));
		
		asf_demux_register_callbacks ((struct asf_demux_state_t *)m_asf_demux_state,
					      appSpecObjLOCALcb,
					      filepropLOCALcb,
					      streamBitratePropLOCALcb,
					      videopropLOCALcb,
					      audiopropLOCALcb,
					      bitrateMutualExclusionLOCALcb,
					      drmLOCALcb,
					      extContentEncryptionLOCALcb,
					      payloadExtensionLOCALcb,
					      digitalSignatureLOCALcb,
					      languagelistLOCALcb,
					      extpropLOCALcb,
					      payloadLOCALcb,
					      simpleIndexLOCALcb,
					      indexLOCALcb,
					      aspectRatioLOCALcb);
		// enable all registered callbacks
		ActivateCallbacks(m_registeredCallbacks);


	}
}

void RMasfdemux::ActivateCallbacks(RMuint32 mask)
{

	RMDBGLOG((ENABLE, "Activate Callbacks: mask %08lX, new mask %08lX, actived callbacks:\n", m_activeCallbacks, mask));
	MaskToCallbackName(mask);

	m_activeCallbacks = mask;

}

void RMasfdemux::DeactivateCallbacks(RMuint32 mask)
{
	RMuint32 temp = m_activeCallbacks & (~mask);
	
	RMDBGLOG((ENABLE, "Deactivate Callbacks: mask %08lX, new mask %08lX, deactivated callbacks:\n", m_activeCallbacks, temp));
	MaskToCallbackName(mask);

	m_activeCallbacks = temp;

}

void RMasfdemux::MaskToCallbackName(RMuint32 mask)
{

	if (mask & APP_SPEC_OBJ_CB) {
		RMDBGLOG((LOCALDBG, "\tApplicationSpecificObject\n"));
	}

	if (mask & FILE_PROP_CB) {
		RMDBGLOG((LOCALDBG, "\tFileProperties\n"));
	}

	if (mask & STREAM_BITRATE_PROP_CB) {
		RMDBGLOG((LOCALDBG, "\tStreamBitrateProperties\n"));
	}

	if (mask & VIDEO_PROP_CB) {
		RMDBGLOG((LOCALDBG, "\tVideoStreamProperties\n"));
	}

	if (mask & AUDIO_PROP_CB) {
		RMDBGLOG((LOCALDBG, "\tAudioStreamProperties\n"));
	}

	if (mask & BITRATE_MUTEX_CB) {
		RMDBGLOG((LOCALDBG, "\tBitrateMutualExclusion\n"));
	}

	if (mask & DRM_CB) {
		if (m_drmcb != drmLOCALcb)
			RMDBGLOG((LOCALDBG, "\tContentEncryption\n"));
		else
			RMDBGLOG((LOCALDBG, "\tContentEncryption (local to demux)\n"));
	}

	if (mask & EXT_DRM_CB) {
		if (m_extdrmcb != extContentEncryptionLOCALcb)
			RMDBGLOG((LOCALDBG, "\tExtendedContentEncryption\n"));
		else
			RMDBGLOG((LOCALDBG, "\tExtendedContentEncryption (local to demux)\n"));
	}

	if (mask & PAYLOAD_EXT_CB) {
		RMDBGLOG((LOCALDBG, "\tPayloadExtensionSystem\n"));
	}

	if (mask & DIGITAL_SIGNATURE_CB) {
		RMDBGLOG((LOCALDBG, "\tDigitalSignature\n"));
	}

	if (mask & LANG_LIST_CB) {
		RMDBGLOG((LOCALDBG, "\tLanguageList\n"));
	}

	if (mask & EXT_PROP_CB) {
		RMDBGLOG((LOCALDBG, "\tExtendedStreamProperties\n"));
	}

	if (mask & PAYLOAD_CB) {
		RMDBGLOG((LOCALDBG, "\tPayload\n"));
	}

	if (mask & SIMPLE_INDEX_CB) {
		if (m_simpleindexentrycb != simpleIndexLOCALcb)
			RMDBGLOG((LOCALDBG, "\tSimpleIndexEntry\n"));
		else
			RMDBGLOG((LOCALDBG, "\tSimpleIndexEntry (local to demux)\n"));
	}

	if (mask & INDEX_CB) {
		if (m_indexentrycb != indexLOCALcb)
			RMDBGLOG((LOCALDBG, "\tIndexEntry\n"));
		else
			RMDBGLOG((LOCALDBG, "\tIndexEntry (local to demux)\n"));
	}

	if (mask & ASPECT_RATIO_CB) {