dcc_display.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

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

#include "dcc_common.h"

static RMuint32 get_mixer_moduleID(struct DCC *pDCC, RMuint32 scaler)
{
	enum RMcategoryID category = EMHWLIB_MODULE_CATEGORY(scaler);
	
	switch (category) {
	case DispVCRMultiScaler:
	case DispCRTMultiScaler:
	case DispGFXMultiScaler:
#ifdef RMFEATURE_HAS_VCR_MIXER
		{
			RMstatus err;
			enum EMhwlibMixerSourceState state;
			RMuint32 src_index;
			
			// Is scaler in master mode on VCRMixer?
			err = RUAExchangeProperty(pDCC->pRUA, 
				EMHWLIB_MODULE(DispVCRMixer, 0), 
				RMGenericPropertyID_MixerSourceIndex, 
				&category, sizeof(category), 
				&src_index, sizeof(src_index));
			if (RMSUCCEEDED(err)) {
				err = RUAGetProperty(pDCC->pRUA, 
					EMHWLIB_TARGET_MODULE(DispVCRMixer, 0, src_index), 
					RMGenericPropertyID_MixerSourceState, 
					&state, sizeof(state));
				if (RMSUCCEEDED(err) && (state == EMhwlibMixerSourceState_Master)) {
					return EMHWLIB_MODULE(DispVCRMixer, 0);
				}
			}
		}
		/* no break */
#endif
	case DispMainVideoScaler:
#ifdef RMFEATURE_HAS_SPU_SCALER
	case DispSubPictureScaler:
#endif
#ifdef RMFEATURE_HAS_VIDEO_PLANE
	case DispVideoPlane:
#endif
	case DispOSDScaler:
		return EMHWLIB_MODULE(DispMainMixer, 0);
	default:
		return 0;
	}
	
	return 0;
}


static RMstatus get_mixer_from_route(enum DCCRoute route, RMuint32 *mixer)
{
	switch (route) {
	case DCCRoute_Main:
		*mixer = EMHWLIB_MODULE(DispMainMixer, 0);
		return RM_OK;
	case DCCRoute_Secondary:
#ifdef RMFEATURE_HAS_VCR_MIXER
		*mixer = EMHWLIB_MODULE(DispVCRMixer, 0);
		return RM_OK;
#else
#ifdef RMFEATURE_HAS_VCR_CHANNEL
		*mixer = EMHWLIB_MODULE(DispVCRMultiScaler, 0);
		return RM_OK;
#else
		return RM_ERROR;
#endif
#endif
	case DCCRoute_HDSD:   /* TO BE REMOVED */
		*mixer = EMHWLIB_MODULE(DispHDSDConverter, 0);
		return RM_OK;
	case DCCRoute_ColorBars:
		*mixer = EMHWLIB_MODULE(DispColorBars, 0);
		return RM_OK;
	}
	RMDBGLOG((ENABLE, "Invalid route\n"));
	return RM_ERROR;
}


static RMstatus get_route_from_mixer( RMuint32 mixer, enum DCCRoute *route)
{
	switch (EMHWLIB_MODULE_CATEGORY(mixer)) {
	case DispMainMixer: 
#ifdef RMFEATURE_HAS_HDSD_CONVERTER
	case DispHDSDConverter:
#endif
		*route = DCCRoute_Main;
		break;
	case DispVCRMixer: 
#ifdef RMFEATURE_HAS_CRT_CHANNEL
	case DispCRTMultiScaler: 
#endif
#ifdef RMFEATURE_HAS_VCR_CHANNEL
 	case DispVCRMultiScaler: 
#endif
		*route = DCCRoute_Secondary;
		break;
	case DispColorBars: 
		*route = DCCRoute_Main;
		break;
	default:
		return RM_ERROR;
	}
	
	return RM_OK;
}





