dcc_display.c

dcc code for smp 8634 media processor

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

	if (enable) {
		if (pVideoSource == NULL) {
			RMDBGLOG((ENABLE, "Invalid video source\n"));
			return RM_ERROR;
		}

		if (pVideoSource->spu_surface != 0) {
			spu_surface.Scaler =  spu_scaler;
			spu_surface.Surface = pVideoSource->spu_surface;
			DCCSP(pDCC->pRUA, video_scaler, RMGenericPropertyID_SubPictureSurface, &spu_surface, sizeof(spu_surface));
			DCCSP(pDCC->pRUA, video_scaler, RMGenericPropertyID_Validate, NULL, 0);
		}

		if (pVideoSource->spu_decoder_moduleID != 0)
			DCCSP(pDCC->pRUA, pVideoSource->spu_decoder_moduleID, RMSpuDecoderPropertyID_Scaler, &spu_scaler, sizeof(spu_scaler));

		state = EMhwlibMixerSourceState_Slave;
		DCCSP(pDCC->pRUA, mixer, RMGenericPropertyID_MixerSourceState, &state, sizeof(state));
		
		DCCSP(pDCC->pRUA, mixer, RMGenericPropertyID_Validate, NULL, 0);
	}
	else {
		RMuint32 surface;
		
		spu_surface.Scaler = 0;
		spu_surface.Surface = 0;
		DCCSP(pDCC->pRUA, video_scaler, RMGenericPropertyID_SubPictureSurface, &spu_surface, sizeof(spu_surface));
		DCCSP(pDCC->pRUA, video_scaler, RMGenericPropertyID_Validate, NULL, 0);

		surface = 0;
		DCCSP(pDCC->pRUA, spu_scaler, RMGenericPropertyID_Surface, &surface, sizeof(surface));

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

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

RMstatus DCCGetScalerModuleID(struct DCC *pDCC, enum DCCRoute route, enum DCCSurface surface, RMuint32 index, RMuint32 *scaler)
{
	RMstatus err = RM_OK;

	switch (route) {
	case DCCRoute_Main:
		switch (surface) {
		case DCCSurface_Video:
			if (index == 0) 
				*scaler = EMHWLIB_MODULE(DispMainVideoScaler, 0);
#ifdef RMFEATURE_HAS_VCR_SCALER
			else if (index == 1)
				*scaler = EMHWLIB_MODULE(DispVCRMultiScaler, 0);
			else if (index == 2)
				*scaler = EMHWLIB_MODULE(DispGFXMultiScaler, 0);
#ifdef RMFEATURE_HAS_CRT_SCALER
			else if (index == 3)
				*scaler = EMHWLIB_MODULE(DispCRTMultiScaler, 0);
#endif
#else
			else if (index == 1)
				*scaler = EMHWLIB_MODULE(DispGFXMultiScaler, 0);
#endif
			else
				err = RM_ERROR;
			break;
		case DCCSurface_OSD:
			if (index == 0)
				*scaler = EMHWLIB_MODULE(DispOSDScaler, 0); // it only supports RGB (not good for YUV in JPEGs...)
			else if (index == 1)
				*scaler = EMHWLIB_MODULE(DispGFXMultiScaler, 0);
			else if (index == 2)	
				*scaler = EMHWLIB_MODULE(DispMainVideoScaler, 0);
#ifdef RMFEATURE_HAS_VCR_SCALER
			else if (index == 3)
				*scaler = EMHWLIB_MODULE(DispVCRMultiScaler, 0);
#endif
#ifdef RMFEATURE_HAS_CRT_SCALER
			else if (index == 4)
				*scaler = EMHWLIB_MODULE(DispCRTMultiScaler, 0);
#endif
#ifdef RMFEATURE_HAS_GENERIC_SPU_SCALER
			else if (index == 5)
				*scaler = EMHWLIB_MODULE(DispSubPictureScaler, 0);
#endif
			else if (index == 6)
				*scaler = EMHWLIB_MODULE(DispVideoPlane, 0);

			else
				err = RM_ERROR;
			break;
		case DCCSurface_SPU:
#ifdef RMFEATURE_HAS_SPU_SCALER
			*scaler = EMHWLIB_MODULE(DispSubPictureScaler, 0);
#else
			*scaler = EMHWLIB_MODULE(DispGFXMultiScaler, 0);
#endif
			break;
		}
		break;

	case DCCRoute_Secondary:
		switch (surface) {
		case DCCSurface_Video:
			if (index == 0) 
				*scaler = EMHWLIB_MODULE(DispVCRMultiScaler, 0);
			else
				err = RM_ERROR;
			break;
		case DCCSurface_OSD:
			if (index == 0)
				*scaler = EMHWLIB_MODULE(DispVCRMultiScaler, 0);
			else if (index == 1)	
				*scaler = EMHWLIB_MODULE(DispCRTMultiScaler, 0);
			else
				err = RM_ERROR;
			break;
		case DCCSurface_SPU:
			err = RM_ERROR;
			break;
		}
		break;
	case DCCRoute_ColorBars:
		err = RM_ERROR;
		break;
	case DCCRoute_HDSD:
		err = RM_ERROR;
		break;
	}

	return err;
}

RMstatus DCCSetSurfaceSource(struct DCC *pDCC, RMuint32 surfaceID, struct DCCVideoSource *pVideoSource)
{
	RMuint32 surface, scaler, mixer;
	RMbool enable;

	scaler = surfaceID;

	if (pVideoSource == NULL) {
		surface = 0;
		DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_Surface, &surface, sizeof(surface));
		scaler = 0;
		mixer = 0;
	}
	else {
		RMuint32 spu_scaler;

		surface = pVideoSource->surface;
		DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_Surface, &surface, sizeof(surface));

		enable = FALSE;
 		DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_PersistentSurface, &enable, sizeof(enable));

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

		mixer = get_mixer_moduleID(pDCC, scaler);

		if (pVideoSource->spu_decoder_moduleID) {
			RMstatus err;
			err = DCCGetScalerModuleID(pDCC, DCCRoute_Main, DCCSurface_SPU, 0, &(pVideoSource->spu_scaler_moduleID));
			if (RMFAILED(err)) {
				RMDBGLOG((ENABLE, "Cannot get SPU scaler for this video source\n"));
				return err;
			}
			spu_scaler = pVideoSource->spu_scaler_moduleID;
		}
		else
			spu_scaler = 0;
		
		if (spu_scaler != 0) {
			struct EMhwlibSubPictureSurface_type spu_surface;
			
			spu_surface.Scaler =  spu_scaler;
			spu_surface.Surface = pVideoSource->spu_surface;
			DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_SubPictureSurface, &spu_surface, sizeof(spu_surface));
			DCCSP(pDCC->pRUA, scaler, RMGenericPropertyID_Validate, NULL, 0);

			DCCSP(pDCC->pRUA, pVideoSource->spu_decoder_moduleID, RMSpuDecoderPropertyID_Scaler, &spu_scaler, sizeof(spu_scaler));
		}
		pVideoSource->scaler_moduleID = scaler;
		pVideoSource->mixer_moduleID = mixer;
	}


	return RM_OK;
} 


RMstatus DCCSetHDSDStandards(struct DCC *pDCC, enum DCCRoute route, enum EMhwlibTVStandard sd_standard, enum EMhwlibTVStandard hd_standard, enum EMhwlibHDSDConversionMode hdsd_mode)
{
#ifdef RMFEATURE_HAS_HDSD_CONVERTER

#if 1
	RMstatus err;
	err = DCCSetMasterConnector(pDCC, DCCVideoConnector_DVI, route, hd_standard);
	if(RMFAILED(err)){
		RMDBGLOG((ENABLE, "Error while setting the DVI connector\n"));
		return err;
	}
	err = DCCSetSDSlaveConnector(pDCC, DCCVideoConnector_COMPOSITE, DCCVideoConnector_DVI, sd_standard, hdsd_mode);
	if(RMFAILED(err)){
		RMDBGLOG((ENABLE, "Error while setting the COMPOSITE connector\n"));
		return err;
	}
	if (DCCGetDoubleRate(hd_standard)) {
		err = DCCSetSDSlaveConnector(pDCC, DCCVideoConnector_COMPONENT, DCCVideoConnector_DVI, sd_standard, hdsd_mode);
		if(RMFAILED(err)){
			RMDBGLOG((ENABLE, "Error while setting the COMPONENT connector\n"));
			return err;
		}
	} else {
		err = DCCSetSlaveConnector(pDCC, DCCVideoConnector_COMPONENT, DCCVideoConnector_DVI, route);
		if(RMFAILED(err)){
			RMDBGLOG((ENABLE, "Error while setting the COMPONENT connector\n"));
			return err;
		}
	}

	return RM_OK;

#else

	enum EMhwlibColorSpace colorspace;

	RMbool enable;
	RMuint32 hd_outport_id, sd_outport_id, hdslave_outport_id, mixer=0;
	RMuint32 routing = EMHWLIB_MODULE(DispRouting, 0); 
	RMuint32 dumped_lines = 0,  bus_size;
	struct DispRouting_Route_type disp_route;
	RMstatus err;

	struct EMhwlibClockGenerator sd_clock_pll;

	struct DispHDSDConverter_OnTheFlyModeParameters_in_type fly_params_in;
	struct DispHDSDConverter_OnTheFlyModeParameters_out_type fly_params_out;

	struct DispHDSDConverter_BufferedModeParameters_in_type buffer_params_in;
	struct DispHDSDConverter_BufferedModeParameters_out_type buffer_params_out;
	struct DispHDSDConverter_Open_type hdsd_open;
	struct DispComponentOut_TimingResetMaster_type reset_master;

 	sd_outport_id = EMHWLIB_MODULE(DispMainAnalogOut, 0);
	hd_outport_id = EMHWLIB_MODULE(DispDigitalOut, 0);
	hdslave_outport_id = EMHWLIB_MODULE(DispComponentOut, 0);

	/*
	  sd_outport_id: 
	                * slave of hd_outport_id
			* reset source of hd_outport_id
			* plugged to the HDSD block route
			* output standard is 'sd_standard'
	  hd_outport_id:
	                * master of sd_outport_id and hdslave_outport_id
			* uses sd_outpourt_id as reset source
			* plugged to the route specifed by the 'route' parameter
			* output standard is 'hd_standard'
	  hdslave_outport_id:
	                * slave of hd_outport_id
			* plugged to the route specifed by the 'route' parameter
			* output standard is 'hd_standard'
			* gets all timing from hd_outport_id
	*/


	switch (route) {
	case DCCRoute_Main:
		mixer = EMHWLIB_MODULE(DispMainMixer, 0);
		break;
	case DCCRoute_Secondary:
#ifdef RMFEATURE_HAS_VCR_MIXER
		mixer = EMHWLIB_MODULE(DispVCRMixer, 0);
		break;
#else
		return RM_ERROR;
#endif
	case DCCRoute_ColorBars:
		mixer = EMHWLIB_MODULE(DispColorBars, 0);
		break;
	}



	/* recover from a previous DCCSetHDSDStandards */
	{
		struct DispHDSDConverter_ConversionBuffer_type conversion_buffer;
		RMstatus err;
		reset_master.ResetSourceID = hd_outport_id;
		reset_master.DelayLines = 0;
		reset_master.DelayPixels = 0;
		DCCSP(pDCC->pRUA, hd_outport_id, RMGenericPropertyID_TimingResetMaster, &reset_master, sizeof(reset_master));
		err = RUAGetProperty(pDCC->pRUA, DispHDSDConverter, RMDispHDSDConverterPropertyID_ConversionBuffer, &conversion_buffer, sizeof(conversion_buffer));
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Cannot get HDSD converter's converison buffer info\n"));
			return err;
		}
		
		DCCSP(pDCC->pRUA, DispHDSDConverter,RMDispHDSDConverterPropertyID_Close, NULL, 0);
		if(conversion_buffer.BufferAddress){
			pDCC->rua_free(pDCC->pRUA, conversion_buffer.BufferAddress);
			RMDBGLOG((ENABLE, "Freed %ld bytes from 0x%08lx\n",conversion_buffer.BufferSize, conversion_buffer.BufferAddress));
		}
	}

	colorspace = EMhwlibColorSpace_RGB_0_255;
	DCCSP(pDCC->pRUA, hd_outport_id, RMGenericPropertyID_ColorSpace, &colorspace, sizeof(colorspace));
	bus_size = 24;
	DCCSP(pDCC->pRUA, hd_outport_id, RMDispDigitalOutPropertyID_BusSize, &bus_size, sizeof(bus_size));



	/* setup routing */
