device.h

Go to the documentation of this file.

/* -*- c -*-
 
    Copyright (C) 2005-2006, 2008-2013 Rocky Bernstein <rocky@gnu.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 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_DEVICE_H_
#define CDIO_DEVICE_H_
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
#include <cdio/types.h>
#include <cdio/cdio.h>
 
  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_FREEBSD, 
    DRIVER_NETBSD,  
    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_drivers[];
 
  extern const driver_id_t cdio_device_drivers[];
 
  extern const driver_id_t cdio_os_driver;
 
 
  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_OP_MMC_SENSE_DATA = -8, 
  } 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);
 
  const char * cdio_get_driver_name_from_id (driver_id_t driver_id);
 
 
  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_driver (driver_id_t driver_id);
 
  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_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_ */