dispfmt.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.
******************************************************************************/
/****************************************************************************/
/* dispfmt.c                                                                */
/*                                                                          */
/* dispfmt: Implements control functions to configure shape of image        */
/*          such as scaling, keystone, and image flip                       */
/****************************************************************************/

#include "common.h"

#include "src.h"
#include "disp.h"
#include "dei.h"
#include "dmd.h"
#include "frame.h"

#include "datapath.h"
#include "dispfmt.h"
#include "dbmessage.h"
#include "guiStyle.h"
#include "global.h"
#include "eeprom.h"

/* Private variables */
static int16 magnifyPercent = 0;
static uint08 aspectRatio = 2;
static uint08 imageSize = 0;
static int16 imageSizeSteps = 0;
static int16 imagePosy = 0;
static int16 pan = 0, scan = 0;
static uint08 overscan = 0;
static BOOL ceilingMount = FALSE;
static BOOL rearProjection = FALSE;
static int16 anglePitch = 0;
static uint16 throwRatio = 0;
static int16 verticalOffset = 0;

static int16 minPan=0, maxPan=0;
static int16 minScan=0, maxScan=0;
static int16 minImagePosy=0, maxImagePosy=0;

static float internalOutputRate = 60.0f;


void dispfmt_ApplyDEI( void );
void dispfmt_CalculateCroppedArea( DP_SOURCEDESC *srcDesc, DISP_DISPLAY_CONFIG *disp_cfg );
void dispfmt_CalculateDisplayArea( DP_SOURCEDESC *srcDesc, DISP_DISPLAY_CONFIG *disp_cfg );
void dispfmt_ApplyScalingFilter( DP_SOURCEDESC *srcDesc, DISP_DISPLAY_CONFIG *disp_cfg );
int08 dispfmt_ApplyDisplay( void );
int08 dispfmt_ApplyFlip( void );
int08 dispfmt_ApplyKeystone( void );


void dispfmt_InitializeOnce( void )
{
    DISP_DISPLAY_CONFIG disp_cfg;
    uint16 DMD_Height;
    uint16 DMD_Width;

    DISP_SetBackgroundColor( 0, 0, 0 );
    DEI_Enable(FALSE);

    FRAME_SetFrameRateConversion( 30, 60, FRAME_FRC_MODE_FIXED );
    internalOutputRate = 60.0f;

    DISP_SetHorizontalFlip( TRUE );
    DISP_SetVerticalFlip( FALSE );
    
    DISP_SetKeystoneAngles( 0.0f, 0x100, 0x100 );
    DISP_EnableKeystone( TRUE );
    
    throwRatio = gpConfiguration->Datapath.ThrowRatio;
    verticalOffset = gpConfiguration->Datapath.VerticalOffset;
    
    DMD_GetResolution( &DMD_Width, &DMD_Height );
    disp_cfg.CroppedArea.FirstPixel = 0;
    disp_cfg.CroppedArea.FirstLine = 0;
    disp_cfg.CroppedArea.PixelsPerLine = 1024;
    disp_cfg.CroppedArea.LinesPerFrame = 768;
    disp_cfg.DisplayArea.FirstPixel = 0;
    disp_cfg.DisplayArea.FirstLine = 0;
    disp_cfg.DisplayArea.PixelsPerLine = DMD_Width;
    disp_cfg.DisplayArea.LinesPerFrame = DMD_Height;
    DISP_SetDisplay( SRC_PRIMARY, disp_cfg );
}

