em86xx.cpp.svn-base

sigmadesign smp8623 gui source code ,bingo

//
//	if(m_pAsvBufferPool != 0){
//		status = RUAClosePool(m_pAsvBufferPool);
//		m_pAsvBufferPool = NULL;
//		if (status != RM_OK) {
//			RMDBGLOG((ENABLE, "Error closing asv DMA pool: %s\n", RMstatusToString(status)));
//		}
//	}
//
//	m_initialized = FALSE;
//	m_audioFormat.audioType = CURACAO_AUDIO_UNKNOWN;
//
//	RMDBGLOG((QBDBG, "*********************************** Em86xx decoder : finish Close *********************************** \n"));
//	return status;
//}

RMstatus RMem86xxDecoder::ResetDCCLeaveDisplay() {
	RMstatus status = RM_OK;
/*
	if(m_pDCC != NULL){
		DCCClose(m_pDCC);
		m_pDCC = NULL;
	}

	status = DCCOpen(m_pInstance, &m_pDCC);
	if (status != RM_OK) {
		RMDBGLOG((ENABLE, "!!!!! Error Opening DCC : %s !!!!!\n", RMstatusToString(status)));
		CleanallAndExit();
		return status;
	}
*/
	status = DCCInitMicroCodeEx(m_pDCC, DCCInitMode_LeaveDisplay);
	if (status != RM_OK) {
		RMDBGLOG((ENABLE, "Cannot initialize microcode %s\n", RMstatusToString(status)));
		return status;
	}

	return status;
}

//RMstatus RMem86xxDecoder::CloseDecoder()
//{
//	RMstatus status = RM_OK;
//	RMDBGLOG((QBDBG, "*********************************** Em86xx decoder : CloseDecoder *********************************** \n"));
//
//	// CC
//	if (m_CC.UncachedAddress != 0)
//	{
//		RMuint32 nCCFifoID = EMHWLIB_MODULE(CCFifo, 0);
//
//		while ((status = RUASetProperty(m_pInstance, nCCFifoID, RMCCFifoPropertyID_Clear, NULL, 0, 0)) == RM_PENDING);
//		if (RMFAILED(status)) {
//			RMDBGLOG((ENABLE, "Cannot clear CCFifo %s\n", RMstatusToString(status)));
//		}
//
//		while ((status = RUASetProperty(m_pInstance, nCCFifoID, RMCCFifoPropertyID_Close, NULL, 0, 0)) == RM_PENDING);
//		if (RMFAILED(status)) {
//			RMDBGLOG((ENABLE, "Cannot close CCFifo %s\n", RMstatusToString(status)));
//		}
//
//		RUAFree(m_pInstance, m_CC.UncachedAddress);
//
//		if(RMSUCCEEDED(status)) {
//			m_CC.UncachedAddress = 0;
//		}
//	}
//
//	if(m_pVideoSource != 0){
//		status = DCCCloseVideoSource(m_pVideoSource);
//		if(status != RM_OK){
//			RMDBGLOG((ENABLE, "!!!!! Error closing video source - %s!!!!!\n", RMstatusToString(status)));
//		}
//		m_pVideoSource = NULL;
//	}
//
//	if(m_pAudioSource != 0){
//		status = DCCCloseAudioSource(m_pAudioSource);
//		if(status != RM_OK){
//			RMDBGLOG((ENABLE, "!!!!! Error closing audio source - %s!!!!!\n", RMstatusToString(status)));
//		}
//		m_pAudioSource = NULL;
//	}
//
//	if(m_pDemuxSource != NULL){
//		status = DCCCloseDemuxSource(m_pDemuxSource);
//		if (RMFAILED(status)) {
//			RMDBGLOG((ENABLE, "!!!!! Error closing demux source - %s!!!!!\n", RMstatusToString(status)));
//		}
//		m_pDemuxSource = NULL;
//	}
//
//#ifndef NO_STC
//	if (m_pStcSource) {
//		status = DCCSTCClose(m_pStcSource);
//		if (RMFAILED(status)) {
//			RMDBGLOG((ENABLE, "!!!!! Error closing STC - %s!!!!!\n", RMstatusToString(status)));
//		}
//		m_pStcSource = NULL;
//	}
//#endif
//
//	RMDBGLOG((QBDBG, "*********************************** Em86xx decoder : finish CloseDecoder *********************************** \n"));
//	return status;
//}

RMstatus RMem86xxDecoder::SetDecodingVideoStream(RMuint16 StreamID)
{
	struct DemuxProgram_ProgramParameters_type ProgrParam;
	RMstatus status = RM_OK;

	RUAGetProperty(m_pInstance, m_hw_demux_program0, RMDemuxProgramPropertyID_ProgramParameters,
		       &ProgrParam, sizeof(ProgrParam));

	if ( ProgrParam.VideoSID != StreamID ) {
		ProgrParam.VideoSID = StreamID;
		if(m_pDemuxSource != NULL){
			status = DCCPauseDemuxSource(m_pDemuxSource);
			RUASetProperty(m_pInstance, m_hw_demux_program0, RMDemuxProgramPropertyID_ProgramParameters,
				&ProgrParam, sizeof(ProgrParam), 0);

			status = DCCPlayDemuxSource(m_pDemuxSource);
			if(status != RM_OK){
				RMDBGLOG((ENABLE, "!!!!!! Error DCCDemuxVideoSource - %s !!!!!!\n", RMstatusToString(status)));
				CleanallAndExit();
			}
		}
	}

	return status;
}

RMstatus RMem86xxDecoder::SetDecodingAudioStream(RMuint8 StreamID, RMuint8 SubStreamID)
{
	struct DemuxProgram_ProgramParameters_type ProgrParam;
	RMstatus status = RM_OK;

	RUAGetProperty(m_pInstance, m_hw_demux_program0, RMDemuxProgramPropertyID_ProgramParameters,
		       &ProgrParam, sizeof(ProgrParam));

	if ( (ProgrParam.AudioSID != StreamID) ||
	     (ProgrParam.AudioSSID != SubStreamID) ) {
		RMDBGLOG((QBDBG, "SetDecodingAudioStream: sid=0x%02x, ssid=0x%02x\n", StreamID, SubStreamID));
		ProgrParam.AudioSID = StreamID;
		ProgrParam.AudioSSID = SubStreamID;
		if(m_pDemuxSource != NULL){
			DCCPauseDemuxSource(m_pDemuxSource);
			RUASetProperty(m_pInstance, m_hw_demux_program0, RMDemuxProgramPropertyID_ProgramParameters,
				&ProgrParam, sizeof(ProgrParam), 0);

			status = DCCPlayDemuxSource(m_pDemuxSource);
			if(status != RM_OK){
				RMDBGLOG((ENABLE, "!!!!!! Error DCCDemuxVideoSource - %s !!!!!!\n", RMstatusToString(status)));
				CleanallAndExit();
			}
		}
	}

	// Force SetAudioParameters
	m_audioFormat.audioType = CURACAO_AUDIO_UNKNOWN;

	return status;
}

RMstatus RMem86xxDecoder::SetDecodingSubpictureStream(RMuint8 StreamID, RMuint8 SubStreamID)
{
	struct DemuxProgram_ProgramParameters_type ProgrParam;
	RUAGetProperty(m_pInstance, m_hw_demux_program0, RMDemuxProgramPropertyID_ProgramParameters,
		       &ProgrParam, sizeof(ProgrParam));

	if ( (ProgrParam.SubpictureSID != StreamID) ||
	     (ProgrParam.SubpictureSSID != SubStreamID) ) {
		ProgrParam.SubpictureSID = StreamID;
		ProgrParam.SubpictureSSID = SubStreamID;

		RMDBGLOG((QBDBG, "SetDecodingSubpictureStream: sid=0x%02x, ssid=0x%02x\n", StreamID, SubStreamID));
		RUASetProperty(m_pInstance, m_hw_demux_program0, RMDemuxProgramPropertyID_ProgramParameters,
			       &ProgrParam, sizeof(ProgrParam), 0);

		struct InbandCommand_type InbandCmd;
		InbandCmd.Tag = INBAND_COMMAND_TAG_PID |
			INBAND_COMMAND_ACTION_CONTINUE |
			INBAND_COMMAND_DEST_DEMUX;
		InbandCmd.Coordinate = 0;
		RUASetProperty(m_pInstance, m_hw_demux, RMGenericPropertyID_InbandCommand,
			       &InbandCmd, sizeof(InbandCmd), 0);
	}

	return RM_OK;
}

