/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 07/04/09 11:49a   $       ****************/
/***************  $Revision:: 2                $       ****************/
/***************                                       ****************/
/***************   Description : OSD                   ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer : Peter Huang           ****************/
/**********************************************************************/

#define _AVSHOW_C_

#pragma NOAREGS

#include "general.h"
#include "osdshow.h"

// *********************************************************************
// Function : void vOsdShowVol(BYTE bLevel, BYTE bTime) large
// Description :
// Parameter :  cLevel
// Return    : None
// *********************************************************************
void vOsdShowVol(BYTE bLevel, BYTE bTime) large
{
  BYTE pbStr[13];
  BYTE i;

  if (bLevel < 0)
  {
    bLevel = 0;
  }

  if (bLevel > MAX_VOL_LEVEL)
  {
    bLevel = MAX_VOL_LEVEL;
  }

  pbStr[0] = 12;

  for(i=0; i<bLevel/2; i++)
  {
    if (i == 10)
    {
      break;
    }
    pbStr[i+1] = ICON_VOL_1; //3;
  }
  if (bLevel % 2)
  {
    pbStr[i+1] = ICON_VOL_2; //4;
    i ++;
  }
  for(; i<20/2; i++)
  {
    pbStr[i+1] = ICON_VOL_0; //2;
  }
  bLevel = bHEXToBCD(bLevel);
  pbStr[11] = BCD_HI(bLevel) + '0';
  pbStr[12] = BCD_LO(bLevel) + '0';

#ifdef PCD_SHOW_AUD_CTRL
  if (fgIsPcdPlay())
  {
    vOsdPosShowArg(OSD_POS_PCD_AUD_CTRL, OSD_MSG_VOLUME, bTime, pbStr);
  }
  else
#endif
  {
    vOsdPosShowArg(OSD_POS_AUD_CTRL, OSD_MSG_VOLUME, bTime, pbStr);
  }
}

// *********************************************************************
// Function : void vOsdShowMute(BYTE bMode) large
// Description :
// Parameter :  
// Return    : None
// *********************************************************************
void vOsdShowMute(BYTE bMode) large
{
  WORD wPos;
#ifdef PLAYER_FLMENU
  BOOL fgFlMenuOn = fgFlCheckStatus(FL_STATUS_IN_MENU);
#endif

#ifdef PCD_SHOW_AUD_CTRL
  if (fgIsPcdPlay())
  {
    wPos = OSD_POS_PCD_AUD_CTRL;
  }
  else
#endif
  {
    wPos = OSD_POS_AUD_CTRL;
  }

  switch (bMode)
  {
    case OSD_MUTE_OFF:
    {
#ifdef PLAYER_FLMENU
      if (fgFlMenuOn)
        vFlIpShowInfo(IP_INFO_VOLUME, bAdspCurrVol(), FLIP_VOLUME_MUTE_OFF | FLIP_VOLUME_REDRAW);
#endif
      vOsdPosShow(wPos, OSD_MSG_MUTEOFF, OSD_TIMEOUT);
      vOsdCoreSetAudioStatus(OSD_AUDIO_SHOW_CLEAR, 0);
      break;
    }

    case OSD_MUTE_ON:
    {
#ifdef PLAYER_FLMENU
      if (fgFlMenuOn)
        vFlIpShowInfo(IP_INFO_VOLUME, bAdspCurrVol(), FLIP_VOLUME_MUTE_ON);
#endif
      vOsdPosShow(wPos, OSD_MSG_MUTE, OSD_NO_DISAPPEAR);
      vOsdCoreSetAudioStatus(OSD_AUDIO_SHOW_MUTE, OSD_NO_DISAPPEAR);
      break;
    }

    case OSD_MUTE_CLEAR:
    default:
    {
#ifdef PLAYER_FLMENU
      if (fgFlMenuOn)
        vFlIpShowInfo(IP_INFO_VOLUME, bAdspCurrVol(), FLIP_VOLUME_REDRAW);
#endif
      vOsdPosClear(wPos);
      vOsdCoreSetAudioStatus(OSD_AUDIO_SHOW_CLEAR, 0);
      break;
    }
  }
}

