📄 msapi_scaler.c
字号:
switch(enColorOfPattern)
{
default:
case TEST_COLOR_OFF:
msAPI_Scaler_SetTimingAndWindow(enInputSourceType, enVideoScreen);
MDrv_Scaler_SetBlueScreen(DISABLE, NULL);
MDrv_Scaler_SetFreezeImg( FALSE );
break;
case TEST_COLOR_WHITE:
// MDrv_Scaler_SetBlueScreen(ENABLE, FREE_RUN_COLOR_WHITE);
//lachesis_070428
//msAPI_Scaler_FreezeImageWithColor(255, 255, 255);
msAPI_Scaler_FreezeImageWithColor(216, 216, 216);
break;
case TEST_COLOR_RED:
// MDrv_Scaler_SetBlueScreen(ENABLE, FREE_RUN_COLOR_RED);
msAPI_Scaler_FreezeImageWithColor(255, 0, 0);
break;
case TEST_COLOR_GREEN:
// MDrv_Scaler_SetBlueScreen(ENABLE, FREE_RUN_COLOR_GREEN);
msAPI_Scaler_FreezeImageWithColor(0, 255, 0);
break;
case TEST_COLOR_BLUE:
// MDrv_Scaler_SetBlueScreen(ENABLE, FREE_RUN_COLOR_BLUE);
msAPI_Scaler_FreezeImageWithColor(0, 0, 255);
break;
case TEST_COLOR_BLACK:
// MDrv_Scaler_SetBlueScreen(ENABLE, FREE_RUN_COLOR_BLACK);
msAPI_Scaler_FreezeImageWithColor(0, 0, 0);
break;
}
}
// ============== JPEG =====================================================
#ifdef BOOT_JPEG_TEST
void msAPI_Scaler_JPEGSetWindow ( MS_VOP_TIMING *ptiming, U8 u8ModeIndex, EN_ASPECT_RATIO_TYPE enVideoScreen)
{
g_SrcInfo.u16H_DisStart = devPanel_HSTART();
g_SrcInfo.u16H_DisSize = devPanel_WIDTH();
g_SrcInfo.u16V_DisStart = PANEL_DE_VSTART;
g_SrcInfo.u16V_DisSize = devPanel_HEIGHT();
MDrv_Scaler_ProgJPEGWin( u8ModeIndex,ptiming );
g_SrcInfo.u8DisplayStatus &= ~DISPLAYWINDOW_NINELATTICE;
MDrv_Scaler_SetDisplayWindow( &g_SrcInfo );
MDrv_Scaler_SetCaptureWindow( &g_SrcInfo );
MDrv_Scaler_SetScalingRatio();
if(g_SrcInfo.u8DisplayStatus & DISPLAYWINDOW_NINELATTICE) // if enable FRC
{
MDrv_Scaler_SetFreeRunWindow();
MDrv_Scaler_SetFreeRunTiming();
}
else
{
MDrv_Scaler_SetAnalogLCDOutputTiming();
}
}
#endif
// ============== CRT =====================================================
#if(PANEL_TYPE_SEL == PNL_DAC_CRT)
BOOLEAN msAPI_Scaler_ExecuteCRTScanMode(void)
{
if (!MDrv_Scaler_CheckScanMode())
return FALSE;
if (MDrv_Scaler_CheckScanMode())
{
if (g_VdInfo.u16VideoStatus & VD_VSYNC_50HZ)
{
if(g_CRT_ScanMode == 0)
g_CRT_ScanMode = CRT_SCAN_MODE_DOUBLEi;
else
g_CRT_ScanMode = 0;
}
else
{
if(g_CRT_ScanMode == 0)
g_CRT_ScanMode = CRT_SCAN_MODE_60i;
else if(g_CRT_ScanMode == CRT_SCAN_MODE_60i)
g_CRT_ScanMode = CRT_SCAN_MODE_DOUBLEi;
else
g_CRT_ScanMode = 0;
}
}
// g_CRT_ScanMode %= CRTSCAN_MODE_75i;
// printf("\r\n g_CRT_ScanMode 2=%x",g_CRT_ScanMode);
if (g_CRT_ScanMode == CRT_SCAN_MODE_75i)
{
if(IsSrcTypeYPbPr(stSystemInfo.enInputSourceType))
{
if(g_PcadcModeSetting.u8ModeIndex == MD_720x576_50I)
g_u8CRT_OutTimingSel = DAC_FOR_PAL_3375K_75I;
else
g_u8CRT_OutTimingSel = DAC_FOR_NTSC_3375K_90I;
}
else
{
if (g_VdInfo.u16VideoStatus & VD_VSYNC_50HZ)
g_u8CRT_OutTimingSel = DAC_FOR_PAL_3375K_75I;
else
g_u8CRT_OutTimingSel = DAC_FOR_NTSC_3375K_90I;
}
}
else if (g_CRT_ScanMode == CRT_SCAN_MODE_60i)
{
if(IsSrcTypeYPbPr(stSystemInfo.enInputSourceType))
{
if(g_PcadcModeSetting.u8ModeIndex == MD_720x576_50I)
{
g_u8CRT_OutTimingSel = DAC_FOR_PAL_3375K_100I;
}
else
{
g_u8CRT_OutTimingSel = DAC_FOR_NTSC_3375K_60I;
}
}
else
{
if (g_VdInfo.u16VideoStatus & VD_VSYNC_50HZ)
{
g_u8CRT_OutTimingSel = DAC_FOR_PAL_3375K_100I;
}
else
{
g_u8CRT_OutTimingSel = DAC_FOR_NTSC_3375K_60I;
}
}
}
else if (g_CRT_ScanMode == CRT_SCAN_MODE_DOUBLEi)
{
if(IsSrcTypeYPbPr(stSystemInfo.enInputSourceType))
{
if(g_PcadcModeSetting.u8ModeIndex == MD_720x576_50I)
g_u8CRT_OutTimingSel = DAC_FOR_PAL_3375K_100I;
else
g_u8CRT_OutTimingSel = DAC_FOR_NTSC_3375K_120I;
}
else
{
if (g_VdInfo.ucVideoSystem & VD_VSYNC_50HZ)
g_u8CRT_OutTimingSel = DAC_FOR_PAL_3375K_100I;
else
g_u8CRT_OutTimingSel = DAC_FOR_NTSC_3375K_120I;
}
}
MDrv_Scaler_Set_DACHSYNC();
//msProgWindowFull( ucSrcIdx );
#if 0
msWriteByte(BK0_00, REG_BANK_SCALER);
if (g_CRT_ScanMode == CRT_SCAN_MODE_PROGRESS)
msOsdWriteByte(OSD_45, 0x00);
else
msOsdWriteByte(OSD_45, 0x03); //Interlaced out and invert.
msSoftwareReset(RST_OSD);
#endif
return TRUE;
}
#endif
// PC mode function
//*************************************************************************
//Function name: msAPI_Scaler_SetSyncStatusFlag
//Passing parameter: U8 u8TempSyncStatus: b0: VSync polarity
// b1: HSync polarity
// b2: Hsync active
// b3: Vsync active
//Return parameter: none
//Description: Set signal sync status flags
//*************************************************************************
void msAPI_Scaler_SetSyncStatusFlag ( U8 u8TempSyncStatus )
{
g_u8CurrentSyncStatus = u8TempSyncStatus;
}
//*************************************************************************
//Function name: msAPI_Scaler_SyncLossFlag
//Passing parameter: none
//Return parameter: BOOLEAN: true: sync loss false: sync active
//Description: Get signal sync status, true for sync loss, false for sync active
//*************************************************************************
BOOLEAN msAPI_Scaler_SyncLossFlag(void)
{
if(g_u8CurrentSyncStatus & MD_SYNC_LOSS)
return TRUE;
else
return FALSE;
}
//*************************************************************************
//Function name: msAPI_Scaler_DetectSync
//Passing parameter: none
//Return parameter: BOOLEAN: false: sync loss true: sync active
//Description: Get signal sync status, false for sync loss, true for sync active
//*************************************************************************
BOOLEAN msAPI_Scaler_DetectSync ( void )
{
U8 u8SyncStatus;
BOOLEAN bResult = FALSE;
u8SyncStatus = msAPI_Scaler_GetInputStatus();
if ( u8SyncStatus & MD_SYNC_LOSS ) // check no signal
{
PCMODE_MSG(printf("MD_SYNC_LOSS \r\n" )) ;
#if (MS_VGA_SOG_EN)
if( IsSrcTypeVga(stSystemInfo.enInputSourceType) &&
((g_ucInputTimingStableCounter%MD_TIMING_SOG_DETECT)==0) )
{
msAPI_Scaler_ProgAnalogInputPort(); // toggle analog input and detect next time
}
#endif // #if (MS_VGA_SOG_EN)
}
else // have signal
{
bResult = TRUE;
PCMODE_MSG(printf("MD_SYNC_DETECT \r\n" )) ;
}
if ( bResult ) // neet to update flag
{
msAPI_Scaler_SetSyncStatusFlag( u8SyncStatus );
} // set global sync status flag
return bResult;
}
//*************************************************************************
//Function name: msAPI_Scaler_InvalidTimingDetect
//Passing parameter: none
//Return parameter: BOOLEAN : timing is valid or not
//Description: Detect invalid timing. true: timing invalid false : timing valid
//*************************************************************************
BOOLEAN msAPI_Scaler_InvalidTimingDetect ( void )
{
U8 ucSyncStatus; // sync status
U16 wSyncCounter; // sync counter
BOOLEAN bResult = FALSE;
ucSyncStatus = msAPI_Scaler_GetInputStatus(); // get input status
if ( ( ucSyncStatus & MD_SYNC_LOSS ) || // no sync
( (bit)(g_u8CurrentSyncStatus&MD_VSYNC_POR_BIT) != (bit)(ucSyncStatus&MD_VSYNC_POR_BIT) ) || // sync polarity changed
( (bit)(g_u8CurrentSyncStatus&MD_HSYNC_POR_BIT) != (bit)(ucSyncStatus&MD_HSYNC_POR_BIT) ) ||
( (bit)(g_u8CurrentSyncStatus&MD_INTERLACE_BIT) != (bit)(ucSyncStatus&MD_INTERLACE_BIT) ) )
{
bResult = TRUE;
PCMODE_MSG(printf("oldSyncStatus=0x%bx, new=0x%bx\n", g_u8CurrentSyncStatus, ucSyncStatus);)
}
else // have signal
{
// HSync
wSyncCounter = msAPI_Scaler_GetHorizontalPeriod();
if ( g_ucInputTimingStableCounter == 0 )
g_wHorizontalPeriod = wSyncCounter;
if ( abs( wSyncCounter - g_wHorizontalPeriod ) > MD_HPERIOD_TORLANCE )
{
PCMODE_MSG(printf("MD_HPERIOD_TORLANCE\n");)
bResult = TRUE;
}
// VSync
wSyncCounter = msAPI_Scaler_GetVerticalTotal();
if ( g_ucInputTimingStableCounter == 0 )
g_wVerticalTotal = wSyncCounter;
if ( abs( wSyncCounter - g_wVerticalTotal ) > MD_VTOTAL_TORLANCE )
{
PCMODE_MSG(printf("MD_VTOTAL_TORLANCE %bu\n", (U8)abs( wSyncCounter - g_wVerticalTotal ) );)
bResult = TRUE;
}
}
msAPI_Scaler_SetSyncStatusFlag( ucSyncStatus ); // set global sync status flag
return bResult; // stable sync
}
//*************************************************************************
//Function name: msAPI_Scaler_PrepareForTimingChange
//Passing parameter: none
//Return parameter: none
//Description: This function will pre-set flags and registers for timing change
//*************************************************************************
void msAPI_Scaler_PrepareForTimingChange (void)
{
PCMODE_MSG(printf("msAPI_Scaler_PrepareForTimingChange\n");)
msAPI_Scaler_SetBlueScreen( ENABLE, FREE_RUN_COLOR_BLACK );
if( g_bInputTimingStable )
{
msAPI_Scaler_InitRegInTimingChange();
}
// reset input timing stable and wait for timing stable
g_bInputTimingStable = FALSE;
g_bUnsupportMode = FALSE;
g_PcadcModeSetting.u8ModeIndex = 0xFF;
msAPI_Scaler_SetDisplayWindowStatus( 0 );
// reset timing stable counter
g_ucInputTimingStableCounter = 0;
}
//*************************************************************************
//Function name: msAPI_Scaler_TimingMonitor
//Passing parameter: none
//Return parameter: none
//Description: Monitor signal timing from analog port
//*************************************************************************
void msAPI_Scaler_TimingMonitor (void)
{
if( g_bInputTimingChange==FALSE && g_ucModeDetectPollingCounter )
return;
g_ucModeDetectPollingCounter = PC_POLLING_COUNTER; // reset counter
//--------------------------------------------------
if ( g_bInputTimingChange == FALSE ) // check timing change flag have be setting
{
if ( msAPI_Scaler_SyncLossFlag() ) // no sync
{
if ( msAPI_Scaler_DetectSync() ) // check signal active
{
g_bInputTimingChange = TRUE;
#if (ENABLE_DIGITAL_SOURCE)// kevin 071213_1
if(IsDigitalInUse())
{
#if (HDMI_CHIP_SEL == HDMI_CHIP_MST3383M)
// step 1
SetBlackScreen(TRUE);
HDCP_Reinit();
HDMI_Reset();
MDrv_Timer_Delayms(200);
//SetAudioOutput(FALSE);
#endif
}
#endif
/* Reset ACC Existing Scheme */
}
}
else // valid timing
{
if ( msAPI_Scaler_InvalidTimingDetect() ) // check invalid sync
{
PCMODE_MSG(printf("InvalidTimingDetect GO TO UNSTABLE! \r\n" )) ;
g_u8CurrentSyncStatus |= MD_SYNC_LOSS;
g_bInputTimingChange = TRUE;
#if (HDMI_CHIP_SEL == HDMI_CHIP_MST3383M)// kevin 071213_1
#if (ENABLE_DIGITAL_SOURCE)
if (IsDigitalInUse())
{
SetAudioOutput(FALSE);
//devAudioSetVolume(0);
}
#endif
#endif
}
else
{
}
#if NEW_LOCK
if( IsSrcTypeVideo(SYS_INPUT_SOURCE_TYPE) )
msAPI_Scaler_MonitorLPLL();
#endif
}
}
//--------------------------------------------------
if( g_bInputTimingChange ) // input timing is unstable
{
g_ucTimingChangeDebounce++;
PCMODE_MSG(printf("Deb=%bu\n", g_ucTimingChangeDebounce);)
if ( !msAPI_Scaler_SyncLossFlag() ) // have signal
{
if ( g_ucTimingChangeDebounce <= 3 ) // prevent from SOG
{
g_u8CurrentSyncStatus |= MD_SYNC_LOSS;
return;
}
}
msAPI_Scaler_PrepareForTimingChange();
g_bInputTimingChange = FALSE;
}
else // input timing is stable
{
g_ucTimingChangeDebounce = 0; // reset timing change debounce counter
g_ucInputTimingStableCounter++; // timing stable counter
if ( g_ucInputTimingStableCounter == 0 )
g_ucInputTimingStableCounter = 1;
if ( !g_bInputTimingStable )
{
if( (!msAPI_Scaler_SyncLossFlag() && g_ucInputTimingStableCounter >= MD_TIMING_STABLE_COUNT) ||
(msAPI_Scaler_SyncLossFlag() && g_ucInputTimingStableCounter >= MD_TIMING_NOSYNC_COUNT) )
{
g_bInputTimingStable = TRUE;
g_bDoModeSetting = TRUE;
g_PcadcModeSetting.u8ModeIndex = 0; // reset mode index
}
}
}
}
#undef MSAPI_SCALER_C
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -