#!/usr/bin/python # $Id: cdio.py,v 1.6 2008/05/01 16:55:03 karl Exp $ # # Copyright (C) 2006, 2008 Rocky Bernstein # # 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 . """The CD Input and Control library (pycdio) encapsulates CD-ROM reading and control. Applications wishing to be oblivious of the OS- and device-dependent properties of a CD-ROM can use this library.""" import pycdio import types class DeviceException(Exception): """General device or driver exceptions""" class DriverError(DeviceException): pass class DriverUnsupportedError(DeviceException): pass class DriverUninitError(DeviceException): pass class DriverNotPermittedError(DeviceException): pass class DriverBadParameterError(DeviceException): pass class DriverBadPointerError(DeviceException): pass class NoDriverError(DeviceException): pass class TrackError(DeviceException): pass # Note: the keys below match those the names returned by # cdio_get_driver_name() drivers = { 'Unknown' : pycdio.DRIVER_UNKNOWN, 'AIX' : pycdio.DRIVER_AIX, 'aix' : pycdio.DRIVER_AIX, 'BSDI' : pycdio.DRIVER_BSDI, 'bsdi' : pycdio.DRIVER_BSDI, 'FreeBSD' : pycdio.DRIVER_FREEBSD, 'freebsd' : pycdio.DRIVER_FREEBSD, 'GNU/Linux': pycdio.DRIVER_LINUX, 'Solaris' : pycdio.DRIVER_SOLARIS, 'solaris' : pycdio.DRIVER_SOLARIS, 'OS X' : pycdio.DRIVER_OSX, 'WIN32' : pycdio.DRIVER_WIN32, 'CDRDAO' : pycdio.DRIVER_CDRDAO, 'cdrdao' : pycdio.DRIVER_CDRDAO, 'BIN/CUE' : pycdio.DRIVER_BINCUE, 'NRG' : pycdio.DRIVER_NRG, 'Nero' : pycdio.DRIVER_NRG, 'device' : pycdio.DRIVER_DEVICE } read_mode2blocksize = { pycdio.READ_MODE_AUDIO: pycdio.CD_FRAMESIZE_RAW, pycdio.READ_MODE_M1F1: pycdio.M2RAW_SECTOR_SIZE, pycdio.READ_MODE_M1F2: pycdio.CD_FRAMESIZE, pycdio.READ_MODE_M2F1: pycdio.M2RAW_SECTOR_SIZE, pycdio.READ_MODE_M2F2: pycdio.CD_FRAMESIZE } def __possibly_raise_exception__(drc, msg=None): """Raise a Driver Error exception on error as determined by drc""" if drc==pycdio.DRIVER_OP_SUCCESS: return if drc==pycdio.DRIVER_OP_ERROR: raise DriverError if drc==pycdio.DRIVER_OP_UNINIT: raise DriverUninitError if drc==pycdio.DRIVER_OP_UNSUPPORTED: raise DriverUnsupportedError if drc==pycdio.DRIVER_OP_NOT_PERMITTED: raise DriverUnsupportedError if drc==pycdio.DRIVER_OP_BAD_PARAMETER: raise DriverBadParameterError if drc==pycdio.DRIVER_OP_BAD_POINTER: raise DriverBadPointerError if drc==pycdio.DRIVER_OP_NO_DRIVER: raise NoDriverError raise DeviceException('unknown exception %d' % drc) def close_tray(drive=None, driver_id=pycdio.DRIVER_UNKNOWN): """close_tray(drive=None, driver_id=DRIVER_UNKNOWN) -> driver_id close media tray in CD drive if there is a routine to do so. The driver id is returned. A DeviceException is thrown on error.""" drc, found_driver_id = pycdio.close_tray(drive, driver_id) __possibly_raise_exception__(drc) return found_driver_id def get_default_device_driver(driver_id=pycdio.DRIVER_DEVICE): """get_default_device_driver(self, driver_id=pycdio.DRIVER_DEVICE) ->[device, driver] Return a string containing the default CD device if none is specified. if driver_id is DRIVER_UNKNOWN or DRIVER_DEVICE then one set the default device for that. None is returned as the device if we couldn't get a default device.""" result = pycdio.get_default_device_driver(driver_id) if type(result) == type([1,2]): return result return None def get_devices(driver_id=pycdio.DRIVER_UNKNOWN): """ get_devices(driver_id)->[device1, device2, ...] Get an list of device names. """ result = pycdio.get_devices(driver_id) if type(result) == types.StringType: return [result] else: return result def get_devices_ret(driver_id=pycdio.DRIVER_UNKNOWN): """ get_devices_ret(driver_id)->[device1, device2, ... driver_id] Like get_devices, but return the p_driver_id which may be different from the passed-in driver_id if it was pycdio.DRIVER_DEVICE or pycdio.DRIVER_UNKNOWN. The return driver_id may be useful because often one wants to get a drive name and then *open* it afterwards. Giving the driver back facilitates this, and speeds things up for libcdio as well. """ # FIXME: SWIG code is not removing a parameter properly, hence the [1:] # at the end return pycdio.get_devices_ret(driver_id)[1:] def get_devices_with_cap(capabilities, any=False): """ get_devices_with_cap(capabilities, any=False)->[device1, device2...] Get an array of device names in search_devices that have at least the capabilities listed by the capabities parameter. If any is False then every capability listed in the extended portion of capabilities (i.e. not the basic filesystem) must be satisified. If any is True, then if any of the capabilities matches, we call that a success. To find a CD-drive of any type, use the mask pycdio.CDIO_FS_MATCH_ALL. The array of device names is returned or NULL if we couldn't get a default device. It is also possible to return a non NULL but after dereferencing the the value is NULL. This also means nothing was found. """ # FIXME: SWIG code is not removing a parameter properly, hence the [1:] # at the end return pycdio.get_devices_with_cap(capabilities, any)[1:] def get_devices_with_cap_ret(capabilities, any=False): """ get_devices_with_cap(capabilities, any=False) [device1, device2..., driver_id] Like cdio_get_devices_with_cap but we return the driver we found as well. This is because often one wants to search for kind of drive and then *open* it afterwards. Giving the driver back facilitates this, and speeds things up for libcdio as well. """ # FIXME: SWIG code is not removing a parameter properly, hence the [1:] # at the end return pycdio.get_devices_with_cap_ret(capabilities, any)[1:] def have_driver(driver_id): """ have_driver(driver_id) -> bool Return True if we have driver driver_id. """ if type(driver_id)==types.IntType: return pycdio.have_driver(driver_id) elif type(driver_id)==types.StringType and driver_id in drivers: ret = pycdio.have_driver(drivers[driver_id]) if ret == 0: return False if ret == 1: return True raise ValueError('internal error: driver id came back %d' % ret) else: raise ValueError('need either a number or string driver id') def is_binfile(binfile_name): """ is_binfile(binfile_name)->cue_name Determine if binfile_name is the BIN file part of a CDRWIN CD disk image. Return the corresponding CUE file if bin_name is a BIN file or None if not a BIN file. """ return pycdio.is_binfile(binfile_name) def is_cuefile(cuefile_name): """ is_cuefile(cuefile_name)->bin_name Determine if cuefile_name is the CUE file part of a CDRWIN CD disk image. Return the corresponding BIN file if bin_name is a CUE file or None if not a CUE file. """ return pycdio.is_cuefile(cuefile_name) def is_device(source, driver_id=pycdio.DRIVER_UNKNOWN): """ is_device(source, driver_id=pycdio.DRIVER_UNKNOWN)->bool Return True if source refers to a real hardware CD-ROM. """ if driver_id is None: driver_id=pycdio.DRIVER_UNKNOWN return pycdio.is_device(source, driver_id) def is_nrg(nrgfile_name): """ is_nrg(nrgfile_name)->bool Determine if nrgfile_name is a Nero CD disc image """ return pycdio.is_nrg(nrgfile_name) def is_tocfile(tocfile_name): """ is_tocfile(tocfile_name)->bool Determine if tocfile_name is a cdrdao CD disc image """ return pycdio.is_tocfile(tocfile_name) def convert_drive_cap_misc(bitmask): """Convert bit mask for miscellaneous drive properties into a dictionary of drive capabilities""" result={} if bitmask & pycdio.DRIVE_CAP_ERROR: result['DRIVE_CAP_ERROR'] = True if bitmask & pycdio.DRIVE_CAP_UNKNOWN: result['DRIVE_CAP_UNKNOWN'] = True if bitmask & pycdio.DRIVE_CAP_MISC_CLOSE_TRAY: result['DRIVE_CAP_MISC_CLOSE_TRAY'] = True if bitmask & pycdio.DRIVE_CAP_MISC_EJECT: result['DRIVE_CAP_MISC_EJECT'] = True if bitmask & pycdio.DRIVE_CAP_MISC_LOCK: result['DRIVE_CAP_MISC_LOCK'] = True if bitmask & pycdio.DRIVE_CAP_MISC_SELECT_SPEED: result['DRIVE_CAP_MISC_SELECT_SPEED'] = True if bitmask & pycdio.DRIVE_CAP_MISC_SELECT_DISC: result['DRIVE_CAP_MISC_SELECT_DISC'] = True if bitmask & pycdio.DRIVE_CAP_MISC_MULTI_SESSION: result['DRIVE_CAP_MISC_MULTI_SESSION'] = True if bitmask & pycdio.DRIVE_CAP_MISC_MEDIA_CHANGED: result['DRIVE_CAP_MISC_MEDIA_CHANGED'] = True if bitmask & pycdio.DRIVE_CAP_MISC_RESET: result['DRIVE_CAP_MISC_RESET'] = True if bitmask & pycdio.DRIVE_CAP_MISC_FILE: result['DRIVE_CAP_MISC_FILE'] = True return result def convert_drive_cap_read(bitmask): """Convert bit mask for drive read properties into a dictionary of drive capabilities""" result={} if bitmask & pycdio.DRIVE_CAP_READ_AUDIO: result['DRIVE_CAP_READ_AUDIO'] = True if bitmask & pycdio.DRIVE_CAP_READ_CD_DA: result['DRIVE_CAP_READ_CD_DA'] = True if bitmask & pycdio.DRIVE_CAP_READ_CD_G: result['DRIVE_CAP_READ_CD_G'] = True if bitmask & pycdio.DRIVE_CAP_READ_CD_R: result['DRIVE_CAP_READ_CD_R'] = True if bitmask & pycdio.DRIVE_CAP_READ_CD_RW: result['DRIVE_CAP_READ_CD_RW'] = True if bitmask & pycdio.DRIVE_CAP_READ_DVD_R: result['DRIVE_CAP_READ_DVD_R'] = True if bitmask & pycdio.DRIVE_CAP_READ_DVD_PR: result['DRIVE_CAP_READ_DVD_PR'] = True if bitmask & pycdio.DRIVE_CAP_READ_DVD_RAM: result['DRIVE_CAP_READ_DVD_RAM'] = True if bitmask & pycdio.DRIVE_CAP_READ_DVD_ROM: result['DRIVE_CAP_READ_DVD_ROM'] = True if bitmask & pycdio.DRIVE_CAP_READ_DVD_RW: result['DRIVE_CAP_READ_DVD_RW'] = True if bitmask & pycdio.DRIVE_CAP_READ_DVD_RPW: result['DRIVE_CAP_READ_DVD_RPW'] = True if bitmask & pycdio.DRIVE_CAP_READ_C2_ERRS: result['DRIVE_CAP_READ_C2_ERRS'] = True if bitmask & pycdio.DRIVE_CAP_READ_MODE2_FORM1: result['DRIVE_CAP_READ_MODE2_FORM1'] = True if bitmask & pycdio.DRIVE_CAP_READ_MODE2_FORM2: result['DRIVE_CAP_READ_MODE2_FORM2'] = True if bitmask & pycdio.DRIVE_CAP_READ_MCN: result['DRIVE_CAP_READ_MCN'] = True if bitmask & pycdio.DRIVE_CAP_READ_ISRC: result['DRIVE_CAP_READ_ISRC'] = True return result def convert_drive_cap_write(bitmask): """Convert bit mask for drive write properties into a dictionary of drive capabilities""" result={} if bitmask & pycdio.DRIVE_CAP_WRITE_CD_R: result['DRIVE_CAP_WRITE_CD_R'] = True if bitmask & pycdio.DRIVE_CAP_WRITE_CD_RW: result['DRIVE_CAP_WRITE_CD_RW'] = True if bitmask & pycdio.DRIVE_CAP_WRITE_DVD_R: result['DRIVE_CAP_WRITE_DVD_R'] = True if bitmask & pycdio.DRIVE_CAP_WRITE_DVD_PR: result['DRIVE_CAP_WRITE_DVD_PR'] = True if bitmask & pycdio.DRIVE_CAP_WRITE_DVD_RAM: result['DRIVE_CAP_WRITE_DVD_RAM'] = True if bitmask & pycdio.DRIVE_CAP_WRITE_DVD_RW: result['DRIVE_CAP_WRITE_DVD_RW'] = True if bitmask & pycdio.DRIVE_CAP_WRITE_DVD_RPW: result['DRIVE_CAP_WRITE_DVD_RPW'] = True if bitmask & pycdio.DRIVE_CAP_WRITE_MT_RAINIER: result['DRIVE_CAP_WRITE_MT_RAINIER'] = True if bitmask & pycdio.DRIVE_CAP_WRITE_BURN_PROOF: result['DRIVE_CAP_WRITE_BURN_PROOF'] = True return result class Device: """CD Input and control class for discs/devices""" def __init__(self, source=None, driver_id=None, access_mode=None): self.cd = None if source is not None or driver_id is not None: self.open(source, driver_id, access_mode) def audio_pause(self): """ audio_pause(cdio)->status Pause playing CD through analog output. A DeviceError exception may be raised. """ drc=pycdio.audio_pause(self.cd) __possibly_raise_exception__(drc) def audio_play_lsn(self, start_lsn, end_lsn): """ auto_play_lsn(cdio, start_lsn, end_lsn)->status Playing CD through analog output at the given lsn to the ending lsn A DeviceError exception may be raised. """ drc=pycdio.audio_play_lsn(self.cd, start_lsn, end_lsn) __possibly_raise_exception__(drc) def audio_resume(self): """ audio_resume(cdio)->status Resume playing an audio CD through the analog interface. A DeviceError exception may be raised. """ drc=pycdio.audio_resume(self.cd) __possibly_raise_exception__(drc) def audio_stop(self): """ audio_stop(cdio)->status Stop playing an audio CD through the analog interface. A DeviceError exception may be raised. """ drc=pycdio.audio_stop(self.cd) __possibly_raise_exception__(drc) def close(self): """close(self) Free resources associated with p_cdio. Call this when done using using CD reading/control operations for the current device. """ if self.cd is not None: pycdio.close(self.cd) else: print "***No object to close" self.cd=None def eject_media(self): """eject_media(self) Eject media in CD drive if there is a routine to do so. A DeviceError exception may be raised. """ drc=pycdio.eject_media(self.cd) self.cd = None __possibly_raise_exception__(drc) ### FIXME: combine into above by testing if drive is the string ### None versus drive = pycdio.DRIVER_UNKNOWN def eject_media_drive(self, drive=None): """eject_media_drive(self, drive=None) Eject media in CD drive if there is a routine to do so. An exception is thrown on error.""" pycdio.eject_media_drive(drive) def get_arg(self, key): """get_arg(self, key)->string Get the value associatied with key.""" return pycdio.get_arg(self.cd, key) def get_device(self): """get_device(self)->str Get the default CD device. If we haven't initialized a specific device driver), then find a suitable one and return the default device for that. In some situations of drivers or OS's we can't find a CD device if there is no media in it and it is possible for this routine to return None even though there may be a hardware CD-ROM.""" if self.cd is not None: return pycdio.get_arg(self.cd, "source") return pycdio.get_device(self.cd) def get_disc_last_lsn(self): """ get_disc_last_lsn(self)->int Get the LSN of the end of the CD DriverError and IOError may raised on error. """ lsn = pycdio.get_disc_last_lsn(self.cd) if lsn == pycdio.INVALID_LSN: raise DriverError('Invalid LSN returned') return lsn def get_disc_mode(self): """ get_disc_mode(p_cdio) -> str Get disc mode - the kind of CD (CD-DA, CD-ROM mode 1, CD-MIXED, etc. that we've got. The notion of 'CD' is extended a little to include DVD's. """ return pycdio.get_disc_mode(self.cd) def get_drive_cap(self): """ get_drive_cap(self)->(read_cap, write_cap, misc_cap) Get drive capabilities of device. In some situations of drivers or OS's we can't find a CD device if there is no media in it. In this situation capabilities will show up as empty even though there is a hardware CD-ROM. get_drive_cap_dev()->(read_cap, write_cap, misc_cap) Get drive capabilities of device. In some situations of drivers or OS's we can't find a CD device if there is no media in it. In this situation capabilities will show up as empty even though there is a hardware CD-ROM.""" b_read_cap, b_write_cap, b_misc_cap = pycdio.get_drive_cap(self.cd) return (convert_drive_cap_read(b_read_cap), \ convert_drive_cap_write(b_write_cap), \ convert_drive_cap_misc(b_misc_cap)) ### FIXME: combine into above by testing on the type of device. def get_drive_cap_dev(self, device=None): b_read_cap, b_write_cap, b_misc_cap = \ pycdio.get_drive_cap_dev(device) return (convert_drive_cap_read(b_read_cap), \ convert_drive_cap_write(b_write_cap), \ convert_drive_cap_misc(b_misc_cap)) def get_driver_name(self): """ get_driver_name(self)-> string return a string containing the name of the driver in use. An IOError exception is raised on error. """ return pycdio.get_driver_name(self.cd) def get_driver_id(self): """ get_driver_id(self)-> int Return the driver id of the driver in use. if object has not been initialized or is None, return pycdio.DRIVER_UNKNOWN. """ return pycdio.get_driver_id(self.cd) def get_first_track(self): """ get_first_track(self)->Track return a Track object of the first track. None is returned if there was a problem. """ track = pycdio.get_first_track_num(self.cd) if track == pycdio.INVALID_TRACK: return None return Track(self.cd, track) def get_hwinfo(self): """ get_hwinfo(self)->[vendor, model, release] Get the CD-ROM hardware info via a SCSI MMC INQUIRY command. """ return pycdio.get_hwinfo(self.cd) def get_joliet_level(self): """ get_joliet_level(self)->int Return the Joliet level recognized for cdio. This only makes sense for something that has an ISO-9660 filesystem. """ return pycdio.get_joliet_level(self.cd) def get_last_session(self): """get_last_session(self) -> int Get the LSN of the first track of the last session of on the CD. An exception is thrown on error.""" drc, session = pycdio.get_last_session(self.cd) __possibly_raise_exception__(drc) return session def get_last_track(self): """ get_last_track(self)->Track return a Track object of the first track. None is returned if there was a problem. """ track = pycdio.get_last_track_num(self.cd) if track == pycdio.INVALID_TRACK: return None return Track(self.cd, track) def get_mcn(self): """ get_mcn(self) -> str Get the media catalog number (MCN) from the CD. """ return pycdio.get_mcn(self.cd) def get_media_changed(self): """ get_media_changed(self) -> bool Find out if media has changed since the last call. Return True if media has changed since last call. An exception Error is given on error. """ drc = pycdio.get_media_changed(self.cd) if drc == 0: return False if drc == 1: return True __possibly_raise_exception__(drc) raise DeviceException('Unknown return value %d' % drc) def get_num_tracks(self): """ get_num_tracks(self)->int Return the number of tracks on the CD. A TrackError or IOError exception may be raised on error. """ track = pycdio.get_num_tracks(self.cd) if track == pycdio.INVALID_TRACK: raise TrackError('Invalid track returned') return track def get_track(self, track_num): """ get_track(self, track_num)->track Return a track object for the given track number. """ return Track(self.cd, track_num) def get_track_for_lsn(self, lsn): """ get_track_for_lsn(self, lsn)->Track Find the track which contains lsn. None is returned if the lsn outside of the CD or if there was some error. If the lsn is before the pregap of the first track, A track object with a 0 track is returned. Otherwise we return the track that spans the lsn. """ track = pycdio.get_last_track_num(self.cd) if track == pycdio.INVALID_TRACK: return None return Track(self.cd, track) def have_ATAPI(self): """have_ATAPI(self)->bool return True if CD-ROM understand ATAPI commands.""" return pycdio.have_ATAPI(self.cd) def lseek(self, offset, whence): """ lseek(self, offset, whence)->int Reposition read offset Similar to (if not the same as) libc's fseek() cdio is object to get adjested, offset is amount to seek and whence is like corresponding parameter in libc's lseek, e.g. it should be SEEK_SET or SEEK_END. the offset is returned or -1 on error. """ return pycdio.lseek(self.cd, offset, whence) def open(self, source=None, driver_id=pycdio.DRIVER_UNKNOWN, access_mode=None): """ open(self, source=None, driver_id=pycdio.DRIVER_UNKNOWN, access_mode=None) Sets up to read from place specified by source, driver_id and access mode. This should be called before using any other routine except those that act on a CD-ROM drive by name. If None is given as the source, we'll use the default driver device. If None is given as the driver_id, we'll find a suitable device driver. If device object was, previously opened it is closed first. Device is opened so that subsequent operations can be performed. """ if driver_id is None: driver_id=pycdio.DRIVER_UNKNOWN if self.cd is not None: self.close() self.cd = pycdio.open_cd(source, driver_id, access_mode) def read(self, size): """ read(self, size)->[size, data] Reads the next size bytes. Similar to (if not the same as) libc's read() The number of bytes read and the data is returned. A DeviceError exception may be raised. """ size, data = pycdio.read_cd(self.cd, size) __possibly_raise_exception__(size) return [size, data] def read_data_blocks(self, lsn, blocks=1): """ read_data_blocks(blocks, lsn, blocks=1)->[size, data] Reads a number of data sectors (AKA blocks). lsn is sector to read, bytes is the number of bytes. A DeviceError exception may be raised. """ size = pycdio.ISO_BLOCKSIZE*blocks size, data = pycdio.read_data_bytes(self.cd, size, lsn, pycdio.ISO_BLOCKSIZE) if size < 0: __possibly_raise_exception__(size) return [size, data] def read_sectors(self, lsn, read_mode, blocks=1): """ read_sectors(self, lsn, read_mode, blocks=1)->[blocks, data] Reads a number of sectors (AKA blocks). lsn is sector to read, bytes is the number of bytes. If read_mode is pycdio.MODE_AUDIO, the return buffer size will be truncated to multiple of pycdio.CDIO_FRAMESIZE_RAW i_blocks bytes. If read_mode is pycdio.MODE_DATA, buffer will be truncated to a multiple of pycdio.ISO_BLOCKSIZE, pycdio.M1RAW_SECTOR_SIZE or pycdio.M2F2_SECTOR_SIZE bytes depending on what mode the data is in. If read_mode is pycdio.MODE_M2F1, buffer will be truncated to a multiple of pycdio.M2RAW_SECTOR_SIZE bytes. If read_mode is pycdio.MODE_M2F2, the return buffer size will be truncated to a multiple of pycdio.CD_FRAMESIZE bytes. The number of bytes read and the data is returned. A DeviceError exception may be raised. """ try: blocksize = read_mode2blocksize[read_mode] size = blocks * blocksize except KeyError: raise DriverBadParameterError ('Bad read mode %d' % read_mode) size, data = pycdio.read_sectors(self.cd, size, lsn, read_mode) if size < 0: __possibly_raise_exception__(size) blocks = size / blocksize return [blocks, data] def set_blocksize(self, blocksize): """set_blocksize(self, blocksize) Set the blocksize for subsequent reads. An exception is thrown on error. """ drc = pycdio.set_blocksize(self.cd, blocksize) __possibly_raise_exception__(drc) def set_speed(self, speed): """set_speed(self, speed) Set the drive speed. An exception is thrown on error.""" drc = pycdio.set_speed(self.cd, speed) __possibly_raise_exception__(drc) class Track: """CD Input and control track class""" def __init__(self, device, track_num): if type(track_num) != types.IntType: raise TrackError('track number parameter is not an integer') self.track = track_num # See if the device parameter is a string or # a device object. if type(device) == types.StringType: self.device = Device(device) else: test_device=Device() ## FIXME: would like a way to test if device ## is a PySwigObject self.device = device def get_audio_channels(self): """ get_audio_channels(self, track)->int Return number of channels in track: 2 or 4 Not meaningful if track is not an audio track. An exception can be raised on error. """ channels = pycdio.get_track_channels(self.device, self.track) if -2 == channels: raise DriverUnsupportedError elif -1 == channels: raise TrackError else: return channels def get_copy_permit(self): """ get_copy_permit(self, track)->int Return copy protection status on a track. Is this meaningful not an audio track? """ if pycdio.get_track_copy_permit(self.device, self.track): return "OK" else: return "no" def get_format(self): """ get_format(self)->format Get the format (e.g. 'audio', 'mode2', 'mode1') of track. """ return pycdio.get_track_format(self.device, self.track) def get_last_lsn(self): """ get_last_lsn(self)->lsn Return the ending LSN for a track A TrackError or IOError exception may be raised on error. """ lsn = pycdio.get_track_last_lsn(self.device, self.track) if lsn == pycdio.INVALID_LSN: raise TrackError('Invalid LSN returned') return lsn def get_lba(self): """ get_lsn(self)->lba Return the starting LBA for a track A TrackError exception is raised on error. """ lba = pycdio.get_track_lba(self.device, self.track) if lba == pycdio.INVALID_LBA: raise TrackError('Invalid LBA returned') return lba def get_lsn(self): """ get_lsn(self)->lsn Return the starting LSN for a track A TrackError exception is raised on error. """ lsn = pycdio.get_track_lsn(self.device, self.track) if lsn == pycdio.INVALID_LSN: raise TrackError('Invalid LSN returned') return lsn def get_msf(self): """ get_msf(self)->str Return the starting MSF (minutes/secs/frames) for track number track. Track numbers usually start at something greater than 0, usually 1. Returns string of the form mm:ss:ff if all good, or string None on error. """ return pycdio.get_track_msf(self.device, self.track) def get_preemphasis(self): """ get_preemphaisis(self)->result Get linear preemphasis status on an audio track. This is not meaningful if not an audio track? A TrackError exception is raised on error. """ rc = pycdio.get_track_preemphasis(self.device, self.track) if rc == pycdio.TRACK_FLAG_FALSE: return 'none' elif rc == pycdio.TRACK_FLAG_TRUE: return 'preemphasis' elif rc == pycdio.TRACK_FLAG_UNKNOWN: return 'unknown' else: raise TrackError('Invalid return value %d' % d) def get_track_sec_count(self): """ get_track_sec_count(self)->int Get the number of sectors between this track an the next. This includes any pregap sectors before the start of the next track. Track numbers usually start at something greater than 0, usually 1. A TrackError exception is raised on error. """ sec_count = pycdio.get_track_sec_count(self.device, self.track) if sec_count == 0: raise TrackError return sec_count def is_green(self): """ is_track_green(self, track) -> bool 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 """ return pycdio.is_track_green(self.device, self.track) def set_track(self, track_num): """ set_track(self, track_num) Set a new track number. """ self.track = track_num # # Local variables: # mode: Python # End: