flipshow.c

mtk1389L latest sourcecode enjoy

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 07/05/18 1:55p    $       ****************/
/***************  $Revision:: 5                $       ****************/
/***************                                       ****************/
/***************   Description : File Menu             ****************/
/***************                 Info Panel Module     ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer : Jacob Lin             ****************/
/**********************************************************************/

#pragma NOAREGS

#define __FLIPSHOW_C_

#include "../general.h"
#include "../osdshow.h"
#include "flcomm.h"
#include "flctrl.h"
#include "flconfig.h"

#if (defined(FSMENU_INFO_PANEL) && defined(PLAYER_FLMENU))

static code BYTE pbISOFastDispTbl[] = { 0, 2, 4, 8, 16, 32 };
static code BYTE pbISOSlowDispTbl[] = { 0, 2, 4, 8, 16 };

typedef struct sInfoPanelArea
{
  WORD  wPanelPos[2];
  BYTE  bTimeout[2];
};
#if 0
static code WORD _pwListTypeName[] =
{
  OSD_MSG_MP3_NORMAL_MODE
#ifdef FLMN_SUPPORT_FILELIST
  , OSD_MSG_FL_FILELIST
#endif
#ifdef FLMN_SUPPORT_PLAYLIST
  , OSD_MSG_FL_PLAYLIST
#endif
};
#endif
#define OSD_TIMEOUT_SHORTER  2

static code struct sInfoPanelArea _rInfoPanelArea[IP_INFO_MAX] =
{
  // Common
  { { OSD_POS_FS_PLAYTIME,   OSD_POS_FS_PLAYTIME   }, { OSD_NO_DISAPPEAR,    OSD_NO_DISAPPEAR    } },
  { { OSD_POS_FS_TOTALTIME,  OSD_POS_FS_TOTALTIME  }, { OSD_NO_DISAPPEAR,    OSD_NO_DISAPPEAR    } },
  { { OSD_POS_FS_FILE_INDEX, OSD_POS_FS_FILE_INDEX }, { OSD_NO_DISAPPEAR,    OSD_NO_DISAPPEAR    } },
  // Panel 1
  { { OSD_POS_FS_BITRATE,      OSD_POS_FS_INFO_BAR }, { OSD_NO_DISAPPEAR, OSD_TIMEOUT_SHORTER } },
  { { OSD_POS_FS_PBC,          OSD_POS_FS_INFO_BAR }, { OSD_NO_DISAPPEAR, OSD_TIMEOUT_SHORTER } },
  { { OSD_POS_FS_USR_AUX_CTRL, OSD_POS_FS_INFO_BAR }, { OSD_NO_DISAPPEAR, OSD_TIMEOUT_SHORTER } },
  { { OSD_POS_FS_VOLUME,       OSD_POS_FS_INFO_BAR }, { OSD_NO_DISAPPEAR, OSD_TIMEOUT_SHORTER } },
  { { OSD_POS_FS_EQ,           OSD_POS_FS_INFO_BAR }, { OSD_NO_DISAPPEAR, OSD_TIMEOUT_SHORTER } },
  // Panel 2
  { { OSD_POS_FS_INFO_BAR,     OSD_POS_FS_LIST_TYPE }, { OSD_TIMEOUT_SHORTER,  OSD_NO_DISAPPEAR } },
  { { OSD_POS_FS_INFO_BAR,     OSD_POS_FS_KEY_SHIFT }, { OSD_TIMEOUT_SHORTER,  OSD_NO_DISAPPEAR } },
  { { OSD_POS_FS_INFO_BAR,     OSD_POS_FS_RPT_TYPE  }, { OSD_TIMEOUT_SHORTER,  OSD_NO_DISAPPEAR } },
  { { OSD_POS_FS_INFO_BAR,     OSD_POS_FS_REVERB    }, { OSD_TIMEOUT_SHORTER,  OSD_NO_DISAPPEAR } },
  // Info Bar
  { { OSD_POS_FS_INFO_BAR,     OSD_POS_FS_INFO_BAR   }, { OSD_TIMEOUT_SHORTER, OSD_TIMEOUT_SHORTER } },
  { { OSD_POS_FS_INFO_BAR,     OSD_POS_FS_INFO_BAR   }, { OSD_TIMEOUT_SHORTER, OSD_TIMEOUT_SHORTER } }
};

////////////////////////////////////////////////////////////////////////////////
// Utility Function

static void vWord2Str(WORD wVal, BYTE *pbStr, BYTE bLen) large
{
  wVal = wWRDToBCD(wVal);

  pbStr[0] = bLen;
  if (bLen == 3)
  {
    pbStr[1] = BCD_LO(bHiByte(wVal)) + '0';
    pbStr[2] = BCD_HI(bLoByte(wVal)) + '0';
    pbStr[3] = BCD_LO(bLoByte(wVal)) + '0';
  }
  else // if (bLen == 4)
  {
    pbStr[1] = BCD_HI(bHiByte(wVal)) + '0';
    pbStr[2] = BCD_LO(bHiByte(wVal)) + '0';
    pbStr[3] = BCD_HI(bLoByte(wVal)) + '0';
    pbStr[4] = BCD_LO(bLoByte(wVal)) + '0';
  }
}

static void vFlIpDrawInfo(BYTE bInfo, WORD wMsg, BYTE *pbStr) large
{
  BYTE  bTime;
  WORD  wPos;

  wPos  = _rInfoPanelArea[bInfo].wPanelPos[_bFlIpState];
  bTime = _rInfoPanelArea[bInfo].bTimeout[_bFlIpState];

  if (pbStr)
  {
    vOsdPosShowArg(wPos, wMsg, bTime, pbStr);
  }
  else
  {
    vOsdPosShow(wPos, wMsg, bTime);
  }
}

///////////////////////////////////////////////////////////////////////////////
//

static void vFlIpShowTimeRemain(BYTE bMin, BYTE bSec) large
{
  BYTE pbTime[5];

  vCheckTimeValid2(bMin, bSec);

  pbTime[0] = 4;
  pbTime[1] = BCD_HI(bMin) + '0';
  pbTime[2] = BCD_LO(bMin) + '0';
  pbTime[3] = BCD_HI(bSec) + '0';
  pbTime[4] = BCD_LO(bSec) + '0';


  vFlIpDrawInfo(IP_INFO_PLAYTIME, OSD_MSG_TIME_RIGHT_2, pbTime);
}

static void vFlIpShowTotalTime(BYTE bMin, BYTE bSec) large
{
  BYTE pbTime[5];

  vCheckTimeValid2(bMin, bSec);

  pbTime[0] = 4;
  pbTime[1] = BCD_HI(bMin) + '0';
  pbTime[2] = BCD_LO(bMin) + '0';
  pbTime[3] = BCD_HI(bSec) + '0';
  pbTime[4] = BCD_LO(bSec) + '0';

  vFlIpDrawInfo(IP_INFO_TOTALTIME, OSD_MSG_TIME_RIGHT_2, pbTime);
}


/*
  Add the 'Kbps' by Bright_liu 2005/12/01, for CQ(PL00205190)
  And if wBitrate == 0, clear the Kbps.
  Notice modify FS_PBC_X in fslist.h, or overlay the ICON of PBC state.
*/
static void vFlIpShowBitrate(WORD wBitrate) large
{
  BYTE i;
  BYTE pbBr[9];

  if ((wBitrate != 0xFFFF) && (wBitrate != 0))
  {
    vWord2Str(wBitrate, pbBr, 4);
    pbBr[0] = 8;
    pbBr[5] = 'K';
    pbBr[6] = 'b';
    pbBr[7] = 'p';
    pbBr[8] = 's';

    for (i=1; i<=4; i++)
    {
      if (pbBr[i] == '0')
       pbBr[i] = ' ';
      else
        break;
    }
  }
  else
  {
    pbBr[0] = 8;
    pbBr[1] = ' ';
    pbBr[2] = ' ';
    pbBr[3] = ' ';
    pbBr[4] = ' ';
    pbBr[5] = ' ';
    pbBr[6] = ' ';
    pbBr[7] = ' ';
    pbBr[8] = ' ';
  }

  if (_bFlIpState == IP_STATE_PANEL_1)
    vOsdPosShowStr(OSD_POS_FS_BITRATE, pbBr);
}

