bincue.c

linux下的MPEG1

    
    ret = cdio_stream_seek (env->gen.data_source, 0, SEEK_SET);

    if (ret!=0) return ret;

    ret = cdio_stream_read (env->gen.data_source, (uint8_t *) data+272, 
			    CDIO_CD_FRAMESIZE_RAW - 272, nblocks);
  }

  /* ret is number of bytes if okay, but we need to return 0 okay. */
  return ret == 0;
}

/*!
   Reads a single mode2 sector from cd device into data starting
   from lsn. Returns 0 if no error. 
 */
static int
_read_mode1_sector_bincue (void *user_data, void *data, lsn_t lsn, 
			   bool b_form2)
{
  _img_private_t *p_env = user_data;
  int ret;
  char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, };
  int blocksize = CDIO_CD_FRAMESIZE_RAW;

  ret = cdio_stream_seek (p_env->gen.data_source, lsn * blocksize, SEEK_SET);
  if (ret!=0) return ret;

  /* FIXME: Not completely sure the below is correct. */
  ret = cdio_stream_read (p_env->gen.data_source, buf, CDIO_CD_FRAMESIZE_RAW, 1);
  if (ret==0) return ret;

  memcpy (data, buf + CDIO_CD_SYNC_SIZE + CDIO_CD_HEADER_SIZE, 
	  b_form2 ? M2RAW_SECTOR_SIZE: CDIO_CD_FRAMESIZE);

  return 0;
}

/*!
   Reads nblocks of mode1 sectors from cd device into data starting
   from lsn.
   Returns 0 if no error. 
 */
static int
_read_mode1_sectors_bincue (void *user_data, void *data, lsn_t lsn, 
			    bool b_form2, unsigned int nblocks)
{
  _img_private_t *p_env = user_data;
  int i;
  int retval;
  unsigned int blocksize = b_form2 ? M2RAW_SECTOR_SIZE : CDIO_CD_FRAMESIZE;

  for (i = 0; i < nblocks; i++) {
    if ( (retval = _read_mode1_sector_bincue (p_env, 
					    ((char *)data) + (blocksize * i),
					    lsn + i, b_form2)) )
      return retval;
  }
  return 0;
}

/*!
   Reads a single mode1 sector from cd device into data starting
   from lsn. Returns 0 if no error. 
 */
static int
_read_mode2_sector_bincue (void *user_data, void *data, lsn_t lsn, 
			 bool b_form2)
{
  _img_private_t *p_env = user_data;
  int ret;
  char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, };

  /* NOTE: The logic below seems a bit wrong and convoluted
     to me, but passes the regression tests. (Perhaps it is why we get
     valgrind errors in vcdxrip). Leave it the way it was for now.
     Review this sector 2336 stuff later.
  */

  int blocksize = CDIO_CD_FRAMESIZE_RAW;

  ret = cdio_stream_seek (p_env->gen.data_source, lsn * blocksize, SEEK_SET);
  if (ret!=0) return ret;

  ret = cdio_stream_read (p_env->gen.data_source, buf, CDIO_CD_FRAMESIZE_RAW, 1);
  if (ret==0) return ret;


  /* See NOTE above. */
  if (b_form2)
    memcpy (data, buf + CDIO_CD_SYNC_SIZE + CDIO_CD_HEADER_SIZE, 
	    M2RAW_SECTOR_SIZE);
  else
    memcpy (data, buf + CDIO_CD_XA_SYNC_HEADER, CDIO_CD_FRAMESIZE);

  return 0;
}

/*!
   Reads nblocks of mode2 sectors from cd device into data starting
   from lsn.
   Returns 0 if no error. 
 */
static int
_read_mode2_sectors_bincue (void *user_data, void *data, lsn_t lsn, 
			    bool b_form2, unsigned int nblocks)
{
  _img_private_t *p_env = user_data;
  int i;
  int retval;
  unsigned int blocksize = b_form2 ? M2RAW_SECTOR_SIZE : CDIO_CD_FRAMESIZE;

  for (i = 0; i < nblocks; i++) {
    if ( (retval = _read_mode2_sector_bincue (p_env, 
					    ((char *)data) + (blocksize * i),
					    lsn + i, b_form2)) )
      return retval;
  }
  return 0;
}

/*!
  Return an array of strings giving possible BIN/CUE disk images.
 */
char **
cdio_get_devices_bincue (void)
{
  char **drives = NULL;
  unsigned int num_files=0;
#ifdef HAVE_GLOB_H
  unsigned int i;
  glob_t globbuf;
  globbuf.gl_offs = 0;
  glob("*.cue", GLOB_DOOFFS, NULL, &globbuf);
  for (i=0; i<globbuf.gl_pathc; i++) {
    cdio_add_device_list(&drives, globbuf.gl_pathv[i], &num_files);
  }
  globfree(&globbuf);
#else
  cdio_add_device_list(&drives, DEFAULT_CDIO_DEVICE, &num_files);
#endif /*HAVE_GLOB_H*/
  cdio_add_device_list(&drives, NULL, &num_files);
  return drives;
}

/*!
  Return a string containing the default CD device.
 */
char *
cdio_get_default_device_bincue(void)
{
  char **drives = cdio_get_devices_nrg();
  char *drive = (drives[0] == NULL) ? NULL : strdup(drives[0]);
  cdio_free_device_list(drives);
  return drive;
}

static bool
get_hwinfo_bincue ( const CdIo *p_cdio, /*out*/ cdio_hwinfo_t *hw_info)
{
  strcpy(hw_info->psz_vendor, "libcdio");
  strcpy(hw_info->psz_model, "CDRWIN");
  strcpy(hw_info->psz_revision, CDIO_VERSION);
  return true;
  
}

/*!
  Return the number of tracks in the current medium.
  CDIO_INVALID_TRACK is returned on error.
*/
static track_format_t
_get_track_format_bincue(void *user_data, track_t i_track) 
{
  _img_private_t *p_env = user_data;
  
  if (i_track > p_env->gen.i_tracks || i_track == 0) 
    return TRACK_FORMAT_ERROR;

  return p_env->tocent[i_track-p_env->gen.i_first_track].track_format;
}

/*!
  Return true if we have XA data (green, mode2 form1) or
  XA data (green, mode2 form2). That is track begins:
  sync - header - subheader
  12     4      -  8
  
  FIXME: there's gotta be a better design for this and get_track_format?
*/
static bool
_get_track_green_bincue(void *user_data, track_t i_track) 
{
  _img_private_t *p_env = user_data;
  
  if ( NULL == p_env || 
       ( i_track < p_env->gen.i_first_track
	 || i_track >= p_env->gen.i_tracks + p_env->gen.i_first_track ) )
    return false;

  return p_env->tocent[i_track-p_env->gen.i_first_track].track_green;
}

/*!  
  Return the starting LSN track number
  i_track in obj.  Track numbers start at 1.
  The "leadout" track is specified either by
  using i_track LEADOUT_TRACK or the total tracks+1.
  False is returned if there is no track entry.
*/
static lba_t
_get_lba_track_bincue(void *user_data, track_t i_track)
{
  _img_private_t *p_env = user_data;

  if (i_track == CDIO_CDROM_LEADOUT_TRACK) i_track = p_env->gen.i_tracks+1;

  if (i_track <= p_env->gen.i_tracks + p_env->gen.i_first_track && i_track != 0) {
    return p_env->tocent[i_track-p_env->gen.i_first_track].start_lba;
  } else 
    return CDIO_INVALID_LBA;
}

/*! 
  Return corresponding BIN file if psz_cue_name is a cue file or NULL
  if not a CUE file.
*/
char *
cdio_is_cuefile(const char *psz_cue_name) 
{
  int   i;
  char *psz_bin_name;
  
  if (psz_cue_name == NULL) return NULL;

  /* FIXME? Now that we have cue parsing, should we really force
     the filename extension requirement or is it enough just to 
     parse the cuefile? 
   */

  psz_bin_name=strdup(psz_cue_name);
  i=strlen(psz_bin_name)-strlen("cue");
  
  if (i>0) {
    if (psz_cue_name[i]=='c' && psz_cue_name[i+1]=='u' && psz_cue_name[i+2]=='e') {
      psz_bin_name[i++]='b'; psz_bin_name[i++]='i'; psz_bin_name[i++]='n';
      if (parse_cuefile(NULL, psz_cue_name))
	return psz_bin_name;
      else 
	goto error;
    } 
    else if (psz_cue_name[i]=='C' && psz_cue_name[i+1]=='U' && psz_cue_name[i+2]=='E') {
      psz_bin_name[i++]='B'; psz_bin_name[i++]='I'; psz_bin_name[i++]='N';
      if (parse_cuefile(NULL, psz_cue_name))
	return psz_bin_name;
      else 
	goto error;
    }
  }
 error:
  free(psz_bin_name);
  return NULL;
}

