capture.c

本程序为ST公司开发的源代码

                       + (*(cap_input_buffer + 4) << 8)
                       +  *(cap_input_buffer + 6);
      
      return local_good_lba;
    }
  }

  return cap_get_lba_address(local_xfer_pointer, data_type);
}


/******************************************************************************/
/* Function:  cap_esp_make_dummy_sector                                       */
/*                                                                            */
/*! \brief    Make dummy sector for (EOS) or for (Unreadable).
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/
void cap_esp_make_dummy_sector(uint16 local_xfer_pointer, t_bool dummy_type)
{
  uint8 *cap_input_buffer;                        
  uint8 dummy_sector_mark;
  uint32 local_store_lba; 
  
  if (dummy_type)
  {
    dummy_sector_mark = CAP_DUMMY_SECTOR_ERR_MARK; /* Mark : Unreadable error */
  }
  else
  {
    dummy_sector_mark = CAP_DUMMY_SECTOR_EOS_MARK; /* Mark : EOS */
  }    

  cap_input_buffer = CAP_INPUT_BUFFER + (local_xfer_pointer * CAP_INPUT_SECTOR_SIZE);          
  
  if (DATA_TYPE_CDDA == cap_status.write.data_type)
  {
#if (1 == HAVE_SHOCK_MEMORY)
    if (ADPCM_ON == cap_config.adpcm)
    {
      /* Store dummy sector mark. [CDDA] */      
      *(cap_input_buffer + 786) = dummy_sector_mark;
    }
    else
#endif
    {
      /* Store dummy sector mark. [CDDA] */      
      *(cap_input_buffer + 2550) = dummy_sector_mark;
    }                         
  }
  else
  {
    /* Store dummy sector mark. [CDROM] */
    *(cap_input_buffer + 8) = dummy_sector_mark;
  }

  if (dummy_type)
  {
    /* Dummy sector for Unreadable mark. Store first/last sector in Unreadable area. */
    if (DATA_TYPE_CDDA != cap_status.write.data_type) /* Unreadable sector should be detected with only CDROM !! */
    {
       /* First Unreadable sector : cap_status.write.last_good_lba+1 */
       local_store_lba = cap_status.write.last_good_lba + 1;
       
       *(cap_input_buffer + 10) =  (local_store_lba >> 16) & 0xFF;
       *(cap_input_buffer + 12) = (local_store_lba >> 8) & 0xFF;        
       *(cap_input_buffer + 14) = (uint8)local_store_lba & 0xFF;
       
       if ((cap_status.write.last_good_lba + 1 + CAP_NUM_SKIP_ERROR_SECTORS) <= cap_status.write.xfer_sector_end)
       {                                         
         /* local_store_lba = first unreadable "last_good_lba + 1" + "NUM_SKIP_SECTORS - 1"; */
         local_store_lba = cap_status.write.last_good_lba + 1 + (CAP_NUM_SKIP_ERROR_SECTORS - 1);
       }
       else
       {
         /* Last Unreadable sector : local_cap_cmd_event.command_params.xfer_params.sector_stop */
         local_store_lba = cap_status.write.xfer_sector_end;
       }
       
       *(cap_input_buffer + 16) = (local_store_lba >> 16) & 0xFF;
       *(cap_input_buffer + 18) = (local_store_lba >> 8) & 0xFF;        
       *(cap_input_buffer + 20) = (uint8)local_store_lba & 0xFF;
    }
  }    

  event_set_ctr_wakeup(READY); /* Wake up CTR by this event. at dummy sector capturing. */
}


/******************************************************************************/
/* Function:  cap_esp_check_dummy_sector                                      */
/*                                                                            */
/*! \brief    Returm dummy sector flag. (EOS) or (Unreadable).
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/
uint8 cap_esp_check_dummy_sector(uint16 local_xfer_pointer, uint8 data_type)
{
  uint8 *cap_input_buffer;

  cap_input_buffer = CAP_INPUT_BUFFER + (local_xfer_pointer * CAP_INPUT_SECTOR_SIZE);          
  
  if (DATA_TYPE_CDDA == data_type)
  {
#if (1 == HAVE_SHOCK_MEMORY)
    if (ADPCM_ON == cap_config.adpcm)
    {
      /* Return dummy sector mark. [CDDA] */      
      return (uint8) *(cap_input_buffer + 786);
    }
    else
#endif
    {
      /* Return dummy sector mark. [CDDA] */      
      return (uint8) *(cap_input_buffer + 2550);
    }                         
  }
  else
  {
    /* Check dummy sector mark. [CDROM] */
    return (uint8) *(cap_input_buffer + 8);
  }
}


/******************************************************************************/
/* Function:  cap_esp_check_unreadable_sector                                 */
/*                                                                            */
/*! \brief    Check Requested sector is in Unreadable area or not.
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/
t_bool cap_esp_check_unreadable_secctor(uint16 local_xfer_pointer, uint32 requested_sector)
{                
  uint8 *cap_input_buffer;                        
  uint32 local_unread_sector;
  
  cap_input_buffer = CAP_INPUT_BUFFER + (local_xfer_pointer * CAP_INPUT_SECTOR_SIZE);          
  
  if (DATA_TYPE_CDDA != cap_status.read.data_type) /* Only CDROM, Only in Read Transition */
  {
    local_unread_sector = (*(cap_input_buffer + 10) << 16)
                        + (*(cap_input_buffer + 12) << 8)
                        +  *(cap_input_buffer + 14);

    if (local_unread_sector <= requested_sector)
    {
      local_unread_sector = (*(cap_input_buffer + 16) << 16)
                          + (*(cap_input_buffer + 18) << 8)
                          +  *(cap_input_buffer + 20);
    
      if (local_unread_sector >= requested_sector)
      {
        /* Store "requested_sector". */ 
       
        return b_TRUE; /* Found the sector in Unreadable area. */  
      } 
      
      /* fall down. */
    }
  }    

  return b_FALSE; /* Not found the sector in Unreadable area. */
}

/******************************************************************************/
/* Function:  cap_update_xfer_chunk_level                                     */
/*                                                                            */
/*! \brief    Update xfer_chunk_level for write/read status.
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/
void cap_update_xfer_chunk_level(uint16 local_xfer_pointer, t_xfer_type read_n_write)
{
  uint8 *cap_input_buffer;

  cap_input_buffer = CAP_INPUT_BUFFER + (local_xfer_pointer * CAP_INPUT_SECTOR_SIZE);
  if (CAP_WRITE != read_n_write)
  {
    /* CAP_READ : Read xfer_chunk_level value. */
#if (1 == HAVE_SHOCK_MEMORY)
    if ((ADPCM_ON == cap_config.adpcm) && (DATA_TYPE_CDDA == cap_status.read.data_type))
    {
      cap_status.read.xfer_chunk_level = *(cap_input_buffer + 600);
    }
    else
#endif
    {
      cap_status.read.xfer_chunk_level = *(cap_input_buffer + 2466);
    }
  }
  else
  {
    /* CAP_WRITE : Write xfer_chunk_level value as indication for Read controller. */
#if (1 == HAVE_SHOCK_MEMORY)
    if ((ADPCM_ON == cap_config.adpcm) && (DATA_TYPE_CDDA == local_cap_cmd_event.command_params.xfer_params.data_type))
    {
      *((uint16 *) (cap_input_buffer + 600)) = cap_status.write.xfer_chunk_level;
      if (cap_status.write.xfer_condition & CAP_ESP_MARK_FIRST_XFER)
      {
        *((uint16 *) (cap_input_buffer + 602)) = 0x55;  /* Mark of the sector at adpcm enc reset. */
        cap_status.write.xfer_condition &= ~CAP_ESP_MARK_FIRST_XFER;
      }
      else
      {
        *((uint16 *) (cap_input_buffer + 602)) = 0x00;
      }

      /* Copy Block Info */
      *((uint16 *) (cap_input_buffer + 604)) = *(cap_input_buffer + 700);
      *((uint16 *) (cap_input_buffer + 608)) = (*(cap_input_buffer + 705)) << 8;

#if 0
      /* Temporary solution for Mixed mode disc with adpcm ON. */
      if(cap_status.read.xfer_condition & CAP_ESP_SECTOR_SIZE_CHANGE)
      {
        *((uint16 *)(cap_input_buffer + 2466)) = cap_status.write.xfer_chunk_level;
      }
      /* Temporary solution for Mixed mode disc with adpcm ON. */
#endif
    }
    else
#endif
    {
      *((uint16 *) (cap_input_buffer + 2466)) = cap_status.write.xfer_chunk_level;
    }
  }
}

/******************************************************************************/
/* Function:  cap_prepare_subcode_event                                       */
/*                                                                            */
/*! \brief    prepare subcode event
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/

void cap_prepare_subcode_event(uint16 local_xfer_pointer, t_bool end_of_read)
{
  uint8 *SubQPtr;
  BLOCK_INFO_STRUCT *BlockInfoPtr;
  tQsubcode_event *pout_subcode_event;
  t_bool update_time_info = FALSE; /* Patch for #122 issue on B_3_1 development. 21/Sep/2007 */
  /* To check CAP_INVALID_SECTOR_MARK before retriving time info. 25/Sep/2007 */
  uint8 *cap_input_buffer;
  cap_input_buffer = CAP_INPUT_BUFFER + (local_xfer_pointer * CAP_INPUT_SECTOR_SIZE);
  /* To check CAP_INVALID_SECTOR_MARK before retriving time info. 25/Sep/2007 */

#if (1 == HAVE_SHOCK_MEMORY)
  if (ADPCM_ON == cap_config.adpcm)
  {
    SubQPtr = (uint8 *)
              ((uint32 *) (CAP_INPUT_BUFFER + (local_xfer_pointer * CAP_INPUT_SECTOR_SIZE))
             + (588 >> 2));
    BlockInfoPtr = (BLOCK_INFO_STRUCT *)
                   ((uint32 *) (CAP_INPUT_BUFFER + (local_xfer_pointer * CAP_INPUT_SECTOR_SIZE))
                  + (604 >> 2));
  }
  else
#endif
  {
    SubQPtr = (uint8 *)
              ((uint32 *) (CAP_INPUT_BUFFER + (local_xfer_pointer * CAP_INPUT_SECTOR_SIZE))
             + (0x930 >> 2));
    BlockInfoPtr = (BLOCK_INFO_STRUCT *)
                   ((uint32 *) (CAP_INPUT_BUFFER + (local_xfer_pointer * CAP_INPUT_SECTOR_SIZE))
                  + (2464 >> 2));
  }

  pout_subcode_event = (tQsubcode_event *) pevent_get_out(CAPTURE_SUBCODE_EVENT);
  pout_subcode_event->event_type = CAPTURE_EVENT_SUBCODE_NONE;

  if (end_of_read)
  {
    pout_subcode_event->event_type |= CAPTURE_EVENT_SUBCODE_END_OF_READ;
  }

  if (DATA_TYPE_CDDA == cap_status.read.data_type) /* Fix 07/Sep/06 */
  {
    if (CAP_END_OF_PLAY & BlockInfoPtr->SectorFlags)
    {
      BlockInfoPtr->SectorFlags &= ~CAP_END_OF_PLAY;
      pout_subcode_event->event_type |= CAPTURE_EVENT_SUBCODE_END_OF_SONG;

      //CAP_PRINTF("END_OF_SONG\r\n");
      //CAP_PRINTF("->TIME %02x,%02x,%02x\r\n", SubQPtr[3], SubQPtr[4], SubQPtr[5]);
    }
    if (CAP_END_OF_TARGET_TIME & BlockInfoPtr->SectorFlags)
    {
      BlockInfoPtr->SectorFlags &= ~CAP_END_OF_TARGET_TIME;
      pout_subcode_event->event_type |= CAPTURE_EVENT_SUBCODE_END_OF_TARGET_TIME;
    }

    pout_subcode_event->read_error.sector_status = 1;  // Not a good sector

    /* Reset q_subcode Time info. Fixed bug of Track skip during scan forward. [FH] 16/Mar/2007 */
/* Delete, not to reset Time info (Patch for #122 issue on B_3_1 development. 21/Sep/2007) */
//    pout_subcode_event->q_subcode.q_min = 0;
//    pout_subcode_event->q_subcode.q_sec = 0;
//    pout_subcode_event->q_subcode.q_frame = 0;
//    pout_subcode_event->q_subcode.q_zero = 0;
//    pout_subcode_event->q_subcode.q_amin = 0;
//    pout_subcode_event->q_subcode.q_asec = 0;
//    pout_subcode_event->q_subcode.q_aframe = 0;


    //if (BlockInfoPtr->SubcodeStatus & BLOCK_INFO_CRC_OK)
//    if(CrcCheck(SubQPtr))
    if(CrcCheck(SubQPtr) && (*(cap_input_buffer + 2558) != CAP_INVALID_SECTOR_MARK))  /* Check invalid sector mark. 25/Sep/2007 */
    {
      pout_subcode_event->event_type |= CAPTURE_EVENT_SUBCODE_CRCOK;
      switch (SubQPtr[0] & 0x0F)  /* Control Address */
      {
      case 0x01:
        pout_subcode_event->read_error.sector_status = 0;  // Good sector

        /* Mode 1 */
        pout_subcode_event->q_subcode.q_cadr = SubQPtr[0];
        pout_subcode_event->q_subcode.q_tno = SubQPtr[1];
        pout_subcode_event->q_subcode.q_point = SubQPtr[2];
        pout_subcode_event->q_subcode.q_min = SubQPtr[3];
        pout_subcode_event->q_subcode.q_sec = SubQPtr[4];
        pout_subcode_event->q_subcode.q_frame = SubQPtr[5];
        pout_subcode_event->q_subcode.q_zero = SubQPtr[6];
        pout_subcode_event->q_subcode.q_amin = SubQPtr[7];
        pout_subcode_event->q_subcode.q_asec = SubQPtr[8];
        pout_subcode_event->q_subcode.q_aframe = SubQPtr[9];

        update_time_info = TRUE; /* Patch for #122 issue on B_3_1 development 21/Sep/2007 */
        if (0 != SubQPtr[1])  /* Tno */
        {
          pout_subcode_event->event_type |= CAPTURE_EVENT_SUBCODE_NEW_T;

          if (cap_read_q_tno != SubQPtr[1])
          {
            pout_subcode_event->event_type |= CAPTURE_EVENT_SUBCODE_NEW_TRACK;
            cap_read_q_tno = SubQPtr[1];

            // CAP_PRINTF("NEW_TRACK %d\r\n", pout_subcode_event->event_type);
          }

          if (0xAA == SubQPtr[1])
          {
            pout_subcode_event->event_type |= CAPTURE_EVENT_SUBCODE_LEADOUT;

            // CAP_PRINTF("LEAD_OUT %d\r\n", pout_subcode_event->event_type);
          }

          if ((cap_read_q_rmin != SubQPtr[3]) || (cap_read_q_rsec != SubQPtr[4]))
          {
            cap_read_q_rmin = SubQPtr[3];
            cap_read_q_rsec = SubQPtr[4];
            pout_subcode_event->event_type |= CAPTURE_EVENT_SUBCODE