// *********************************************************************
// Function : void vOsdShowZoom(BYTE bState)
// Description :
// Parameter :  bState
// Return    : None
// *********************************************************************
static code BYTE pbZoomMsg[SV_ZOOM_MODE_MAX - 1][3] = {
  { '1', '.', '1' }, /* 1:  SV_ZOOM_11  */
  { '1', '.', '2' }, /* 2:  SV_ZOOM_12  */
  { '1', '.', '5' }, /* 3:  SV_ZOOM_15  */
  { ' ', '2', 'X' }, /* 4:  SV_ZOOM_2   */
  { '2', '.', '5' }, /* 5:  SV_ZOOM_25  */
  { ' ', '3', 'X' }, /* 6:  SV_ZOOM_3   */
  { '3', '.', '5' }, /* 7:  SV_ZOOM_35  */
  { ' ', '4', 'X' }, /* 8:  SV_ZOOM_4   */
  { '1', '/', '2' }, /* 9:  SV_ZOOM_21  */
  { '1', '/', '3' }, /* 10: SV_ZOOM_31  */
  { '1', '/', '4' }  /* 11: SV_ZOOM_41  */
};

void vOsdShowZoom(BYTE bState) large
{
  BYTE pbStr[4];
  BYTE bIdx;

  if (fgIsIsoPlay())
  {
    vOsdPosClear(OSD_POS_ISO_ZOOM);
  }
  else
  {
    vOsdPosClear(OSD_POS_ZOOM);
  }

#ifdef ENABLE_ZOOM_USER_MODE
  if (bState == SV_ZOOM_USR)
  {
    pbStr[0] = 3;
    pbStr[1] = 'F';
    pbStr[2] = 'I';
    pbStr[3] = 'T';
  }
  else
#endif /* ENABLE_ZOOM_USER_MODE */
  if ((bState == SV_ZOOM_1) || (bState >= SV_ZOOM_MODE_MAX))
  {
    pbStr[0] = 0;
  }
  else
  {
    bState--;

    for (pbStr[0] = 0; pbStr[0] < 3; pbStr[0] += 1)
    {
      pbStr[pbStr[0] + 1] = pbZoomMsg[bState][pbStr[0]];
    }
    
    //pbStr[0] = 3;
  }

  if (pbStr[0] > 0)
  {
    if (fgIsIsoPlay())
    {
      vOsdPosShowArg(OSD_POS_ISO_ZOOM, OSD_MSG_ICON_ZOOM, OSD_NO_DISAPPEAR, pbStr);
    }
    else
    {
      vOsdPosShowArg(OSD_POS_ZOOM, OSD_MSG_ICON_ZOOM, OSD_NO_DISAPPEAR, pbStr);
    }
  }
}

#ifdef PLAYER_ZOOMIN_INDICATOR

#define vZoomRectangle(bWbIdx, bClr, wStartX, wStartY, wEndX, wEndY) \
{ \
  _wStartX = wStartX;  \
  _wStartY = wStartY;  \
  _wEndX = wEndX;  \
  _wEndY = wEndY;  \
  vRectangle(bWbIdx, 1, bClr, 1, bClr); \
}

static code BYTE pbZoomBr[SV_ZOOM_IN_MAX - SV_ZOOM_IN_MIN + 1][2] = {
  {86,57}, /* SV_ZOOM_11 */
  {82,54}, /* SV_ZOOM_12 */
  {73,48}, /* SV_ZOOM_15 */
  {64,42}, /* SV_ZOOM_2  */
  {57,37}, /* SV_ZOOM_25 */
  {52,34}, /* SV_ZOOM_3  */
  {48,32}, /* SV_ZOOM_35 */
  {45,29}  /* SV_ZOOM_4  */
};

// *********************************************************************
// Function : void vZoomBrDraw(void)
// Description :
// Parameter :  
// Return    : 
// *********************************************************************
void vOsdShowZoomBr(BYTE bX, BYTE bY, BYTE bMode) large
{
  BYTE bNewX;
  BYTE bNewY;

  // outer rectangle
  vZoomRectangle(WB_ZOOM_BR, 3, 0, 0, ZOOM_BR_WIDTH, ZOOM_BR_HEIGHT);

  bMode -= SV_ZOOM_IN_MIN;

  //Bad code style here.
//  if(((bSharedInfo(SI_ASPECT_RATIO) & 0x7f) == SV_4_3_PS) && fgIsDvdPlay() && (bSharedInfo(SI_V_4_3) == SV_V_16_9))
//    bNewX = bX+(pbZoomBr[bMode][0]+3)*3/4;
//  else
    bNewX = bX+pbZoomBr[bMode][0];
    //2005 Eden
    //Add the check of width
    if(bNewX > ZOOM_BR_WIDTH)
    {
      bNewX = ZOOM_BR_WIDTH;
    }

  // Modify by Bright_liu 2005/10/05
  bNewY = bY + pbZoomBr[bMode][1];
  if(bNewY > ZOOM_BR_HEIGHT)
  {
    bNewY = ZOOM_BR_HEIGHT;
  }
  
  // inner rectangle
  vZoomRectangle(WB_ZOOM_BR, 1, bX, bY, bNewX, bNewY);
}
#endif /* PLAYER_ZOOMIN_INDICATOR */

