menufunc_new_ntsc.c

lcd tv : MST9E19A原代码

//======================== Pc ==============================
BOOL AdjustPcContrast(MenuItemActionType action)
{
    if( SrcTypeIsPC() && !(IsSrcColorSpaceYUV()) )
    {
        g_PCColorSetting.Contrast = DecIncValue(action, g_PCColorSetting.Contrast, MIN_PC_CONTRAST, MAX_PC_CONTRAST, 2);
        msAdjustPCContrast( 0, g_PCColorSetting.Contrast );
    }
    return TRUE;
}

WORD GetPcContrastValue(void)
{
    return GetScale100Value(g_PCColorSetting.Contrast, MIN_PC_CONTRAST, MAX_PC_CONTRAST);
}

BOOL AdjustPcBrightness(MenuItemActionType action)
{
    if( SrcTypeIsPC() && !(IsSrcColorSpaceYUV()) )
    {
        g_PCColorSetting.Brightness = DecIncValue(action, g_PCColorSetting.Brightness, MIN_PC_BRIGHTNESS, MAX_PC_BRIGHTNESS, 2);
        msAdjustBrightness(0x80);
        msAdjustBacklight( g_PCColorSetting.Brightness );
    }
    return TRUE;
}
WORD GetPcBrightnessValue(void)
{
    return GetScale100Value(g_PCColorSetting.Brightness, MIN_PC_BRIGHTNESS, MAX_PC_BRIGHTNESS);
}

BOOL AdjustPcColorTemp(MenuItemActionType action)
{
    if( SrcTypeIsPC() && !(IsSrcColorSpaceYUV()) )
    {
        g_PCColorSetting.ColorTempIndex = DecIncValue_Cycle( action, g_PCColorSetting.ColorTempIndex, 0, PC_COLOR_TEMP_NUMS-1, 1 );
        usrLoadPCColorTempSetting( &g_PCColorTempSetting, g_PCColorSetting.ColorTempIndex );
        SetPCColorTemp();
    }
    return TRUE;
}

BOOL AdjustPcScale(MenuItemActionType action)
{
      if (IsSrcHasSignal())
      {
          g_PCScaleSetting.PcScaleType = DecIncValue_Cycle( action, g_PCScaleSetting.PcScaleType, 0, PC_SCALE_NUM-1, 1 );
    
#if (PANEL_TYPE == WIDE_PANEL)
          // if FrameBufferLess or HDTV mode, no PANORAMA support.
          if ( (!g_bUseMainFrameBuf) || IsSrcHDTVMode() )
          {
              if (g_VideoSetting.VideoScreen == VIDEOSCREEN_PANORAMA)
                  g_VideoSetting.VideoScreen = DecIncValue_Cycle( action, g_VideoSetting.VideoScreen, 0, VIDEOSCREEN_NUMS-1, 1 );
          }
#endif
    
          msProgWindow(g_PCScaleSetting.PcScaleType);
          return TRUE;
      }
      else
      {
          return FALSE;
      }
}

BOOL ExecPcAuto(void)
{
    if( !SRC_TYPE_IS_VGA() )
        return FALSE;

    return msAutoGeometry(AUTO_TUNE_BASIC); // auto-tune
}


//======================== sound =========================
#define INIT_SOUND_BASS     ((MAX_SOUND_BASS-MIN_SOUND_BASS)/2)
#define INIT_SOUND_TREBLE     ((MAX_SOUND_TREBLE-MIN_SOUND_TREBLE)/2)
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
code BYTE tInitSoundSetting[][3] =
{
    // Standard
    {
        INIT_SOUND_BASS,
        INIT_SOUND_TREBLE,
    },
    // Movie
    {
        INIT_SOUND_BASS*18/10,
        INIT_SOUND_TREBLE,
    },
    // Music
    {
        INIT_SOUND_BASS*15/10,
        INIT_SOUND_TREBLE*15/10,
    }
};

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void ResetSoundSetting( BYTE ucSettingIdx )
{
    BYTE* ptInitSoundSetting = tInitSoundSetting[ucSettingIdx];

    g_SoundSetting.Bass= ptInitSoundSetting[0];
    g_SoundSetting.Treble= ptInitSoundSetting[1];

}

