dcc.c

dcc code for smp 8634 media processor

/*****************************************
 Copyright © 2001-2003  
 Sigma Designs, Inc. All Rights Reserved
 Proprietary and Confidential
 *****************************************/
/**
  @file   dcc.c
  @brief  Decoding Chain Control API

  @author Julien Soulier
  @date   2003-10-02
*/

// to enable or disable the debug messages of this source file, put 1 or 0 below
#if 0
#define LOCALDBG ENABLE
#else
#define LOCALDBG DISABLE
#endif

#include "dcc_common.h"

static RMuint32 default_rua_malloc(struct RUA *pRua, RMuint32 ModuleID, RMuint32 dramIndex, enum RUADramType dramtype, RMuint32 size)
{
	return RUAMalloc(pRua, dramIndex, dramtype, size);
}
static void default_rua_free(struct RUA *pRua, RMuint32 ptr)
{
	return RUAFree(pRua, ptr);
}

RMstatus DCCOpen(struct RUA *pRUA, struct DCC **ppDCC)
{
	struct DCC *pDCC;

	pDCC = (struct DCC *) RMMalloc(sizeof(struct DCC));
	if (pDCC == NULL) {
		return RM_FATALOUTOFMEMORY;
	}

	RMMemset(pDCC, 0, sizeof(struct DCC));
	pDCC->pRUA = pRUA;
	pDCC->dram = 0;
	pDCC->rua_malloc = default_rua_malloc;
	pDCC->rua_free = default_rua_free;

	*ppDCC = pDCC;

	RMDBGLOG((LOCALDBG, "dccOpen (RUA @ 0x%08lx DCC @0x%08lx\n", (RMuint32)pRUA, (RMuint32)pDCC));
	
	return RM_OK;
}

RMstatus DCCClose(struct DCC *pDCC)
{
	enum ProcessorState run;
	RMstatus err = RM_OK;
    
	RMASSERT(pDCC);

	RMDBGLOG((LOCALDBG, "dccClose (DCC @ 0x%08lx\n", (RMuint32)pDCC));

#if (EM86XX_CHIP==EM86XX_CHIPID_TANGO2 || EM86XX_CHIP==EM86XX_CHIPID_TANGO15)
	RMDBGLOG((ENABLE, "DCCClose TANGO2 just stops the riscs, it doesn't reset them !\n"));
	run = CPU_STOPPED; /* Prevent gbus crash for first tango2 - riscs reset and then DMEM/PMEM accessed.*/
#else
	run = CPU_RESET;
#endif

#ifndef WITH_XLOADED_UCODE
	if (pDCC->video_ucode_address) {
		/* resetting the MPEG engine */
		DCCSP(pDCC->pRUA, EMHWLIB_MODULE(MpegEngine, 0), RMMpegEnginePropertyID_State, &run, sizeof(run));
#ifdef RMFEATURE_HAS_VIDEO_ENGINE_1
		DCCSP(pDCC->pRUA, EMHWLIB_MODULE(MpegEngine, 1), RMMpegEnginePropertyID_State, &run, sizeof(run));
#endif
		pDCC->rua_free(pDCC->pRUA, pDCC->video_ucode_address);
	}
		
	if (pDCC->audio_ucode_address) {
		/* resetting the Audio engine */
		DCCSP(pDCC->pRUA, EMHWLIB_MODULE(AudioEngine, 0), RMAudioEnginePropertyID_State, &run, sizeof(run));
#ifdef RMFEATURE_HAS_AUDIO_ENGINE_1
		DCCSP(pDCC->pRUA, EMHWLIB_MODULE(AudioEngine, 1), RMAudioEnginePropertyID_State, &run, sizeof(run));
#endif
		pDCC->rua_free(pDCC->pRUA, pDCC->audio_ucode_address);
	}

	if (pDCC->demux_ucode_address) {
		/* resetting the Demux engine */
		DCCSP(pDCC->pRUA, EMHWLIB_MODULE(DemuxEngine, 0), RMDemuxEnginePropertyID_State, &run, sizeof(run));
		pDCC->rua_free(pDCC->pRUA, pDCC->demux_ucode_address);
	}
#endif /* WITH_XLOADED_UCODE */

	RMFree(pDCC);
	
	return err;
}

RMstatus DCCInitChain(struct DCC *pDCC)
{
	return DCCInitChainEx(pDCC, DCCInitMode_LeaveDisplay);
}