#ifdef DDISC_FTYPE_JPEG_SUPPORT
// *********************************************************************
// Function : void vOsdShowZoomPct(BYTE bPercent)
// Description :
// Parameter :  bState
// Return    : None
// *********************************************************************
void vOsdShowZoomPct(BYTE bPercent) large
{
  BYTE pbStr[4];
  
  // 20050323, IS00002440, if already changed to select input state, don't clear Zoom osd or it'll clear select osd
  if (fgIsInputStateValid(INPUT_STATE_FILE_SELECT))
    return ;
 
  if (bPercent <= 100)
  {
    vOsdPosClear(OSD_POS_ERROR);   // clear "PAN xx" message
  }
    
  if (bPercent == 0)
  {
    vOsdPosClear(OSD_POS_ZOOM_PCT);
  }
  else
  {
    pbStr[0] = 3;

    if (bPercent >= 200)
    {
      pbStr[1] = '2';
      bPercent -= 200;
    }
    else if (bPercent >= 100)
    {
      pbStr[1] = '1';
      bPercent -= 100;
    }
    else
    {
      pbStr[1] = ' ';
    }

    bPercent = bHEXToBCD(bPercent);

    pbStr[2] = BCD_HI(bPercent) + '0';
    pbStr[3] = BCD_LO(bPercent) + '0';

    if ((pbStr[1] == ' ') && (pbStr[2] == '0'))
    {
      pbStr[2] = ' ';
    }

    vOsdPosShowArg(OSD_POS_ZOOM_PCT, OSD_MSG_ZOOM_PERCENT, OSD_NO_DISAPPEAR, pbStr);
  }
}
#endif /* DDISC_FTYPE_JPEG_SUPPORT */

#if (defined(PLAYER_KARAOKE) || defined(USE_EXTERNAL_KARAOKE))
// *********************************************************************
// Function : void vOsdShowKeyShift(char cLevel) large
// Description :
// Parameter :  cLevel
// Return    : None
// *********************************************************************
void vOsdShowKeyShift(char cLevel, BYTE bTime) large
{
  BYTE pbKey[4];

  if (cLevel >= MAX_KEY_LEVEL)
  {
    cLevel = MAX_KEY_LEVEL;
  }

  if (cLevel <= MIN_KEY_LEVEL)
  {
    cLevel = MIN_KEY_LEVEL;
  }

#if 0
  // show a slide bar
  vOsdShowLineXY(WB_NORMAL_VOL, 2, 2, 300, 18, 300 + (MAX_KEY_LEVEL - MIN_KEY_LEVEL + 1)*4, 18);
  vOsdShowLineXY(WB_NORMAL_VOL, 3, 4, 300, 20, 300 + (MAX_KEY_LEVEL - MIN_KEY_LEVEL + 1)*4, 20);
  vOsdShowLineXY(WB_NORMAL_VOL, 2, 2, 300, 22, 300 + (MAX_KEY_LEVEL - MIN_KEY_LEVEL + 1)*4, 22);

  vOsdShowLineXY(WB_NORMAL_VOL, 0, 2, 300 + (cLevel + 16 + 1)*4-2, 10, 300 + (cLevel + 16 + 1)*4-2, 30);
  vOsdShowLineXY(WB_NORMAL_VOL, 0, 4, 300 + (cLevel + 16 + 1)*4, 10, 300 + (cLevel + 16 + 1)*4, 30);
  vOsdShowLineXY(WB_NORMAL_VOL, 0, 2, 300 + (cLevel + 16 + 1)*4+2, 10, 300 + (cLevel + 16 + 1)*4+2, 30);
  vOsdShowLineXY(WB_NORMAL_VOL, 0, 2, 300 + (cLevel + 16 - 1)*4-2, 10, 300 + (cLevel + 16 - 1)*4-2, 30);
  vOsdShowLineXY(WB_NORMAL_VOL, 0, 4, 300 + (cLevel + 16 - 1)*4, 10, 300 + (cLevel + 16 - 1)*4, 30);
  vOsdShowLineXY(WB_NORMAL_VOL, 0, 2, 300 + (cLevel + 16 - 1)*4+2, 10, 300 + (cLevel + 16 - 1)*4+2, 30);

  vOsdShowLineXY(WB_NORMAL_VOL, 2, 2, 300 + (cLevel + 16)*4-2, 10, 300 + (cLevel + 16)*4-2, 30);
  vOsdShowLineXY(WB_NORMAL_VOL, 3, 4, 300 + (cLevel + 16)*4, 10, 300 + (cLevel + 16)*4, 30);
  vOsdShowLineXY(WB_NORMAL_VOL, 2, 2, 300 + (cLevel + 16)*4+2, 10, 300 + (cLevel + 16)*4+2, 30);
#endif

  if (cLevel < 0)
  {
    pbKey[1] = '-';
    cLevel = - cLevel;
  }
  else
  {
    pbKey[1] = '+';
  }

  pbKey[0] = bHEXToBCD(cLevel);

  pbKey[2] = BCD_HI(pbKey[0]) + '0';
  pbKey[3] = BCD_LO(pbKey[0]) + '0';

  pbKey[0] = 3;

#ifdef PLAYER_FLMENU
  if (fgFlCheckStatus(FL_STATUS_IN_MENU))
    vFlIpShowInfo(IP_INFO_KEY_SHIFT, cLevel, 0);
  else
#endif
  vOsdPosShowArg(OSD_POS_AUD_CTRL, OSD_MSG_SET_KEY, bTime, pbKey);

  vOsdCoreSetAudioStatus(OSD_AUDIO_SHOW_NORMAL, bTime);
}
#endif /* PLAYER_KARAOKE || USE_EXTERNAL_KARAOKE */

