pictcont.c

IT projecotr reference design.

	    if( srcDesc->isYUV == TRUE )
	    {
	        switch( srcDesc->connector )
	        {
	            case SVIDEO:
	            case COMPONENT:
	            case COMPOSITE:
	                /* Use BT.601 offset YUV CSC for video decoder if using BT.656 */
                    tableIndex = SRC_CSC_TABLE2;
                    tempOffset = -16 * 4;  /* -16 in s8.2 format */
	                break;
	              
	            case VGA:
	                /* Use full range YUV CSC */
	                tableIndex = SRC_CSC_TABLE7;
	                tempOffset = 0;
	                break;
	               
	            case DVI:
	                /* Use BT.601 offset YUV CSC */
	                tableIndex = SRC_CSC_TABLE2;
	                tempOffset = -16 * 4;  /* -16 in s8.2 format */
	                break;
	                
	            default:
	                break;
	        }
	    }
	    else
	    {
	        switch( srcDesc->connector )
	        {
	            case SVIDEO:
	            case COMPONENT:
	            case COMPOSITE:
	            case VGA:         
	            case DVI:
	                /* use full range RGB CSC */
	                tableIndex = SRC_CSC_TABLE0;
	                tempOffset = 0;
	                break;
	                
	            default:
	                break;
	        }
	    }
    }    
    
    /* remove the previous offset and apply the new offset (must be combined with the current internal brightness setting) */    
    if( tempOffset != internalOffset )
    {
        if( SRC_GetSourceConfiguration( srcDesc->port, &sourceConfig ) != PASS )
            return FAIL;
        if( srcDesc->isYUV )
        {
            sourceConfig.Offset[1] += ( tempOffset - internalOffset );
        }
        else
        {
            sourceConfig.Offset[0] += ( tempOffset - internalOffset );
            sourceConfig.Offset[1] += ( tempOffset - internalOffset );
            sourceConfig.Offset[2] += ( tempOffset - internalOffset );
        }
        if( SRC_SetOffset( srcDesc->port, sourceConfig.Offset[0], sourceConfig.Offset[1], sourceConfig.Offset[2]) != PASS )
            return FAIL;
    }
    
    /* load the CSC table */
    
    dbmsg_ftrace( DBM_ALWAYS, "tableIndex %d \r\n", tableIndex );
    
    if( SRC_SetCSCTable( srcDesc->port, tableIndex ) != PASS )
    {       
        /* if this fails, set the internal offset back the way it was */
        if( tempOffset != internalOffset )
        {
            if( srcDesc->isYUV ) 
            {
                sourceConfig.Offset[1] -= ( tempOffset - internalOffset );
            }
            else
            {
                sourceConfig.Offset[0] -= ( tempOffset - internalOffset );
                sourceConfig.Offset[1] -= ( tempOffset - internalOffset );
                sourceConfig.Offset[2] -= ( tempOffset - internalOffset );
            }
            if( SRC_SetOffset( srcDesc->port, sourceConfig.Offset[0], sourceConfig.Offset[1], sourceConfig.Offset[2]) != PASS )
                return FAIL;
        }
        return FAIL;
    }
    
    /* update the internal offset */
    internalOffset = tempOffset;    

    return PASS;
}


/****************************************************************************/
/* HSG Hue Controls                                                         */
/****************************************************************************/
int08 pictcont_GetHSGHueSatGain( int16 colour, int16 *hue, int16 *saturation, int16 *gain)
{
    IMG_HSG HSGStruct;
    IMG_HSG_PARAM *HSGparam_struct_ptr = NULL;
    
    IMG_PCC_GetHSG(&HSGStruct);

    switch ( colour )
    {
        case HSG_RED:
                    HSGparam_struct_ptr = &HSGStruct.Red;
                    break;
        case HSG_GREEN:
                    HSGparam_struct_ptr  = &HSGStruct.Green;
                    break;
        case HSG_BLUE:
                    HSGparam_struct_ptr  = &HSGStruct.Blue;
                    break;
        case HSG_CYAN:
                    HSGparam_struct_ptr  = &HSGStruct.Cyan;
                    break;
        case HSG_MAGENTA:
                    HSGparam_struct_ptr  = &HSGStruct.Magenta;
                    break;
        case HSG_YELLOW:
                    HSGparam_struct_ptr  = &HSGStruct.Yellow;
                    break;
    }
    
    *hue         = HSGparam_struct_ptr->Hue / HSG_HUE_SCALEFACTOR;
    *saturation  = HSGparam_struct_ptr->Saturation / HSG_SATURATION_SCALEFACTOR;
    *gain        = HSGparam_struct_ptr->Gain / HSG_GAIN_SCALEFACTOR;
    
	return PASS;    
}

int08 pictcont_SetAllHSGColorValues( struct colorvaluesstruct *colorValues )
{
    IMG_HSG HSGStruct;
    
    IMG_PCC_GetHSG(&HSGStruct);    

    HSGStruct.Red.Hue             = colorValues[HSG_RED].Hue * HSG_HUE_SCALEFACTOR;
    HSGStruct.Red.Saturation      = colorValues[HSG_RED].Saturation * HSG_SATURATION_SCALEFACTOR;
    HSGStruct.Red.Gain            = colorValues[HSG_RED].Gain * HSG_GAIN_SCALEFACTOR;
    HSGStruct.Green.Hue           = colorValues[HSG_GREEN].Hue * HSG_HUE_SCALEFACTOR;
    HSGStruct.Green.Saturation    = colorValues[HSG_GREEN].Saturation * HSG_SATURATION_SCALEFACTOR;
    HSGStruct.Green.Gain          = colorValues[HSG_GREEN].Gain * HSG_GAIN_SCALEFACTOR;
    HSGStruct.Blue.Hue            = colorValues[HSG_BLUE].Hue * HSG_HUE_SCALEFACTOR;
    HSGStruct.Blue.Saturation     = colorValues[HSG_BLUE].Saturation * HSG_SATURATION_SCALEFACTOR;
    HSGStruct.Blue.Gain           = colorValues[HSG_BLUE].Gain * HSG_GAIN_SCALEFACTOR;
    HSGStruct.Cyan.Hue            = colorValues[HSG_CYAN].Hue * HSG_HUE_SCALEFACTOR;
    HSGStruct.Cyan.Saturation     = colorValues[HSG_CYAN].Saturation * HSG_SATURATION_SCALEFACTOR;
    HSGStruct.Cyan.Gain           = colorValues[HSG_CYAN].Gain * HSG_GAIN_SCALEFACTOR;
    HSGStruct.Magenta.Hue         = colorValues[HSG_MAGENTA].Hue * HSG_HUE_SCALEFACTOR;
    HSGStruct.Magenta.Saturation  = colorValues[HSG_MAGENTA].Saturation * HSG_SATURATION_SCALEFACTOR;
    HSGStruct.Magenta.Gain        = colorValues[HSG_MAGENTA].Gain * HSG_GAIN_SCALEFACTOR;
    HSGStruct.Yellow.Hue          = colorValues[HSG_YELLOW].Hue * HSG_HUE_SCALEFACTOR;
    HSGStruct.Yellow.Saturation   = colorValues[HSG_YELLOW].Saturation * HSG_SATURATION_SCALEFACTOR;
    HSGStruct.Yellow.Gain         = colorValues[HSG_YELLOW].Gain * HSG_GAIN_SCALEFACTOR;
    
	return IMG_PCC_ApplyHSG(&HSGStruct);    
}

int08 pictcont_GetHSGHueLimits( int16 *min, int16 *max )
{         
    DP_SOURCEDESC *srcDesc;

    datapath_GetSourceDesc( &srcDesc );
    if( srcDesc->sourceActive )
    {
        switch( srcDesc->connector )
	    {
	        case SVIDEO:
	        case COMPONENT:
	        case COMPOSITE:
	        case VGA:
	        case DVI: 
	           /* set value for OSD sliders */
	           *min = -100;
	           *max = 99;
	           break;
	            
	        default:
	           return FAIL;
	     }     
	     return PASS;
	}
	else
	    return FAIL;
}

int08 pictcont_SetHSGHue( int16 colour, int16 hue )
{
    IMG_HSG HSGStruct;
    IMG_HSG_PARAM *HSGparam_struct_ptr = NULL;
    int16 min, max;
    
    pictcont_GetHSGHueLimits( &min, &max );
    
	if ((hue < min) || (hue > max))
    	return FAIL;
    
    IMG_PCC_GetHSG(&HSGStruct);

    switch ( colour )
    {
        case HSG_RED:
                    HSGparam_struct_ptr = &HSGStruct.Red;
                    break;
        case HSG_GREEN:
                    HSGparam_struct_ptr  = &HSGStruct.Green;
                    break;
        case HSG_BLUE:
                    HSGparam_struct_ptr  = &HSGStruct.Blue;
                    break;
        case HSG_CYAN:
                    HSGparam_struct_ptr  = &HSGStruct.Cyan;
                    break;
        case HSG_MAGENTA:
                    HSGparam_struct_ptr  = &HSGStruct.Magenta;
                    break;
        case HSG_YELLOW:
                    HSGparam_struct_ptr  = &HSGStruct.Yellow;
                    break;
    }
    
	HSGparam_struct_ptr->Hue = hue * HSG_HUE_SCALEFACTOR;
    
	return IMG_PCC_ApplyHSG(&HSGStruct);
    
}

int08 pictcont_GetHSGGainLimits( int16 *min, int16 *max )
{         
    DP_SOURCEDESC *srcDesc;

    datapath_GetSourceDesc( &srcDesc );
    if( srcDesc->sourceActive )
    {
        switch( srcDesc->connector )
	    {
	        case SVIDEO:
	        case COMPONENT:
	        case COMPOSITE:
	        case VGA:
	        case DVI: 
	           /* set value for OSD sliders */
	           *min = 0;
	           *max = 199;
	           break;
	            
	        default:
	           return FAIL;
	     }     
	     return PASS;
	}
	else
	    return FAIL;
}