/* 	enable = FALSE; */
/* 	DCCSP(pDCC->pRUA, routing, RMGenericPropertyID_Enable, &enable, sizeof(enable)); */

	disp_route.Enable = TRUE;
	disp_route.SourceModuleID = EMHWLIB_MODULE(DispHDSDConverter, 0);
	disp_route.DestinationModuleID = sd_outport_id;
	DCCSP(pDCC->pRUA, routing, RMDispRoutingPropertyID_Route, &disp_route, sizeof(disp_route));

	disp_route.Enable = TRUE;
	disp_route.SourceModuleID = mixer;
	disp_route.DestinationModuleID = hd_outport_id;
	DCCSP(pDCC->pRUA, routing, RMDispRoutingPropertyID_Route, &disp_route, sizeof(disp_route));

	disp_route.Enable = TRUE;
	disp_route.SourceModuleID = mixer;
	disp_route.DestinationModuleID = hdslave_outport_id;
	DCCSP(pDCC->pRUA, routing, RMDispRoutingPropertyID_Route, &disp_route, sizeof(disp_route));
	
	DCCSP(pDCC->pRUA, routing, RMGenericPropertyID_Validate, NULL, 0);
 	enable = TRUE;
	DCCSP(pDCC->pRUA, routing, RMGenericPropertyID_Enable, &enable, sizeof(enable));


	sd_clock_pll.PLL = PLLGen_cd_9;
	sd_clock_pll.PLLOut = PLL_VIDEO_OUT;
 	DCCSP(pDCC->pRUA, sd_outport_id, RMGenericPropertyID_MasterClockGenerator, &sd_clock_pll, sizeof(sd_clock_pll));
	sd_clock_pll.PLL = PLLGen_cd_8;
	sd_clock_pll.PLLOut = PLL_VIDEO_OUT;
 	DCCSP(pDCC->pRUA, hd_outport_id, RMGenericPropertyID_MasterClockGenerator, &sd_clock_pll, sizeof(sd_clock_pll));