#ifdef PLAYER_KARAOKE
 #ifdef KARAOKE_SIMPLE_ECHO
// *********************************************************************
// Function : void vOsdShowEchoLevel(BYTE bLevel)
// Description :
// Parameter :  cLevel
// Return    : None
// *********************************************************************
void vOsdShowEchoLevel(BYTE bLevel) large
{
  BYTE pbStr[3];

  if (bLevel == OSD_MIC_ON)
  {
    vOsdPosShow(OSD_POS_AUD_CTRL, OSD_MSG_MIC_ON, OSD_TIMEOUT);
  }
  else if (bLevel == OSD_MIC_OFF)
  {
    vOsdPosShow(OSD_POS_AUD_CTRL, OSD_MSG_MIC_OFF, OSD_TIMEOUT);
  }
  else
  {
    bLevel = bHEXToBCD(bLevel);

    pbStr[0] = 2;
    pbStr[1] = BCD_HI(bLevel) + '0';
    pbStr[2] = BCD_LO(bLevel) + '0';

    vOsdPosShowArg(OSD_POS_AUD_CTRL, OSD_MSG_ECHO_NO, OSD_TIMEOUT, pbStr);
  }

  vOsdCoreSetAudioStatus(OSD_AUDIO_SHOW_NORMAL, OSD_TIMEOUT);
}
  #endif /* KARAOKE_SIMPLE_ECHO */
#endif /* PLAYER_KARAOKE */

#ifdef PLAYER_SURROUND
// *********************************************************************
// Function : void vOsdShowSurrType(BYTE bType, WORD wPos)
// Description :
// Parameter :  bType
// Return    : None
// *********************************************************************
static code WORD pwSurrTypeMsg[AUD_EQ_TYPE_MAX] = { // include NONE
  /* 00 */ OSD_MSG_OFF, //OSD_MSG_EQ_NONE,
  /* 01 */ OSD_MSG_EQ_ROCK,
  /* 02 */ OSD_MSG_EQ_POP,
  /* 03 */ OSD_MSG_EQ_LIVE,
  /* 04 */ OSD_MSG_EQ_DANCE,
  /* 05 */ OSD_MSG_EQ_TENCO,
  /* 06 */ OSD_MSG_EQ_CLASSIC,
  /* 07 */ OSD_MSG_EQ_SOFT
};

