cdda.h

Go to the documentation of this file.

/*
  Copyright (C) 2004, 2005, 2006, 2008, 2011, 2012
    Rocky Bernstein <rocky@gnu.org>
  Copyright (C) 2014 Robert Kausch <robert.kausch@freac.org>
  Copyright (C) 2001 Xiph.org and Heiko Eissfeldt heiko@escape.colossus.de
 
  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef CDIO__PARANOIA__CDDA_H_
#define CDIO__PARANOIA__CDDA_H_
 
#include <cdio/cdio.h>
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
  typedef struct cdrom_paranoia_s cdrom_paranoia_t;
  typedef struct cdrom_drive_s   cdrom_drive_t;
 
  typedef enum {
    CDDA_MESSAGE_FORGETIT = 0,
    CDDA_MESSAGE_PRINTIT  = 1,
    CDDA_MESSAGE_LOGIT    = 2,
    CD_FRAMESAMPLES       = CDIO_CD_FRAMESIZE_RAW / 4,
    MAXTRK                = (CDIO_CD_MAX_TRACKS+1)
  } paranoia_cdda_enums_t;
 
 
#include <signal.h>
 
#define MAXTRK (CDIO_CD_MAX_TRACKS+1)
 
typedef struct TOC_s {
  unsigned char bTrack;
  int32_t       dwStartSector;
} TOC_t;
 
#define TOC TOC_t
 
struct cdrom_drive_s {
 
  CdIo_t *p_cdio;
  int opened; 
  char *cdda_device_name;
 
  char *drive_model;
  int drive_type;
  int bigendianp; 
  int nsectors;   
  int cd_extra;   
  bool b_swap_bytes;  
  track_t tracks;
  TOC_t disc_toc[MAXTRK]; 
  lsn_t audio_first_sector;
  lsn_t audio_last_sector;
 
  int errordest;
  int messagedest;
  char *errorbuf;
  char *messagebuf;
 
  /* functions specific to particular drives/interfaces */
 
  int  (*enable_cdda)  (cdrom_drive_t *d, int onoff);
  int  (*read_toc)     (cdrom_drive_t *d);
  long (*read_audio)   (cdrom_drive_t *d, void *p, lsn_t begin,
                       long sectors);
  int  (*set_speed)    (cdrom_drive_t *d, int speed);
  int error_retry;
  int report_all;
 
  int is_atapi;
  int is_mmc;
 
  int last_milliseconds;
 
  int i_test_flags; 
};
 
 
  typedef enum {
    CDDA_TEST_JITTER_SMALL   = 1,
    CDDA_TEST_JITTER_LARGE   = 2,
    CDDA_TEST_JITTER_MASSIVE = 3,
    CDDA_TEST_FRAG_SMALL     = (1<<3),
    CDDA_TEST_FRAG_LARGE     = (2<<3),
    CDDA_TEST_FRAG_MASSIVE   = (3<<3),
    CDDA_TEST_UNDERRUN       = 64
  } paranoia_jitter_t;
 
#define CDDA_TEST_ALWAYS_JITTER     4
 
#define CDDA_TEST_FRAG_SMALL   (1<<3)
#define CDDA_TEST_FRAG_LARGE   (2<<3)
#define CDDA_TEST_FRAG_MASSIVE (3<<3)
 
#define CDDA_TEST_UNDERRUN         64
 
#if TESTING_IS_FINISHED
 
#define CDDA_TEST_SCRATCH         128
#undef  CDDA_TEST_BOGUS_BYTES     256
#undef  CDDA_TEST_DROPDUPE_BYTES  512
#endif /* TESTING_IS_FINISHED */
 
extern cdrom_drive_t *cdio_cddap_find_a_cdrom(int messagedest,
                                              char **ppsz_message);
 
extern cdrom_drive_t *cdio_cddap_identify(const char *psz_device,
                                          int messagedest,
                                          char **ppsz_message);
 
cdrom_drive_t *cdio_cddap_identify_cdio(CdIo_t *p_cdio,
                                        int messagedest, char **ppsz_messages);
 
extern const char *cdio_cddap_version();
 
extern char   *cdio_cddap_messages(cdrom_drive_t *d);
 
extern char   *cdio_cddap_errors(cdrom_drive_t *d);
 
extern void    cdio_cddap_free_messages(char *psz_messages);
 
extern int     cdio_cddap_speed_set(cdrom_drive_t *d, int speed);
extern void    cdio_cddap_verbose_set(cdrom_drive_t *d, int err_action,
                                      int mes_action);
 
bool cdio_cddap_close_no_free_cdio(cdrom_drive_t *d);
 