/* this makes the outport stop being slave of other outports */
static RMstatus unbind_outport(struct DCC *pDCC, RMuint32 outport_id)
{
	struct DispComponentOut_TimingResetMaster_type reset_master;
	outport_id = EMHWLIB_MODULE_CATEGORY(outport_id);
	reset_master.ResetSourceID = outport_id;
	reset_master.DelayLines = 0;
	reset_master.DelayPixels = 0;

	DCCSP(pDCC->pRUA, outport_id, RMGenericPropertyID_TimingResetMaster, &reset_master, sizeof(reset_master));
/* 	DCCSP(pDCC->pRUA, outport_id, RMGenericPropertyID_Validate, NULL, 0); */

	if(outport_id != DispDigitalOut){
		DCCSP(pDCC->pRUA, DispDigitalOut, RMGenericPropertyID_RemoveSlaveOutput, &outport_id, sizeof(outport_id));
		DCCSP(pDCC->pRUA, DispDigitalOut, RMGenericPropertyID_Validate, NULL, 0);

	}
/* 	else 	RMDBGLOG((ENABLE, "unbinding digital\n")); */
#ifdef RMFEATURE_HAS_COMPONENT_OUT
	if(outport_id != DispComponentOut){
		DCCSP(pDCC->pRUA, DispComponentOut, RMGenericPropertyID_RemoveSlaveOutput, &outport_id, sizeof(outport_id));
		DCCSP(pDCC->pRUA, DispComponentOut, RMGenericPropertyID_Validate, NULL, 0);

	}
/* 	else 	RMDBGLOG((ENABLE, "unbinding component\n")); */
#endif

	if(outport_id != DispMainAnalogOut){
		DCCSP(pDCC->pRUA, DispMainAnalogOut, RMGenericPropertyID_RemoveSlaveOutput, &outport_id, sizeof(outport_id));
		DCCSP(pDCC->pRUA, DispMainAnalogOut, RMGenericPropertyID_Validate, NULL, 0);

	}
/* 	else 	RMDBGLOG((ENABLE, "unbinding main analog\n")); */

#ifdef RMFEATURE_HAS_COMPOSITE_OUT
	if(outport_id != DispCompositeOut){
		DCCSP(pDCC->pRUA, DispCompositeOut, RMGenericPropertyID_RemoveSlaveOutput, &outport_id, sizeof(outport_id));
		DCCSP(pDCC->pRUA, DispCompositeOut, RMGenericPropertyID_Validate, NULL, 0);
	}
#endif

	return RM_OK;
}

RMstatus DCCGetRouteVCXO(enum DCCRoute route, RMuint32 *vcxo)
{
	/* connect the outport clock to the route VCXO */
	switch (route) {
	case DCCRoute_Main:
		*vcxo = EMHWLIB_MODULE(VCXO, 0);
		break;
	case DCCRoute_Secondary:
		*vcxo = EMHWLIB_MODULE(VCXO, 1);
		break;
	case DCCRoute_ColorBars:
		*vcxo = EMHWLIB_MODULE(VCXO, 2);
		break;
	default:
		RMDBGLOG((ENABLE, "Invalid route %d\n", route));
		return RM_ERROR;
	}
	
	return RM_OK;
}

RMstatus DCCSetRouteDisplayAspectRatio(struct DCC *pDCC, enum DCCRoute route, RMuint8 ar_x, RMuint8 ar_y)
{
	struct EMhwlibAspectRatio dar;
	RMuint32 mixer;
	
	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
#ifdef RMFEATURE_HAS_VCR_CHANNEL
		return RM_NOTIMPLEMENTED;
#else
		return RM_ERROR;
#endif
#endif
	case DCCRoute_ColorBars:
		return RM_OK;
	default:
		return RM_ERROR;
	}
	
	dar.X = ar_x;
	dar.Y = ar_y;	
	DCCSP(pDCC->pRUA, mixer, RMGenericPropertyID_DisplayAspectRatio, &dar, sizeof(dar));

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

	return RM_OK;
}

RMstatus DCCSetRouteDisplayAspectRatioFromSource(struct DCC *pDCC, enum DCCRoute route, RMuint32 scaler) //enum DCCSurface surface, RMuint32 index)
{
	struct EMhwlibAspectRatio dar;
	RMuint32 mixer;
	RMuint32 src_index;
	RMstatus err;
	
	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
#ifdef RMFEATURE_HAS_VCR_CHANNEL
		return RM_NOTIMPLEMENTED;
#else
		return RM_ERROR;
#endif
#endif
	case DCCRoute_ColorBars:
		return RM_OK;
	default:
		return RM_ERROR;
	}

	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(EMHWLIB_MODULE_CATEGORY(mixer), 0, src_index);
	
	dar.X = 0;
	dar.Y = 0;
	DCCSP(pDCC->pRUA, mixer, RMGenericPropertyID_DisplayAspectRatio, &dar, sizeof(dar));

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

	return RM_OK;
}