/* 	DCCSP(pDCC->pRUA, hd2_outport_id, RMGenericPropertyID_RemoveSlaveOutput, &sd_outport_id, sizeof(sd_outport_id)); */
/* 	DCCSP(pDCC->pRUA, hd2_outport_id, RMGenericPropertyID_RemoveSlaveOutput, &hd_outport_id, sizeof(hd_outport_id)); */
/* 	DCCSP(pDCC->pRUA, hd2_outport_id, RMGenericPropertyID_Validate, NULL, 0); */
/* 	enable = FALSE; */
/* 	DCCSP(pDCC->pRUA, hd2_outport_id, RMGenericPropertyID_Enable, &enable, sizeof(enable)); */



	RUAExchangeProperty(pDCC->pRUA, DisplayBlock, RMDisplayBlockPropertyID_TVFormatAnalog,
			    &hd_standard, sizeof(hd_standard), &(fly_params_in.HDFormat), sizeof(fly_params_in.HDFormat));

	RUAExchangeProperty(pDCC->pRUA, DisplayBlock, RMDisplayBlockPropertyID_TVFormatAnalog, 
			    &sd_standard, sizeof(sd_standard), &(fly_params_in.SDFormat), sizeof(fly_params_in.SDFormat));

	RUAExchangeProperty(pDCC->pRUA, DisplayBlock, RMDisplayBlockPropertyID_TVFormatAnalog, 
			    &sd_standard, sizeof(sd_standard), &(buffer_params_in.SDFormat), sizeof(buffer_params_in.SDFormat));

	RUAExchangeProperty(pDCC->pRUA, DisplayBlock, RMDisplayBlockPropertyID_TVFormatAnalog, 
			    &sd_standard, sizeof(sd_standard), &(hdsd_open.SDFormat), sizeof(hdsd_open.SDFormat));
	
	switch(hdsd_mode){