fbm_api.c

tuner扫描

      }




      
      MV_FBM_supervisor(msg,LV_fbm_status_ptr);	
   }

} /* End LF_FBM_task */
#endif

/*LPF=======================================================================*/
/*
    FUNCTION NAME: LF_FBM_Vs_handler	

    DESCRIPTION:  
        
    RETURNS:
        
	

    CALLING SEQUENCE:
*/
static void 
LF_FBM_Vs_handler(
void
)
/*EMP=======================================================================*/
{
   static unsigned long lvs_cur_rdpt = 0;
   static unsigned long lvs_previous_rdpt = 0;
   UInt32 lv_protection_level;
   
   DV_DBG_STORE_EVENT(IPVD_DBG_EV_ISR, IPVD_DBG_ISR_BEGIN_LEVEL,IPVD_VS_ISR, 0, 0, 0);

   MV_FBM_vs_notification();
   
   if((GV_MV_DEC_status.dec_state == MV_DEC_DECODING_STATE_STARTED) || (GV_MV_DEC_status.dec_state == MV_DEC_DECODING_STATE_SCANNING) )
   {  
      lvs_cur_rdpt = MV_drv_video_fifo_rdpt_cur();
   
      if((lvs_cur_rdpt == lvs_previous_rdpt) && (MV_drv_video_fifo_bfmu_cur() != 0) && (GV_MV_DEC_status.dec_pict_synchronized == FALSE))
      {
         LV_vs_nb_without_rdpt_change ++;
      }
      else
      {
         LV_vs_nb_without_rdpt_change = 0;
      }
   
      lvs_previous_rdpt = lvs_cur_rdpt;
   
      if(LV_vs_nb_without_rdpt_change >= GV_MV_DEC_status.dec_watchdog_vs_nb_threshold)
      {
         tmosalDisableInterruptsNoSysCall(&lv_protection_level);
         GV_MV_DEC_status.dec_state = MV_DEC_DECODING_STATE_HANGUP;
         tmosalEnableInterruptsNoSysCall(lv_protection_level);

         if (GV_MV_DEC_status.dec_event_enabled & MV_DEC_UNRECOVERABLE_ERROR_EVENT)
         {       
            /* Notify the application. */
            GV_MV_DEC_status.function_ptr(MV_DEC_UNRECOVERABLE_ERROR_EVENT);
         }         
         
         LV_vs_nb_without_rdpt_change = 0;
      
         {
            DV_DBG_STORE_EVENT(IPVD_DBG_EV_UNRECOV_ERROR,IPVD_DBG_MAJOR_BEHAVIOR_LEVEL,0,0,0,0);
         }
      
      }   
   }

   DV_DBG_STORE_EVENT(IPVD_DBG_EV_ISR, IPVD_DBG_ISR_END_LEVEL,IPVD_VS_ISR, 0, 0, 0);
   
}

/*LPF=======================================================================*/
/*
    FUNCTION NAME: LF_FBM_event_handler	

    DESCRIPTION:  
        
    RETURNS:
        
	

    CALLING SEQUENCE:
*/
static void 
LF_FBM_event_handler(
void
)
/*EMP=======================================================================*/
{
   unsigned long          lv_fbm_event;
   
   DV_DBG_STORE_EVENT(IPVD_DBG_EV_ISR,IPVD_DBG_ISR_BEGIN_LEVEL,IPVD_FBM_EVENT_ISR,0,0,0);

   /* Read fbm_event register */
   lv_fbm_event = GV_itv_fbm_event;

   DV_DBG_STORE_EVENT(IPVD_DBG_EV_FBM_EVENT,IPVD_DBG_MAJOR_BEHAVIOR_LEVEL,lv_fbm_event,0,0,0);

   if ((lv_fbm_event & MV_FBM_EVENT_BUFFER_FULL) != 0)
   {
      /* Log buffer full event only once per Vs */
      if(LV_buffer_full_log == TRUE)
      {

         /* DISable 'Buffer full' event to create an interrupt */
         MV_drv_set_fbm_event_enable(MV_drv_fbm_event_enable()
                                     & (~MV_FBM_EVENT_BUFFER_FULL));
         LV_buffer_full_log = FALSE;
      }
   } /* End MV_FBM_EVENT_BUFFER_FULL */
  
   DV_DBG_STORE_EVENT(IPVD_DBG_EV_ISR, IPVD_DBG_ISR_END_LEVEL,IPVD_FBM_EVENT_ISR, 0, 0, 0);
  
} /* End of LF_FBM_event_handler */

/*LPF=======================================================================*/
/*
    FUNCTION NAME: LF_FBM_eoph_handler	

    DESCRIPTION:  handler for the "End Of Picture Header" event
        
    RETURNS:
        
	

    CALLING SEQUENCE:
*/
static void 
LF_FBM_eoph_handler(
void
)
/*EMP=======================================================================*/
{
   FBM_QUEUE_MSG    lv_msg;
#ifndef FBM_IN_ISR_ONLY
   Int32            lv_timeout = MV_CFG_QUEUE_TIMEOUT;
   tmErrorCode_t returnVal;
#endif

   DV_DBG_STORE_EVENT(IPVD_DBG_EV_ISR, IPVD_DBG_ISR_BEGIN_LEVEL,IPVD_EOPH_ISR, 0, 0, 0);
   
   /* Send MSG_EOPH to FBM */
   lv_msg[0] = FBM_MSG_EOPH;

#ifndef FBM_IN_ISR_ONLY
   /* Send MSG_EOPH to FBM */
   returnVal = tmosalQueueSend(GV_fbm_qid, lv_msg, sizeof(FBM_QUEUE_MSG), &lv_timeout, tmosalQueueSendFlagNone);

   if (returnVal != TM_OK)
   {
      switch (returnVal)
      {
         case TMOSAL_ERR_QUE_TIMEOUT:
            DV_DBG_STORE_EVENT(IPVD_DBG_EV_TIMEOUT, IPVD_DBG_QUEUE_TIMEOUT_LEVEL,1, 0,0,0);
            break;

         default:
            DV_DBG_STORE_EVENT(IPVD_DBG_EV_TMOSAL_ERROR,
                               IPVD_DBG_MAJOR_BEHAVIOR_LEVEL,
                               IPVD_QUEUE_SEND, returnVal, lv_msg[0], 0); // Log the error
            break;

      } /* End switch */
   }
#else 
   MV_FBM_supervisor(lv_msg,LV_fbm_status_ptr);	
#endif
   
   /* User Data algorithm */
   if(GV_MV_DEC_ud_status.dec_ud_found & (MV_DEC_PICT_UD|MV_DEC_GOP_UD|MV_DEC_SEQ_UD))
   {
      if (GV_MV_DEC_status.dec_event_enabled & MV_DEC_UD_PROCESSING_NEEDED_EVENT)
      {
         /* flag to inform ISR system video event that it can or not log next
            user data start code */
         GV_MV_DEC_ud_status.dec_ud_parsing_done = FALSE;

         DV_DBG_STORE_EVENT(IPVD_DBG_EV_UD_PROCESSING_NEEDED,IPVD_DBG_MINOR_BEHAVIOR_LEVEL,0,0,0,0);

         /* Notify the application to call MV_DEC_user_data_process() */
         GV_MV_DEC_status.function_ptr(MV_DEC_UD_PROCESSING_NEEDED_EVENT);
      }
   }

   DV_DBG_STORE_EVENT(IPVD_DBG_EV_ISR, IPVD_DBG_ISR_END_LEVEL,IPVD_EOPH_ISR, 0, 0, 0);

} /* End LF_FBM_eoph_handler */

/*LPF=======================================================================*/
/*
    FUNCTION NAME: LF_FBM_eopd_handler	

    DESCRIPTION:  handler for the "End Of Picture Decoding" event
        
    RETURNS:
        
	

    CALLING SEQUENCE:
*/
static void 
LF_FBM_eopd_handler(
void
)
/*EMP=======================================================================*/
{
   FBM_QUEUE_MSG    lv_msg;
#ifndef FBM_IN_ISR_ONLY
   Int32            lv_timeout = MV_CFG_QUEUE_TIMEOUT;
   tmErrorCode_t returnVal;
#endif
   
   DV_DBG_STORE_EVENT(IPVD_DBG_EV_ISR, IPVD_DBG_ISR_BEGIN_LEVEL,IPVD_EOPD_ISR, 0, 0, 0);

   lv_msg[0] = FBM_MSG_EOPD;

#ifndef FBM_IN_ISR_ONLY
   returnVal = tmosalQueueSend(GV_fbm_qid, lv_msg, sizeof(FBM_QUEUE_MSG), &lv_timeout, tmosalQueueSendFlagNone);

   if (returnVal != TM_OK)
   {
      switch (returnVal)
      {
         case TMOSAL_ERR_QUE_TIMEOUT:
            DV_DBG_STORE_EVENT(IPVD_DBG_EV_TIMEOUT, IPVD_DBG_QUEUE_TIMEOUT_LEVEL,1, 0,0,0);
            break;

         default:
            DV_DBG_STORE_EVENT(IPVD_DBG_EV_TMOSAL_ERROR,
                               IPVD_DBG_MAJOR_BEHAVIOR_LEVEL,
                               IPVD_QUEUE_SEND, returnVal, lv_msg[0], 0); // Log the error
            break;

      } /* End switch */
   }
#else 
   MV_FBM_supervisor(lv_msg,LV_fbm_status_ptr);	
#endif
   
   if (GV_MV_DEC_status.dec_event_enabled & MV_DEC_EOPD_EVENT)
   {
      /* Notify the application. */
      GV_MV_DEC_status.function_ptr(MV_DEC_EOPD_EVENT);
   }   

   DV_DBG_STORE_EVENT(IPVD_DBG_EV_ISR, IPVD_DBG_ISR_END_LEVEL,IPVD_EOPD_ISR, 0, 0, 0);

} /* End LF_FBM_eopd_handler */

/*LPF=======================================================================*/
/*
    FUNCTION NAME: LF_FBM_error_handler	

    DESCRIPTION:  
        
    RETURNS:
        
	

    CALLING SEQUENCE:
*/
static void 
LF_FBM_error_handler(
void
)
/*EMP=======================================================================*/
{
   FBM_QUEUE_MSG    lv_msg;
#ifndef FBM_IN_ISR_ONLY
   Int32            lv_timeout = MV_CFG_QUEUE_TIMEOUT;
#endif
   unsigned long   lv_error_event;
     
   BOOLEAN         lv_abort_decoding = FALSE;

   DV_DBG_STORE_EVENT(IPVD_DBG_EV_ISR, IPVD_DBG_ISR_BEGIN_LEVEL,IPVD_FBM_ERROR_ISR, 0, 0, 0);

   lv_error_event = GV_itv_error_event;

   DV_DBG_STORE_EVENT(IPVD_DBG_EV_ERROR_EVENT,IPVD_DBG_MAJOR_BEHAVIOR_LEVEL,lv_error_event,0,0,0);

   if (GV_MV_DEC_status.dec_event_enabled & MV_DEC_BITSTREAM_ERROR_EVENT)
   {
      /* Notify the application. */
      GV_MV_DEC_status.function_ptr(MV_DEC_BITSTREAM_ERROR_EVENT);
   }

   /* Abort decoding for the errors which need FBM software action */

   if ((lv_error_event & MV_ERROR_EVENT_MB_NUMB_ERROR) != 0)
   {
      lv_abort_decoding = TRUE;
   }
   else if ((lv_error_event & MV_ERROR_EVENT_EOP_MISS_ERROR) != 0)
   {
      lv_abort_decoding = TRUE;
   }
   else if ((lv_error_event & MV_ERROR_EVENT_HIGH_FLAGED_ERROR) != 0)
   {
      lv_abort_decoding = TRUE;
   }

   /* Here begins the list of registers for which there is a choice between default 
      error concealment processing (copy operation) or the alternate error concealment: 
      abort decoding and freeze */
   else if(
      ((lv_error_event & MV_ERROR_EVENT_MEDIUM_FLAGED_ERROR) != 0)&&
      (MV_drv_medium_flaged_error_lock() == MV_BIT_ON)
      )
   {
      lv_abort_decoding = TRUE;
   }
   else if(
      ((lv_error_event & MV_ERROR_EVENT_LOW_FLAGED_ERROR) != 0)&&
      (MV_drv_low_flaged_error_lock() == MV_BIT_ON)
      )
   {
      lv_abort_decoding = TRUE;
   }
   else if(
      ((lv_error_event & MV_ERROR_EVENT_VLC_COEF_ERROR) != 0)&&
      (MV_drv_vlc_coef_error_lock() == MV_BIT_ON)
      )
   {
      lv_abort_decoding = TRUE;
   }
   else if(
      ((lv_error_event & MV_ERROR_EVENT_VLC_EOB_MISS_ERROR) != 0)&&
      (MV_drv_vlc_eob_miss_error_lock() == MV_BIT_ON)
      )
   {
      lv_abort_decoding = TRUE;
   }
   else if(
      ((lv_error_event & MV_ERROR_EVENT_VLC_MB_ERROR) != 0)&&
      (MV_drv_vlc_mb_error_lock() == MV_BIT_ON)
      )
   {
      lv_abort_decoding = TRUE;
   }
   else if(
      ((lv_error_event & MV_ERROR_EVENT_VECT_ERROR) != 0)&&
      (MV_drv_vect_error_lock() == MV_BIT_ON)
      )
   {
//      lv_abort_decoding = TRUE; //JI 2005-06-30 
   }

   /* If needed, trigger abort decoding */

   if(lv_abort_decoding == TRUE)
   {
      lv_msg[0] = FBM_MSG_ABORT_DECODING;

#ifndef FBM_IN_ISR_ONLY
      returnVal = tmosalQueueSend(GV_fbm_qid, lv_msg, sizeof(FBM_QUEUE_MSG), &lv_timeout, tmosalQueueSendFlagNone);

      if (returnVal != TM_OK)
      {
         switch (returnVal)
         {
            case TMOSAL_ERR_QUE_TIMEOUT:
               DV_DBG_STORE_EVENT(IPVD_DBG_EV_TIMEOUT, IPVD_DBG_QUEUE_TIMEOUT_LEVEL,1, 0,0,0);
               break;

            default:
               DV_DBG_STORE_EVENT(IPVD_DBG_EV_TMOSAL_ERROR,
                                  IPVD_DBG_MAJOR_BEHAVIOR_LEVEL,
                                  IPVD_QUEUE_SEND, returnVal, lv_msg[0], 0); // Log the error
               break;

         } /* End switch */
      }
#else 
      MV_FBM_supervisor(lv_msg,LV_fbm_status_ptr);	
#endif
   }

   DV_DBG_STORE_EVENT(IPVD_DBG_EV_ISR, IPVD_DBG_ISR_END_LEVEL,IPVD_FBM_ERROR_ISR, 0, 0, 0);
} /* End LF_FBM_error_handler */