mst705Ȧ

MST705源代码

    ucBk0_57 |= _BIT2; // Scaling range add 1

    if( ucOutputTimingCtl&OUTPUT_FREERUN )
    {
        ;
    }
    else
    {
        if( IsAnalogPortInUse()) // PC/YPBPR
        {
            ucBk0_57 |= _BIT1;
            ucBk0_57 |= _BIT7;
        }
        else
        {
            ucBk0_57 |= _BIT1;
        }
    }

    msWriteByte_Bank_BackupBank( REG_BANK_SCALER, BK0_57_OSCTRL1, ucBk0_57 );
}

void SetScalingRatio( BOOL bInterlace )
{
    BYTE ucBank; // bank buffer
    DWORD dwTemp;
    WORD wInputVSize;

    ucBank = msReadByte(BK0_00_REGBK); // store bank
    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);

    #if (VGA_ENABLE || YPBPR_ENABLE)
    if(IsVGAInUse()||IsYPbPrInUse()) // PC/YPBPR
        g_WindowInfo.V_DisSize = PanelHeight;
    else
    #endif
        g_WindowInfo.V_DisSize=PanelVSiEnd;

    printf("\r\nSCALING_H_IN=%d", SCALING_H_IN);
    printf("\r\nSCALING_H_OUT=%d", SCALING_H_OUT);
    printf("\r\nSCALING_V_IN=%d", SCALING_V_IN);
    printf("\r\nSCALING_V_OUT=%d", SCALING_V_OUT);

    // Horizontal
    if( SCALING_H_IN == SCALING_H_OUT )
    {
        dwTemp = 0;
        g_WindowInfo.H_SaclingRatioInfo = SCALING_RATIO_TYPE_NATIVE;
    }
    else
    {
        if( SCALING_H_IN < SCALING_H_OUT )
        {
            g_WindowInfo.H_SaclingRatioInfo = SCALING_RATIO_TYPE_UP;
            dwTemp = 0;
        }
        else // if( SCALING_H_IN > SCALING_H_OUT )
        {
            g_WindowInfo.H_SaclingRatioInfo = SCALING_RATIO_TYPE_DOWN;
            dwTemp = ScalingRatio_H( SCALING_H_IN, SCALING_H_OUT );

            //printf("ScalingRatio_H===%x", dwTemp/0x100); //get high 2 bytes
            if(IsVideoPortInUse())
                dwTemp&=0xFFF000;
            if( dwTemp > 0xFF000 )
                dwTemp |= 0x800000;
            else
                dwTemp |= 0xC00000;
        }
    }
    msWrite3Bytes(BK0_32_SRH_H, dwTemp);

    // Vertical
    wInputVSize = SCALING_V_IN;

    if( bInterlace )
        wInputVSize = wInputVSize/2;

    if( wInputVSize == SCALING_V_OUT )
    {
        dwTemp = 0;
        g_WindowInfo.V_SaclingRatioInfo = SCALING_RATIO_TYPE_NATIVE;
    }
    else
    {
        if( wInputVSize < SCALING_V_OUT )
        {
            g_WindowInfo.V_SaclingRatioInfo = SCALING_RATIO_TYPE_UP;
        }
        else // ( wInputVSize > SCALING_V_OUT ) // Scaling down
        {
            g_WindowInfo.V_SaclingRatioInfo = SCALING_RATIO_TYPE_DOWN;
        #if(ENABLE_V_PRE_SCALING_DOWN)
            if(IsAnalogPortInUse())
                g_WindowInfo.V_SaclingRatioInfo |= SCALING_RATIO_FLAG_PRE;
        #endif
        }

    	#if (ENABLE_V_PRE_SCALING_DOWN)
        if( g_WindowInfo.V_SaclingRatioInfo&SCALING_RATIO_FLAG_PRE )
        {
            dwTemp = PRE_SCALING_RATIO_V( SCALING_V_IN, SCALING_V_OUT );
            if( bInterlace )
                dwTemp = dwTemp<<1;
            dwTemp |= 0xC00000;
        }
        else
    	#endif
        {
            dwTemp = ScalingRatio_V( SCALING_V_IN, SCALING_V_OUT );
            if( bInterlace )
                dwTemp = (dwTemp+1)>>1;

            if(IsVideoPortInUse())
                dwTemp&=0xFFF000;

            if( dwTemp>0x3FFFFF)
            {
                dwTemp = 0x3FFFFF;
            }
            dwTemp &= 0x3FFFFF;
            dwTemp |= 0x800000;
        }
    }
    //printf("\r\nVScaleRatio=0x%xXX", dwTemp>>8);

	//dwTemp -= 0x300;		//gan add
    msWrite3Bytes(BK0_35_SRV_H, dwTemp);

