show_ain.c

MTK 1389E SOURCE CODE

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 04/08/27 9:40a    $       ****************/
/***************  $Revision:: 1                $       ****************/
/***************                                       ****************/
/***************   Description :                       ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer :                       ****************/
/**********************************************************************/

#define _SHOW_AIN_C_

#pragma NOAREGS
#include "general.h"

#ifdef AUDIO_IN_EN

// test flags
//#define SPDIF_INFO_UPD_CHK_LOCK

// *********************************************************************
// Local varlables
// *********************************************************************
xdata struct
{
  BYTE  bType:3;
  BYTE  Reserve:5;
}
_rAinShowFlag;

#define AIN_DISP_NONE       0
#define AIN_DISP_LINE_IN    1
#define AIN_DISP_NO_SYNC    2
#define AIN_DISP_PCM        3
#define AIN_DISP_RAW        4

// *********************************************************************
// Local function
// *********************************************************************
void vAINShowDispType(BYTE bDispType) large;

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vAINUpdateBitRate(void) large
{
  if (fgIsSpdifInMode())
  {
#ifdef SPDIF_INFO_UPD_CHK_LOCK
    if (fgIsSpdifInputLock())
    {
      vAINShowBitRate(bSharedInfo(SI_A_BITRATE0) + bSharedInfo(SI_A_BITRATE1) * 256);
    }
    else
    {
      vAINShowBitRate(0);
    }
#else
    vAINShowBitRate(bSharedInfo(SI_A_BITRATE0) + bSharedInfo(SI_A_BITRATE1) * 256);
#endif
  }
}

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vAINUpdateBitLen(void) large
{
  if (fgIsSpdifInMode())
  {
#ifdef SPDIF_INFO_UPD_CHK_LOCK
    if (fgIsSpdifInputLock())
    {
      vAINShowFsBit(bSharedInfo(SI_A_SRC_FREQ), bSharedInfo(SI_A_BITLEN));
    }
    else
    {
      vAINShowFsBit(0xff, 0xff);
    }
#else
    vAINShowFsBit(bSharedInfo(SI_A_SRC_FREQ), bSharedInfo(SI_A_BITLEN));
#endif
  }
}

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vAINUpdateChInfo(void) large
{
  if (fgIsSpdifInMode())
  {
#ifdef SPDIF_INFO_UPD_CHK_LOCK
    if (fgIsSpdifInputLock())
    {
      vAINShowChInfo(bSharedInfo(SI_DSP_CH_CFG));
    }
    else
    {
      vAINShowChInfo(0xff);
    }
#else
    vAINShowChInfo(bSharedInfo(SI_DSP_CH_CFG));
#endif
  }
}

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vAINUpdateUpsmapling(void) large
{
  if (fgIsSpdifInMode())
  {
#ifdef SPDIF_INFO_UPD_CHK_LOCK
    if (fgIsSpdifInputLock())
    {
      vAINShowOutputMode(bSharedInfo(SI_A_UPSAMPLING));
    }
    else
    {
      vAINShowOutputMode(UPSAMPLE_OFF);
    }
#else
    vAINShowOutputMode(bSharedInfo(SI_A_UPSAMPLING));
#endif
  }
}

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
BYTE bAINGetSpdifMode(BYTE bAudioType) large
{
  if (fgIsSpdifInputLock())
  {
    if (bAudioType == SV_A_CODE_NONE)
    {
      return (AIN_DISP_NO_SYNC);
    }
    else if (bAudioType == SV_A_CODE_PCM)
    {
      return (AIN_DISP_PCM);
    }
    else
    {
      return (AIN_DISP_RAW);
    }
  }
  else // unlocked
  {
    return (AIN_DISP_NO_SYNC);
  }
}

// *********************************************************************
// Initial OSD state for audio input state
// *********************************************************************
void vAINShowInit(void) large
{
  BYTE bMode = bEepromReadByte(AUDIO_IN_POS);

  VfdClearMsg();
  /* show audio input mode icon on VFD here */
  
  _rOsdStateCtx.fgTimeShow = FALSE;
  _rOsdStateCtx.bTimeType = OSD_SHOW_DISABLE;
  _rOsdStateCtx.fgRemainMsgShow = FALSE;
  _rOsdStateCtx.fgPlayInfoShow = FALSE;
  _rOsdStateCtx.bPlayInfoType = AIN_DISP_MODE_DISABLE;
  _rOsdStateCtx.fgPlayShow = FALSE;
  _rOsdStateCtx.bPlayType = OSD_SHOW_PLAY;
  _rOsdStateCtx.fgRepeatShow = FALSE;
  _rOsdStateCtx.fgABShow = FALSE;
  _rOsdStateCtx.fgUsrCtrlShow = FALSE;
  _rOsdStateCtx.fgZoomShow = FALSE;
  _rOsdStateCtx.fgTimePos = OSD_SHOW_TIME_LEFT;

  // init OSD display
  vAINShowDispMode(AIN_DISP_MODE_ON);
}

// *********************************************************************
// Function : BOOL fgAINIsFuncChgAllow(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
BOOL fgAINIsFuncChgAllow(void) large
{
  BYTE bInitState;

  if (fgIsPeriCmdBusy())
  {
    return (FALSE);
  }

  if (fgIsFuncAin())
  {
    // OK
    return (TRUE);
  }
  else if (fgIsFuncDvd())
  {
    bInitState = bSharedInfo(SI_INIT_STATE);
    
    if ((bInitState == SV_DISC_IDENTIFIED) ||
        (bInitState == SV_LOADING_DISC) ||
        (bInitState == SV_NO_DISC))
    {
      return (TRUE);
    }
  }

  // other state do not allow to enter audio in mode
  return (FALSE);
}

// *********************************************************************
// Function : BOOL fgAINIsFuncChgAllow(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vAINSwitchSource(BYTE bMode) large
{
  BYTE bDispType;
  
  switch (bMode)
  {
    case EV_AI_LINE_1:
    case EV_AI_LINE_2:
    case EV_AI_LINE_3:
    case EV_AI_LINE_4:
      vAdspAinSel(bMode - EV_AI_LINE_1 + AIN_SEL_L0);
      break;

    case EV_AI_SPDIF_1:
    case EV_AI_SPDIF_2:
    case EV_AI_SPDIF_3:
    case EV_AI_SPDIF_4:
      vAdspAinSel(bMode - EV_AI_SPDIF_1 + AIN_SEL_D0);
      break;

    case EV_AI_OFF:
    default:
      vAdspAinSel(AIN_SEL_OFF);
      bMode = EV_AI_OFF;
      break;
  }

  if (bMode != EV_AI_OFF)
  {
    if (_rOsdStateCtx.bPlayInfoType == AIN_DISP_MODE_ON)
    {
      // get current display type
      if (fgEVIsLineMode(bMode))
      {
        bDispType = AIN_DISP_LINE_IN;
      }
      else if (fgEVIsSpdifMode(bMode))
      {
        bDispType = bAINGetSpdifMode(bSharedInfo(SI_A_CODE_MODE));
      }
      else
      {
        bDispType = AIN_DISP_NONE;
      }
  
      vAINShowDispType(bDispType);
    }
    else // display off
    {
      // show selected input source only
      vAINShowInputSource(bMode);
    }
  } /* bMode != EV_AI_OFF */
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
static BOOL fgCheckAudioEffect(BYTE bEffect) large
{
  BYTE bFlag;

  if (bEffect >= 16)
  {
    /* not valid UOP */
    return (TRUE);
  }

  if (bEffect >= 24)
  {
    bFlag = bSharedInfo(SI_A_EFFECT_3);
    bEffect -= 24;
  }
  else if (bEffect >= 16)
  {
    bFlag = bSharedInfo(SI_A_EFFECT_2);
    bEffect -= 16;
  }
  else if (bEffect >= 8)
  {
    bFlag = bSharedInfo(SI_A_EFFECT_1);
    bEffect -= 8;
  }
  else /* if if (bNvUop < 8) */
  {
    bFlag = bSharedInfo(SI_A_EFFECT_0);
  }

  if (bFlag & (1 << bEffect))
  {
    return (TRUE);
  }
  else
  {
    return (FALSE);
  }
}

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vAINShow3DMark(void) large
{
  if (fgCheckAudioEffect(SV_A_PL2))
  {
    vAINShow3DMode(AIN_3D_PL2);
  }
  else if (fgCheckAudioEffect(SV_A_N22))
  {
    vAINShow3DMode(AIN_3D_N22);
  }
  else if (fgCheckAudioEffect(SV_A_VSURR))
  {
    vAINShow3DMode(AIN_3D_VSURR);
  }
  else
  {
    vAINShow3DMode(AIN_3D_OFF);
  }
}

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vAINShowModeDisable(void) large
{
  _rOsdStateCtx.fgPlayInfoShow = FALSE;
  _rOsdStateCtx.bPlayInfoType = AIN_DISP_MODE_DISABLE;
}

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vAINShowModeVideoOff(void) large
{
  _rOsdStateCtx.fgPlayInfoShow = FALSE;
  _rOsdStateCtx.bPlayInfoType = AIN_DISP_MODE_VDO_OFF;
}

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vAINShowLineIn(void) large
{
  vAINShow3DMark();
}

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vAINShowSPDIF(BYTE bMode) large
{
  if ((bMode == AIN_DISP_PCM) || (bMode == AIN_DISP_RAW))
  {
    vAINShowStreamType(bSharedInfo(SI_A_CODE_MODE));
    vAINShowFsBit(bSharedInfo(SI_A_SRC_FREQ), bSharedInfo(SI_A_BITLEN));
    vAINShowBitRate(bSharedInfo(SI_A_BITRATE0) + bSharedInfo(SI_A_BITRATE1) * 256);
    if (bMode == AIN_DISP_PCM)
    {
      vAINShowChInfo(SV_A_CH_20_0);
    }
    else
    {
      vAINShowChInfo(bSharedInfo(SI_DSP_CH_CFG));
    }
    vAINShowOutputMode(bSharedInfo(SI_A_UPSAMPLING));
    vAINShow3DMark();
  }
  else /* bMode == AIN_DISP_NO_SYNC */
  {
    vAINShowStreamType(SV_A_CODE_NONE);
    vAINShowFsBit(0xff, 0xff);
    vAINShowBitRate(0);
    vAINShowChInfo(0xff);
    vAINShowOutputMode(UPSAMPLE_OFF);
  }
}

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vAINShowDispType(BYTE bDispType) large
{
  switch (bDispType)
  {
    case AIN_DISP_LINE_IN:
      if (_rAinShowFlag.bType != AIN_DISP_LINE_IN)
      {
        vOsdShowWb(OSD_WB_CLEAR);
      }
      vAINShowLineIn();
      break;

    case AIN_DISP_NO_SYNC:
    case AIN_DISP_PCM:
    case AIN_DISP_RAW:
      if ((_rAinShowFlag.bType != AIN_DISP_NO_SYNC) &&
          (_rAinShowFlag.bType != AIN_DISP_PCM) &&
          (_rAinShowFlag.bType != AIN_DISP_RAW))
      {
        vOsdShowWb(OSD_WB_CLEAR);
      }
      vAINShowSPDIF(bDispType);
      break;

    case AIN_DISP_NONE:
    default:
      if (_rAinShowFlag.bType != AIN_DISP_NONE)
      {
        vOsdShowWb(OSD_WB_CLEAR);
      }
      bDispType = AIN_DISP_NONE;
      break;
  }

  _rAinShowFlag.bType = bDispType;

  // show selected input source
  vAINShowInputSource(bEepromReadByte(AUDIO_IN_POS));
}

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vAINShowSwitchType(BYTE bType) large
{
  BYTE bDispType;

  if (fgIsSpdifInputOn())
  {
    bDispType = bAINGetSpdifMode(bType);
  }
  else // not in SPDIF in mode, it's in line in mode
  {
    bDispType = AIN_DISP_LINE_IN;
  }

  if (_rAinShowFlag.bType == bDispType)
  {
    if (bDispType == AIN_DISP_RAW)
    {
      vAINShowStreamType(bType);
    }
    
    return;
  }

  vAINShowDispType(bDispType);
}

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vAINShowModeOn(void) large
{
  BYTE bMode = bEepromReadByte(AUDIO_IN_POS);

  _rOsdStateCtx.fgPlayInfoShow = TRUE;
  _rOsdStateCtx.bPlayInfoType = AIN_DISP_MODE_ON;

  // get current display type
  if (fgEVIsLineMode(bMode))
  {
    bMode = AIN_DISP_LINE_IN;
  }
  else if (fgEVIsSpdifMode(bMode))
  {
    bMode = bAINGetSpdifMode(bSharedInfo(SI_A_CODE_MODE));
  }
  else
  {
    bMode = AIN_DISP_NONE;
  }

  vAINShowDispType(bMode);
}

// *********************************************************************
// Function : 
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vAINShowDispMode(BYTE bMode) large
{
  if (_rOsdStateCtx.bPlayInfoType == bMode)
  {
    return;
  }
  else if (bMode != AIN_DISP_MODE_ON)
  {
    // clear WB
    vOsdShowWb(OSD_WB_CLEAR);
    
    _rAinShowFlag.bType = AIN_DISP_NONE;
  }

  switch (bMode)
  {
    case AIN_DISP_MODE_ON:
      vAINShowModeOn();
      break;

    case AIN_DISP_MODE_VDO_OFF:
      vAINShowModeVideoOff();
      break;

    case AIN_DISP_MODE_DISABLE:
    default:
      bMode = AIN_DISP_MODE_DISABLE;
      vAINShowModeDisable();
      break;
  }

  if (bMode == AIN_DISP_MODE_VDO_OFF)
  {
    // turn video off
  }
  else if (_rOsdStateCtx.bPlayInfoType == AIN_DISP_MODE_VDO_OFF)
  {
    // turn video on
  }

  _rOsdStateCtx.bPlayInfoType = bMode;
}

#endif /* AUDIO_IN_EN */