toc.c

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

      {
        if (toc_retries != 0)
        {
          set_jump_parameters(JUMP_TRACKS, CDT_0, CONTINUITY_SKIP_TRACKS);
          toc_read_subcodes_result = TOC_REQUEST_WAIT_FOR_SERVO;
        }
        else
        {
#if (1==HAVE_CDTEXT)
          if (text_get_status() == BUSY)
          {
            /* only CD text is problem so return OK */
            toc_read_subcodes_result = OK;
          }
          else
#endif
          {
            toc_read_subcodes_result = ERROR_TOC_CONTINUITY;
          }
        }
      }
    }
  } // end if (toc_q_tno == 0)

  return toc_read_subcodes_result;
}


/******************************************************************************/
/* Function:  toc_check_subcodes                                              */
/*                                                                            */
/*! \brief    when a new subcode is ready, this function freezes
 *            subcode data acquisition and runs subcode reading
 *  \param    void
 *  \return
 *  \remark
 */
/******************************************************************************/

RETVAL toc_check_subcodes(void)
{
  RETVAL toc_check_subcodes_result;

  toc_check_subcodes_result = IN_PROGRESS;

  if (IS_CAPTURE_SUBCODE_EVENT)
  {
    toc_check_subcodes_result = toc_read_subcodes();
  }
  return toc_check_subcodes_result;
}


/******************************************************************************/
/* Function:  toc_access                                                      */
/*                                                                            */
/*! \brief    function just waits until first subcode is available for
 *            TOC reading
 *  \param    void
 *  \return
 *  \remark
 */
/******************************************************************************/

RETVAL toc_access(void)
{
  RETVAL toc_access_result;

  toc_access_result = IN_PROGRESS;

  if (timer_in_progress(TOC_TIMER))
  {
    if ((IS_CAPTURE_SUBCODE_EVENT) && ((toc_q_cadr & 0x0F) == MODE1))
    {
      stop_timer(TOC_TIMER);
      toc_access_result = OK;
    }
  }
  else   // (!timer_in_progress(TOC_TIMER))
  {
#if (1==HAVE_CDTEXT)
    text_idle();
#endif
    toc_access_result = ERROR_TOC_TIMEOUT;
  }

  return toc_access_result;
}


/******************************************************************************/
/* Function:  toc_read_init                                                   */
/*                                                                            */
/*! \brief    function clears session structure;
 *            it sets counter the subcode counter
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

static const SESSION_STRUCT session_init =
{
  0x00,  /* min_track */
  0x00,  /* max_track */
  0x00,  /* num_of_audio_track */
  0x00,  /* T_next_program_area */
  {0xFF,0xFF,0xFF},  /* Tmsf_lead_out[3] */
  0x00,  /* type */
  0x00,  /* control */
  0x00,  /* flags */
  0x00   /* warnings */
};

void toc_read_init(void)
{
  session = session_init;

  subcode_counter = TOC_MAX_SUBCODE;
  toc_retries = TOC_MAX_RETRY;
  track_read = 0;

#if (1==HAVE_CDTEXT)
  text_start_reading();
#endif
}


/******************************************************************************/
/* Function:  toc_data_init                                                   */
/*                                                                            */
/*! \brief    clears TOC data
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void toc_data_init(void)
{
  uint8 index;

  TOC_data.min_track = 0;
  TOC_data.max_track = 0;
  TOC_data.num_of_audio_track = 0;
  TOC_data.Tmsf_lead_out[MIN] = 0xff;
  TOC_data.Tmsf_lead_out[SEC] = 0xff;
  TOC_data.Tmsf_lead_out[FRAME] = 0xff;

  for (index = 0; index < 99; index++)
  {
    TOC_data.track_data.min[index] = 0xff;
  }

  TOC_data.num_of_sessions = 0;
  T_program_area = CDT_1SEC;

  CDinfo &= (LOW_REFLECTIVE | DISC_12CM | DISC_8CM);
}


/******************************************************************************/
/* Function:  set_dummy_toc                                                   */
/*                                                                            */
/*! \brief    function sets dummy TOC
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void set_dummy_toc(uint8 is_audio_track)
{
  TOC_data.min_track = 0x01;
  TOC_data.max_track = 0x01;
  TOC_data.Tmsf_lead_out[MIN] = 99;
  TOC_data.Tmsf_lead_out[SEC] = 0;
  TOC_data.Tmsf_lead_out[FRAME] = 0;
  if (0 == is_audio_track)  /* BB050915a */
  {
    TOC_data.num_of_audio_track = 0;
    TOC_data.track_data.min[0] = 0x80;
  }
  else
  {
    TOC_data.num_of_audio_track = 0x01;
    TOC_data.track_data.min[0] = 0x00;
  }
  TOC_data.track_data.sec[0] = 0x02;
  TOC_data.track_data.frame[0] = 0x80;
  TOC_data.num_of_sessions = 1;
}