BOOL AdjustSoundBass(MenuItemActionType action)
{
    g_SoundSetting.Bass = DecIncValue(action, g_SoundSetting.Bass, MIN_SOUND_BASS, MAX_SOUND_BASS, 1);
    devAudioSetBass(g_SoundSetting.Bass);
    g_SoundSetting.SoundMode = SOUND_MODE_USER;
    return TRUE;
}
WORD GetSoundBassValue(void)
{
    return GetScale100Value(g_SoundSetting.Bass, MIN_SOUND_BASS, MAX_SOUND_BASS);
}

BOOL AdjustSoundTreble(MenuItemActionType action)
{
    g_SoundSetting.Treble = DecIncValue(action, g_SoundSetting.Treble, MIN_SOUND_TREBLE, MAX_SOUND_TREBLE, 1);
    devAudioSetTreble(g_SoundSetting.Treble);
    g_SoundSetting.SoundMode = SOUND_MODE_USER;
    return TRUE;
}
WORD GetSoundTrebleValue(void)
{
    return GetScale100Value(g_SoundSetting.Treble, MIN_SOUND_TREBLE, MAX_SOUND_TREBLE);
}

BOOL AdjustSoundBalance(MenuItemActionType action)
{
    g_SoundSetting.Balance = DecIncValue(action, g_SoundSetting.Balance, MIN_SOUND_BALANCE, MAX_SOUND_BALANCE, 1);
    devAudioSetBalance(g_SoundSetting.Balance);
    return TRUE;
}
WORD GetSoundBalanceValue(void)
{
    return GetScale100Value(g_SoundSetting.Balance, MIN_SOUND_BALANCE, MAX_SOUND_BALANCE);
}

BOOL AdjustMTSMode(MenuItemActionType action)
{
    if (action == MIA_INCVALUE)
    {
        g_SoundSetting.Mts = (g_SoundSetting.Mts + 1) % SOUND_MTS_NUMS;

        if (g_ucMtsStatus != 0)
        {
            if ((g_SoundSetting.Mts == SOUND_MTS_STEREO) && (!(g_ucMtsStatus & _MTS_STEREO_)))
            {
                g_SoundSetting.Mts = SOUND_MTS_SAP;
            }
            if ((g_SoundSetting.Mts == SOUND_MTS_SAP) && (!(g_ucMtsStatus & _MTS_SAP_)))
            {
                g_SoundSetting.Mts = SOUND_MTS_MONO;
            }
        }
    }
    else
    {
        g_SoundSetting.Mts = (g_SoundSetting.Mts + SOUND_MTS_NUMS-1) % SOUND_MTS_NUMS;
        if (g_ucMtsStatus != 0)
        {            
            if ((g_SoundSetting.Mts == SOUND_MTS_SAP) && (!(g_ucMtsStatus & _MTS_SAP_)))
            {
                g_SoundSetting.Mts = SOUND_MTS_STEREO;
            }
            if ((g_SoundSetting.Mts == SOUND_MTS_STEREO) && (!(g_ucMtsStatus & _MTS_STEREO_)))
            {
                g_SoundSetting.Mts = SOUND_MTS_MONO;
            }
        }
    }
    g_ucSoundMts = g_SoundSetting.Mts;
    devAudioVolumeCtl( AUDIO_VOLUME_TURN_OFF );
    devAudioMTSSelect(g_SoundSetting.Mts);
    NTSC_AdjustMTSMode();
    return TRUE;
}

BOOL AdjustSoundSoundMode(MenuItemActionType action)
{
    BYTE ucPMIdx;

    devAudioVolumeCtl( AUDIO_VOLUME_TURN_OFF );
    g_SoundSetting.SoundMode=DecIncValue_Cycle( action, g_SoundSetting.SoundMode, 0, SOUND_MODE_NUMS-1, 1 );
    ucPMIdx = g_SoundSetting.SoundMode;
    // Reset HSCB
    if( SOUND_MODE_USER != g_SoundSetting.SoundMode ) // Preset mode
    {
        ResetSoundSetting( g_SoundSetting.SoundMode );
    }
    else
    {
        usrLoadSoundSetting();
        g_SoundSetting.SoundMode = ucPMIdx;
    }

    devAudioSetBass(g_SoundSetting.Bass);
    devAudioSetTreble(g_SoundSetting.Treble);
    devAudioVolumeCtl( AUDIO_VOLUME_TURN_ON);
    return TRUE;
}