extern int     cdio_cddap_close(cdrom_drive_t *d);
 
extern int     cdio_cddap_open(cdrom_drive_t *d);
 
extern long    cdio_cddap_read(cdrom_drive_t *d, void *p_buffer,
                               lsn_t beginsector, long sectors);
 
extern long    cdio_cddap_read_timed(cdrom_drive_t *d, void *p_buffer,
                                     lsn_t beginsector, long sectors, int *milliseconds);
 
extern lsn_t   cdio_cddap_track_firstsector(cdrom_drive_t *d,
                                      track_t i_track);
 
extern lsn_t   cdio_cddap_track_lastsector(cdrom_drive_t *d, track_t i_track);
 
extern track_t cdio_cddap_tracks(cdrom_drive_t *d);
 
extern int     cdio_cddap_sector_gettrack(cdrom_drive_t *d, lsn_t lsn);
 
extern int     cdio_cddap_track_channels(cdrom_drive_t *d, track_t i_track);
 
extern int     cdio_cddap_track_audiop(cdrom_drive_t *d, track_t i_track);
 
extern int     cdio_cddap_track_copyp(cdrom_drive_t *d, track_t i_track);
 
extern int     cdio_cddap_track_preemp(cdrom_drive_t *d, track_t i_track);
 
extern lsn_t   cdio_cddap_disc_firstsector(cdrom_drive_t *d);
 
extern lsn_t   cdio_cddap_disc_lastsector(cdrom_drive_t *d);
 
extern int data_bigendianp(cdrom_drive_t *d);
 
typedef enum {
  TR_OK =            0,
  TR_EWRITE =        1  ,
  TR_EREAD =         2  ,
  TR_UNDERRUN =      3  ,
  TR_OVERRUN =       4  ,
  TR_ILLEGAL =       5  ,
  TR_MEDIUM =        6  ,
  TR_BUSY =          7  ,
  TR_NOTREADY =      8  ,
  TR_FAULT =         9  ,
  TR_UNKNOWN =      10  ,
  TR_STREAMING =    11  ,
} transport_error_t;
 
 
#ifdef NEED_STRERROR_TR
const char *strerror_tr[]={
  "Success",
  "Error writing packet command to device",
  "Error reading command from device",
  "SCSI packet data underrun (too little data)",
  "SCSI packet data overrun (too much data)",
  "Illegal SCSI request (rejected by target)",
  "Medium reading data from medium",
  "Device busy",
  "Device not ready",
  "Target hardware fault",
  "Unspecified error",
  "Drive lost streaming"
};
#endif /*NEED_STERROR_TR*/
 
#ifndef DO_NOT_WANT_PARANOIA_COMPATIBILITY
#define cdda_find_a_cdrom       cdio_cddap_find_a_cdrom
#define cdda_identify           cdio_cddap_identify
#define cdda_version            cdio_cddap_version
#define cdda_speed_set          cdio_cddap_speed_set
#define cdda_verbose_set        cdio_cddap_verbose_set
#define cdda_messages           cdio_cddap_messages
#define cdda_errors             cdio_cddap_errors
#define cdda_close              cdio_cddap_close
#define cdda_open               cdio_cddap_open
#define cdda_read               cdio_cddap_read
#define cdda_read_timed         cdio_cddap_read_timed
#define cdda_track_firstsector  cdio_cddap_track_firstsector
#define cdda_track_lastsector   cdio_cddap_track_lastsector
#define cdda_tracks             cdio_cddap_tracks
#define cdda_sector_gettrack    cdio_cddap_sector_gettrack
#define cdda_track_channels     cdio_cddap_track_channels
#define cdda_track_audiop       cdio_cddap_track_audiop
#define cdda_track_copyp        cdio_cddap_track_copyp
#define cdda_track_preemp       cdio_cddap_track_preemp
#define cdda_disc_firstsector   cdio_cddap_disc_firstsector
#define cdda_disc_lastsector    cdio_cddap_disc_lastsector
#define cdrom_drive             cdrom_drive_t
 
#endif /*DO_NOT_WANT_PARANOIA_COMPATIBILITY*/
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
extern paranoia_jitter_t     debug_paranoia_jitter;
extern paranoia_cdda_enums_t debug_paranoia_cdda_enums;
 
#ifdef __cplusplus
extern "C" {
#endif
  extern const char *cdio_cddap_version(void);
  extern void cdio_cddap_free_messages(char *psz_messages);
 
#ifdef __cplusplus
}
#endif
 
#endif /*CDIO__PARANOIA__CDDA_H_*/