combine.c

MTK portableDVD 采用mtk1389方案的代码

      bResult = bAINHandleUopRet(bUopId, bUopRet);
    }
  }

  if (bResult == UOP_FAIL)
  {
    vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
  }
  else /* UOP O.K. */
  {
    vOsdShowError(OSD_ERROR_CLEAR, 0);
  }

  return (bResult);
}

/************************************************************************
     Function :
  Description : Error return dispatch
    Parameter :
    Return    :
************************************************************************/
BYTE bHandleErrRet(BYTE bItem) large
{
  BYTE bRet = UOP_OK;

  switch (bItem)
  {
    case bSIItemIndex(SI_OSD_ERR_RET):
    {
      if (bSharedInfo(SI_OSD_ERR_RET) == SV_ERR_OSD_MEM_FULL)
      {
        vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
      }
      break;
    }

    case bSIItemIndex(SI_UOP_ID):
    case bSIItemIndex(SI_UOP_RET_VAL):
    case bSIItemIndex(SI_UOP_SUB_ID):
    {
      bRet = bHandleUopRet(_rOsdStateCtx.bUopRetId, _rOsdStateCtx.bUopRetVal);
      break;
    }

    default:
      /* not a valid item, ignore it! */
      break;
  } /* switch (bItem) */

  if (bRet == UOP_FAIL)
  {
    vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
  }
  else /* UOP O.K. */
  {
    vOsdShowError(OSD_ERROR_CLEAR, 0);
  }

  return (bRet);
}

/************************************************************************
     Function :
  Description : Share info update handle
    Parameter :
    Return    :
************************************************************************/
void vGroupPbcUpdateUsrCtrl(BYTE bItem) large
{
  BYTE bAuxCtrl = bSharedInfo(SI_USR_AUX_CTRL);
  BYTE bRepeatMode = bSharedInfo(SI_REPEAT_MODE);
  BYTE bUsrPbc = bSharedInfo(SI_USR_PBC_CTRL);

  switch (bItem)
  {
    case bSIItemIndex(SI_USR_AUX_CTRL):
    case bSIItemIndex(SI_REPEAT_MODE):
    case bSIItemIndex(SI_USR_PBC_CTRL):
    {
      if (fgShowAuxCtrl(bAuxCtrl))
      {
        break;
      }

      /* for ISO play, we do not need to show repeat mode and user control mode */
      if (fgIsIsoPlay() || fgIsPcdPlay())
      {
      #ifdef RUSSIAN_BUYER_REQUEST2			//songchen 061211
          vOsdPosClear(OSD_POS_ISO_REPEAT);
      #else
        if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_LEFT)
        {
          vOsdPosClear(OSD_POS_ISO_REPEAT);
        }
        else if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_RIGHT)
        {
          vOsdPosClear(OSD_POS_ISO_REPEAT_LEFT);
        }
	#endif	
        break;
      }

      if (fgShowRepeatMode(bRepeatMode))
      {
        break;
      }
      vShowUsrPbcCtrl(bUsrPbc);
      break;
    }
  } /* switch (bItem) */

  if (bItem == bSIItemIndex(SI_USR_PBC_CTRL))
  {
    if (fgIsInputStateValid(INPUT_STATE_PROGRAM))
    {
      vSelMenuUsrPbcChange();
    }
    else if (fgIsInputStateValid(INPUT_STATE_DIGEST))
    {
      vDigestUsrPbcChange();
    }
  }
  vVfdUpdateUsrMode();
}

/************************************************************************
     Function :
  Description : Share info update handle
    Parameter :
    Return    :
************************************************************************/
void vGroupPbcUpdate(BYTE bItem) large
{
  BYTE bTmp1, bTmp2;

  switch (bItem)
  {

    case bSIItemIndex(SI_INIT_STATE):
    {
      // usb
      bTmp1 = bSharedInfo(SI_INIT_STATE);
      bTmp2 = bSharedInfo(SI_DISC_TYPE);
	  
#ifdef GUI_DC_SELECT
      if(bTmp1 == SV_NO_DISC) //  avoid vfd and osd error.
      {
        if (_bDevType == DEVICE_DVD && bSharedInfo(SI_DEVICE_ID) != SV_DEVID_CDVDROM)
        {
	        break;
        }
        else if (_bDevType == DEVICE_USB && !fgisUSBDev(bSharedInfo(SI_DEVICE_ID)))
        {
      	  break;
        }
	    }
#endif
//bywhy 2003/03/31
#ifdef SUPPORT_EMD
 if((DEVICE_USB == _bDevType) || (DEVICE_CARD == _bDevType))//billy[060908]
 {
	 if ((bTmp1 == SV_NO_DISC) || (bTmp1 == SV_DISC_IDENTIFIED))
	   { 
		   if (bKeyState() == KEY_SCRSAV) 
		   	 {	
			   _bIRKey = IR_ESCAPE_SCRSAV;
			   fgSCRSAVKeyProc();
			   _bIRKey = IR_NONE;
			   vOsdShowWb(OSD_WB_RESET);  
		   	 } 
		   else if (bSharedInfo(SI_DISC_TYPE) != SV_UPG) //mod by linshangbo 06.03.02
			 {
          		  vClearPlayType();
          		  vOsdShowWb(OSD_WB_RESET);  
       		 }
    	  }
		 
     if (bTmp1 == SV_DISC_IDENTIFIED) 
		 {
       		if ((bTmp2 < SV_PCD) || (bTmp2 > SV_DATA && bTmp2 != SV_UPG)) 
			{  
         		vISOExit();
       		}
     		}
 }
#endif

#ifdef GUI_DC_SELECT	
   _bDCStChged = DEVICE_NONE;
#endif

//tanglushan 729
   #if 0//for test  //billy[060822]
     if(bTmp1 == SV_TRAY_OPENING ||bTmp1 == SV_TRAY_CLOSING||bTmp1 == SV_LOADING_DISC )
     	{
     	 
         vSendUopCmd(UOP_CHG_DEV, SV_RE_DETECT, SV_ALL_DEV, 0); 

     	}
   #endif  
   
   
//end tanglushan 729   
   
      vShowInitState(bTmp1);
#ifdef DOLBY_CANCEL
      bTmp1 = bSharedInfo(SI_INIT_STATE);
      bTmp2 = bSharedInfo(SI_DISC_TYPE);
#endif
      break;
    }

    case bSIItemIndex(SI_DISC_TYPE):
    {
      bTmp1 = bSharedInfo(SI_DISC_TYPE);
      vAdspAudioTypeChange(SV_A_CODE_NONE, bTmp1, SV_DISC_IDENTIFIED);
      /* vShowDiscType(bTmp); */ /* move to vSetPlayType() */
      break;
    }

    case bSIItemIndex(SI_UPGRADE_ST):
    {
      vUpgShowState(bSharedInfo(SI_UPGRADE_ST));
      return;
    }
  }

  if (fgIsNonPlay())
  {
#ifdef EN_DISC_ID_CHK
    if ((bItem == bSIItemIndex(SI_PBC_STATE)) &&
        fgIsDiscInitFlagSet(DISC_INIT_DISC_TYPE))
    {
      if ((bSharedInfo(SI_PBC_STATE) == SV_REGION_ERR) &&
          (bSharedInfo(SI_DISC_TYPE) == SV_DVD_VIDEO))
      {
        // reset init flag
        vResetDiscInitFlag();
        // clear play type
        if (!fgIsNonPlay())
        {
          vClearPlayType();
        }
        // clear OSD
        vOsdShowInitState(SV_DISC_IDENTIFIED);
        // sho error message
        vOsdPosShow(OSD_POS_ERROR, OSD_MSG_WRONG_REGION, OSD_NO_DISAPPEAR);
        vOsdShowPbcState(SV_STOP, 0, OSD_NO_DISAPPEAR);
      }
    }
#endif /* EN_DISC_ID_CHK */

    return; /* not a good method! */
  }

  switch (bItem)
  {
#ifdef KARAOKE_MIC_REC
    case bSIItemIndex(SI_REC_PROGRESS):
    {
      if (bEepromReadByte(MIC_SW_POS) == EV_ON)
      {
        vMicRecProgressUpdate();
      }

      break;
    }
    case bSIItemIndex(SI_AB_STATE):
    {
      if (bEepromReadByte(MIC_SW_POS) == EV_ON)
      {
        vMicRecStateChange(bSharedInfo(SI_AB_STATE));
      }

      break;
    }
#endif /* KARAOKE_MIC_REC */

    case bSIItemIndex(SI_PBC_SWITCH): /* only usefule for disc play startup */
    {
      if (fgIsVcdPlay())
      {
        bTmp1 = bSharedInfo(SI_PBC_SWITCH);

        if (bTmp1== SV_PBC_ON)
          vVfdSymbol(VFD_SYM_PBC_ON);
        else
          vVfdSymbol(VFD_SYM_PBC_OFF);
      }
      break;
    }

    case bSIItemIndex(SI_PBC_STATE):
    case bSIItemIndex(SI_PBC_SPEED):
    {
      bTmp1 = bSharedInfo(SI_PBC_STATE);


      vChangePbcState(bTmp1);
      #ifndef SUPPORT_BROWSER
      vShowPbcState(bTmp1);
      #else
      if(!fgIsInBrowser())
      {
        vShowPbcState(bTmp1);
      }
      else
      {
        vVfdShowPbcState(bTmp1);
      }
      #endif
	#ifdef BBK_NEW_GUI
      if ((fgFlCheckStatus(FL_STATUS_IN_MENU)) && (!fgIsInFlItemInfo))
      {
        vFlshowPlayInfoMsg();
      }
      #endif
      vAdspPbcChange(bTmp1);
      break;
    }

    case bSIItemIndex(SI_USR_AUX_CTRL):
    case bSIItemIndex(SI_REPEAT_MODE):
    case bSIItemIndex(SI_USR_PBC_CTRL):
    {
      vGroupPbcUpdateUsrCtrl(bItem);
      break;
    }

#ifdef PLAYER_ZOOMIN_INDICATOR
    case bSIItemIndex(SI_ZOOM_OFST_X_HI):
    case bSIItemIndex(SI_ZOOM_OFST_X_LO):
    case bSIItemIndex(SI_ZOOM_OFST_Y_HI):
    case bSIItemIndex(SI_ZOOM_OFST_Y_LO):
    {
      if (fgIsZoomBrShow())
      {
        vZoomBrUpdate();
      }
      break;
    }
#endif /* PLAYER_ZOOMIN_INDICATOR */

    case bSIItemIndex(SI_ZOOM_SWITCH):
    {
      bTmp1 = bSharedInfo(SI_ZOOM_SWITCH);
      bTmp2 = bSharedInfo(SI_ISO_ITEM_TYPE);

#ifdef SUPPORT_BROWSER
      if(fgIsInBrowser())
      {
        vBrowserUpdateZoom();
      }
#endif
#ifdef DDISC_FTYPE_JPEG_SUPPORT
      if (fgIsPcdPlay() ||
          (fgIsIsoPlay() && (fgFlCheckStatus(FL_STATUS_IN_JPEG))))
      {
        vOsdShowZoomPct(bTmp1);
        vVfdSymbol(VFD_SYM_ZOOM_ON);

        if ((bTmp1 == 0) && fgIsInputStateValid(INPUT_STATE_PCD_ZOOM))
        {
          /* need to escape zoom control mode */
          fgSetPlayPostKey(IR_ZOOM_IN);
          vVfdSymbol(VFD_SYM_ZOOM_OFF);
        }
      }
      else
#endif
      {
#ifdef DDISC_FTYPE_JPEG_SUPPORT
        if ((fgIsIsoPlay() && (!fgFlCheckStatus(FL_STATUS_IN_JPEG))) &&
            fgIsInputStateValid(INPUT_STATE_PCD_ZOOM))
        {
          /* need to escape zoom control mode */
          fgSetPlayPostKey(IR_ZOOM_IN);
          vVfdSymbol(VFD_SYM_ZOOM_OFF);
        }
        else
#endif
        {
          #ifndef CUSTOMER_REQUEST		//songchen 061112
          vOsdShowZoom(bTmp1);
	   #endif

#ifdef PLAYER_ZOOMIN_INDICATOR
          if ((bTmp1 >= SV_ZOOM_IN_MIN) &&
              (bTmp1 <= SV_ZOOM_IN_MAX))
          {
            if (fgIsZoomBrShow())
            {
              vZoomBrUpdate();
            }
            else
            {
              vZoomBrOn();
            }
          }
          else // not in zoom-in mode
          {
            if (fgIsZoomBrShow())
            {
              vZoomBrOff();
            }
          }
#endif /* PLAYER_ZOOMIN_INDICATOR */


          if ((bTmp1 == SV_ZOOM_OFF) || (bTmp1 >= SV_ZOOM_MODE_MAX))
          {
            vVfdSymbol(VFD_SYM_ZOOM_OFF);
          }
          else
          {
            vVfdSymbol(VFD_SYM_ZOOM_ON);
          }
        }
      }
      break;
    }



    default:
      break;
  }
}

/************************************************************************
     Function :
  Description : Share info update handle
    Parameter :
    Return    :
************************************************************************/
void vGroupTimeUpdate(BYTE bItem) large
{
#ifdef KARAOKE_SCORING
  BOOL fgShow = FALSE;
  BOOL fgRmn2Sec = FALSE;
  BOOL fgRmnLast2Sec = FALSE;
  BYTE bKScore;
  #ifdef KARAOKE_SCORE_TEST
  BYTE pbStr[13];
  WORD wHit0;
  WORD wHit1;
  WORD wMiss;
  #else
  BYTE pbStr[4];
  #endif
#endif

  switch (bItem)
  {
    case bSIItemIndex(SI_TIME_SS):
    {
#ifdef SUPPORT_BROWSER
      if(fgIsInBrowser())
      {
        vBrowserUpdateTime();
      }
#endif
      vOsdDisplayChange(DISP_TIME_MARK, 0);
#ifdef KARAOKE_SCORING
      if (fgIsDvdPlay() && bSharedInfo(SI_DVD_DOM) == SV_VTSTT_DOM)
      {
        fgShow = TRUE;
        if (bSharedInfo(SI_TIME_CHAPTER_RMN_SS) <= 2)
        {
          fgRmn2Sec = TRUE;
          if (bSharedInfo(SI_TIME_CHAPTER_RMN_HH) == 0 &&
              bSharedInfo(SI_TIME_CHAPTER_RMN_MM) == 0)
            fgRmnLast2Sec = TRUE;
        }
      }
      else if (fgIsVcdPlay() || fgIsCddaPlay())
      {
        fgShow = TRUE;
        if (bSharedInfo(SI_TIME_TRACK_RMN_SS) <= 2)
        {
          fgRmn2Sec = TRUE;
          if (bSharedInfo(SI_TIME_TRACK_RMN_HH) == 0 &&
              bSharedInfo(SI_TIME_TRACK_RMN_MM) == 0)
            fgRmnLast2Sec = TRUE;
        }
      }
      if (fgShow)
      {
        bKScore = bAdspGetKScore();
        pbStr[0] = 3;
        pbStr[1] = '0';
        pbStr[2] = BCD_HI(bKScore) + '0';
        pbStr[3] = BCD_LO(bKScore) + '0';
        if(fgAdspKscoreSupport())
        {
        vOsdPosShowArg(OSD_POS_KSCORE, OSD_MSG_KSCORE, OSD_TIMEOUT, pbStr);
        }
  #ifdef KARAOKE_SCORE_TEST
        vAdspGetKSHitMiss(&wHit0,&wHit1, &wMiss);
        pbStr[0] = 12;
        pbStr[1] = bDigToAsc(wHit0 / 0x1000);
        wHit0 %= 0x1000;
        pbStr[2] = bDigToAsc(wHit0 / 0x100);
        wHit0 %= 0x100;
        pbStr[3] = bDigToAsc(wHit0 / 0x10);
        wHit0 %= 0x10;
        pbStr[4] = bDigToAsc(wHit0);
        pbStr[5] = bDigToAsc(wHit1 / 0x1000);
        wHit1 %= 0x1000;
        pbStr[6] = bDigToAsc(wHit1 / 0x100);
        wHit1 %= 0x100;
        pbStr[7] = bDigToAsc(wHit1 / 0x10);
        wHit1 %= 0x10;
        pbStr[8] = bDigToAsc(wHit1);
        pbStr[9] = bDigToAsc(wMiss / 0x1000);
        wMiss %= 0x1000;
        pbStr[10] = bDigToAsc(wMiss / 0x100);
        wMiss %= 0x100;
        pbStr[11] = bDigToAsc(wMiss / 0x10);
        wMiss %= 0x10;
        pbStr[12] = bDigToAsc(wMiss);
        vOsdPosShowArg(OSD_POS_KSINFO, OSD_MSG_KSHITMISS, OSD_TIMEOUT, pbStr);
  #endif
      }
#endif /* KARAOKE_SCORING */
      break;
    }

    default:
      break;
  }
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void vGroupNvUpdateAngle(BYTE bAglNo, BYTE bAglNs) large
{
  if (bAglNs > 9)
  {
    bAglNs = 0;
  }

  if (bAglNs > 1)
    vVfdSymbol(VFD_SYM_ANGLE_ON);
  else
    vVfdSym