BOOL ExecSoundSubWoofer(void)
{
    g_SoundSetting.SubWoofer = (g_SoundSetting.SubWoofer + 1) % 2;
    devAudioSetSubWoofer(g_SoundSetting.SubWoofer);
    return TRUE;
}

BOOL ExecSoundAVC(void)
{
    g_SoundSetting.AVCControl = (g_SoundSetting.AVCControl + 1) %2;
    devAudioSetAVC(g_SoundSetting.AVCControl);
    return TRUE;
}

BOOL AdjustSoundLoudness(MenuItemActionType action)
{
    if (action == MIA_INCVALUE)
        g_SoundSetting.Loudness = (g_SoundSetting.Loudness + 1) % 5;
    else
        g_SoundSetting.Loudness = (g_SoundSetting.Loudness + 4) % 5;
    devAudioSetLoudness(g_SoundSetting.Loudness);
    return TRUE;
}

BOOL AdjustSoundSuperBass(MenuItemActionType action)
{
    if (action == MIA_INCVALUE)
        g_SoundSetting.SuperBass = (g_SoundSetting.SuperBass + 1) % 13;
    else
        g_SoundSetting.SuperBass = (g_SoundSetting.SuperBass + 12) % 13;
    devAudioSetSuperBass(g_SoundSetting.SuperBass);
    return TRUE;
}

//===================function===========================
BOOL ExecFunction3DNRAdjust(void)
{
    if( SrcTypeIsPC() )
        return FALSE;

    g_VideoSetting.Function3DNR = (g_VideoSetting.Function3DNR + 1) % FUNCTION_3DNR_NUMS;

    SetNRParam();

    return TRUE;
}

//==============pc gemoetry====================
BOOL AdjustPcHPosition(MenuItemActionType action)
{
    if( SRC_TYPE_IS_VGA())
    {
        g_ModeSetting.HorizontalStart = DecIncValue(action, g_ModeSetting.HorizontalStart, MIN_H_START, MAX_H_START, 1);
        msAdjustPcHPosition(MAX_H_START - g_ModeSetting.HorizontalStart + MIN_H_START);
    }
    return TRUE;
}
WORD GetPcHPositionValue(void)
{
    return GetScale100Value(g_ModeSetting.HorizontalStart, MIN_H_START, MAX_H_START);
}

BOOL AdjustPcVPosition(MenuItemActionType action)
{
    if( SRC_TYPE_IS_VGA())
    {
        g_ModeSetting.VerticalStart = DecIncValue(action, g_ModeSetting.VerticalStart, MIN_V_START, MAX_V_START, 1);
        msAdjustPcVPosition(g_ModeSetting.VerticalStart);
    }
    return TRUE;
}
WORD GetPcVPositionValue(void)
{
    return GetScale100Value(g_ModeSetting.VerticalStart, MIN_V_START, MAX_V_START);
}

BOOL AdjustPcPhase(MenuItemActionType action)
{
    if(SRC_TYPE_IS_VGA())
    {
        g_ModeSetting.Phase = DecIncValue(action, g_ModeSetting.Phase, MIN_PHASE, MAX_PHASE, 1);
        msAdjustAdcPhase(g_ModeSetting.Phase);
    }
    return TRUE;
}
WORD GetPcPhaseValue(void)
{
    return GetScale100Value(g_ModeSetting.Phase, MIN_PHASE, MAX_PHASE);
}

BOOL AdjustPcClock(MenuItemActionType action)
{
    if( SRC_TYPE_IS_VGA() )
    {
        g_ModeSetting.HorizontalTotal = DecIncValue(action, g_ModeSetting.HorizontalTotal, MIN_CLOCK, MAX_CLOCK, 1);
        msAdjustAdcClock(g_ModeSetting.HorizontalTotal);
    }
    return TRUE;
}
WORD GetPcClockValue(void) // adjust range
{
    return GetScale100Value(g_ModeSetting.HorizontalTotal, MIN_CLOCK, MAX_CLOCK);
}

//===================== Osd ==========================
BOOL AdjustSleepTimer(MenuItemActionType action)
{
    if (g_wSleepCount == 0)
        g_SysSetting.SleepTimer = SLEEP_TIMER_OFF;

    g_SysSetting.SleepTimer = DecIncValue_Cycle( action, g_SysSetting.SleepTimer, SLEEP_TIMER_OFF, SLEEP_TIMER_60, 1 );
    g_wSleepCount = (WORD)g_SysSetting.SleepTimer * 15 * 60;

    return TRUE;
}
WORD GetSleepTimer(void)
{
    return (g_wSleepCount/60);
}

BOOL AdjustOsdLanguageAdjust(MenuItemActionType action)
{
    if(action == MIA_INCVALUE)
    {
        g_SysSetting.Languange = (g_SysSetting.Languange + 1) % LANGUAGE_MAX;
    }
    else
    {
        g_SysSetting.Languange = (g_SysSetting.Languange + LANGUAGE_MAX-1) % LANGUAGE_MAX;
    }
    msOsdHide();
    return TRUE;
}

BOOL AdjustOsdHPosition(MenuItemActionType action)
{
    g_SysSetting.OSDHPos = DecIncValue(action,g_SysSetting.OSDHPos, MIN_OSD_H_POS ,MAX_OSD_H_POS,1);
    SetOsdMenuPos(g_SysSetting.OSDHPos, g_SysSetting.OSDVPos);

    return TRUE;
}
WORD GetOsdHpositionValue(void)
{
    return GetScale100Value(g_SysSetting.OSDHPos,MIN_OSD_H_POS,MAX_OSD_H_POS);
}

BOOL AdjustOsdVPosition(MenuItemActionType action)
{
    g_SysSetting.OSDVPos = DecIncValue(action,g_SysSetting.OSDVPos, MIN_OSD_V_POS ,MAX_OSD_V_POS,1);
    SetOsdMenuPos(g_SysSetting.OSDHPos, g_SysSetting.OSDVPos);
    return TRUE;
}
WORD GetOsdVpositionValue(void)
{
    return GetScale100Value(g_SysSetting.OSDVPos,MIN_OSD_V_POS,MAX_OSD_V_POS);
}

BOOL AdjustOsdDurationValue(MenuItemActionType action)
{
    g_SysSetting.OSDTime = DecIncValue(action, g_SysSetting.OSDTime, MIN_OSD_DURATION, MAX_OSD_DURATION, 1);
    return TRUE;
}
WORD GetOsdDurationValue(void)
{
    return GetScale100Value(g_SysSetting.OSDTime, MIN_OSD_DURATION, MAX_OSD_DURATION);
}

BOOL AdjustOsdBlendValue(MenuItemActionType action)
{
    g_SysSetting.OSDBlend = DecIncValue(action, g_SysSetting.OSDBlend, 0, 8, 1);
    msAdjustOsdBlending(g_SysSetting.OSDBlend);

    return TRUE;
}
WORD GetOsdHalftoneValue(void)
{
    return GetScale100Value(g_SysSetting.OSDBlend, 0, 8);
}

BOOL ExecMemoryRecall(void)
{
    devAudioSetVolume(0);
    // Reset EEPROM
    rmWriteByte(RM_EEPROM_ID_ADDRESS, USR_EEPROM_ID+1); // reset EEPROM ID
    usrCheckEEPROM();

    AdjustOsdDurationValue(MIA_NOTHING);
    AdjustOsdBlendValue(MIA_NOTHING);
    InputSourceSwitch( g_SysSetting.ucInputSourceType );

    return TRUE;
}

//===============chanel==========================
BOOL ExecTVChannelAutoSearch(void)
{
    msOsdHide();
    TV_ChannelSearchInit(TVSearch_AUTO);        
    return TRUE;
}

BOOL AdjustTVChannelFineTune(MenuItemActionType action)
{
    BYTE FreqOffset;

    FreqOffset = usrLoadNTSCChannelOffset( g_TVChSetting.ucCurChannelNO ); // -128~127
    if(action == MIA_INCVALUE)
    {
        FreqOffset++;
    }
    else
    {
        FreqOffset--;
    }

    devTunerSetChannel( g_TVSetting.ChannelSource, g_TVChSetting.ucCurChannelNO, FreqOffset );
    usrSaveNTSCChannelOffset( g_TVChSetting.ucCurChannelNO, FreqOffset );

    return TRUE;
}
WORD GetTVChannelFineTune(void)
{
    BYTE FreqOffset;

    FreqOffset = usrLoadNTSCChannelOffset( g_TVChSetting.ucCurChannelNO );
    // -128~127 => 0~255