pictcont.c

IT projecotr reference design.

/*****************************************************************************
**             TEXAS INSTRUMENTS PROPRIETARY INFORMATION
**
**  (c) Copyright, Texas Instruments Incorporated, 2006.
**      All Rights Reserved.
**
**  Property of Texas Instruments Incorporated. Restricted Rights -
**  Use, duplication, or disclosure is subject to restrictions set
**  forth in TI's program license agreement and associated documentation.
******************************************************************************/
/****************************************************************************/
/* pictcont.c                                                               */
/*                                                                          */
/* pictcont: Implements control functions to configure internal and         */
/*           picture controls such as brightness, contrast, and CSC         */
/****************************************************************************/

#include "common.h"
#include "src.h"
#include "img.h"
#include "disp.h"
#include "anr.h"
#include "splash.h"
#include "flash_table.h"
#include "tmr.h"
#include "ddp2230_rtos_include.h"
#include "global.h"

#include "pictcont.h"
#include "datapath.h"
#include "app_cfg.h"
#include "eeprom.h"
#include "TVP5146.h"
#include "dbmessage.h"
#include "guiStyle.h"
#include "guiApp.h"

int16 internalOffset;  //offset used in internal brightness/CSC controls
uint08 lastSetColorTempEnum;



void pictcont_InitializeOnce( void )
{
    if ( ANR_Init() != PASS )
        dbmsg_ftrace( DBM_DPATH, "ANR Task failed to initialize\r\n");
    
    /* The following only need to be set once */
    IMG_EnableAlgorithm( SRC_PRIMARY, IMG_ALG_NBM,      TRUE );
    IMG_EnableAlgorithm( SRC_PRIMARY, IMG_ALG_CHI,      TRUE );
    IMG_EnableAlgorithm( SRC_PRIMARY, IMG_ALG_CTI,      FALSE );
    IMG_EnableAlgorithm( SRC_PRIMARY, IMG_ALG_GAMMA,    TRUE );
    IMG_EnableAlgorithm( SRC_PRIMARY, IMG_ALG_CCA,      TRUE );
    IMG_EnableAlgorithm( SRC_PRIMARY, IMG_ALG_STM,      TRUE );
    
    pictcont_SetBrilliantColor( TRUE );
    pictcont_SetBrilliantColorLook( 0 );
//    pictcont_SetSequenceGroup( 0 );
    pictcont_SetWhitePeaking( 10 );
    pictcont_SetGamma( 0 );
}

/****************************************************************************/
/* Set internal picture controls to nominal for SFG, Splash, and TPG        */
/****************************************************************************/
int08 pictcont_ConfigureForInternalSource( void )
{
    SRC_SetOffset( SRC_PORT1, 0, 0, 0 );
    IMG_CSC_SetContrastAdjustment( SRC_PRIMARY, 100 );
    IMG_CSC_SetHueAndColorAdjustment( SRC_PRIMARY, 0, 100 );
    SRC_SetCSCTable( SRC_PORT1, 0 );
    IMG_CSC_SetRGBGainAdjustment( SRC_PRIMARY, 100, 100, 100 );

    return PASS;
}