RMstatus DCCInitChainEx(struct DCC *pDCC, enum DCCInitMode init_mode)
{
	RMstatus err;
	RMuint32 mixer, scaler, surface;
	RMbool enable;
	struct DispMainMixer_LayerOrder_type layer;

	struct EMhwlibDisplayWindow window;
	enum EMhwlibScalingMode scalingmode;
	struct EMhwlibDownScalingMode downscalingmode;
	struct EMhwlibNonLinearScalingMode nonlinearmode;
	struct EMhwlibBlackStripMode blackstrip;
	struct EMhwlibCutStripMode cutstrip;
	enum EMhwlibDeinterlacingMode deinterlacing_mode;
	enum EMhwlibScalerFieldSelection field_selection;
	struct DispMainVideoScaler_DeinterlacingProportion_type deinterlacing_prop;
	struct DispMainVideoScaler_FilterSelection_type filtermode;
	struct EMhwlibColor color;
	RMuint32 src_index, val;
	RMint8 brightness;
	RMuint8 contrast, saturation;
	enum EMhwlibMixerSourceState state;
	struct DispOSDScaler_ScalingConfig_type scalingcfg;
	RMbool scaler_already_enabled;
	RMuint32 deinterlacing_scaler;
	struct DispMainVideoScaler_DeinterlacingMotionConfig_type deinterlacer_mode;
	RMuint32 force_interlaced_boundary;

	mixer = EMHWLIB_MODULE(DispMainMixer, 0); 
	scaler = EMHWLIB_MODULE(DispMainVideoScaler, 0);

	RMDBGLOG((LOCALDBG, "dccInitChainEx DCC @ 0x%08lx\n", (RMuint32)pDCC));

	if ( init_mode == DCCInitMode_LeaveDisplay ){
		/* Don't reset the whole chain if scaler already enabled */
		err = RUAGetProperty(pDCC->pRUA, scaler, RMGenericPropertyID_Enable, &scaler_already_enabled, sizeof(RMbool));
		if (err != RM_OK) {
			RMDBGLOG((ENABLE, "Cannot get Property %d on module %d, %s\n", RMGenericPropertyID_Enable, scaler, RMstatusToString(err)));
			return err;
		}

		if (scaler_already_enabled){
			RMDBGLOG((ENABLE, "Display already configured and initDisplay=FALSE. Do not reconfigure it!\n"));
			return RM_OK;
		}
	}
	
	
	/* set up VCR Mixer */
#ifdef RMFEATURE_HAS_VCR_MIXER
	{
		struct DispVCRMixer_LayerOrder_type vcr_layer;
		RMuint32 vcr_mixer, vcr_scaler;
		
		vcr_mixer = EMHWLIB_MODULE(DispVCRMixer, 0); 
		
		vcr_layer.Layer0SourceModuleID = EMHWLIB_MODULE(DispCRTMultiScaler, 0);
		vcr_layer.Layer1SourceModuleID = EMHWLIB_MODULE(DispVCRMultiScaler, 0);
		vcr_layer.Layer2SourceModuleID = EMHWLIB_MODULE(DispGFXMultiScaler, 0);
		vcr_layer.Layer3SourceModuleID = EMHWLIB_MODULE(DispSubPictureScaler, 0);
		DCCSP(pDCC->pRUA, vcr_mixer, RMDispVCRMixerPropertyID_LayerOrder, &vcr_layer, sizeof(vcr_layer));
		
		color.R_Cr = 128;
		color.G_Y = 64;
		color.B_Cb = 128;
		DCCSP(pDCC->pRUA, vcr_mixer, RMGenericPropertyID_BackgroundColor, &color, sizeof(color));
		
		enable = TRUE;
		DCCSP(pDCC->pRUA, vcr_mixer, RMGenericPropertyID_ForceBackGround, &enable, sizeof(enable));
		
		DCCSP(pDCC->pRUA, vcr_mixer, RMGenericPropertyID_Validate, NULL, 0);
		
		enable = TRUE;
		DCCSP(pDCC->pRUA, vcr_mixer, RMGenericPropertyID_Enable, &enable, sizeof(enable));
		
		
		/* put all Scaler of the VCRMixer in "slave" mode, to avoid them being handled twice. */
		
		vcr_scaler = EMHWLIB_MODULE(DispVCRMultiScaler, 0);
		err = RUAExchangeProperty(pDCC->pRUA, vcr_mixer, RMGenericPropertyID_MixerSourceIndex, &vcr_scaler, sizeof(vcr_scaler), &src_index, sizeof(src_index));
		if (err != RM_OK) {
			RMDBGLOG((ENABLE, "Cannot get scaler index, %s\n", RMstatusToString(err)));
			return err;
		}
		vcr_mixer = EMHWLIB_TARGET_MODULE(EMHWLIB_MODULE_CATEGORY(vcr_mixer), EMHWLIB_MODULE_INDEX(vcr_mixer), src_index);
		state = EMhwlibMixerSourceState_Slave;
		DCCSP(pDCC->pRUA, vcr_mixer, RMGenericPropertyID_MixerSourceState, &state, sizeof(state));
		
		vcr_scaler = EMHWLIB_MODULE(DispCRTMultiScaler, 0);
		err = RUAExchangeProperty(pDCC->pRUA, vcr_mixer, RMGenericPropertyID_MixerSourceIndex, &vcr_scaler, sizeof(vcr_scaler), &src_index, sizeof(src_index));
		if (err != RM_OK) {
			RMDBGLOG((ENABLE, "Cannot get scaler index, %s\n", RMstatusToString(err)));
			return err;
		}
		vcr_mixer = EMHWLIB_TARGET_MODULE(EMHWLIB_MODULE_CATEGORY(vcr_mixer), EMHWLIB_MODULE_INDEX(vcr_mixer), src_index);
		state = EMhwlibMixerSourceState_Slave;
		DCCSP(pDCC->pRUA, vcr_mixer, RMGenericPropertyID_MixerSourceState, &state, sizeof(state));
		
		vcr_scaler = EMHWLIB_MODULE(DispGFXMultiScaler, 0);
		err = RUAExchangeProperty(pDCC->pRUA, vcr_mixer, RMGenericPropertyID_MixerSourceIndex, &vcr_scaler, sizeof(vcr_scaler), &src_index, sizeof(src_index));
		if (err != RM_OK) {
			RMDBGLOG((ENABLE, "Cannot get scaler index, %s\n", RMstatusToString(err)));
			return err;
		}
		vcr_mixer = EMHWLIB_TARGET_MODULE(EMHWLIB_MODULE_CATEGORY(vcr_mixer), EMHWLIB_MODULE_INDEX(vcr_mixer), src_index);
		state = EMhwlibMixerSourceState_Slave;
		DCCSP(pDCC->pRUA, vcr_mixer, RMGenericPropertyID_MixerSourceState, &state, sizeof(state));
		
		vcr_scaler = EMHWLIB_MODULE(DispSubPictureScaler, 0);
		err = RUAExchangeProperty(pDCC->pRUA, vcr_mixer, RMGenericPropertyID_MixerSourceIndex, &vcr_scaler, sizeof(vcr_scaler), &src_index, sizeof(src_index));
		if (err != RM_OK) {
			RMDBGLOG((ENABLE, "Cannot get scaler index, %s\n", RMstatusToString(err)));
			return err;
		}
		vcr_mixer = EMHWLIB_TARGET_MODULE(EMHWLIB_MODULE_CATEGORY(vcr_mixer), EMHWLIB_MODULE_INDEX(vcr_mixer), src_index);
		state = EMhwlibMixerSourceState_Slave;
		DCCSP(pDCC->pRUA, vcr_mixer, RMGenericPropertyID_MixerSourceState, &state, sizeof(state));
	}
#endif
	
	/* set up Main Mixer and connect Main Video Scaler to it */
	layer.Layer0SourceModuleID = EMHWLIB_MODULE(DispCRTMultiScaler, 0);
	layer.Layer1SourceModuleID = EMHWLIB_MODULE(DispVCRMultiScaler, 0);
	layer.Layer2SourceModuleID = EMHWLIB_MODULE(DispMainVideoScaler, 0);
	layer.Layer3SourceModuleID = EMHWLIB_MODULE(DispGFXMultiScaler, 0);
	layer.Layer4SourceModuleID = EMHWLIB_MODULE(DispOSDScaler, 0);
	layer.Layer5SourceModuleID = EMHWLIB_MODULE(DispSubPictureScaler, 0);
	layer.Layer6SourceModuleID = EMHWLIB_MODULE(DispGraphicInput, 0);
	DCCSP(pDCC->pRUA, mixer, RMDispMainMixerPropertyID_LayerOrder, &layer, sizeof(layer));

	color.R_Cr = 128;
	color.G_Y = 16;
	color.B_Cb = 128;
	DCCSP(pDCC->pRUA, mixer, RMGenericPropertyID_BackgroundColor, &color, sizeof(color));

	enable = TRUE;
	DCCSP(pDCC->pRUA, mixer, RMGenericPropertyID_ForceBackGround, &enable, sizeof(enable));

	err = RUAExchangeProperty(pDCC->pRUA, mixer, RMGenericPropertyID_MixerSourceIndex, &scaler, sizeof(scaler), &src_index, sizeof(src_index));
	if (err != RM_OK) {
		RMDBGLOG((ENABLE, "Cannot get scaler index, %s\n", RMstatusToString(err)));
		return err;
	}
	mixer = EMHWLIB_TARGET_MODULE(DispMainMixer, 0 , src_index);

	window.X = 0;
	window.Y = 0;
	window.Width = 4096;
	window.Height = 4096;
	window.XPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
	window.YPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
	window.XMode = EMhwlibDisplayWindowValueMode_Relative;
	window.YMode = EMhwlibDisplayWindowValueMode_Relative;
	window.WidthMode = EMhwlibDisplayWindowValueMode_Relative;
	window.HeightMode = EMhwlibDisplayWindowValueMode_Relative;
	DCCSP(pDCC->pRUA, mixer, RMGenericPropertyID_MixerSourceWindow, &window, sizeof(window));

	state = EMhwlibMixerSourceState_Master;
	DCCSP(pDCC->pRUA, mixer, RMGenericPropertyID_MixerSourceState, &state, sizeof(state));

	DCCSP(pDCC->pRUA, mixer, RMGenericPropertyID_Validate, NULL, 0);

	enable = TRUE;
	DCCSP(pDCC->pRUA, mixer, RMGenericPropertyID_Enable, &enable, sizeof(enable));
	
	
	/* set up Main Video Scaler */
	
	surface = 0;
	DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_Surface, &surface, sizeof(surface));

	window.X = 0;
	window.Y = 0;
	window.Width = 4096;
	window.Height = 4096;
	window.XPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
	window.YPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
	window.XMode = EMhwlibDisplayWindowValueMode_Relative;
	window.YMode = EMhwlibDisplayWindowValueMode_Relative;
	window.WidthMode = EMhwlibDisplayWindowValueMode_Relative;
	window.HeightMode = EMhwlibDisplayWindowValueMode_Relative;
	DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_ScalerInputWindow, &window, sizeof(window));

	scalingmode = EMhwlibScalingMode_LetterBox;
	DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_ScalingMode, &scalingmode, sizeof(scalingmode));

	field_selection = EMhwlibScalerFieldSelection_BestFieldType;
	DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_ScalerFieldSelection, &field_selection, sizeof(field_selection));

	filtermode.Boundary_0_1 = 0x1400;
	filtermode.Boundary_1_2 = 0x1c00;
	filtermode.Boundary_2_3 = 0x2c00;
	DCCSP(pDCC->pRUA, scaler, RMDispMainVideoScalerPropertyID_FilterSelection, &filtermode, sizeof(filtermode));

	downscalingmode.Discard = FALSE;
	downscalingmode.FilterBoundary[0] = 384;
	downscalingmode.FilterBoundary[1] = 256;
	downscalingmode.FilterBoundary[2] = 128;
	DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_DownScalingMode, &downscalingmode, sizeof(downscalingmode));
	
	nonlinearmode.Width = 0;
	nonlinearmode.Level = 0;
	DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_NonLinearScalingMode, &nonlinearmode, sizeof(nonlinearmode));

	blackstrip.Horizontal = 4096;
 	blackstrip.Vertical = 4096;
	DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_BlackStripMode, &blackstrip, sizeof(blackstrip));

	cutstrip.Horizontal = 0;
 	cutstrip.Vertical = 0;
	DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_CutStripMode, &cutstrip, sizeof(cutstrip));
	
	deinterlacing_mode = EMhwlibDeinterlacingMode_Discard_Bob;
	DCCSP(pDCC->pRUA, scaler, RMDispMainVideoScalerPropertyID_DeinterlacingMode, &deinterlacing_mode, sizeof(deinterlacing_mode));

	deinterlacing_prop.NewLineProportion = 12;
	deinterlacing_prop.ExistingLineProportion = 4;
	DCCSP(pDCC->pRUA, scaler, RMDispMainVideoScalerPropertyID_DeinterlacingProportion, &deinterlacing_prop, sizeof(deinterlacing_prop));
	
	deinterlacer_mode.Value0 = 0x00;
	deinterlacer_mode.Value8 = 0x04;
	deinterlacer_mode.Value16 = 0x40;
	deinterlacer_mode.Value32 = 0xC0;
	DCCSP(pDCC->pRUA, scaler, RMDispMainVideoScalerPropertyID_DeinterlacingMotionConfig, &deinterlacer_mode, sizeof(deinterlacer_mode));

	deinterlacing_scaler = EMHWLIB_MODULE(DispGFXMultiScaler, 0);
	DCCSP(pDCC->pRUA, scaler, RMDispMainVideoScalerPropertyID_DeinterlacingMotionScaler, &deinterlacing_scaler, sizeof(deinterlacing_scaler));

	val = 0x80;
	DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_Alpha0, &val, sizeof(val));

	brightness = 0;
	DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_Brightness, &brightness, sizeof(brightness));

	contrast = 0x80;
	DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_Contrast, &contrast, sizeof(contrast));

	saturation = 0x80;
	DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_CbSaturation, &saturation, sizeof(saturation));

	saturation = 0x80;
	DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_CrSaturation, &saturation, sizeof(saturation));

	force_interlaced_boundary = 0x100;