/* returns TRUE if the mode requires to set the DoubleRate feature on the digital output */
RMbool DCCGetDoubleRate(enum EMhwlibTVStandard standard)
{
	switch (standard) {
		case EMhwlibTVStandard_HDMI_480i59: 
		case EMhwlibTVStandard_HDMI_480i60: 
		case EMhwlibTVStandard_HDMI_240p59: 
		case EMhwlibTVStandard_HDMI_240p60: 
		case EMhwlibTVStandard_HDMI_576i50: 
		case EMhwlibTVStandard_HDMI_288p50: 
		case EMhwlibTVStandard_HDMI_576i100: 
		case EMhwlibTVStandard_HDMI_480i119: 
		case EMhwlibTVStandard_HDMI_480i120: 
		case EMhwlibTVStandard_HDMI_576i200: 
		case EMhwlibTVStandard_HDMI_480i239: 
		case EMhwlibTVStandard_HDMI_480i240: 
			return TRUE;
		default:
			return FALSE;
	}
}

RMstatus DCCSetMasterConnector(struct DCC *pDCC,
			       enum DCCVideoConnector connector,
			       enum DCCRoute route,
			       enum EMhwlibTVStandard standard)
{
	RMbool enable;
	RMuint32 master, mixer=0;
	RMuint32 bus_size = 24;
	enum EMhwlibColorSpace colorspace;
	RMuint32 routing = EMHWLIB_MODULE(DispRouting, 0); 
	struct DispRouting_Route_type disp_route;
	RMstatus err;

	if (RMFAILED(err = DCCGetVideoConnectorModuleID(pDCC, route, connector, &master))) 
		return err;

	if (RMFAILED(err = get_mixer_from_route(route, &mixer))) 
		return err;

	unbind_outport(pDCC, master);

	colorspace = EMhwlibColorSpace_RGB_0_255;
	DCCSP(pDCC->pRUA, master, RMGenericPropertyID_ColorSpace, &colorspace, sizeof(colorspace));
	if (EMHWLIB_MODULE_CATEGORY(master) == DispDigitalOut) {
		RMbool DoubleRate;
		DCCSP(pDCC->pRUA, master, RMDispDigitalOutPropertyID_BusSize, &bus_size, sizeof(bus_size));
		DoubleRate = DCCGetDoubleRate(standard);
		RMDBGLOG((LOCALDBG, "Applying DoubleRate(%s)\n", DoubleRate ? "TRUE" : "FALSE"));
		DCCSP(pDCC->pRUA, DispDigitalOut, RMDispDigitalOutPropertyID_DoubleRate, &DoubleRate, sizeof(DoubleRate));
	}
	DCCSP(pDCC->pRUA, master, RMGenericPropertyID_TVStandard, &standard, sizeof(standard));
	DCCSP(pDCC->pRUA, master, RMGenericPropertyID_SyncSourceModuleID, &master, sizeof(master));
	DCCSP(pDCC->pRUA, master, RMGenericPropertyID_Validate, NULL, 0);
	
 	enable = TRUE;
	DCCSP(pDCC->pRUA, master, RMGenericPropertyID_Enable, &enable, sizeof(enable));

	disp_route.Enable = TRUE;
	disp_route.SourceModuleID = mixer;
	disp_route.DestinationModuleID = master;
	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));

	return RM_OK;

}

RMstatus DCCSetSlaveConnector(struct DCC *pDCC,
			      enum DCCVideoConnector slave_connector,
			      enum DCCVideoConnector master_connector,
			      enum DCCRoute route)
{

	RMbool enable;
	RMuint32 master, slave, mixer=0;
	RMuint32 routing = EMHWLIB_MODULE(DispRouting, 0); 
	struct DispRouting_Route_type disp_route;
	enum EMhwlibTVStandard standard;
	RMstatus err;


	if (RMFAILED(err = DCCGetVideoConnectorModuleID(pDCC, DCCRoute_Main, master_connector, &master))) 
		return err;