BYTE pbStr[2];
   BOOL fgRet = TRUE;
   
#ifdef SMSUI_FOR_MULTI_PARTITION_FAT     //simon mul
 BYTE bAttach;
 bAttach = ((bSharedInfo(SI_EMD_DRIVE_0) >> SV_MCR_TOTAL_NS) | 
                     (bSharedInfo(SI_EMD_DRIVE_1) << SV_MCR_TOTAL_NS));

#endif
   
   switch( _bIRKey )
   	{   	
   	case IR_USB_COPY:
    case IR_STOP:    
    	vSetExitInputState();
   		return(TRUE);
   		
   	case IR_PLAY:
   	case IR_PLAY_ENTER:
   	case IR_ENTER:
   		
   		_bUSBChange = TRUE;
   		
   		_bSourceDev = bSharedInfo(SI_DEVICE_ID); 
       
         _bSaveToDev = _bUSBCurItem ;
      	 #ifdef USB_COPY_DEBUG
           DBGLogS("Usb need to swith device?");
           DBGLogB(_bSourceDev, _bSaveToDev, bSharedInfo(SI_EMD_ATTACH), _bUSBCurItem);
         #endif

         
#ifdef SMSUI_FOR_MULTI_PARTITION_FAT   
           
         
         if(bAttach & (1 << _bSaveToDev))
            
#else
         if(bSharedInfo(SI_EMD_ATTACH) & (1 << _bSaveToDev))
#endif
           {
             _bUSBUIState = USBUI_CARD_WAIT_CHANGE_ST;
             _bUSBSavToEnter = TRUE;
       	   }
         else
       	   {
       	     #ifdef USB_COPY_DEBUG
             DBGLogS("no_card:");
       	     #endif
       	     _bUSBUIState = USBUI_CARD_NONE_ST;  
       	    }
       
         pbStr[0] = 1;
         pbStr[2] = _bSaveToDev + '0';
         vUSBUIShowInit(_bUSBUIState, pbStr);

         if(_bUSBUIState == USBUI_CARD_WAIT_CHANGE_ST) 
            {
          	  if(_bSourceDev != _bSaveToDev)
   		        vSendUopCmd(UOP_CHG_DEV, SV_ASSIGN_DEV, _bSaveToDev, 0);         	   	
   		      else
          	   _bUSBSwitchSuccess = TRUE;
          	} 
         	
   		return(TRUE);
   		
   	case IR_UP:
   		   vUSBMainHLItem(FALSE);
   		   if(bSharedInfo(SI_EMD_ATTACH))
   		   	{
   		      do{
   		          _bUSBCurItem = (--_bUSBCurItem + USB_PAGE_ITEM_NUM) % USB_PAGE_ITEM_NUM;
   		          vUSBChkValid(_prUSBItem[_bUSBCurItem].bStName);  
                 }while(!(_wEffact & (1<<_bUSBCurItem)));
   		      vRedrawUSBItem(TRUE);   		   
   		      vUSBMainHLItem(TRUE);
   		   	 }
   		   else
   		   	 {
   		   	   _bUSBUIState = USBUI_CARD_NONE_ST;
   		   	   vUSBUIShowInit(_bUSBUIState, 0);   		   	
   		   	  }
           break; 
          	   			
   	case IR_DOWN:
   		    vUSBMainHLItem(FALSE);
   		    if(bSharedInfo(SI_EMD_ATTACH))
   		      {
   		         do{
                     _bUSBCurItem = ++_bUSBCurItem % USB_PAGE_ITEM_NUM;
                     vUSBChkValid(_prUSBItem[_bUSBCurItem].bStName);  
                    }while(!(_wEffact & (1<<_bUSBCurItem)));
        	     vRedrawUSBItem(TRUE);   		   
   		         vUSBMainHLItem(TRUE);  		       		    
   		       }
   		    else
   		       {
   		   	      _bUSBUIState = USBUI_CARD_NONE_ST;
   		   	      vUSBUIShowInit(_bUSBUIState,0);   		   	
   		   	    }	
   			break;
   			   			  	
   	default:
   		   break;
   	_bIRKey = IR_NONE;	  
    return(fgRet);

  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
static BOOL fgUSBUISavingState(void) large
{
  BOOL fgRet = TRUE;
  #ifdef USB_COPY_DEBUG
  DBGLogS("fgUSBUISavingState  .");
  #endif

  switch(_bIRKey)
  	{
      case IR_USB_COPY:
      case IR_STOP: 
      case IR_PLAY:
      case IR_ENTER:
      case IR_PLAY_ENTER:
        fgFlMnOnIrCancelCopy();
        vSetExitInputState();
   		return(TRUE);
  	}
  	
 _bIRKey = IR_NONE;
  return(fgRet);
}

// *********************************************************************
// Function :   BOOL fgUSBUISureState(void) large
// Description :
// Parameter :
// Return    :
// *********************************************************************
static BOOL fgUSBUISureState(void) large
{
  BOOL fgRet = TRUE;
  #ifdef SMSUI_FOR_MULTI_PARTITION_FAT     //simon mul
 BYTE bAttach;
 bAttach = ((bSharedInfo(SI_EMD_DRIVE_0) >> SV_MCR_TOTAL_NS) | 
                     (bSharedInfo(SI_EMD_DRIVE_1) << SV_MCR_TOTAL_NS));

#endif
  #ifdef USB_COPY_DEBUG
  DBGLogS("fgUSBUISureState  .");
  #endif
  switch(_bIRKey)
    {
      case IR_USB_COPY:
      case IR_STOP: 
      	vSetExitInputState();
   		return(TRUE);
   		
    case IR_PLAY:
   	case IR_PLAY_ENTER:
   	case IR_ENTER: 
   		_bUSBPercent = 0;
   		if(_bSureCurItem == 0)
   		  {
#ifdef SMSUI_FOR_MULTI_PARTITION_FAT
                if(bAttach & (1 << _bSaveToDev))
#else
            if(bSharedInfo(SI_EMD_ATTACH) & (1 << _bSaveToDev))
#endif
              {
                 if(bSharedInfo(SI_FMV_PERCENT) == 0x64)
             {
                   vSetSharedInfo(SI_FMV_PERCENT, 0x00);    //protect the file is 00 copy first 
             }
                 _bUSBUIState = USBUI_CARD_SAVING_ST;
                 fgFlMnOnIrCopy();
       	       }
             else
          {
                 _bUSBUIState = USBUI_CARD_NONE_ST;
   		   }
   	}
   		else
   		   {
   		      vSetExitInputState();
   		   }
       vUSBUIShowInit(_bUSBUIState, 0);      
   	   return(TRUE);

	case IR_UP:
	case IR_DOWN:
       vUSBSureHLItem(FALSE);
		if(_bSureCurItem == 0)
	       _bSureCurItem = TRUE;
		else
		   _bSureCurItem = FALSE;		   		   
   		vUSBSureHLItem(TRUE);  
		break;		
	}
   
   _bIRKey = IR_NONE;
   return(fgRet);
}

// *********************************************************************
// Function :   BOOL fgUSBUIWaitState(void) large
// Description :
// Parameter :
// Return    :
// *********************************************************************
static BOOL fgUSBUIWaitState(void) large
{
  BOOL fgRet = TRUE;
  #ifdef USB_COPY_DEBUG
  DBGLogS("fgUSBUIWaitState  .");
  #endif
  switch(_bIRKey)
    {
     case IR_STOP:
            fgFlMnOnIrCancelCopy();
            vSetExitInputState();
     	   return(TRUE);
  	 }
}



// *********************************************************************
// Function :void vUSBDisInputInit()large
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vUSBDisInputInit()large
{
 #ifdef USB_COPY_DEBUG
 DBGLogS("Input USB Copy init.");
 #endif  
 _bUSBSavToEnter = FALSE;
 _bUSBSwitchSuccess = FALSE;
 _bUSBCurItem = FALSE;
 _bSureCurItem = FALSE;
 _bUSBJustCopy = FALSE;
 _bUSBShowInit = FALSE;
 _bUSBInterput = FALSE;
 _bSourceDev = bSharedInfo(SI_DEVICE_ID);
 _bSaveToDev = bSharedInfo(SI_DEVICE_ID);
  
  _wEffact = 0xffff;
  
  vOsdShowWb(OSD_WB_DISABLE); 
  vCreateWB(WB_USB_MENU, TRUE);
  vSetWBTcColor(WB_USB_MENU); 
  vEnableWB(WB_USB_MENU);
  vOsdSetSt(OSD_ST_BURST);   
  vUSBUIShowInit(_bUSBUIState, 0);

}

// *********************************************************************
// Function :BOOL vUSBDisInputState(void)large
// Description :
// Parameter :
// Return    :
// *********************************************************************
BOOL vUSBDisInputState(void)large
{
    BOOL fgRet = FALSE;	
  #ifdef USB_COPY_DEBUG
  DBGLogS("vUSBDisInputState   .");
  #endif   
switch(_bUSBUIState)
    {
	case USBUI_CARD_NONE_ST:
	case USBUI_CARD_FULL_ST:
	case USBUI_CARD_ERR_ST:	
	case USBUI_CARD_CREATEFILEFAIL_ST:
	case USBUI_CARD_COPYFAIL_ST:
	        fgRet = fgUSBErrorState(); 
		  break;
		  
    case USBUI_CARD_COPYFINISH_ST:
    	   fgRet  =  fgUSBFinishState();
    	  break;
		  
	case USBUI_CARD_SAVETO_ST:
	        fgRet = fgUSBSaveToSelectState();
		 break;
	
	case USBUI_CARD_SAVING_ST:
             fgRet = fgUSBUISavingState();  
	        break;
	case USBUI_CARD_SURE_ST:
		     fgRet = fgUSBUISureState();
		     break;
    case USBUI_CARD_WAIT_CHANGE_ST:
    	     fgRet = fgUSBUIWaitState();
    	     break;
	
    }
   _bIRKey = IR_NONE;
    return(fgRet);
}
// *********************************************************************
// Function :  void vUSBDisInputExit(void)large
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vUSBDisInputExit(void)large
{ 
  #ifdef USB_COPY_DEBUG
  DBGLogS("vUSBDisInputExit .");
  DBGLogB(0, _bSourceDev, _bSaveToDev, _bUSBUIState);
  #endif
  _fgFlSrcSet=FALSE;
  _bInputState = INPUT_STATE_NONE;

  if (fgFlCheckStatus(FL_STATUS_IN_MENU))
  	{
     vOsdSetSt(OSD_ST_BURST);      
  	} 
  
  vDeleteWB(WB_USB_MENU);       
  vOsdPosHili(OSD_POS_HILI_CLEAR, 0, 0); 
  vSetExitInputState();


  if(((_bSourceDev != _bSaveToDev) && (_bSaveToDev != SV_DEVID_CDVDROM))
     ||(_bUSBUIState == USBUI_CARD_COPYFINISH_ST))
    {
       vSendUopCmd(UOP_CHG_DEV, SV_ASSIGN_DEV, _bSourceDev, 0); 
       _bUSBUIState = USBUI_MAX_ST;
       return;   
    }
 
  if (fgFlCheckStatus(FL_STATUS_IN_MENU))
    {
      // - disable all previous white board
      if (fgFlCheckStatus(FL_STATUS_IN_MENU))
 	    {
 	      vOsdShowWb(OSD_WB_DISABLE);     
 	     }
     }
  else
     vOsdShowWb(OSD_WB_RESTORE);

#ifdef PLAYER_FLMENU
    vPlayerShowLogo(ISO_STOP_LOGO, ISO_LOGO_COLOR); 
    vEnableWB(FSMENU_INFO);   
    vFlIpShowInfo(IP_INFO_VOLUME, bAdspCurrVol(), FLIP_VOLUME_MUTE_OFF | FLIP_VOLUME_REDRAW);
    vFlRecover();                                          
    vOsdShowWb(OSD_WB_USER);                  
    vOsdSetSt(OSD_ST_NML);  
 
    vEnableWB(FSMENU_OSD_WBIDX_BASIC);
    vEnableWB(FSMENU_INFO);    
#endif
   _bUSBUIState = USBUI_MAX_ST;
}
#else
   BYTE code _bUSBData[1] ;
#endif

#endif