void dispfmt_ConfigureForSource( BOOL resetLocalVars )
{
    DP_SOURCEDESC *srcDesc;
    int16 min, max;
    
    datapath_GetSourceDesc( &srcDesc );
    
    if( resetLocalVars == TRUE )
    {
        /* private variable initialization */
        magnifyPercent = 0;
        
        EE_GETVAR( UserMachine.Projector.AspectRatio, aspectRatio );
        aspectRatio = MIN( aspectRatio, 3 );
        
        EE_GETVAR( UserMachine.Projector.ImageSizeEnum, imageSize );
        imageSize = MIN( imageSize, 2 );
        
        EE_GETVAR( UserMachine.Projector.ImageSizeManualSteps, imageSizeSteps );
        dispfmt_GetImageSizeLimits( &min, &max );
        imageSizeSteps = LMT( min, imageSizeSteps, max );
        
        EE_GETVAR( UserMachine.Projector.ImageOffset, imagePosy );
        pan = 0, scan = 0;
        if( srcDesc->isVideo == TRUE && srcDesc->activeDisplay == DP_EXTERNAL )
        {
            EE_GETVAR( UserMachine.ConnectorSettings[srcDesc->connector].Overscan, overscan );
        }
        else
        {
            overscan = 0;
        }
        EE_GETVAR( UserMachine.Projector.RearProjection, rearProjection );
        EE_GETVAR( UserMachine.Projector.CeilingMount, ceilingMount );
        EE_GETVAR( UserMachine.Projector.KeystonePitch, anglePitch );
        anglePitch = anglePitch << 8;
    }   
    
    if( srcDesc->activeDisplay == DP_EXTERNAL )
    {
        /* deinterlacer setup */
        dispfmt_ApplyDEI();

        /* frame rate conversion setup */
        if( 23.5f <= srcDesc->inputFrameRate && srcDesc->inputFrameRate <= 31.0f )
        {
            if( FRAME_SetFrameRateConversion( srcDesc->inputFrameRate, 2*srcDesc->inputFrameRate, FRAME_FRC_MODE_SYNC_2X ) != PASS )
            {
                dbmsg_ftrace( DBM_DPATH, "dispfmt: Sync 2x frame rate conversion config failed in=%d\r\n", srcDesc->inputFrameRate );
            }
            internalOutputRate = 2*srcDesc->inputFrameRate;
        }
        else if( 47.0f <= srcDesc->inputFrameRate && srcDesc->inputFrameRate <= 63.0f )
        {
            if( FRAME_SetFrameRateConversion( srcDesc->inputFrameRate, srcDesc->inputFrameRate, FRAME_FRC_MODE_SYNC_1X ) != PASS )
            {
                dbmsg_ftrace( DBM_DPATH, "dispfmt: Sync 1x frame rate conversion config failed in=%d\r\n", srcDesc->inputFrameRate );
            }
            internalOutputRate = srcDesc->inputFrameRate;
        }
        else
        {
            if( FRAME_SetFrameRateConversion( srcDesc->inputFrameRate, 60.0f, FRAME_FRC_MODE_FIXED ) != PASS )
            {
                dbmsg_ftrace( DBM_DPATH, "dispfmt: Fixed frame rate conversion config failed in=%d out=60.0\r\n", srcDesc->inputFrameRate );
            }
            internalOutputRate = 60.0f;
        }
    }
    else /* internal sources use last stable frame rate */
    {
        if( FRAME_SetFrameRateConversion( srcDesc->inputFrameRate, internalOutputRate, FRAME_FRC_MODE_FIXED ) != PASS )
        {
            dbmsg_ftrace( DBM_DPATH, "dispfmt: Fixed frame rate conversion config failed in=%d out=%d\r\n", srcDesc->inputFrameRate, internalOutputRate );
        }
    }

    
    if( dispfmt_ApplyFlip() != PASS )
    {
        dbmsg_ftrace( DBM_DPATH, "dispfmt: initial image flip setup failed!\r\n" );
    }
    if( dispfmt_ApplyKeystone() != PASS )
    {
        dbmsg_ftrace( DBM_DPATH, "dispfmt: initial keystone setup failed!\r\n" );
    }
    if( dispfmt_ApplyDisplay() != PASS )
    {
        dbmsg_ftrace( DBM_DPATH, "dispfmt: initial display setup failed!\r\n" );
    }
    
    dbmsg_ftrace( DBM_DPATH, "dispfmt: input resolution: %d x %d\r\n", srcDesc->inputWidth, srcDesc->inputHeight );
}


/****************************************************************************/
/* Overscan user controls                                                   */
/****************************************************************************/
int08 dispfmt_GetOverscan( uint08 *enable )
{    
    *enable = overscan;
    return PASS;
}

int08 dispfmt_SetOverscan( uint08 enable )
{
    uint08 temp;
    
    temp = overscan;
    overscan = enable;
    
    if( dispfmt_ApplyDisplay() != PASS)
    {
        overscan = temp;
        return FAIL;
    }
    return PASS;
}

/****************************************************************************/
/* Magnify user controls                                                    */
/****************************************************************************/
int08 dispfmt_GetMagnifyLimits( int16 *min, int16 *max )
{
    *min = 0;
    *max = 100;  /* from product spec -- we can magnify to 1/2 image size (100% magnification) */

    return PASS;
}

int08 dispfmt_GetMagnify( int16 *value )
{
    *value = magnifyPercent;
    return PASS;
}

int08 dispfmt_SetMagnify( int16 value )
{
    int16 min, max;
    int16 temp;
    
    dispfmt_GetMagnifyLimits( &min, &max );
    if( value < min || value > max )
        return FAIL;
    
    temp = magnifyPercent;
    magnifyPercent = value;
    
    if( dispfmt_ApplyDisplay() != PASS)
    {
        magnifyPercent = temp;
        return FAIL;
    }
    return PASS;
}