int08 pictcont_SetHSGGain( int16 colour, int16 gain )
{
    IMG_HSG HSGStruct;
    IMG_HSG_PARAM *HSGparam_struct_ptr = NULL;
    int16 min, max;
    
    pictcont_GetHSGGainLimits( &min, &max );
    
	if ((gain < min) || (gain > max))
    	return FAIL;
    
    IMG_PCC_GetHSG(&HSGStruct);

    switch ( colour )
    {
        case HSG_RED:
                    HSGparam_struct_ptr = &HSGStruct.Red;
                    break;
        case HSG_GREEN:
                    HSGparam_struct_ptr  = &HSGStruct.Green;
                    break;
        case HSG_BLUE:
                    HSGparam_struct_ptr  = &HSGStruct.Blue;
                    break;
        case HSG_CYAN:
                    HSGparam_struct_ptr  = &HSGStruct.Cyan;
                    break;
        case HSG_MAGENTA:
                    HSGparam_struct_ptr  = &HSGStruct.Magenta;
                    break;
        case HSG_YELLOW:
                    HSGparam_struct_ptr  = &HSGStruct.Yellow;
                    break;
    }
    
	HSGparam_struct_ptr->Gain = gain * HSG_GAIN_SCALEFACTOR;
    
	return IMG_PCC_ApplyHSG(&HSGStruct);

}

int08 pictcont_GetHSGSaturationLimits( int16 *min, int16 *max )
{         
    DP_SOURCEDESC *srcDesc;

    datapath_GetSourceDesc( &srcDesc );
    if( srcDesc->sourceActive )
    {
        switch( srcDesc->connector )
	    {
	        case SVIDEO:
	        case COMPONENT:
	        case COMPOSITE:
	        case VGA:
	        case DVI: 
	           /* set value for OSD sliders */
	           *min = 0;
	           *max = 199;
	           break;
	            
	        default:
	           return FAIL;
	     }     
	     return PASS;
	}
	else
	    return FAIL;
}

int08 pictcont_SetHSGSaturation( int16 colour, int16 saturation )
{
    IMG_HSG HSGStruct;
    IMG_HSG_PARAM *HSGparam_struct_ptr = NULL;
    int16 min, max;
    
    pictcont_GetHSGSaturationLimits( &min, &max );
    
	if ((saturation < min) || (saturation > max))
    	return FAIL;
    
    IMG_PCC_GetHSG(&HSGStruct);

    switch ( colour )
    {
        case HSG_RED:
                    HSGparam_struct_ptr = &HSGStruct.Red;
                    break;
        case HSG_GREEN:
                    HSGparam_struct_ptr  = &HSGStruct.Green;
                    break;
        case HSG_BLUE:
                    HSGparam_struct_ptr  = &HSGStruct.Blue;
                    break;
        case HSG_CYAN:
                    HSGparam_struct_ptr  = &HSGStruct.Cyan;
                    break;
        case HSG_MAGENTA:
                    HSGparam_struct_ptr  = &HSGStruct.Magenta;
                    break;
        case HSG_YELLOW:
                    HSGparam_struct_ptr  = &HSGStruct.Yellow;
                    break;
    }
    
	HSGparam_struct_ptr->Saturation = saturation * HSG_SATURATION_SCALEFACTOR;
    
	return IMG_PCC_ApplyHSG(&HSGStruct);

}

int08 pictcont_GetHSGWhiteGainsLimits( int16 *min, int16 *max )
{         
    DP_SOURCEDESC *srcDesc;

    datapath_GetSourceDesc( &srcDesc );
    if( srcDesc->sourceActive )
    {
        switch( srcDesc->connector )
	    {
	        case SVIDEO:
	        case COMPONENT:
	        case COMPOSITE:
	        case VGA:
	        case DVI: 
	           /* set value for OSD sliders */
	           *min = 0;
	           *max = 199;
	           break;
	            
	        default:
	           return FAIL;
	     }     
	     return PASS;
	}
	else
	    return FAIL;
}

int08 pictcont_SetAllHSGWhiteGains( int16 redGain, int16 greenGain, int16 blueGain )
{
    IMG_HSG HSGStruct;
    int16 min, max;
    
    pictcont_GetHSGWhiteGainsLimits( &min, &max );
    
	if ((redGain < min) || (redGain > max))
    	return FAIL;
    
	if ((greenGain < min) || (greenGain > max))
    	return FAIL;

	if ((blueGain < min) || (blueGain > max))
    	return FAIL;

    IMG_PCC_GetHSG(&HSGStruct);

	HSGStruct.White.RedGain   = redGain * WHITEGAINSCALEFACTOR;
	HSGStruct.White.GreenGain = greenGain * WHITEGAINSCALEFACTOR;
	HSGStruct.White.BlueGain  = blueGain * WHITEGAINSCALEFACTOR;

	return IMG_PCC_ApplyHSG(&HSGStruct);
}


/****************************************************************************/
/* Gamma user controls                                                      */
/****************************************************************************/
int08 pictcont_GetGamma( uint08 *gammaTable )
{
    *gammaTable = IMG_GAM_GetLut();
    return PASS;
}