void vOsdShowSurrType(BYTE bType, WORD wPos) large
{
  BYTE pbStr[3];
  
  if (bType >= AUD_EQ_TYPE_MAX)
  {
    return;
  }

  pbStr[0] = 2;
  pbStr[1] = bLoByte(pwSurrTypeMsg[bType]);
  pbStr[2] = bHiByte(pwSurrTypeMsg[bType]);

  if (wPos == OSD_POS_AUD_CTRL)
  {
    vOsdPosShowArg(OSD_POS_AUD_CTRL, OSD_MSG_SURR_TYPE, OSD_TIMEOUT, pbStr);

    vOsdCoreSetAudioStatus(OSD_AUDIO_SHOW_NORMAL, OSD_TIMEOUT);
  }
  #ifdef AUDIO_IN_EN
  else if (wPos == OSD_POS_AIN_EQ_TYPE)
  {
    vOsdPosShowArg(OSD_POS_AIN_EQ_TYPE, OSD_MSG_EQ_TYPE_MSG, OSD_NO_DISAPPEAR, pbStr);
  }
  #endif
}

// *********************************************************************
// Function : void vOsdShowReverbType(BYTE bType, WORD wPos)
// Description :
// Parameter :  bType
// Return    : None
// *********************************************************************
static code WORD pwReverbModeMsg[AUD_REVERB_MODE_MAX + 1] = { // include OFF
  /* 00 */ OSD_MSG_OFF,
  /* 01 */ OSD_MSG_CONCERT,
  /* 02 */ OSD_MSG_LIVING_ROOM,
  /* 03 */ OSD_MSG_HALL,
  /* 04 */ OSD_MSG_BATHROOM,
  /* 05 */ OSD_MSG_CAVE,
  /* 06 */ OSD_MSG_ARENA,
  /* 07 */ OSD_MSG_CHURCH
};

void vOsdShowReverbType(BYTE bType, WORD wPos) large
{
  BYTE pbStr[3];
  
  if (bType > AUD_REVERB_MODE_MAX)
  {
    return;
  }

  pbStr[0] = 2;
  pbStr[1] = bLoByte(pwReverbModeMsg[bType]);
  pbStr[2] = bHiByte(pwReverbModeMsg[bType]);

  if (wPos == OSD_POS_AUD_CTRL)
  {
#ifdef PLAYER_FLMENU
    if (fgFlCheckStatus(FL_STATUS_IN_MENU))
      vFlIpShowInfo(IP_INFO_REVERB, 0, pwReverbModeMsg[bType]);
    else
#endif
    vOsdPosShowArg(OSD_POS_AUD_CTRL, OSD_MSG_REVERB_TYPE, OSD_TIMEOUT, pbStr);
  
    vOsdCoreSetAudioStatus(OSD_AUDIO_SHOW_NORMAL, OSD_TIMEOUT);
  }
  #ifdef AUDIO_IN_EN
  else if (wPos == OSD_POS_AIN_REV_TYPE)
  {
    vOsdPosShowArg(OSD_POS_AIN_REV_TYPE, OSD_MSG_REV_TYPE_MSG, OSD_NO_DISAPPEAR, pbStr);
  }
  #endif
}
#endif /* PLAYER_SURROUND */

#ifdef IR_SUPPORT_SHIFT_KEY
// *********************************************************************
// Function : void vOsdShowShiftMark(BOOL fgShow)
// Description :
// Parameter :
// Return    : None
// Note      :
// *********************************************************************
static code WORD pwPosShiftMark[OSD_SHIFT_MARK_MAX] = {
  OSD_POS_SHIFT_MARK,
  #ifdef PLAYER_DIGEST
  OSD_POS_DGST_SHIFT_MARK
  #else
  OSD_POS_NULL
  #endif
};

void vOsdShowShiftMark(BYTE bMode, BOOL fgShow) large
{
  BYTE bIdx;

  if (bMode == OSD_SHIFT_MARK_ALL)
  {
    for (bIdx = 0;bIdx < OSD_SHIFT_MARK_MAX; bIdx++)
    {
      if (fgShow) /* show mark */
      {
        vOsdPosPaste(pwPosShiftMark[bIdx], OSD_MSG_ICON_SHIFT);
      }
      else /* clear mark */
      {
        vOsdPosClear(pwPosShiftMark[bIdx]);
      }
    }
  }
  else if (bMode >= OSD_SHIFT_MARK_MAX) /* not a valid value */
  {
    return;
  }
  else
  {
    if (fgShow) /* show mark */
    {
      vOsdPosPaste(pwPosShiftMark[bMode], OSD_MSG_ICON_SHIFT);
    }
    else /* clear mark */
    {
      vOsdPosClear(pwPosShiftMark[bMode]);
    }
  }
}
#endif /* IR_SUPPORT_SHIFT_KEY */