static void vFlIpShowVolume(BYTE bVal, BYTE bStyle) large
{
  BYTE pbStr[13];
  BYTE i;

  if (bStyle & FLIP_VOLUME_MUTE_ON)
  {
/*
    _wStartX = FS_VOLUME_X;
    _wEndX = FS_VOLUME_X + FS_VOLUME_W;
    _wStartY = FS_VOLUME_Y;
    _wEndY = FS_VOLUME_H;
*/
    if (_bFlIpState == IP_STATE_PANEL_1)
    {
      vOsdPosClear(OSD_POS_FS_VOLUME);
      vOsdPosShow(OSD_POS_FS_VOLUME, OSD_MSG_MUTE, OSD_NO_DISAPPEAR);
    }
    else
      vOsdPosShow(OSD_POS_FS_INFO_BAR, OSD_MSG_MUTE, OSD_TIMEOUT_SHORT);
    return;
  }
  else if (bStyle & FLIP_VOLUME_MUTE_OFF)
  {
    if (_bFlIpState == IP_STATE_PANEL_1)
    {
      vOsdPosClear(OSD_POS_FS_VOLUME);
    }
    else
    {
      vOsdPosShow(OSD_POS_FS_INFO_BAR, OSD_MSG_MUTEOFF, OSD_TIMEOUT_SHORT);
      return;
    }
  }

  if (_bFlIpState == IP_STATE_PANEL_1)
  {
    if (bStyle & FLIP_VOLUME_REDRAW)
    {
      _wStartX = FS_VOLUME_X;
      _wEndX = FS_VOLUME_X + FS_VOLUME_W;
      _wStartY = FS_VOLUME_Y;
      _wEndY = FS_VOLUME_H;
      vOsdPosClear(OSD_POS_FS_VOLUME);

      _wStartY = FS_VOLUME_Y;
      _wEndY = FS_VOLUME_H;
      vDrawProgress(bVal, MAX_VOL_LEVEL);
    }
    else
    {
      _wStartX = FS_VOLUME_X;
      _wEndX = FS_VOLUME_X + FS_VOLUME_W;
      _wStartY = FS_VOLUME_Y;
      _wEndY = FS_VOLUME_H;

      if (bStyle & FLIP_VOLUME_UP)
      {
        //vMoveProgress(bVal-1, MAX_VOL_LEVEL, FALSE);
      }
      else if (bStyle & FLIP_VOLUME_DOWN)
      {
        vMoveProgress(bVal+1, MAX_VOL_LEVEL, FALSE);
      }

      _wStartX = FS_VOLUME_X;
      _wEndX = FS_VOLUME_X + FS_VOLUME_W;
      _wStartY = FS_VOLUME_Y;
      _wEndY = FS_VOLUME_H;

      vMoveProgress(bVal, MAX_VOL_LEVEL, TRUE);
    }
  }
  else
  {
    if (bVal < 0)
    {
      bVal = 0;
    }

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

    pbStr[0] = 12;

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

    vOsdPosShowArg(OSD_POS_FS_INFO_BAR, OSD_MSG_VOLUME, OSD_TIMEOUT_SHORTER, pbStr);
  }
}

#ifdef FL_CHK_FOLDER_NS
static void vFlIpShowFolderIndex(WORD wCurr) large
{
  BYTE pbStr[10];

  wCurr++;

  vFlIpClearInfoArea(IP_INFO_FILE_INDEX);

  pbStr[1] = 'D';
  pbStr[2] = 'i';
  pbStr[3] = 'r';

  if (wCurr < 1000)
  {
    vWord2Str(wCurr, pbStr + 4, 3);
    pbStr[0] = 7;
  }
  else
  {
    vWord2Str(wCurr, pbStr + 4, 4);
    pbStr[0] = 8;
  }
  pbStr[4] = ':';

  vInMsgColDis(FL_INFO_WB);
  vOsdPosShowStr(OSD_POS_FS_FILE_INDEX, pbStr);
}
#endif

static void vFlIpShowFileIndex(WORD wCurr, BYTE bType) large
{
  BYTE pbStr[10];
  WORD wTotal, wFldrNs;


  if (bType == IP_INFO_FILE_INDEX_5)
  {
    // tmp
    if (_rNumInStateCtx.wNum != 0)
    {
      wCurr = (WORD) _rNumInStateCtx.bDig[0] * 100 +
                     _rNumInStateCtx.bDig[1] * 10 +
                     _rNumInStateCtx.bDig[2];
      if (_wFlMnListLen >= 1000)
        wCurr = wCurr * 10 + _rNumInStateCtx.bDig[3];
    }
    else
    {
      wCurr = wFlGetItemIdx(_bFlMnCurItemIdx) + 1;
    }

    if (wCurr > _wFlMnListLen)
      wCurr = wFlGetItemIdx(_bFlMnCurItemIdx) + 1;

    if (wCurr)  wCurr--;
    bType = IP_INFO_FILE_INDEX;
  }

  if (bType == IP_INFO_FILE_INDEX)
  {
    //if (bFlGetItemType(wCurr % FL_ITEM_N) == FTYPE_FOLDER)
#ifdef FL_CHK_FOLDER_NS
    if (bFlGetItemType(wCurr % 6) == FTYPE_FOLDER)
    {
      vFlIpShowFolderIndex(wCurr);
      return;
    }
#endif

    wTotal = _wFlMnListLen;

    wCurr++;
#ifdef FL_CHK_FOLDER_NS
    wFldrNs = wFlGetSubFldrNs(_bFlMnListId);
    wCurr -= (wFldrNs - 1);
    wTotal -= (wFldrNs - 1);
#endif

    if (_wFlMnListLen == 0)
    {
      wCurr = 0;
    }

    if (wTotal < 1000)
    {
      vWord2Str(wCurr, pbStr, 3);
      vWord2Str(wTotal, pbStr+4, 3);
      pbStr[4] = '/';
      pbStr[8] = pbStr[9] = ' ';
    }
    else  // if (wTotal > 1000)
    {
      vWord2Str(wCurr, pbStr, 4);
      vWord2Str(wTotal, pbStr+5, 4);
      pbStr[5] = '/';
    }
    pbStr[0] = 9;
    vInMsgColDis(FL_INFO_WB);
    vOsdPosShowStr(OSD_POS_FS_FILE_INDEX, pbStr);
  }
  else // IP_INFO_FILE_INDEX_?
  {
    wTotal = _wFlMnListLen;

    if (wTotal < 1000)
    {
      pbStr[0] = 6;
      pbStr[1] = pbStr[2] = 3;
    }
    else
    {
      pbStr[0] = 7;
      pbStr[1] = pbStr[2] = 4;
    }
    pbStr[3] = 0;
    pbStr[4] = pbStr[5] = pbStr[6] = pbStr[7] = '-';

    wCurr = wWRDToBCD(wCurr);

    switch(bType)
    {
      case IP_INFO_FILE_INDEX_0:
        break;
      case IP_INFO_FILE_INDEX_1:
    #ifdef FLIP_DIGIT_RIGHT
        if (wTotal < 1000)
          pbStr[6] = BCD_LO(bHiByte(wCurr)) + '0';
        else
          pbStr[7] = BCD_HI(bHiByte(wCurr)) + '0';
    #else
        pbStr[4] = BCD_HI(bHiByte(wCurr)) + '0';
    #endif
        break;
      case IP_INFO_FILE_INDEX_2:
    #ifdef FLIP_DIGIT_RIGHT
        if (wTotal < 1000)
        {
          pbStr[5] = BCD_LO(bHiByte(wCurr)) + '0';
          pbStr[6] = BCD_HI(bLoByte(wCurr)) + '0';
        }
        else
        {
          pbStr[6] = BCD_HI(bHiByte(wCurr)) + '0';
          pbStr[7] = BCD_LO(bHiByte(wCurr)) + '0';
        }
    #else
        pbStr[4] = BCD_LO(bHiByte(wCurr)) + '0';
        pbStr[5] = BCD_HI(bLoByte(wCurr)) + '0';
    #endif
        break;
      case IP_INFO_FILE_INDEX_3:
    #ifdef FLIP_DIGIT_RIGHT
        if (wTotal < 1000)
        {
          pbStr[4] = BCD_LO(bHiByte(wCurr)) + '0';
          pbStr[5] = BCD_HI(bLoByte(wCurr)) + '0';
          pbStr[6] = BCD_LO(bLoByte(wCurr)) + '0';
        }
        else
        {
          pbStr[5] = BCD_HI(bHiByte(wCurr)) + '0';
          pbStr[6] = BCD_LO(bHiByte(wCurr)) + '0';
          pbStr[7] = BCD_HI(bLoByte(wCurr)) + '0';
        }
    #else
        pbStr[4] = BCD_LO(bHiByte(wCurr)) + '0';
        pbStr[5] = BCD_HI(bLoByte(wCurr)) + '0';
        pbStr[6] = BCD_LO(bLoByte(wCurr)) + '0';
    #endif
        break;
      case IP_INFO_FILE_INDEX_4:
        pbStr[4] = BCD_HI(bHiByte(wCurr)) + '0';
        pbStr[5] = BCD_LO(bHiByte(wCurr)) + '0';
        pbStr[6] = BCD_HI(bLoByte(wCurr)) + '0';
        pbStr[7] = BCD_LO(bLoByte(wCurr)) + '0';
        break;
    }

#ifdef FL_CHK_FOLDER_NS
    if (bFlGetItemType(wCurr % 6) == FTYPE_FOLDER)
      vFlIpClearInfoArea(IP_INFO_FILE_INDEX);
#endif
    vInMsgColEn(FL_INFO_WB);
    vOsdPosPasteArg(OSD_POS_FS_FILE_INDEX, OSD_MSG_FLMENU_SELECT, pbStr, 0);
  }
}

