device.h

Go to the documentation of this file.

/* -*- c -*-
 
    Copyright (C) 2005-2006, 2008-2013, 2025-2026 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/cdio.h>
#include <cdio/types.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);

int cdio_get_device_fd(CdIo_t *p_cdio);
 
#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_ */