/****************************************************************************/
/* Set picture controls for external sources                                */
/****************************************************************************/
int08 pictcont_ConfigureForExternalSource( void )
{
    DP_SOURCEDESC *srcDesc;

    int16                    tempBrightness;
    int16                    tempContrast;
    int16                    tempHue;
    int16                    tempColor;
    int16                    tempSharpness;
    uint08                   tempColorSpace;
    BOOL                     tempNoiseReduction;
    uint08                   tempGamma;
    uint08                   tempWhitePeaking;
    struct colorvaluesstruct tempHSGSettings[NUM_HSG_COLORS];
    int16                    tempHSGWhiteRedGain;
    int16                    tempHSGWhiteGreenGain;
    int16                    tempHSGWhiteBlueGain;
    uint08                   tempBrilliantColorLook;
    uint08                   i;
    
    datapath_GetSourceDesc( &srcDesc );
    internalOffset = 0;    
    
    /* read all picture controls settings from the EEPROM */
    EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].Brightness, tempBrightness );
    EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].Contrast, tempContrast );
    EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].Hue, tempHue );
    EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].Color, tempColor );
    EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].Sharpness, tempSharpness );
    EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].ColorSpace, tempColorSpace );
    EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].NoiseReduction, tempNoiseReduction );
    EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].Gamma, tempGamma );
    EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].WhitePeaking, tempWhitePeaking );
    EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].BrilliantColorLook, tempBrilliantColorLook );
    
    for( i = 0; i < NUM_HSG_COLORS; i++ )
    {
        EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].HSGColorValues[i], tempHSGSettings[i] );
    }
    EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].HSGWhiteRedGain, tempHSGWhiteRedGain );
    EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].HSGWhiteGreenGain, tempHSGWhiteGreenGain );
    EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].HSGWhiteBlueGain, tempHSGWhiteBlueGain );

    /* set hardware to match EEPROM */
    pictcont_SetBrightness( tempBrightness );
    pictcont_SetContrast( tempContrast );
    pictcont_SetHue( tempHue );
    pictcont_SetColor( tempColor );
    pictcont_SetSharpness( tempSharpness );
    pictcont_SetColorSpace( tempColorSpace );
    pictcont_SetNoiseReduction( tempNoiseReduction );
    pictcont_SetGamma( tempGamma );
    pictcont_SetWhitePeaking( tempWhitePeaking );
    pictcont_SetBrilliantColorLook( tempBrilliantColorLook );
    pictcont_SetAllHSGColorValues( tempHSGSettings );
    pictcont_SetAllHSGWhiteGains( tempHSGWhiteRedGain, tempHSGWhiteGreenGain, tempHSGWhiteBlueGain );
            
    /* Chroma Transient Improvement setup - enable for SDTV sources */
    if( srcDesc->isYUV && !srcDesc->isHighDefinitionVideo && srcDesc->okToDeinterlace)
    {   
        if( srcDesc->connector == COMPOSITE )
        {
            IMG_CTI_Setup( FALSE ); /* FALSE == SDTV center frequency*/
            IMG_CTI_SetGain( IMG_CTI_GAIN_1 );
        }
        else // s-video or component interlaced
        {
            IMG_CTI_Setup( TRUE ); /* decrease strength */
            IMG_CTI_SetGain( IMG_CTI_GAIN_8 );
        }
        IMG_EnableAlgorithm( SRC_PRIMARY, IMG_ALG_CTI, TRUE );   
    }
    else
    { 
        IMG_EnableAlgorithm( SRC_PRIMARY, IMG_ALG_CTI, FALSE );   
    }
    return PASS;
}


/****************************************************************************/
/* Brightness user controls                                                 */
/****************************************************************************/
int08 pictcont_GetBrightnessLimits( int16 *min, int16 *max )
{
    DP_SOURCEDESC *srcDesc;
    ALC_LimitStruct limits;

    datapath_GetSourceDesc( &srcDesc );
    if( srcDesc->sourceActive )
    {
	    switch( srcDesc->connector )
	    {
	        case SVIDEO:
	        case COMPONENT:
	        case COMPOSITE: 
	            *min = 0;   /* from videodecoder driver */
	            *max = 255;            
	            break;
	          
	        case VGA:
	            if( ALC_GetOffsetLimits( &limits ) != PASS )
	                return FAIL;
	            *min = limits.LowerLimit - srcDesc->alcOffset.Green;
	            *max = limits.UpperLimit - srcDesc->alcOffset.Green;
	            break;
	           
	        case DVI: 
	            *min = -1024 + internalOffset;  /* -256.00 in s8.2 format (from SRC_SOURCE_CONFIG::Offset[3]) */
	            *max = 1023 + internalOffset;   /*  255.75 in s8.2 format (from SRC_SOURCE_CONFIG::Offset[3]) */
	            break;

	        default:
	            return FAIL;
	    } 
	}
	else
	    return FAIL;
    
    return PASS;
}


int08 pictcont_GetBrightness( int16 *value )
{
    ALC_RGB16Struct alcOffset;
    DP_SOURCEDESC *srcDesc;    
    SRC_SOURCE_CONFIG sourceConfig;
    uint08 temp08;
    
    datapath_GetSourceDesc( &srcDesc );
    if ( !srcDesc->sourceActive )
        return FAIL;    
    
    switch( srcDesc->connector )
    {
        case SVIDEO:
        case COMPONENT:
        case COMPOSITE:
            if( DEC_GetOffset( &temp08 ) != PASS )
                return FAIL;
            *value = (int16) temp08;
            break;
          
        case VGA:
            if( ALC_GetOffset( &alcOffset ) != PASS )
                return FAIL;  
            *value = (int16) (alcOffset.Green - srcDesc->alcOffset.Green);
            break;
           
        case DVI:
            SRC_GetSourceConfiguration( srcDesc->port, &sourceConfig );
            *value = sourceConfig.Offset[1] - internalOffset;
            break;

        default:
            return FAIL;
    }
    return PASS;
}

int08 pictcont_SetBrightness( int16 value )
{
    int16 min, max;
    DP_SOURCEDESC *srcDesc;
    SRC_SOURCE_CONFIG sourceConfig;    
    
    datapath_GetSourceDesc( &srcDesc );
    if ( !srcDesc->sourceActive )
        return FAIL;
          
    pictcont_GetBrightnessLimits( &min, &max );
    if( value < min || value > max )
        return FAIL;
            
    switch( srcDesc->connector )
    {
        case SVIDEO:
        case COMPONENT:
        case COMPOSITE:
            if( DEC_SetOffset( (int08) value ) != PASS )
                return FAIL;
            break;
          
        case VGA:
            if( srcDesc->isYUV )
            {
                if( ALC_SetOffset( srcDesc->alcOffset.Red, (uint16) srcDesc->alcOffset.Green + value, srcDesc->alcOffset.Blue ) != PASS )
                    return FAIL;
            }
            else
            {
                if( ALC_SetOffset( (uint16) srcDesc->alcOffset.Red + value,
                                   (uint16) srcDesc->alcOffset.Green + value,
                                   (uint16) srcDesc->alcOffset.Blue + value ) != PASS )
                    return FAIL;
            }
            break;
           
        case DVI:
            if( SRC_GetSourceConfiguration( srcDesc->port, &sourceConfig ) != PASS )
                return FAIL;
            if( srcDesc->isYUV )
            {
                sourceConfig.Offset[1] = (int16) value + internalOffset;
            }
            else
            {
                sourceConfig.Offset[0] = (int16) value + internalOffset;
                sourceConfig.Offset[1] = (int16) value + internalOffset;
                sourceConfig.Offset[2] = (int16) value + internalOffset;
            }
            if( SRC_SetOffset( srcDesc->port, sourceConfig.Offset[0], sourceConfig.Offset[1], sourceConfig.Offset[2]) != PASS )
                return FAIL;
            break;

        default:
            return FAIL;
    }
    
    return PASS;
}

/****************************************************************************/
/* Contrast user controls                                                   */
/****************************************************************************/
int08 pictcont_GetContrastLimits( int16 *min, int16 *max )
{
    DP_SOURCEDESC *srcDesc;
    ALC_LimitStruct limits;    
    
    datapath_GetSourceDesc( &srcDesc );
    if ( !srcDesc->sourceActive )
        return FAIL;    

    switch( srcDesc->connector )
    {
        case SVIDEO:
        case COMPONENT:
        case COMPOSITE:
            *min = 0;   /* from videodecoder driver */
            *max = 255;
            break;
          
        case VGA:
            if( ALC_GetOffsetLimits( &limits ) != PASS )
                return FAIL;
            *min = limits.LowerLimit - srcDesc->alcGain.Green;
            *max = limits.UpperLimit - srcDesc->alcGain.Green;
            break;
           
        case DVI:
            /* 0 to 200% (from IMG_CSC_SetContrastAdjustment) */
            *min = 0;
            *max = 200;
            break;

        default:
            return FAIL;
    }
    
    return PASS;
}


int08 pictcont_GetContrast( int16 *value )
{   
    uint08 gain;
    ALC_RGB16Struct alcGain;
    DP_SOURCEDESC *srcDesc;
    
    datapath_GetSourceDesc( &srcDesc );
    if ( !srcDesc->sourceActive )
        return FAIL;

    switch( srcDesc->connector )
    {
        case SVIDEO:
        case COMPONENT:
        case COMPOSITE:
            if( DEC_GetGain( &gain ) != PASS )
                return FAIL;
            *value = (int16) gain;
            break;
          
        case VGA:
            if( ALC_GetGain( &alcGain ) != PASS )
                return FAIL;
            *value = (int16) (alcGain.Green - srcDesc->alcGain.Green);
            break;
           
        case DVI:
            if( IMG_CSC_GetContrastAdjustment( SRC_PRIMARY, value ) != PASS )
                return FAIL;
            break;

        default:
            return FAIL;
    }
    return PASS;
}

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

    datapath_GetSourceDesc( &srcDesc );
    if ( !srcDesc->sourceActive )
        return FAIL;

    pictcont_GetContrastLimits( &min, &max );
    if( value < min || value > max )
        return FAIL;
         
    switch( srcDesc->connector )
    {
        case SVIDEO:
        case COMPONENT:
        case COMPOSITE:
            if( DEC_SetGain( (uint08) value ) != PASS )
                return FAIL;
            break;
          
        case VGA:
            if( srcDesc->isYUV )
            {
                if( ALC_SetGain( srcDesc->alcGain.Red, (uint16) srcDesc->alcGain.Green + value, srcDesc->alcGain.Blue ) != PASS )
                    return FAIL;
            }            
            else
            {
                if( ALC_SetGain( (uint16) srcDesc->alcGain.Red + value,
                                 (uint16) srcDesc->alcGain.Green + value,
                                 (uint16) srcDesc->alcGain.Blue + value ) != PASS )
                    return FAIL;
            }
            break;
           
        case DVI:
            IMG_CSC_SetContrastAdjustment( SRC_PRIMARY, (int16) value );
            break;

        default:
            return FAIL;
    }

    return PASS;
}         

/****************************************************************************/
/* Hue (tint) user controls                                                 */
/****************************************************************************/
int08 pictcont_GetHueLimits( int16 *min, int16 *max )
{        
    DP_SOURCEDESC *srcDesc;