/**
 * Show the equalizer info (visual spectrum).
 */
#ifdef SPTM_SUPPORT
static void vFlIpShowEq(void) large
{
  BYTE  bTmp;

  _wStartX = FS_EQ_X;
  _wStartY = FS_INFO_PANEL_LINE_2_Y;
  _wEndX = FS_EQ_LINE_W;
  _wEndY = 32;

  bTmp = bSharedInfo(SI_MP3_MOD);
  vSetSharedInfo(SI_PBC_STATE, bTmp);

  vShowEqBar(FL_INFO_WB, OSD_EQ_TYPE_BAR, FALSE, 14, 4);
}
#endif

static void vFlIpShowRptType(BYTE bRptType) large
{
  WORD  wMsg;

  switch(bRptType)
  {
    case SV_REPEAT_NONE:
      wMsg = OSD_MSG_MP3_NORMAL_MODE;
      break;
    case SV_REPEAT_ALL:
      wMsg = OSD_MSG_MP3_REPEAT_FOLDER;
      break;
    case SV_REPEAT_TRACK:
      wMsg = OSD_MSG_MP3_REPEAT_ONE;
      break;
    case SV_SHUFFLE:
      wMsg = OSD_MSG_MP3_SHUFFLE;
      break;
    case SV_RANDOM:
      wMsg = OSD_MSG_MP3_RANDOM;
      break;
    case SV_SINGLE:
      wMsg = OSD_MSG_MP3_SINGLE;
      break;
    default:
      // TODO: add the error handling.
      return;
  }

  vFlIpDrawInfo(IP_INFO_RPT_TYPE, wMsg, 0);
  //void vOsdPosShow(WORD wPosIndex, WORD wMsgIndex, BYTE bTime) large
  //vOsdPosShow(OSD_POS_FS_RPT_TYPE, wMsg, 0xFF);
}

static void vFlIpShowListType(BYTE bType) large
{
  WORD  wMsg;

//  wMsg = _pwListTypeName[bType];

  switch(bType)
  {
    case FLPARM_LIST_FOLDER:
      wMsg = OSD_MSG_MP3_NORMAL_MODE;
      break;
    case FLPARM_LIST_DISC:
      wMsg = OSD_MSG_FL_FILELIST;
      break;
    case FLPARM_LIST_PLAYLIST:
      wMsg = OSD_MSG_FL_PLAYLIST;
      break;
    case FLPARM_LIST_INVALID: