toc.c

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

    break;
  }

  return read_first_toc_result;
}


/******************************************************************************/
/* Function:  read_restof_toc                                                 */
/*                                                                            */
/*! \brief    reading higher sessions TOC
 *  \param    void
 *  \return
 *  \remark
 */
/******************************************************************************/

RETVAL read_restof_toc(void)
{
  RETVAL read_restof_toc_result;

  read_restof_toc_result = IN_PROGRESS;

  switch (toc_sm_state[READ_RESTOF_TOC_LEVEL])
  {
  case STATE_1:
    toc_sm_state[READ_RESTOF_TOC_LEVEL] = STATE_2;
    // break; [RB] fall through, we do not always have an OS event to make this transition

  //case STATE_2:
  default:
    switch (read_toc())
    {
    case IN_PROGRESS:
      break;

    case OK:
      update_session_data();
      if (session.flags & NEXT_SESSION)
      {
        toc_session_count = (uint8)(toc_session_count + 1);
        T_program_area = session.T_next_program_area;
      }
      else
      {
        read_restof_toc_result = OK;
        toc_sm_state[READ_RESTOF_TOC_LEVEL] = STATE_1;
      }
      break;

    case TOC_REQUEST_WAIT_FOR_SERVO:
      read_restof_toc_result = TOC_REQUEST_WAIT_FOR_SERVO;
      break;

    default:
      CDinfo |= OPEN_MULTISESSION;
      read_restof_toc_result = OK;
      toc_sm_state[READ_RESTOF_TOC_LEVEL] = STATE_1;
      break;
    }
    break;
  }
  return read_restof_toc_result;
}


#ifdef TOC_READ_JUMP_TO_START
/******************************************************************************/
/* Function:  jump_to_start_data_area                                         */
/*                                                                            */
/*! \brief    after TOC reading in CAV mode, function jumps to inner track
 *            and starts CLV control for playback
 *  \param    void
 *  \return
 *  \remark
 */
/******************************************************************************/

RETVAL jump_to_start_data_area(void)
{
  RETVAL jump_to_start_data_area_result;

  switch (toc_sm_state[JUMP_TO_START_DATA_AREA_LEVEL])
  {
  case STATE_1:
    set_jump_parameters(JUMP_TARGET_1, toc_get_track_time(TOC_data.min_track), NO_SKIP);
    jump_to_start_data_area_result = TOC_REQUEST_WAIT_FOR_SERVO;
    toc_sm_state[JUMP_TO_START_DATA_AREA_LEVEL] = STATE_2;
    break;

  //case STATE_2:
  default:
    toc_sm_state[JUMP_TO_START_DATA_AREA_LEVEL] = STATE_1;
    jump_to_start_data_area_result = OK;
    break;
  }
  return jump_to_start_data_area_result;
}
#endif

/******************************************************************************/
/* Function:  toc_wait_for_servo                                              */
/*                                                                            */
/*! \brief    after a jump request, function waits until servo is READY
 *  \param    void
 *  \return
 *  \remark
 */
/******************************************************************************/

RETVAL toc_wait_for_servo(void)
{
  RETVAL toc_wait_for_servo_result;

  toc_wait_for_servo_result = IN_PROGRESS;

  if (IS_CAPTURE_EVENT)
  {
    if (IS_CAPTURE_EVENT_READY)
    {
      toc_wait_for_servo_result = OK;
      if (!toc_flags.field.wait_for_set_speed)
      {
        toc_retries--;
        subcode_counter = TOC_MAX_SUBCODE;
      }
      toc_flags.field.wait_for_set_speed = 0;
    }
    else if (IS_CAPTURE_EVENT_ERROR)
    {
#if (1==HAVE_CDTEXT)
      text_idle();
#endif
      toc_wait_for_servo_result = TOC_REPORT_OF_SERVO_ERROR;
    }
  }

  return toc_wait_for_servo_result;
}


/******************************************************************************/
/* Function:  toc_all_toc_read                                                */
/*                                                                            */
/*! \brief
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void toc_all_toc_read(void)
{
  CDinfo |= ALL_TOC_READ;
#if (HAVE_CD_MECHA == 1)  
  lastplay_T = toc_get_track_time(toc_get_min_track()); //STTODO remove
#endif
}




///////////////////////////////////////////////////////////////////////////////
// TOC reading Top Level State functions
///////////////////////////////////////////////////////////////////////////////


/******************************************************************************/
/* Function:  idle_state                                                      */
/*                                                                            */
/*! \brief    stable state: function just returns toc_error_reason in case
 *            of servo failure
 *  \param    void
 *  \return
 *  \remark
 */
/******************************************************************************/

RETVAL toc_idle_state(void)
{
  RETVAL state_result;

  state_result = BUSY;

  if (toc_flags.field.toc_fsm_started)
  {
    if (NO_ERROR_REASON == toc_error_reason)
    {
      state_result = READY;
    }
    else  // return toc_fsm or servo_fsm error
    {
      state_result = toc_error_reason;
    }
  }

  return state_result;
}


/******************************************************************************/
/* Function:  read_first_toc_state                                            */
/*                                                                            */
/*! \brief    read first TOC
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void read_first_toc_state(void)
{
  RETVAL state_result;

  state_result = read_first_toc();

  switch (state_result)
  {
  case IN_PROGRESS:
    break;

  case OK:
    CDinfo |= FIRST_TOC_READABLE;
    toc_flags.field.reading_first_toc = 0;
    if (MULTISESSION_ENABLED && (session.flags & NEXT_SESSION))
    {
      toc_session_count = (uint8)(toc_session_count + 1);
      T_program_area = session.T_next_program_area;
      {
        toc_state = READ_REST_OF_TOC;
      }
    }
    else
    {
      toc_all_toc_read();
#ifdef TOC_READ_JUMP_TO_START
      toc_state = JUMP_TO_START_DATA_AREA;
#else
      toc_state = TOC_IDLE;
#endif
    }
    break;

  case TOC_REQUEST_WAIT_FOR_SERVO:
    toc_state_tmp = toc_state;
    toc_state = TOC_WAIT_FOR_SERVO;
    break;

  //case ERROR_TOC_TIMEOUT:
  //case ERROR_ACCESS_TOC:
  //case ERROR_TOC_NOT_FOUND:
  //case ERROR_TOC_CONTINUITY:
  default:
    toc_error_reason = state_result;
    if (IS_TOC_ERROR(toc_error_reason))
    {
      set_error_toc();
    }
#ifdef TOC_READ_JUMP_TO_START
    toc_state = JUMP_TO_START_DATA_AREA;
#else
    toc_state = TOC_IDLE;
#endif
    toc_all_toc_read();
    break;
  }
}


/******************************************************************************/
/* Function:  read_restof_toc_state                                           */
/*                                                                            */
/*! \brief    function reads rest of TOC for multisession discs
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void read_restof_toc_state(void)
{
  RETVAL state_result;

  state_result = read_restof_toc();
  switch (state_result)
  {
  case IN_PROGRESS:
    break;

  case OK:
#ifdef TOC_READ_JUMP_TO_START
    toc_state = JUMP_TO_START_DATA_AREA;
#else
    toc_state = TOC_IDLE;
#endif
    toc_all_toc_read();
    break;

  case TOC_REQUEST_WAIT_FOR_SERVO:
    toc_state_tmp = toc_state;
    toc_state = TOC_WAIT_FOR_SERVO;
    break;

  //case ERROR_ACCESS_TOC:
  //case ERROR_TOC_NOT_FOUND:
  //case ERROR_TOC_CONTINUITY:
  //case ERROR_TOC_TIMEOUT:
  default:
    toc_error_reason = state_result;
    if (IS_TOC_ERROR(toc_error_reason))
    {
      set_error_toc();
    }
#ifdef TOC_READ_JUMP_TO_START
    toc_state = JUMP_TO_START_DATA_AREA;
#else
    toc_state = TOC_IDLE;
#endif
    toc_all_toc_read();
    break;
  }
}


/******************************************************************************/
/* Function:  jump_to_start_data_area_state                                   */
/*                                                                            */
/*! \brief    function starts CLV control for playback
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void jump_to_start_data_area_state(void)
{
  RETVAL state_result;

  state_result = jump_to_start_data_area();
  switch (state_result)
  {
  case IN_PROGRESS:
    break;

  case OK:
    toc_state = TOC_IDLE;
    break;

  case TOC_REQUEST_WAIT_FOR_SERVO:
    toc_state_tmp = toc_state;
    toc_state = TOC_WAIT_FOR_SERVO;
    break;

  //case servo errors:
  default:
    toc_error_reason = state_result;
    toc_state = TOC_IDLE;
    break;
  }
}


/******************************************************************************/
/* Function:  toc_wait_for_servo_state                                         */
/*                                                                            */
/*! \brief    function waits for servo READY after any issued jump
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void toc_wait_for_servo_state(void)
{
  RETVAL state_result;

  state_result = toc_wait_for_servo();
  switch (state_result)
  {
  case IN_PROGRESS:
    break;

  case OK:
    toc_state = toc_state_tmp;
    break;

  //case unrecoverable servo errors:
  default:
    toc_error_reason = state_result;
    toc_state = TOC_IDLE;
    break;
  }
}




///////////////////////////////////////////////////////////////////////////////
// TOC reading Top Level State Machine
///////////////////////////////////////////////////////////////////////////////


/******************************************************************************/
/* Function:  toc_fsm                                                         */
/*                                                                            */
/*! \brief    finite state machine implementing TOC reading algorithm
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

RETVAL toc_fsm(void)
{
  RETVAL toc_fsm_result = BUSY;
  switch (toc_state)
  {
  //case TOC_IDLE:
  default:
    toc_fsm_result = toc_idle_state();
    break;

  case READ_FIRST_TOC:
    read_first_toc_state();
    break;

  case READ_REST_OF_TOC:
    read_restof_toc_state();
    break;

#ifdef TOC_READ_JUMP_TO_START
  case JUMP_TO_START_DATA_AREA:
    jump_to_start_data_area_state();
    break;
#endif

  case TOC_WAIT_FOR_SERVO:
    toc_wait_for_servo_state();
    break;
  }
#if (1 == HAVE_CDTEXT)
  text_fsm();
#endif
  return toc_fsm_result;
}

///////////////////////////////////////////////////////////////////////////////
// Translation to Xfile format  [RB]
///////////////////////////////////////////////////////////////////////////////

/******************************************************************************/
/* Function:  msf2lba                                                         */
/*                                                                            */
/*! \brief    Convert the MSF format of the TOC entry into an LBA
 *  \param    uint16 index into the TOC
 *  \return   uint32 converted LBA
 *  \remark
 */
/******************************************************************************/
#if 0 // [RB] unused
uint32 msf2lba(uint16 track)
{
  uint32 lba;

  /* The MSB of MSF in the TOC is used for flags, mask it out */
  lba = toc_get_track_min(track) * 60 * 75;
  lba += toc_get_track_sec(track) * 75;
  lba += toc_get_track_frame(track);
  lba -= (0 * 60 * 75) + (2 * 75) + 0; // subtract 2 seconds
  return lba;
}
#endif