dcc_audio.c

dcc code for smp 8634 media processor

	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot AudioDecoder_Command_Uninit, %s\n", RMstatusToString(err)));
		return err;
	}

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));
	
	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Ac3Parameters,
		pFormat, sizeof(struct AudioDecoder_Ac3Parameters_type));

	return send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Init);
}

RMstatus DCCSetAudioDtsFormat(struct DCCAudioSource *pAudioSource, struct AudioDecoder_DtsParameters_type *pFormat)
{
	RMstatus err;
	enum AudioDecoder_Codec_type codec = AudioDecoder_Codec_DTS;

	RMDBGLOG((ENABLE, "Set DTS audio\n"));

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Uninit);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot AudioDecoder_Command_Uninit, %s\n", RMstatusToString(err)));
		return err;
	}

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));
	
	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_DtsParameters,
		pFormat, sizeof(struct AudioDecoder_DtsParameters_type));

	return send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Init);
}

RMstatus DCCSetAudioTToneFormat(struct DCCAudioSource *pAudioSource, struct AudioDecoder_TToneParameters_type *pFormat)
{
	RMstatus err;
	enum AudioDecoder_Codec_type codec = AudioDecoder_Codec_TTONE;

	RMDBGLOG((ENABLE, "Set Test Tone Genertor\n"));

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Uninit);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot AudioDecoder_Command_Uninit, %s\n", RMstatusToString(err)));
		return err;
	}

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_TToneParameters,
		pFormat, sizeof(struct AudioDecoder_TToneParameters_type));

	return send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Init);
}

RMstatus DCCSetAudioDVDAFormat(struct DCCAudioSource *pAudioSource, struct AudioDecoder_DVDAParameters_type *pFormat)
{
	RMstatus err;
	enum AudioDecoder_Codec_type codec = AudioDecoder_Codec_DVDA;

	RMDBGLOG((ENABLE, "Set DVDA audio\n"));

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Uninit);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot AudioDecoder_Command_Uninit, %s\n", RMstatusToString(err)));
		return err;
	}

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_DVDAParameters,
		pFormat, sizeof(struct AudioDecoder_DVDAParameters_type));

	return send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Init);
}

RMstatus DCCSetAudioMpegFormat(struct DCCAudioSource *pAudioSource, struct AudioDecoder_MpegParameters_type *pFormat)
{
	RMstatus err;
	enum AudioDecoder_Codec_type codec = AudioDecoder_Codec_MPEG1;

	RMDBGLOG((ENABLE, "Set MPEG audio\n"));

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Uninit);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot AudioDecoder_Command_Uninit, %s\n", RMstatusToString(err)));
		return err;
	}

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));
	
	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_MpegParameters,
		pFormat, sizeof(struct AudioDecoder_MpegParameters_type));

	return send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Init);
}

RMstatus DCCSetAudioPcmxFormat(struct DCCAudioSource *pAudioSource, struct AudioDecoder_PCMXParameters_type *pFormat)
{
	RMstatus err;
	enum AudioDecoder_Codec_type codec = AudioDecoder_Codec_PCMX;

	RMDBGLOG((ENABLE, "Set PCMX format for audio_decoder %lu\n", pAudioSource->decoder_moduleID));

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Uninit);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot AudioDecoder_Command_Uninit, %s\n", RMstatusToString(err)));
		return err;
	}

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_PCMXParameters,
		pFormat, sizeof(struct AudioDecoder_PCMXParameters_type));

	return send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Init);
}


RMstatus DCCSetAudioPcmCdaFormat(struct DCCAudioSource *pAudioSource, struct AudioDecoder_PcmCdaParameters_type *pFormat)
{
	RMstatus err;
	enum AudioDecoder_Codec_type codec = AudioDecoder_Codec_PCM;

	RMDBGLOG((ENABLE,"Set PCM format for audio_decoder %lu\n", pAudioSource->decoder_moduleID));

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Uninit);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot AudioDecoder_Command_ Uninit, %s\n", RMstatusToString(err)));
		return err;
	}

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));
	
	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_PcmCdaParameters,
		pFormat, sizeof(struct AudioDecoder_PcmCdaParameters_type));

	return send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Init);
}

RMstatus DCCSetAudioLpcmVobFormat(struct DCCAudioSource *pAudioSource, struct AudioDecoder_LpcmVobParameters_type *pFormat)
{
	RMstatus err;
	enum AudioDecoder_Codec_type codec = AudioDecoder_Codec_PCM;

	RMDBGLOG((ENABLE, "Set LPCM_VOB audio\n"));

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Uninit);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot AudioDecoder_Command_Uninit, %s\n", RMstatusToString(err)));
		return err;
	}

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));
	
	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_LpcmVobParameters,
		pFormat, sizeof(struct AudioDecoder_LpcmVobParameters_type));

	return send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Init);
}

RMstatus DCCSetAudioLpcmBDFormat(struct DCCAudioSource *pAudioSource, struct AudioDecoder_LpcmBDParameters_type *pFormat)
{
	RMstatus err;
	enum AudioDecoder_Codec_type codec = AudioDecoder_Codec_PCM;

	RMDBGLOG((ENABLE, "Set LPCM_BD audio\n"));

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Uninit);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot AudioDecoder_Command_Uninit, %s\n", RMstatusToString(err)));
		return err;
	}

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));
	
	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_LpcmBDParameters,
		pFormat, sizeof(struct AudioDecoder_LpcmBDParameters_type));

	return send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Init);
}

RMstatus DCCSetAudioLpcmAobFormat(struct DCCAudioSource *pAudioSource, struct AudioDecoder_LpcmAobParameters_type *pFormat)
{
	RMstatus err;
	enum AudioDecoder_Codec_type codec = AudioDecoder_Codec_PCM;

	RMDBGLOG((ENABLE, "Set LPCM_AOB audio\n"));

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Uninit);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot AudioDecoder_Command_Uninit, %s\n", RMstatusToString(err)));
		return err;
	}

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));
	
	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_LpcmAobParameters,
		pFormat, sizeof(struct AudioDecoder_LpcmAobParameters_type));

	return send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Init);
}

RMstatus DCCSetAudioWMAFormat(struct DCCAudioSource *pAudioSource, struct AudioDecoder_WMAParameters_type *pFormat)
{
	RMstatus err;
	enum AudioDecoder_Codec_type codec = AudioDecoder_Codec_WMA;

	RMDBGLOG((ENABLE, "Set WMA audio\n"));

	if (pFormat->VersionNumber == 0x162) {
		if(pFormat->OutputSpdif != OutputSpdif_NoDecodeCompressed && pFormat->OutputSpdif != OutputSpdif_Compressed)
			codec = AudioDecoder_Codec_WMAPRO;
		else		
			codec = AudioDecoder_Codec_WMAPRO_SPDIF;		
	}	

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Uninit);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot AudioDecoder_Command_Uninit, %s\n", RMstatusToString(err)));
		return err;
	}

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));
	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_WMAParameters, 
			       pFormat, sizeof(struct AudioDecoder_WMAParameters_type));

	RMDBGLOG((LOCALDBG, "(audio decoder : %lu) version 0x%x\n freq %d\n channels %d\n bitrate %d\n size 0x%x\n options 0x%x\n bits %d\n validbits %d\n mask %d\n version %d\n output %d\n output2 %d\n ", 
		  pAudioSource->decoder_moduleID,
		  pFormat->VersionNumber,
		  pFormat->SamplingFrequency,
		  pFormat->NumberOfChannels,
		  pFormat->Bitrate,
		  pFormat->PacketSize,
		  pFormat->EncoderOptions,
		  pFormat->BitsPerSample,
		  pFormat->WMAProValidBitsPerSample,
		  pFormat->WMAProChannelMask,
		  pFormat->WMAProVersionNumber,
		  pFormat->OutputDualMode,
		  pFormat->OutputSpdif));
	
	return send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Init);
}

RMstatus DCCSetAudioAACFormat(struct DCCAudioSource *pAudioSource, struct AudioDecoder_AACParameters_type *pFormat)
{
	RMstatus err;
	enum AudioDecoder_Codec_type codec = AudioDecoder_Codec_AAC;
	
	RMDBGLOG((ENABLE, "Set AAC audio\n"));

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Uninit);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot AudioDecoder_Command_Uninit, %s\n", RMstatusToString(err)));
		return err;
	}

	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));
	DCCSP(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_AACParameters, 
			       pFormat, sizeof(struct AudioDecoder_AACParameters_type));
	
	return send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Init);
}

RMstatus DCCPlayAudioSource(struct DCCAudioSource *pAudioSource)
{
	RMstatus err;
	RMuint32 audio_bts_threshold = 256;
	enum AudioDecoder_Codec_type codec;

	err = RUAGetProperty(pAudioSource->pRUA, pAudioSource->decoder_moduleID, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot get audio codec, %s\n", RMstatusToString(err)));
		return err;
	}

	// different decoder should have different bts threshold.
	RMDBGLOG((LOCALDBG, "decoder = %lx\n", codec));
	if(codec == AudioDecoder_Codec_WMA)		
		audio_bts_threshold = 1024;
		else if(codec == AudioDecoder_Codec_MPEG1)
		audio_bts_threshold = 256*2;
	if(codec == AudioDecoder_Codec_TTONE)
		audio_bts_threshold = 0;

	DCCSetAudioBtsThreshold(pAudioSource, audio_bts_threshold); 	

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Play);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot send AudioDecoder_Command_Play (decoder_module_id = %lu) , %s\n", pAudioSource->decoder_moduleID, RMstatusToString(err)));
		return err;
	}
	
	return RM_OK;
}

RMstatus DCCStopAudioSource(struct DCCAudioSource *pAudioSource)
{
 	RMstatus err;

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Stop);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot send AudioDecoder_Command_Stop, %s\n", RMstatusToString(err)));
		return err;
	}
	
	return RM_OK;
}

RMstatus DCCPauseAudioSource(struct DCCAudioSource *pAudioSource)
{
 	RMstatus err;

	err = send_audio_command(pAudioSource->pRUA, pAudioSource->decoder_moduleID, AudioDecoder_Command_Pause);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot send AudioDecoder_Command_Pause, %s\n", RMstatusToString(err)));
		return err;
	}

	return err;
}

RMstatus DCCSetAudioSourceVolume(struct DCCAudioSource *pAudioSource, RMuint32 volume)
{
	struct AudioEngine_Volume_type vol;
	RMuint32 i;

	for (i = 0; i <= 11; i++) {
		vol.Channel = i;
		vol.Volume = volume;
		DCCSP(pAudioSource->pRUA, pAudioSource->engine_moduleID, RMAudioEnginePropertyID_Volume, &vol, sizeof(vol));
	}

	return RM_OK;
}


RMstatus DCCGetAudioSourceVolume(struct DCCAudioSource *pAudioSource, RMuint32 *volume)
{
	struct AudioEngine_Volume_type vol;
	RMuint32 i;
	RMbool volumeSet = FALSE;

	*volume = 0;

	for (i = 0; i <= 11; i++) {
		vol.Channel = i;					
		RUAGetProperty(pAudioSource->pRUA, pAudioSource->engine_moduleID, RMAudioEnginePropertyID_Volume, &vol, sizeof(vol));
		if (*volume != vol.Volume) {
			if (!volumeSet) {
				*volume = vol.Volume;
				volumeSet = TRUE;
			}
			else {
				RMDBGLOG((LOCALDBG, "channels set to different volumes!!\n"));
				return RM_ERROR;
			}
		}
	}

	return RM_OK;
}