/******************************************************************************/
/* Function:  set_error_toc                                                   */
/*                                                                            */
/*! \brief    function sets TOC data in case of error
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void set_error_toc(void)
{
  CDinfo &= ~FIRST_TOC_READABLE;
  set_dummy_toc(0);
  //TODO  event_set_toc(SERVO_EVENT_TOC_ERROR);
}


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

void check_copy_protection(void)
{
  if (SESSION_LEAD_OUT_TIME() < toc_get_track_time(SESSION_MAX_TRACK))
  {
    CDinfo |= COPY_PROTECTED;
  }
  else if (session.flags & B0_FOUND)
  {
    if (((CDinfo & MS_R_RW) == 0)
     || ((session.T_next_program_area < T_program_area)
      && (session.flags & NEXT_SESSION)))
    {
      CDinfo |= COPY_PROTECTED;
    }
    else if (toc_flags.field.reading_first_toc)
    {
      uint32 t_min_track;
      t_min_track = toc_get_track_time(SESSION_MIN_TRACK);
      if ((t_min_track < CDT_2SEC) || (t_min_track >= CDT_4SEC))
      {
        CDinfo |= COPY_PROTECTED;
      }
    }
  }
}


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

void update_session_data(void)
{
  uint8 tr;
  if ((session.control & 0x20) == 0)
  {
    CDinfo |= DIGITAL_COPY_PROHIBITED;
  }

  TOC_data.track_data.frame[(uint8)(session.min_track - 1)] |= 0x80;
  TOC_data.num_of_sessions = toc_session_count;
  for (tr = session.min_track; tr <= session.max_track; tr++)
  {
    TOC_data.track_data.type[(uint8)(tr - 1)] = session.type;
  }

  check_copy_protection();

  if (toc_flags.field.reading_first_toc)
  {
    TOC_data.min_track = session.min_track;
    TOC_data.max_track_in_1_toc = session.max_track;
    TOC_data.num_of_audio_track_in_1_toc = session.num_of_audio_track;
    if (COPY_PROTECTION_ENABLED)
    {
      TOC_data.Tmsf_lead_out_in_1_toc[MIN] = session.Tmsf_lead_out[MIN]  ;
      TOC_data.Tmsf_lead_out_in_1_toc[SEC] = session.Tmsf_lead_out[SEC]  ;
      TOC_data.Tmsf_lead_out_in_1_toc[FRAME] = session.Tmsf_lead_out[FRAME];
    }
  }

  if ((CDinfo & COPY_PROTECTED) && (COPY_PROTECTION_ENABLED))
  {
    TOC_data.max_track = TOC_data.max_track_in_1_toc;
    TOC_data.num_of_audio_track = TOC_data.num_of_audio_track_in_1_toc;
    TOC_data.Tmsf_lead_out[MIN] = TOC_data.Tmsf_lead_out_in_1_toc[MIN]  ;
    TOC_data.Tmsf_lead_out[SEC] = TOC_data.Tmsf_lead_out_in_1_toc[SEC]  ;
    TOC_data.Tmsf_lead_out[FRAME] = TOC_data.Tmsf_lead_out_in_1_toc[FRAME];
    TOC_data.num_of_sessions = 1;
    session.flags &= (uint8)~NEXT_SESSION;
  }
  else
  {
    TOC_data.max_track = session.max_track;
    TOC_data.num_of_audio_track += session.num_of_audio_track;
    TOC_data.Tmsf_lead_out[MIN] = session.Tmsf_lead_out[MIN]  ;
    TOC_data.Tmsf_lead_out[SEC] = session.Tmsf_lead_out[SEC]  ;
    TOC_data.Tmsf_lead_out[FRAME] = session.Tmsf_lead_out[FRAME];
  }
/* HW060202a - BEGIN */
#ifdef DISKSIZE_WORKAROUND
   //Workarround Reset with higher speeds and  directly  next startup
   // to prevent wrong disk diamater detection
   // and no startup in case of wrong TTM controler parameters
  if((TOC_data.Tmsf_lead_out[MIN] > 30) && (CDinfo & DISC_8CM))
  {
    CDinfo &= ~DISC_8CM;
    CDinfo |= DISC_12CM;
  }
#endif
/* HW060202a - END */
}


/******************************************************************************/
/* Function:  read-toc                                                        */
/*                                                                            */
/*! \brief    function initializes data, waits for first available subcode and
 *            starts reading subcodes information for TOC collection
 *  \param    void
 *  \return
 *  \remark
 */
/******************************************************************************/

RETVAL read_toc(void)
{
  RETVAL read_toc_result;
  RETVAL toc_access_result;
  RETVAL toc_check_subcodes_result;

  read_toc_result = IN_PROGRESS;

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

  case STATE_2:
    toc_access_result = toc_access();
    switch (toc_access_result)
    {
    case IN_PROGRESS:
    case TOC_REQUEST_WAIT_FOR_TIME: // BB070110a
      break;

    case OK:
      toc_sm_state[READ_TOC_LEVEL] = STATE_3;
      break;

    //case ERROR_TOC_TIMEOUT:
    default:
      toc_sm_state[READ_TOC_LEVEL] = STATE_1;
      read_toc_result = toc_access_result;
      break;
    }
    break;

  //case STATE_3:
  default:
    toc_check_subcodes_result = toc_check_subcodes();
    switch (toc_check_subcodes_result)
    {
    case IN_PROGRESS:
      break;

    case TOC_REQUEST_WAIT_FOR_SERVO:
      read_toc_result = TOC_REQUEST_WAIT_FOR_SERVO;
      break;

    //case OK:
    //case ERROR_ACCESS_TOC:
    //case ERROR_TOC_NOT_FOUND:
    //case ERROR_TOC_CONTINUITY:
    default:
#if (1==HAVE_CDTEXT)
      text_idle();
#endif
      toc_sm_state[READ_TOC_LEVEL] = STATE_1;
      read_toc_result = toc_check_subcodes_result;
      break;
    }
    break;
  }

  return read_toc_result;
}


/******************************************************************************/
/* Function:  read_first_toc                                                  */
/*                                                                            */
/*! \brief    reading first TOC
 *  \param    void
 *  \return
 *  \remark
 */
/******************************************************************************/

RETVAL read_first_toc(void)
{
  RETVAL read_first_toc_result;
  RETVAL read_toc_result;

  read_first_toc_result = IN_PROGRESS;

  switch (toc_sm_state[READ_FIRST_TOC_LEVEL])
  {
  case STATE_1:
    toc_error_reason = NO_ERROR_REASON;
    toc_data_init();
    toc_sm_state[READ_FIRST_TOC_LEVEL] = STATE_2;
    set_jump_parameters(JUMP_TRACKS, 0, 0);  // dummy jump to enable subcode events
    read_first_toc_result = TOC_REQUEST_WAIT_FOR_SERVO;
    break;

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

    case OK:
      if ((session.min_track > 1) &&
          (session.min_track != last_min_track) &&
          !((session.flags & B0_FOUND) && (session.flags & C0_FOUND)))
      {
        if (session.min_track > last_min_track)
        {
          read_first_toc_result = ERROR_ACCESSING_FIRST_TOC;
        }
        else
        {
          last_min_track = session.min_track;
          set_jump_parameters(JUMP_TARGET_PLUS_TRACKS, CDT_2SEC, TRACKS_INTO_FIRST_LEADIN);
          read_first_toc_result = TOC_REQUEST_WAIT_FOR_SERVO;    // restart TOC reading...
        }
      }
      else if (((session.control & 0xD0) == 0x40) && (session.type == 0x10))
      {
        set_dummy_toc(0);
        session.flags &= (uint8)~NEXT_SESSION;
        read_first_toc_result = OK;
      }
      else
      {
        update_session_data();
        read_first_toc_result = OK;
      }
      toc_sm_state[READ_FIRST_TOC_LEVEL] = STATE_1;
      break;

    case TOC_REQUEST_WAIT_FOR_SERVO:
      read_first_toc_result = TOC_REQUEST_WAIT_FOR_SERVO;
      break;

    //case ERROR_TOC_TIMEOUT, ERROR_ACCESS_TOC, ERROR_TOC_NOT_FOUND, ERROR_TOC_CONTINUITY
    default:
      read_first_toc_result = read_toc_result;
      toc_sm_state[READ_FIRST_TOC_LEVEL] = STATE_1;
      break;
    }