/****************************************************************************/
/* Pan (horizontal framing) user controls                                   */
/****************************************************************************/
int08 dispfmt_GetPanLimits( int16 *min, int16 *max )
{
    *min = minPan;
    *max = maxPan;
    
    return PASS;
}

int08 dispfmt_GetPan( int16 *value )
{
    *value = pan;
    
    return PASS;
}

int08 dispfmt_SetPan( int16 value )
{
    int16 min, max;
    int16 temp;
    
    dispfmt_GetPanLimits( &min, &max );
    if( value < min || value > max )
        return FAIL;

    temp = pan;
    pan = value;
    
    if( dispfmt_ApplyDisplay() != PASS)
    {
        pan = temp;
        return FAIL;
    }
    return PASS;
}

/****************************************************************************/
/* Scan (vertical framing) user controls                                    */
/****************************************************************************/
int08 dispfmt_GetScanLimits( int16 *min, int16 *max )
{
    *min = minScan;
    *max = maxScan;
    
    return PASS;
}

int08 dispfmt_GetScan( int16 *value )
{
    *value = scan;
    
    return PASS;
}

int08 dispfmt_SetScan( int16 value )
{
    int16 min, max;
    int16 temp;
    
    dispfmt_GetScanLimits( &min, &max );
    if( value < min || value > max )
        return FAIL;

    temp = scan;
    scan = value;
    
    if( dispfmt_ApplyDisplay() != PASS)
    {
        scan = temp;
        return FAIL;
    }
    return PASS;
}

/****************************************************************************/
/* Image Size user controls                                                 */
/****************************************************************************/
int08 dispfmt_GetImageSizeLimits( int16 *min, int16 *max )
{
    DP_SOURCEDESC *srcDesc;
    uint16 dmdWidth, dmdHeight;

    datapath_GetSourceDesc( &srcDesc );
    DMD_GetResolution( &dmdWidth, &dmdHeight );  

                        /****************************************************/
                        /*     return limits for the manual size adjustment */
                        /****************************************************/
    *min = srcDesc->inputHeight * 2 / 5;  /* we can scale to 40% image height before keystone */
    *max = dmdHeight;
    return PASS;
}

int08 dispfmt_GetImageSize( uint08 *value, int16 *size )
{
    *value = imageSize;
    *size = imageSizeSteps;
    return PASS;
}

int08 dispfmt_SetImageSize( uint08 value, int16 size )
{
    int16 min, max;
    uint08 temp1;
    int16 temp2;
    
    if( value == 2 )
    {
        dispfmt_GetImageSizeLimits( &min, &max );
        if( size < min || size > max )
            return FAIL;
    }
    temp1 = imageSize;
    temp2 = imageSizeSteps;
    imageSize = value;
    imageSizeSteps = size;
    
    if( dispfmt_ApplyDisplay() != PASS)
    {
        imageSize = temp1;
        imageSizeSteps = temp2;
        return FAIL;
    }
    return PASS;
}

/****************************************************************************/
/* Aspect Ratio user controls                                               */
/****************************************************************************/
int08 dispfmt_GetAspectRatio( uint08 *value )
{
    *value = aspectRatio;
    return PASS;
}

int08 dispfmt_SetAspectRatio( uint08 value )
{
    uint08 temp;
    
    temp = aspectRatio;
    aspectRatio = value;
    
    if( dispfmt_ApplyDisplay() != PASS)
    {
        aspectRatio = temp;
        return FAIL;
    }
    return PASS;
}

/****************************************************************************/
/* Image Position user controls                                             */
/****************************************************************************/
int08 dispfmt_GetImagePositionLimits( int16 *min, int16 *max )
{
    *min = minImagePosy;
    *max = maxImagePosy;
    return PASS;
}

int08 dispfmt_GetImagePosition( int16 *value )
{
    *value = imagePosy;
    return PASS;
}

int08 dispfmt_SetImagePosition( int16 value )
{
    int16 min, max;
    int16 temp;
    
    dispfmt_GetImagePositionLimits( &min, &max );
    if( value < min || value > max )
        return FAIL;

    temp = imagePosy;
    imagePosy = value;

    if( dispfmt_ApplyDisplay() != PASS)
    {
        imagePosy = temp;
        return FAIL;
    }
    return PASS;
}

/****************************************************************************/
/* Rear projection user controls                                            */
/****************************************************************************/
int08 dispfmt_SetRearProjection( uint08 enable )
{
    uint08 temp;
    
    temp = rearProjection;
    rearProjection = enable;