#if(ENABLE_V_PRE_SCALING_DOWN)
	if(IsYPbPrInUse())		//gan  add
		msWriteBit( BK0_C3, 0, _BIT6 );
	else
	{
	    if ((g_WindowInfo.V_SaclingRatioInfo&SCALING_RATIO_FLAG_PRE) && (!bInterlace))
	    {
	        msWriteBit( BK0_C3, 1, _BIT6 );
	    }
	    else
	    {
	        msWriteBit( BK0_C3, 0, _BIT6 );
	    }
	}
#endif

    msWriteByte(BK0_00_REGBK, ucBank); // recovery bank
}

void CalculateAspectRatio(void)
{
#if(ENABLE_OVER_SCAN)
    WORD wTemp;
    BYTE ucOverScanH;
    BYTE ucOverScanV;

    // Get over scan ratio
    ucOverScanH = g_ucOverScanH;
    ucOverScanV = g_ucOverScanV;

    // Cal Over scan
    if( ucOverScanH )
    {
        wTemp = (DWORD)g_WindowInfo.H_CapSize * g_ucOverScanH / 1000;
        //g_WindowInfo.H_CapStart += wTemp;
        g_WindowInfo.H_CapSize = (g_WindowInfo.H_CapSize - 2 * wTemp);
    }

    if( ucOverScanV )
    {
    
#if CCIR656_ENABLE
       if(IsCCIR656InUse())
       	{
       	 return;
       	}
#endif

        wTemp = (DWORD)g_WindowInfo.V_CapSize * g_ucOverScanV / 1000;
        //g_WindowInfo.V_CapStart += wTemp;
        g_WindowInfo.V_CapSize = (g_WindowInfo.V_CapSize - 2 * wTemp);
    }
#endif
}

void msSetupFreeRunMode( BYTE ucVFreq )
{
    BYTE ucBank; // bank buffer

    ucBank = msReadByte(BK0_00_REGBK); // backup bank
    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);
    //printf("\r\nSetFreeRunMode(%d)", ucVFreq);

    g_InOutCtl.inOutVFreq = ucVFreq;

    SetDisplayWindow();

    msSetOutputTiming( OUTPUT_FREERUN );
    msWriteRegsTbl(tFreeRunModeTbl);

    Set_FreeRunModeFlag();

    msWriteByte (BK0_00_REGBK, ucBank); // recovery bank
}

void msSetOutputTiming( BYTE ucOutputTimingCtl )
{
    BYTE ucBank; // bank buffer

    ucBank = msReadByte(BK0_00_REGBK); // store bank

    //printf("\r\nmsSetOutputTiming(%x)", ucOutputTimingCtl);

    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);

    msSetOutputSyncControl( ucOutputTimingCtl );

    if( ucOutputTimingCtl&OUTPUT_FREERUN )
    {
        msWriteWord(BK0_4F_VDTOT_H, PanelVTotal - 1);  // output vtotal
        msWriteWord(BK0_55_HDTOT_H, PanelHTotal - 1);  // output htotal
    }
    else
    {
        msWriteWord(BK0_4F_VDTOT_H, 0x7FF); // output vtotal
    }

    SetOutputClock( ucOutputTimingCtl );

    msWriteByte(BK0_00_REGBK, ucBank);
}

void SetCaptureWindow()
{
    BYTE ucBank;

    ucBank = msReadByte(BK0_00_REGBK); // store bank

    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);
   #if (VGA_ENABLE || YPBPR_ENABLE/*||CCIR656_ENABLE*/)
    if(IsVGAInUse()||IsYPbPrInUse()/*||IsCCIR656InUse()*/) // PC/YPBPR
    {
        msWriteWord(BK0_06_SPRVST_H, g_ModeSetting.VStart);
        msWriteWord(BK0_08_SPRHST_H, g_ModeSetting.HStart);
    }
    else
    #endif
    {
        msWriteWord(BK0_06_SPRVST_H, g_WindowInfo.V_CapStart);
        msWriteWord(BK0_08_SPRHST_H, g_WindowInfo.H_CapStart);
    }
    msWriteWord(BK0_0A_SPRVDC_H, g_WindowInfo.V_CapSize);
    msWriteWord(BK0_0C_SPRHDC_H, g_WindowInfo.H_CapSize+8);