/*! 
  Return corresponding CUE file if psz_bin_name is a bin file or NULL
  if not a BIN file.
*/
char *
cdio_is_binfile(const char *psz_bin_name) 
{
  int   i;
  char *psz_cue_name;
  
  if (psz_bin_name == NULL) return NULL;

  psz_cue_name=strdup(psz_bin_name);
  i=strlen(psz_bin_name)-strlen("bin");
  
  if (i>0) {
    if (psz_bin_name[i]=='b' && psz_bin_name[i+1]=='i' && psz_bin_name[i+2]=='n') {
      psz_cue_name[i++]='c'; psz_cue_name[i++]='u'; psz_cue_name[i++]='e';
      return psz_cue_name;
    } 
    else if (psz_bin_name[i]=='B' && psz_bin_name[i+1]=='I' && psz_bin_name[i+2]=='N') {
      psz_cue_name[i++]='C'; psz_cue_name[i++]='U'; psz_cue_name[i++]='E';
      return psz_cue_name;
    }
  }
  free(psz_cue_name);
  return NULL;
}

/*!
  Initialization routine. This is the only thing that doesn't
  get called via a function pointer. In fact *we* are the
  ones to set that up.
 */
CdIo *
cdio_open_am_bincue (const char *psz_source_name, const char *psz_access_mode)
{
  if (psz_access_mode != NULL)
    cdio_warn ("there is only one access mode for bincue. Arg %s ignored",
	       psz_access_mode);
  return cdio_open_bincue(psz_source_name);
}

/*!
  Initialization routine. This is the only thing that doesn't
  get called via a function pointer. In fact *we* are the
  ones to set that up.
 */
CdIo *
cdio_open_bincue (const char *source_name)
{
  char *psz_bin_name = cdio_is_cuefile(source_name);

  if (NULL != psz_bin_name) {
    free(psz_bin_name);
    return cdio_open_cue(source_name);
  } else {
    char *psz_cue_name = cdio_is_binfile(source_name);
    CdIo *cdio = cdio_open_cue(psz_cue_name);
    free(psz_cue_name);
    return cdio;
  }
}

CdIo *
cdio_open_cue (const char *psz_cue_name)
{
  CdIo *ret;
  _img_private_t *_data;
  char *psz_bin_name;
  
  cdio_funcs _funcs;
  
  memset( &_funcs, 0, sizeof(_funcs) );
  
  _funcs.eject_media        = _eject_media_image;
  _funcs.free               = _free_image;
  _funcs.get_arg            = _get_arg_image;
  _funcs.get_cdtext         = get_cdtext_generic;
  _funcs.get_devices        = cdio_get_devices_bincue;
  _funcs.get_default_device = cdio_get_default_device_bincue;
  _funcs.get_discmode       = _get_discmode_image;
  _funcs.get_drive_cap      = _get_drive_cap_image;
  _funcs.get_first_track_num= _get_first_track_num_image;
  _funcs.get_hwinfo         = get_hwinfo_bincue;
  _funcs.get_mcn            = _get_mcn_image;
  _funcs.get_num_tracks     = _get_num_tracks_image;
  _funcs.get_track_format   = _get_track_format_bincue;
  _funcs.get_track_green    = _get_track_green_bincue;
  _funcs.get_track_lba      = _get_lba_track_bincue;
  _funcs.get_track_msf      = _get_track_msf_image;
  _funcs.lseek              = _lseek_bincue;
  _funcs.read               = _read_bincue;
  _funcs.read_audio_sectors = _read_audio_sectors_bincue;
  _funcs.read_mode1_sector  = _read_mode1_sector_bincue;
  _funcs.read_mode1_sectors = _read_mode1_sectors_bincue;
  _funcs.read_mode2_sector  = _read_mode2_sector_bincue;
  _funcs.read_mode2_sectors = _read_mode2_sectors_bincue;
  _funcs.set_arg            = _set_arg_image;
  _funcs.stat_size          = _stat_size_bincue;
  
  if (NULL == psz_cue_name) return NULL;
  
  _data                 = _cdio_malloc (sizeof (_img_private_t));
  _data->gen.init       = false;
  _data->psz_cue_name   = NULL;
  
  ret = cdio_new ((void *)_data, &_funcs);
  
  if (ret == NULL) {
    free(_data);
    return NULL;
  }
  
  psz_bin_name = cdio_is_cuefile(psz_cue_name);
  
  if (NULL == psz_bin_name) {
    cdio_error ("source name %s is not recognized as a CUE file", 
		psz_cue_name);
  }
  
  _set_arg_image (_data, "cue", psz_cue_name);
  _set_arg_image (_data, "source", psz_bin_name);
  free(psz_bin_name);
  
  if (_init_bincue(_data)) {
    return ret;
  } else {
    _free_image(_data);
    free(ret);
    return NULL;
  }
}

bool
cdio_have_bincue (void)
{
  return true;
}