RMstatus RMem86xxDecoder::SetAudioParameter(typeCuracaoAudioParameters parameters, RMint8 astn)
{
	RMstatus err;

	// TODO: outputSampleRate should be set by mediaplayer
	if(parameters.audioType != CURACAO_AUDIO_PCM_VOB){
		parameters.outputSampleRate = parameters.sampleRate;
	}

	if(m_pAudioSource == NULL) {
		RMDBGLOG((ENABLE, "Cannot set audio format : NO audio source\n"));
		return RM_ERROR;
	}

	if ( (RMMemcmp((void*)&m_audioFormat, (void*)&parameters, sizeof(typeCuracaoAudioParameters)) == 0) &&
		(m_SPDIFMode == m_SPDIFModeReq) ){
		RMDBGLOG((ENABLE, "Cannot set audio format : Same format !!\n"));
		return RM_OK;
	}

	if((parameters.audioType == CURACAO_AUDIO_MULTIGROUP_MLP)){
		RMDBGLOG((ENABLE, "MLP/PCM Multigroups not handled yet ...\n"));
		return RM_ERROR;
	}

	RMDBGLOG((QBDBG, "Setting audio format\n"));

	RUASetProperty(m_pInstance, m_audio_engine, RMAudioEnginePropertyID_SampleFrequency,
	       &parameters.outputSampleRate, sizeof(parameters.outputSampleRate), 0);
	m_audioFormat.outputSampleRate = parameters.outputSampleRate;

	if(m_pDemuxSource != NULL){
		struct DemuxProgram_OutputControl_type demuxOutCtrl;
		memcpy(&demuxOutCtrl, &m_demuxOutCtrl, sizeof(demuxOutCtrl));

		DCCPauseDemuxSource(m_pDemuxSource);
		demuxOutCtrl.Audio = FALSE;	// disable audio to be able to stop the audio and keep the fifo pointers in sync
		RUASetProperty(m_pInstance, m_hw_demux_program0, RMDemuxProgramPropertyID_OutputControl,
			&demuxOutCtrl, sizeof(demuxOutCtrl), 0);
		DCCPlayDemuxSource(m_pDemuxSource);
		DCCPauseDemuxSource(m_pDemuxSource);
	}

	if (parameters.audioType == m_audioFormat.audioType){

		DCCStopAudioSource(m_pAudioSource);

		if ( m_SPDIFMode != m_SPDIFModeReq ) {
			m_SPDIFMode = m_SPDIFModeReq;

			if(parameters.audioType == CURACAO_AUDIO_PCM_VOB){
				m_LpcmVobParams.OutputSpdif = m_SPDIFMode;
				err = RUASetProperty(m_pInstance, m_audio_decoder, RMAudioDecoderPropertyID_LpcmVobParameters,
					&m_LpcmVobParams, sizeof(m_LpcmVobParams), 0);
			}
			else if(parameters.audioType == CURACAO_AUDIO_PCM_AOB){
				m_LpcmAobParams.OutputSpdif = m_SPDIFMode;
				err = RUASetProperty(m_pInstance, m_audio_decoder, RMAudioDecoderPropertyID_LpcmAobParameters,
					&m_LpcmAobParams, sizeof(m_LpcmAobParams), 0);
			}
			else if ((parameters.audioType == CURACAO_AUDIO_PCM) || (parameters.audioType == CURACAO_AUDIO_RPCM)){
				m_PcmCdaParams.OutputSpdif = m_SPDIFMode;
				err = RUASetProperty(m_pInstance, m_audio_decoder, RMAudioDecoderPropertyID_PcmCdaParameters,
					&m_PcmCdaParams, sizeof(m_PcmCdaParams), 0);
			}
			else if (parameters.audioType == CURACAO_AUDIO_MPEG){
				m_MpegParams.OutputSpdif = m_SPDIFMode;
				err = RUASetProperty(m_pInstance, m_audio_decoder, RMAudioDecoderPropertyID_MpegParameters,
					&m_MpegParams, sizeof(m_MpegParams), 0);
			}
			else if (parameters.audioType == CURACAO_AUDIO_AC3){
				m_Ac3Params.OutputSpdif = m_SPDIFMode;
				err = RUASetProperty(m_pInstance, m_audio_decoder, RMAudioDecoderPropertyID_Ac3Parameters,
					&m_Ac3Params, sizeof(m_Ac3Params), 0);
			}
			else if (parameters.audioType == CURACAO_AUDIO_DTS){
#ifdef GUI_REFID_3
				m_DtsParams.OutputSpdif = OutputSpdif_NoDecodeCompressed;
#else
				m_DtsParams.OutputSpdif = m_SPDIFMode;
#endif
				err = RUASetProperty(m_pInstance, m_audio_decoder, RMAudioDecoderPropertyID_DtsParameters,
					&m_DtsParams, sizeof(m_DtsParams), 0);
			}
			else {
				RMDBGLOG((QBDBG, "SetAudioParameter: no spdif change for this audio type\n"));
			}
		}
	}
	else {
		m_SPDIFMode = m_SPDIFModeReq;

		if(parameters.audioType == CURACAO_AUDIO_PCM_VOB){
			RMuint32 i;

			RMDBGLOG((QBDBG, "Codec : PCM VOB : \n"));
			RMDBGLOG((QBDBG, "\tChannel assign = %lu\n", parameters.audioChannelAssign));
			RMDBGLOG((QBDBG, "\tBits per sample = %lu\n", parameters.bitsPerSample));
			RMDBGLOG((QBDBG, "\tSampling Frequency = %lu\n", parameters.sampleRate));
			RMDBGLOG((QBDBG, "\tDownmix coef : \n"));

			m_LpcmVobParams.ChannelAssign = (enum LpcmVobChannelAssign_type)parameters.audioChannelAssign;
			m_LpcmVobParams.BitsPerSample = parameters.bitsPerSample;
			m_LpcmVobParams.SamplingFrequency = parameters.sampleRate;
			m_LpcmVobParams.DownMix = FALSE; // downmixing not yet implemented

			for (i=0; i<8; i++) {
				m_LpcmVobParams.CoefLR[i] = parameters.coef[i];
				RMDBGLOG((QBDBG, "\t\tCoef[%lu] : %lu\n", i, parameters.coef[i]));
			}

			m_LpcmVobParams.OutputDualMode = m_dualMode;
			m_LpcmVobParams.OutputSpdif = m_SPDIFMode;
			m_LpcmVobParams.OutputChannels = (m_AudioChannels == 6 ? Audio_Out_Ch_LCRLsRs : Audio_Out_Ch_LR);
			err = DCCSetAudioLpcmVobFormat(m_pAudioSource, &m_LpcmVobParams);
		}
		else if(parameters.audioType == CURACAO_AUDIO_PCM_AOB){
			RMuint32 i;

			RMDBGLOG((QBDBG, "Codec : PCM AOB\n"));
			RMDBGLOG((QBDBG, "\tChannel assign = %lu\n", parameters.audioChannelAssign));
			RMDBGLOG((QBDBG, "\tBits per sample GR1 = %lu\n", parameters.bitsPerSample));
			RMDBGLOG((QBDBG, "\tBits per sample GR2 = %lu\n", parameters.bitsPerSample_gr2));
			RMDBGLOG((QBDBG, "\tSampling Frequency GR1 = %lu\n", parameters.sampleRate));
			RMDBGLOG((QBDBG, "\tSampling Frequency GR2 = %lu\n", parameters.sampleRate_gr2));
			RMDBGLOG((QBDBG, "\tGroup shift 2 = %lu\n", parameters.group2Shift));
			RMDBGLOG((QBDBG, "\tPase LR = %lu\n", parameters.ph));
			RMDBGLOG((QBDBG, "\tDownmix coef : \n"));

			m_LpcmAobParams.ChannelAssign = (enum LpcmAobChannelAssign_type)parameters.audioChannelAssign;
			m_LpcmAobParams.BitsPerSampleGroup1 = parameters.bitsPerSample;
			m_LpcmAobParams.BitsPerSampleGroup2 = parameters.bitsPerSample_gr2;
			m_LpcmAobParams.SamplingFrequencyGroup1 = parameters.sampleRate;
			m_LpcmAobParams.SamplingFrequencyGroup2 = parameters.sampleRate_gr2;
			m_LpcmAobParams.DownMix = FALSE; // downmixing not yet implemented
			m_LpcmAobParams.Group2Shift = parameters.group2Shift;
			m_LpcmAobParams.PhaseLR = parameters.ph;
			for (i=0; i<6; i++) {
				m_LpcmAobParams.CoefLR[i] = parameters.coef[i];
				RMDBGLOG((QBDBG, "\t\tCoef[%lu] : %lu\n", i, parameters.coef[i]));
			}

			m_LpcmAobParams.OutputDualMode = m_dualMode;
			m_LpcmAobParams.OutputSpdif = m_SPDIFMode;
			m_LpcmAobParams.OutputChannels = (m_AudioChannels == 6 ? Audio_Out_Ch_LCRLsRs : Audio_Out_Ch_LR);
			err = DCCSetAudioLpcmAobFormat(m_pAudioSource, &m_LpcmAobParams);
		}
		else if ((parameters.audioType == CURACAO_AUDIO_PCM) || (parameters.audioType == CURACAO_AUDIO_RPCM)) {

			m_PcmCdaParams.ChannelAssign = (enum PcmCdaChannelAssign_type)parameters.audioChannelAssign;
			m_PcmCdaParams.BitsPerSample = parameters.bitsPerSample;
			m_PcmCdaParams.SamplingFrequency = parameters.sampleRate;
			m_PcmCdaParams.OutputChannels = (m_AudioChannels == 6 ? Audio_Out_Ch_LCRLsRs : Audio_Out_Ch_LR);
			m_PcmCdaParams.SignedPCM = TRUE;

			if(parameters.audioType == CURACAO_AUDIO_RPCM) {
				m_PcmCdaParams.MsbFirst = TRUE;
				RMDBGLOG((QBDBG, "Codec : REVERSE PCM : \n"));
			}
			else{
				m_PcmCdaParams.MsbFirst = FALSE;
				RMDBGLOG((QBDBG, "Codec : PCM : \n"));
			}

			m_PcmCdaParams.OutputDualMode = m_dualMode;
			m_PcmCdaParams.OutputSpdif = m_SPDIFMode;

			RMDBGLOG((QBDBG, "\tChannel assign = %lu\n", parameters.audioChannelAssign));
			RMDBGLOG((QBDBG, "\tBits per sample = %lu\n", parameters.bitsPerSample));
			RMDBGLOG((QBDBG, "\tSampling Frequency = %lu\n", parameters.sampleRate));

			err = DCCSetAudioPcmCdaFormat(m_pAudioSource, &m_PcmCdaParams);
		}
		else if (parameters.audioType == CURACAO_AUDIO_MPEG){

			RMDBGLOG((QBDBG, "Codec : MPEG1\n"));
			RMDBGLOG((QBDBG, "\tBits per sample = %lu\n", parameters.bitsPerSample));
			RMDBGLOG((QBDBG, "\tSampling Frequency = %lu\n", parameters.sampleRate));
			RMDBGLOG((QBDBG, "\tNumber of channels = %lu\n", parameters.numberOfChannel));