#if(ENABLE_MONITOR_VTOTAL)
    if( IsVideoPortInUse() )
        msMonitorVTotal( 1 ); // Init
#endif

    msWriteByte(BK0_00_REGBK, ucBank); // recovery bank
}

void SetDisplayWindow()
{
    BYTE ucBank; // bank buffer

    ucBank = msReadByte(BK0_00_REGBK); // store bank

    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);

    msWriteWord(BK0_49_SIHST_H, PanelHStart); // Image H start
    msWriteWord(BK0_4D_SIHEND_H, PanelHStart + PanelWidth - 1); // Image H end

    msWriteWord(BK0_41_VFDEST_H, PANEL_DE_VSTART); // DE V start

    if(IsVGAInUse())
        {
            msWriteWord(BK0_45_VFDEEND_H, PanelHeight-1);
            msWriteWord(BK0_4B_SIVEND_H, PanelHeight-1);
        }
    else
        {
            msWriteWord(BK0_45_VFDEEND_H, PanelVdeEnd-1);
            msWriteWord(BK0_4B_SIVEND_H, PanelVSiEnd-1);
        }


    msWriteByte(BK0_00_REGBK, ucBank); // recovery bank
}

void msProgDigitalWin( BYTE ucOutputTimingCtl )
{
    BYTE ucVideoSystem;

    if( IsSrcHasSignal() && ((ucOutputTimingCtl&3)==0))
    {
        #if CCIR656_ENABLE
        if(IsCCIR656InUse())
        {
            if(g_CCIR656Info.ucSyncStatus&PAL_MODE_B)
                ucVideoSystem = SIG_PAL;
            else
                ucVideoSystem = SIG_NTSC;
        }
        else
        #endif
        {
            ucVideoSystem = g_VdInfo.ucVideoSystem;
        }
    }
    else // No signal or Freerun
    {
        if( g_InOutCtl.inOutVFreq == 50)
            ucVideoSystem = SIG_PAL;
        else
            ucVideoSystem = SIG_NTSC;
    }

    if(IsSVideoInUse())
    {
        g_WindowInfo.H_CapStart= tSvideoCaptureStart[ucVideoSystem].SVideoHStart;
        g_WindowInfo.V_CapStart = tSvideoCaptureStart[ucVideoSystem].SVideoVStart;
    }
    else
    {
        g_WindowInfo.H_CapStart= tMsVDCapture[ucVideoSystem].VideoHStart;
        g_WindowInfo.V_CapStart = tMsVDCapture[ucVideoSystem].VideoVStart;
    }
    g_WindowInfo.H_CapSize = tMsVDCapture[ucVideoSystem].HRange;
    g_WindowInfo.V_CapSize = tMsVDCapture[ucVideoSystem].VRange;

    CalculateAspectRatio();

    SetDisplayWindow();

    SetCaptureWindow();
    SetScalingRatio(1);
}

void msProgWindow( BYTE ucOutputTimingCtl )
{
#if (VGA_ENABLE || YPBPR_ENABLE)
    if( IsVGAInUse()||IsYPbPrInUse()) // PC/YPBPR
        msProgAnalogWin();
    else
#endif
        msProgDigitalWin( ucOutputTimingCtl );
}

BOOL IsSrcHasSignal(void)
{
    #if (VGA_ENABLE || YPBPR_ENABLE)
    if( IsVGAInUse()||IsYPbPrInUse()  ) // PC/YPBPR
    {
        if( g_bInputTimingChangeFlag || SyncLossState() || UnsupportedModeFlag )
            return FALSE;
    }
    else // Digital port
    #endif
    {
        #if CCIR656_ENABLE
        if(IsCCIR656InUse())
        {
            if(g_CCIR656Info.ucSyncStatus&SYNC_LOSS_MASK)
                return FALSE;
        }
        else
        #endif
        {
            if( (g_VdInfo.ucVideoSystem==SIG_NONE)||((g_VdInfo.wVideoStatus&VD_HSYNC_LOCKED)==0))
                return FALSE;
        }
    }
    return TRUE;
}


void SetOutputTimingAndWindow( BYTE ucOutputTimingCtl )
{
    // Get input sync info
    if( IsSrcHasSignal() || (ucOutputTimingCtl&OUTPUT_SNOW) ) // Has signal or snow
    {
        GetInputSignalHV();
    }
    else // No signal or Freerun
    {
        g_I