device.h

Go to the documentation of this file.

/* -*- c -*-
    $Id: device_8h-source.html,v 1.9 2006/10/27 11:16:41 rocky Exp $

    Copyright (C) 2005, 2006 Rocky Bernstein <rocky@cpan.org>

    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 2 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, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef __CDIO_DEVICE_H__
#define __CDIO_DEVICE_H__

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

  typedef uint32_t cdio_drive_read_cap_t;
  typedef uint32_t cdio_drive_write_cap_t;
  typedef uint32_t cdio_drive_misc_cap_t;
  
  typedef enum {
    CDIO_DRIVE_CAP_ERROR             = 0x40000, 
    CDIO_DRIVE_CAP_UNKNOWN           = 0x80000, 
    CDIO_DRIVE_CAP_MISC_CLOSE_TRAY   = 0x00001, 
    CDIO_DRIVE_CAP_MISC_EJECT        = 0x00002, 
    CDIO_DRIVE_CAP_MISC_LOCK         = 0x00004, 
    CDIO_DRIVE_CAP_MISC_SELECT_SPEED = 0x00008, 
    CDIO_DRIVE_CAP_MISC_SELECT_DISC  = 0x00010, 
    CDIO_DRIVE_CAP_MISC_MULTI_SESSION= 0x00020, 
    CDIO_DRIVE_CAP_MISC_MEDIA_CHANGED= 0x00080, 
    CDIO_DRIVE_CAP_MISC_RESET        = 0x00100, 
    CDIO_DRIVE_CAP_MISC_FILE         = 0x20000 
  } cdio_drive_cap_misc_t;

  typedef enum {
    CDIO_DRIVE_CAP_READ_AUDIO        = 0x00001, 
    CDIO_DRIVE_CAP_READ_CD_DA        = 0x00002, 
    CDIO_DRIVE_CAP_READ_CD_G         = 0x00004, 
    CDIO_DRIVE_CAP_READ_CD_R         = 0x00008, 
    CDIO_DRIVE_CAP_READ_CD_RW        = 0x00010, 
    CDIO_DRIVE_CAP_READ_DVD_R        = 0x00020, 
    CDIO_DRIVE_CAP_READ_DVD_PR       = 0x00040, 
    CDIO_DRIVE_CAP_READ_DVD_RAM      = 0x00080, 
    CDIO_DRIVE_CAP_READ_DVD_ROM      = 0x00100, 
    CDIO_DRIVE_CAP_READ_DVD_RW       = 0x00200, 
    CDIO_DRIVE_CAP_READ_DVD_RPW      = 0x00400, 
    CDIO_DRIVE_CAP_READ_C2_ERRS      = 0x00800, 
    CDIO_DRIVE_CAP_READ_MODE2_FORM1  = 0x01000, 
    CDIO_DRIVE_CAP_READ_MODE2_FORM2  = 0x02000, 
    CDIO_DRIVE_CAP_READ_MCN          = 0x04000, 
    CDIO_DRIVE_CAP_READ_ISRC         = 0x08000 
  } cdio_drive_cap_read_t;

  typedef enum {
    CDIO_DRIVE_CAP_WRITE_CD_R        = 0x00001, 
    CDIO_DRIVE_CAP_WRITE_CD_RW       = 0x00002, 
    CDIO_DRIVE_CAP_WRITE_DVD_R       = 0x00004, 
    CDIO_DRIVE_CAP_WRITE_DVD_PR      = 0x00008, 
    CDIO_DRIVE_CAP_WRITE_DVD_RAM     = 0x00010, 
    CDIO_DRIVE_CAP_WRITE_DVD_RW      = 0x00020, 
    CDIO_DRIVE_CAP_WRITE_DVD_RPW     = 0x00040, 
    CDIO_DRIVE_CAP_WRITE_MT_RAINIER  = 0x00080, 
    CDIO_DRIVE_CAP_WRITE_BURN_PROOF  = 0x00100, 
    CDIO_DRIVE_CAP_WRITE_CD =
    (CDIO_DRIVE_CAP_WRITE_CD_R | CDIO_DRIVE_CAP_WRITE_CD_RW),
    CDIO_DRIVE_CAP_WRITE_DVD = 
    (CDIO_DRIVE_CAP_WRITE_DVD_R | CDIO_DRIVE_CAP_WRITE_DVD_PR 
     | CDIO_DRIVE_CAP_WRITE_DVD_RAM | CDIO_DRIVE_CAP_WRITE_DVD_RW 
     | CDIO_DRIVE_CAP_WRITE_DVD_RPW ),
    CDIO_DRIVE_CAP_WRITE = 
    (CDIO_DRIVE_CAP_WRITE_CD | CDIO_DRIVE_CAP_WRITE_DVD)
  } cdio_drive_cap_write_t;
    
  typedef enum {
    CDIO_MMC_HW_VENDOR_LEN   =  8, 
    CDIO_MMC_HW_MODEL_LEN    = 16, 
    CDIO_MMC_HW_REVISION_LEN =  4  
  } cdio_mmc_hw_len_t;
    

  typedef struct cdio_hwinfo 
  {
    char psz_vendor  [CDIO_MMC_HW_VENDOR_LEN+1];
    char psz_model   [CDIO_MMC_HW_MODEL_LEN+1];
    char psz_revision[CDIO_MMC_HW_REVISION_LEN+1];
  } cdio_hwinfo_t;


  typedef enum {
    CDIO_SRC_IS_DISK_IMAGE_MASK = 0x0001, 
    CDIO_SRC_IS_DEVICE_MASK     = 0x0002, 
    CDIO_SRC_IS_SCSI_MASK       = 0x0004, 
    CDIO_SRC_IS_NATIVE_MASK     = 0x0008
  } cdio_src_category_mask_t;
    

  typedef enum  {
    DRIVER_UNKNOWN, 
    DRIVER_AIX,     
    DRIVER_BSDI,    
    DRIVER_FREEBSD, 
    DRIVER_LINUX,   
    DRIVER_SOLARIS, 
    DRIVER_OSX,     
    DRIVER_WIN32,   
    DRIVER_CDRDAO,  
    DRIVER_BINCUE,  
    DRIVER_NRG,     
    DRIVER_DEVICE   
  } driver_id_t;

  extern const driver_id_t cdio_os_driver;
  

#define CDIO_MIN_DRIVER        DRIVER_AIX
#define CDIO_MIN_DEVICE_DRIVER CDIO_MIN_DRIVER
#define CDIO_MAX_DRIVER        DRIVER_NRG
#define CDIO_MAX_DEVICE_DRIVER DRIVER_WIN32

  typedef enum  {
    DRIVER_OP_SUCCESS = 0,       
    DRIVER_OP_ERROR = -1,        
    DRIVER_OP_UNSUPPORTED = -2,  
    DRIVER_OP_UNINIT = -3,       
    DRIVER_OP_NOT_PERMITTED = -4, 
    DRIVER_OP_BAD_PARAMETER = -5, 
    DRIVER_OP_BAD_POINTER =   -6, 
    DRIVER_OP_NO_DRIVER  =    -7, 
  } driver_return_code_t;

  driver_return_code_t cdio_close_tray (const char *psz_drive, 
                                        /*in/out*/ driver_id_t *p_driver_id);

  const char *cdio_driver_errmsg(driver_return_code_t drc);
  
  driver_return_code_t cdio_eject_media (CdIo_t **p_cdio);

  driver_return_code_t cdio_eject_media_drive (const char *psz_drive);

  void cdio_free_device_list (char * device_list[]);

  char * cdio_get_default_device (const CdIo_t *p_cdio);

  char * cdio_get_default_device_driver (/*in/out*/ driver_id_t *p_driver_id);

  char ** cdio_get_devices (driver_id_t driver_id);

  char ** cdio_get_devices_with_cap (/*in*/ char *ppsz_search_devices[],
                                     cdio_fs_anal_t capabilities, bool b_any);

  char ** cdio_get_devices_with_cap_ret (/*in*/ char* ppsz_search_devices[],
                                         cdio_fs_anal_t capabilities, 
                                         bool b_any,
                                         /*out*/ driver_id_t *p_driver_id);

  char ** cdio_get_devices_ret (/*in/out*/ driver_id_t *p_driver_id);

  void cdio_get_drive_cap (const CdIo_t *p_cdio,
                           cdio_drive_read_cap_t  *p_read_cap,
                           cdio_drive_write_cap_t *p_write_cap,
                           cdio_drive_misc_cap_t  *p_misc_cap);
  
  void cdio_get_drive_cap_dev (const char *device,
                               cdio_drive_read_cap_t  *p_read_cap,
                               cdio_drive_write_cap_t *p_write_cap,
                               cdio_drive_misc_cap_t  *p_misc_cap);

  const char * cdio_get_driver_name (const CdIo_t *p_cdio);

  driver_id_t cdio_get_driver_id (const CdIo_t *p_cdio);

  bool cdio_get_hwinfo ( const CdIo_t *p_cdio, 
                         /*out*/ cdio_hwinfo_t *p_hw_info );


  driver_return_code_t cdio_get_last_session (CdIo_t *p_cdio,
                                              /*out*/ lsn_t *i_last_session);

  int cdio_get_media_changed(CdIo_t *p_cdio);

  bool_3way_t cdio_have_atapi (CdIo_t *p_cdio);

  bool cdio_have_aix    (void);

  bool cdio_have_bsdi    (void);

  bool cdio_have_freebsd (void);

  bool cdio_have_linux   (void);

  bool cdio_have_solaris (void);

  bool cdio_have_osx     (void);

  bool cdio_have_win32   (void);

  bool cdio_have_nrg     (void);

  bool cdio_have_bincue  (void);

  bool cdio_have_cdrdao  (void);

  bool cdio_have_driver (driver_id_t driver_id);
  
  /*
    Free any resources associated with p_cdio. Call this when done using p_cdio
    and using CD reading/control operations.

    @param p_cdio the CD object to eliminated.
   */
  void cdio_destroy (CdIo_t *p_cdio);

  const char *cdio_driver_describe (driver_id_t driver_id);
  
  CdIo_t * cdio_open (const char *psz_source, driver_id_t driver_id);

  CdIo_t * cdio_open_am (const char *psz_source, 
                         driver_id_t driver_id, const char *psz_access_mode);

  CdIo_t * cdio_open_bincue (const char *psz_cue_name);
  
  CdIo_t * cdio_open_am_bincue (const char *psz_cue_name, 
                                const char *psz_access_mode);
  
  CdIo_t * cdio_open_cdrdao (const char *psz_toc_name);
  
  CdIo_t * cdio_open_am_cdrdao (const char *psz_toc_name, 
                                const char *psz_access_mode);
  
  char * cdio_get_default_device_bincue(void);

  char **cdio_get_devices_bincue(void);

  char * cdio_get_default_device_cdrdao(void);

  char **cdio_get_devices_cdrdao(void);

  CdIo_t * cdio_open_cd (const char *device_name);

  CdIo_t * cdio_open_am_cd (const char *psz_device,
                            const char *psz_access_mode);

  CdIo_t * cdio_open_cue (const char *cue_name);

  CdIo_t * cdio_open_am_aix (const char *psz_source,
                             const char *psz_access_mode);
  
  CdIo_t * cdio_open_aix (const char *psz_source);
  
  char * cdio_get_default_device_aix(void);

  char **cdio_get_devices_aix(void);
  
  CdIo_t * cdio_open_bsdi (const char *psz_source);
  
  CdIo_t * cdio_open_am_bsdi (const char *psz_source,
                              const char *psz_access_mode);
  
  char * cdio_get_default_device_bsdi(void);

  char **cdio_get_devices_bsdi(void);
  
  CdIo_t * cdio_open_freebsd (const char *paz_psz_source);
  
  CdIo_t * cdio_open_am_freebsd (const char *psz_source,
                                 const char *psz_access_mode);
  
  char * cdio_get_default_device_freebsd(void);

  char **cdio_get_devices_freebsd(void);
  
  CdIo_t * cdio_open_linux (const char *psz_source);

  CdIo_t * cdio_open_am_linux (const char *psz_source,
                               const char *access_mode);

  char * cdio_get_default_device_linux(void);

  char **cdio_get_devices_linux(void);
  
  CdIo_t * cdio_open_solaris (const char *psz_source);
  
  CdIo_t * cdio_open_am_solaris (const char *psz_source, 
                                 const char *psz_access_mode);
  
  char * cdio_get_default_device_solaris(void);
  
  char **cdio_get_devices_solaris(void);
  
  CdIo_t * cdio_open_osx (const char *psz_source);

  CdIo_t * cdio_open_am_osx (const char *psz_source,
                             const char *psz_access_mode);

  char * cdio_get_default_device_osx(void);
  
  char **cdio_get_devices_osx(void);
  
  CdIo_t * cdio_open_win32 (const char *psz_source);
  
  CdIo_t * cdio_open_am_win32 (const char *psz_source,
                               const char *psz_access_mode);
  
  char * cdio_get_default_device_win32(void);

  char **cdio_get_devices_win32(void);
  
  CdIo_t * cdio_open_nrg (const char *psz_source);
  
  CdIo_t * cdio_open_am_nrg (const char *psz_source,
                             const char *psz_access_mode);
  
  char * cdio_get_default_device_nrg(void);

  char **cdio_get_devices_nrg(void);

  char *cdio_is_binfile(const char *bin_name);
  
  char *cdio_is_cuefile(const char *cue_name);
  
  bool cdio_is_nrg(const char *psz_nrg);
  
  bool cdio_is_tocfile(const char *psz_toc);
  
  bool cdio_is_device(const char *psz_source, driver_id_t driver_id);

  driver_return_code_t cdio_set_blocksize ( const CdIo_t *p_cdio, 
                                            int i_blocksize );

  driver_return_code_t cdio_set_speed ( const CdIo_t *p_cdio, 
                                        int i_drive_speed );

  const char * cdio_get_arg (const CdIo_t *p_cdio,  const char key[]);

  driver_return_code_t cdio_set_arg (CdIo_t *p_cdio, const char key[], 
                                     const char value[]);
  
  bool cdio_init(void);
  
#ifdef __cplusplus
}
#endif /* __cplusplus */

extern cdio_drive_cap_misc_t          debug_cdio_drive_cap_misc;
extern cdio_drive_cap_read_t          debug_cdio_drive_cap_read_t;
extern cdio_drive_cap_write_t         debug_drive_cap_write_t;
extern cdio_mmc_hw_len_t              debug_cdio_mmc_hw_len;
extern cdio_src_category_mask_t       debug_cdio_src_category_mask;

#endif /* __CDIO_DEVICE_H__ */

---