def rip_video(index, drive, output):
log.info('ripping video from "{}" to "{}"...'.format(drive, output))
try:
dest = Path(output)
dest.mkdir(exist_ok=True, parents=True)
except IOError:
log.critical("Unable to make directory `{}`.".format(output))
sys.exit(1)
cmd = 'makemkvcon -r mkv disc:{} all {}'.format(
re.sub("[^0-9]", "", index), output)
p = Popen(shlex.split(cmd),
shell=False,
stdout=PIPE,
universal_newlines=True)
while True:
output = p.stdout.readline()
if p.poll() is not None:
break
if output:
log.info(output.strip())
log.info('Exit status: {}'.format(p.poll()))
try:
log.info("Ejecting `{}`".format(drive))
d = cdio.Device(drive)
d.eject_media()
except cdio.DriverUnsupportedError:
log.warning("Eject not supported for `{}`".format(drive))
except cdio.DeviceException:
log.warning("Eject of CD-ROM drive `{}` failed".format(drive))
def test_cdda(self):
"""Test functioning CD-DA"""
global testdir
device = cdio.Device()
cuefile = os.path.join(testdir, "cdda.cue")
device.open(cuefile)
result = device.get_disc_mode()
self.assertEqual(result, 'CD-DA', 'get_disc_mode')
self.assertEqual(device.get_mcn(), '0000010271955', 'get_mcn')
self.assertRaises(cdio.DriverUnsupportedError, device.get_last_session)
# self.assertRaises(IOError, device.get_joliet_level)
result = device.get_num_tracks()
self.assertEqual(result, 1, 'get_num_tracks')
disc_last_lsn = device.get_disc_last_lsn()
self.assertEqual(disc_last_lsn, 302, 'get_disc_last_lsn')
t = device.get_last_track()
self.assertEqual(t.track, 1, 'get_last_track')
self.assertEqual(t.get_last_lsn(), 301, '(track) get_last_lsn')
self.assertEqual(
device.get_track_for_lsn(t.get_last_lsn()).track, t.track)
t = device.get_first_track()
self.assertEqual(t.track, 1, 'get_first_track')
self.assertEqual(t.get_format(), 'audio', 'get_track_format')
device.close()
return
def test_exceptions(self):
"""Test that various routines raise proper exceptions"""
self.device = cdio.Device()
# No CD or or CD image has been set yet. So these fail
try:
lsn = self.device.get_disc_last_lsn()
except IOError:
self.assertEqual(True, True, "get_last_lsn() IO Error")
except cdio.DriverError:
self.assertEqual(True, True, "get_last_lsn() DriverError")
else:
self.assertTrue(False, "get_last_lsn() should raise error")
self.assertRaises(IOError, self.device.get_disc_mode)
try:
track = self.device.get_num_tracks()
except IOError:
self.assertEqual(True, True, "get_num_tracks() IO Error")
except cdio.DriverError:
self.assertEqual(True, True, "get_num_tracks() DriverError")
except cdio.TrackError:
self.assertEqual(True, True, "get_num_tracks() TrackError")
else:
self.assertTrue(False, "get_last_lsn() should raise error")
self.assertRaises(IOError, self.device.get_driver_name)
self.assertRaises(cdio.DriverUninitError,
self.device.get_media_changed)
self.assertRaises(IOError, self.device.open, "***Invalid device***")
return
def getDeviceInfo(path):
try:
import cdio
except ImportError:
return None
device = cdio.Device(path)
_, vendor, model, release = device.get_hwinfo()
return vendor, model, release
def test_device_default(self):
"""Test getting default device"""
result1 = cdio.get_default_device_driver(pycdio.DRIVER_DEVICE)
result2 = cdio.get_default_device_driver()
self.assertEqual(result1, result2,
"get_default_device with/out parameters")
self.device = cdio.Device()
result2 = pycdio.get_device()
if result1 is not None:
self.assertEqual(result1[0], result2)
# Now try getting device using driver that we got back
try:
device = cdio.Device(driver_id=result1[1])
result1 = device.get_device()
self.assertEqual(result1, result2,
"get_default_device using driver name")
except:
pass
return
def test_get_set(self):
"""Test getting and setting CDText"""
tocpath = os.path.join(os.path.dirname(__file__), "cdtext.toc")
device = cdio.Device(tocpath, pycdio.DRIVER_CDRDAO)
text = device.get_cdtext()
self.assertEquals(text.get(pycdio.CDTEXT_FIELD_PERFORMER, 0), "Performer")
self.assertEquals(text.get(pycdio.CDTEXT_FIELD_TITLE, 0), "CD Title")
self.assertEquals(text.get(pycdio.CDTEXT_FIELD_DISCID, 0), "XY12345")
self.assertEquals(text.get(pycdio.CDTEXT_FIELD_PERFORMER, 1), "Performer")
self.assertEquals(text.get(pycdio.CDTEXT_FIELD_TITLE, 1), "Track Title")
def test_read(self):
"""Test functioning of read routines"""
global testdir
cuefile = os.path.join(testdir, "isofs-m1.cue")
device = cdio.Device(source=cuefile)
# Read the ISO Primary Volume descriptor
blocks, data = device.read_sectors(16, pycdio.READ_MODE_M1F1)
self.assertEqual(data[1:6], 'CD001')
self.assertEqual(blocks, 1)
blocks, data = device.read_data_blocks(26)
self.assertEqual(data[6:32], 'GNU GENERAL PUBLIC LICENSE')
return
def test_ops(self):
"""Test running miscellaneous operations
No assumption about the CD-ROM drives is made, so
we're just going to run operations and see that they
don't crash."""
self.device = cdio.Device()
# FIXME: Broken on Darwin?
# self.device.open()
self.device.have_ATAPI()
# FIXME: Broken on Darwin?
# self.device.get_media_changed()
self.assertEqual(True, True, "Test misc operations")
return
def get_disc_info():
# See: https://musicbrainz.org/doc/Disc_ID_Calculation for algorithm
# Some of the stuff described in that doc is already handled by the cdio library. Only
# the leadout adjustment based on the LBA address of data tracks is missing.
d = cdio.Device(driver_id=pycdio.DRIVER_UNKNOWN)
drive_name = d.get_device()
if d.get_disc_mode() != "CD-DA":
raise Exception("Not an audio disc.")
first = pycdio.get_first_track_num(d.cd)
count = d.get_num_tracks()
last = first
tracks = {}
leadout = None
for i in range(first, first + count):
t = d.get_track(i)
if t.get_format() == "audio":
tracks[i] = t.get_lba()
last = i
elif leadout is None:
leadout = t.get_lba() - 11400
if leadout is None:
leadout = d.get_track(pycdio.CDROM_LEADOUT_TRACK).get_lba()
tracks[0] = leadout
data = [
f"{first:02X}",
f"{last:02X}",
]
for i in range(100):
offset = tracks.get(i, 0)
data.append(f"{offset:08X}")
sha = hashlib.sha1()
sha.update("".join(data).encode("utf-8"))
b64 = base64.b64encode(sha.digest()).decode("utf-8")
tbl = str.maketrans("+/=", "._-")
return DiscInfo(
discid=b64.translate(tbl),
track_count=count,
)
def cb_QComboBox(*args):
global drive
global drive_name
selectedName = driveChooseComboBox.currentText()
print("Selected drive named {!r}", selectedName)
if (selectedName == err_no_drive):
drive = None
drive_name = selectedName
else:
try:
drive = cdio.Device(selectedName)
drive_name = selectedName
except OSError:
drive = None
drive_name = 'No drive selected'
cb_refreshDrivesList()
print("Selected drive named {!s} object {!r}".format(drive_name, drive))
enableOrDisableRelevantWidgets()
def __init__(self, device: PathLike = '/dev/cdrom') -> None:
self._dev_path: Path = Path(device).resolve()
self._udev_context: pyudev.Context = pyudev.Context()
self._udev_device: pyudev.Device = pyudev.Devices.from_device_file(
self._udev_context, str(self._dev_path))
self._device: cdio.Device = cdio.Device(str(self._dev_path))
self._cdinfo = None
# sanity checks
try:
self.status()
except OSError: # open failed
if not self.device_name.resolve().is_block_device():
raise CDPlayerException(
f"Device `{self.device_name}' is not a block device")
else:
raise CDPlayerException(
f"Can't open device `{self.device_name}'")
def test_bincue(self):
"""Test functioning of BIN/CUE image routines"""
cuefile = os.path.join(testdir, "cdda.cue")
device = cdio.Device(source=cuefile)
# Test known values of various access parameters:
# access mode, driver name via string and via driver_id
# and cue name
result = device.get_arg("access-mode")
self.assertEqual(
result,
'image',
'get_arg("access_mode")',
)
result = device.get_driver_name()
self.assertEqual(result, 'BIN/CUE', 'get_driver_name')
result = device.get_driver_id()
self.assertEqual(result, pycdio.DRIVER_BINCUE, 'get_driver_id')
result = device.get_arg("cue")
self.assertEqual(result, cuefile, 'get_arg("cue")')
# Test getting is_binfile and is_cuefile
binfile = cdio.is_cuefile(cuefile)
self.assertEqual(True, binfile != None, "is_cuefile(cuefile)")
cuefile2 = cdio.is_binfile(binfile)
# Could check that cuefile2 == cuefile, but some OS's may
# change the case of files
self.assertEqual(True, cuefile2 != None, "is_cuefile(binfile)")
result = cdio.is_tocfile(cuefile)
self.assertEqual(False, result, "is_tocfile(tocfile)")
ok, vendor, model, revision = device.get_hwinfo()
self.assertEqual(True, ok, "get_hwinfo ok")
self.assertEqual('libcdio', vendor, "get_hwinfo vendor")
self.assertEqual('CDRWIN', model, "get_hwinfo model")
result = cdio.is_device(cuefile)
self.assertEqual(False, result, "is_device(tocfile)")
result = device.get_media_changed()
self.assertEqual(False, result, "binfile: get_media_changed")
# There's a bug in libcdio 0.76 that causes these to crash
self.assertRaises(cdio.DriverUnsupportedError, device.set_blocksize,
2048)
self.assertRaises(cdio.DriverUnsupportedError, device.set_speed, 5)
device.close()
return
def test_tocfile(self):
"""Test functioning of cdrdao image routines"""
## TOC reading needs to be done in the directory where the
## TOC/BIN files reside.
olddir = os.getcwd()
os.chdir(testdir)
tocfile = os.path.join(testdir, "cdda.toc")
device = cdio.Device(tocfile, pycdio.DRIVER_CDRDAO)
ok, vendor, model, revision = device.get_hwinfo()
self.assertEqual(True, ok, "get_hwinfo ok")
self.assertEqual('libcdio', vendor, "get_hwinfo vendor")
self.assertEqual('cdrdao', model, "get_hwinfo cdrdao")
# Test known values of various access parameters:
# access mode, driver name via string and via driver_id
# and cue name
result = device.get_arg("access-mode")
self.assertEqual(
result,
'image',
'get_arg("access_mode")',
)
result = device.get_driver_name()
self.assertEqual(result, 'CDRDAO', 'get_driver_name')
result = device.get_driver_id()
self.assertEqual(result, pycdio.DRIVER_CDRDAO, 'get_driver_id')
result = device.get_arg("source")
self.assertEqual(result, tocfile, 'get_arg("source")')
result = device.get_media_changed()
self.assertEqual(False, result, "tocfile: get_media_changed")
# Test getting is_tocfile
result = cdio.is_tocfile(tocfile)
self.assertEqual(True, result, "is_tocfile(tocfile)")
result = cdio.is_nrg(tocfile)
self.assertEqual(False, result, "is_nrgfile(tocfile)")
result = cdio.is_device(tocfile)
self.assertEqual(False, result, "is_device(tocfile)")
self.assertRaises(cdio.DriverUnsupportedError, device.set_blocksize,
2048)
self.assertRaises(cdio.DriverUnsupportedError, device.set_speed, 5)
device.close()
os.chdir(olddir)
return
def current_disc():
"""
Returns the disc information corresponding to the disc
currently insterted into the default USB player.
It contains among other data, the musicbrainz disc id
and the number of tracks.
"""
try:
d = cdio.Device(driver_id=pycdio.DRIVER_UNKNOWN)
except IOError as err:
d = None
if d is not None:
try:
if d.get_disc_mode() == 'CD-DA':
d = libdiscid.read(libdiscid.default_device())
else:
d = None
except:
d = None
return d
def do(self, args):
paths = drive.getAllDevicePaths()
if not paths:
print 'No drives found.'
print 'Create /dev/cdrom if you have a CD drive, '
print 'or install pycdio for better detection.'
return
try:
import cdio
except ImportError:
print 'Install pycdio for vendor/model/release detection.'
return
for path in paths:
device = cdio.Device(path)
ok, vendor, model, release = device.get_hwinfo()
print "drive: %s, vendor: %s, model: %s, release: %s" % (
path, vendor, model, release)
if not paths:
print 'No drives found.'
def do(self, args):
prog = program.Program(record=self.getRootCommand().record)
runner = task.SyncRunner()
def function(r, t):
r.run(t)
# if the device is mounted (data session), unmount it
device = self.parentCommand.options.device
self.stdout.write('Checking device %s\n' % device)
prog.loadDevice(device)
prog.unmountDevice(device)
version = None
# first, read the normal TOC, which is fast
ptoc = common.Persister(self.options.toc_pickle or None)
if not ptoc.object:
t = cdrdao.ReadTOCTask(device=device)
function(runner, t)
version = t.tasks[1].parser.version
from pkg_resources import parse_version as V
# we've built a cdrdao 1.2.3rc2 modified package with the patch
if V(version) < V('1.2.3rc2p1'):
self.stdout.write('''
Warning: cdrdao older than 1.2.3 has a pre-gap length bug.
See http://sourceforge.net/tracker/?func=detail&aid=604751&group_id=2171&atid=102171
''')
ptoc.persist(t.table)
ittoc = ptoc.object
assert ittoc.hasTOC()
# already show us some info based on this
prog.getRipResult(ittoc.getCDDBDiscId())
self.stdout.write("CDDB disc id: %s\n" % ittoc.getCDDBDiscId())
mbdiscid = ittoc.getMusicBrainzDiscId()
self.stdout.write("MusicBrainz disc id %s\n" % mbdiscid)
self.stdout.write("MusicBrainz lookup URL %s\n" %
ittoc.getMusicBrainzSubmitURL())
prog.metadata = prog.getMusicBrainz(ittoc, mbdiscid,
self.options.release)
if not prog.metadata:
# fall back to FreeDB for lookup
cddbid = ittoc.getCDDBValues()
cddbmd = prog.getCDDB(cddbid)
if cddbmd:
self.stdout.write('FreeDB identifies disc as %s\n' % cddbmd)
if not self.options.unknown:
prog.ejectDevice(device)
return -1
# now, read the complete index table, which is slower
itable = prog.getTable(runner, ittoc.getCDDBDiscId(), device)
assert itable.getCDDBDiscId() == ittoc.getCDDBDiscId(), \
"full table's id %s differs from toc id %s" % (
itable.getCDDBDiscId(), ittoc.getCDDBDiscId())
assert itable.getMusicBrainzDiscId() == ittoc.getMusicBrainzDiscId(), \
"full table's mb id %s differs from toc id mb %s" % (
itable.getMusicBrainzDiscId(), ittoc.getMusicBrainzDiscId())
assert itable.getAccurateRipURL() == ittoc.getAccurateRipURL(), \
"full table's AR URL %s differs from toc AR URL %s" % (
itable.getAccurateRipURL(), ittoc.getAccurateRipURL())
prog.outdir = (self.options.output_directory or os.getcwd())
prog.outdir = prog.outdir.decode('utf-8')
# here to avoid import gst eating our options
from morituri.common import encode
profile = encode.PROFILES[self.options.profile]()
# result
prog.result.cdrdao_version = version
prog.result.cdparanoia_version = cdparanoia.ParanoiaVersion()
prog.result.offset = int(self.options.offset)
prog.result.artist = prog.metadata and prog.metadata.artist \
or 'Unknown Artist'
prog.result.title = prog.metadata and prog.metadata.title \
or 'Unknown Title'
# cdio is optional for now
try:
import cdio
_, prog.result.vendor, prog.result.model, prog.result.release = \
cdio.Device(device).get_hwinfo()
except ImportError:
self.stdout.write(
'WARNING: pycdio not installed, cannot identify drive\n')
prog.result.vendor = 'Unknown'
prog.result.model = 'Unknown'
prog.result.release = 'Unknown'
# FIXME: turn this into a method
def ripIfNotRipped(number):
# we can have a previous result
trackResult = prog.result.getTrackResult(number)
if not trackResult:
trackResult = result.TrackResult()
prog.result.tracks.append(trackResult)
path = prog.getPath(prog.outdir, self.options.track_template,
mbdiscid, number) + '.' + profile.extension
trackResult.number = number
assert type(path) is unicode, "%r is not unicode" % path
trackResult.filename = path
if number > 0:
trackResult.pregap = itable.tracks[number - 1].getPregap()
# FIXME: optionally allow overriding reripping
if os.path.exists(path):
self.stdout.write('Verifying track %d of %d: %s\n' %
(number, len(itable.tracks),
os.path.basename(path).encode('utf-8')))
if not prog.verifyTrack(runner, trackResult):
self.stdout.write('Verification failed, reripping...\n')
os.unlink(path)
if not os.path.exists(path):
tries = 0
self.stdout.write('Ripping track %d of %d: %s\n' %
(number, len(itable.tracks),
os.path.basename(path).encode('utf-8')))
while tries < MAX_TRIES:
tries += 1
try:
self.debug('ripIfNotRipped: track %d, try %d', number,
tries)
prog.ripTrack(runner,
trackResult,
offset=int(self.options.offset),
device=self.parentCommand.options.device,
profile=profile,
taglist=prog.getTagList(number),
what='track %d of %d' %
(number, len(itable.tracks)))
break
except Exception, e:
self.debug('Got exception %r on try %d', e, tries)
if tries == MAX_TRIES:
self.error('Giving up on track %d after %d times' %
(number, tries))
if trackResult.testcrc == trackResult.copycrc:
self.stdout.write('Checksums match for track %d\n' %
number)
else:
self.stdout.write(
'ERROR: checksums did not match for track %d\n' %
number)
raise
self.stdout.write('Peak level: %.2f %%\n' %
(math.sqrt(trackResult.peak) * 100.0, ))
self.stdout.write('Rip quality: %.2f %%\n' %
(trackResult.quality * 100.0, ))
# overlay this rip onto the Table
if number == 0:
# HTOA goes on index 0 of track 1
itable.setFile(1, 0, trackResult.filename,
ittoc.getTrackStart(1), number)
else:
itable.setFile(number, 1, trackResult.filename,
ittoc.getTrackLength(number), number)
prog.saveRipResult()
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import os, sys
libdir = os.path.join(os.path.dirname(__file__), '..')
if libdir[-1] != os.path.sep:
libdir += os.path.sep
sys.path.insert(0, libdir)
import pycdio
import cdio
if sys.argv[1:]:
try:
drive_name = sys.argv[1]
d = cdio.Device(drive_name)
except IOError:
print("Problem opening CD-ROM: %s" % drive_name)
sys.exit(1)
else:
try:
d = cdio.Device(driver_id=pycdio.DRIVER_UNKNOWN)
drive_name = d.get_device()
except IOError:
print("Problem finding a CD-ROM")
sys.exit(1)
try:
print("Ejecting CD in drive %s" % drive_name)
d.eject_media()
def do(self):
self.config = config.Config()
self.program = program.Program(self.config,
record=self.options.record,
stdout=sys.stdout)
self.runner = task.SyncRunner()
# if the device is mounted (data session), unmount it
self.device = self.options.device
sys.stdout.write('Checking device %s\n' % self.device)
utils.load_device(self.device)
utils.unmount_device(self.device)
# first, read the normal TOC, which is fast
self.ittoc = self.program.getFastToc(self.runner,
self.options.toc_pickle,
self.device)
# already show us some info based on this
self.program.getRipResult(self.ittoc.getCDDBDiscId())
sys.stdout.write("CDDB disc id: %s\n" % self.ittoc.getCDDBDiscId())
self.mbdiscid = self.ittoc.getMusicBrainzDiscId()
sys.stdout.write("MusicBrainz disc id %s\n" % self.mbdiscid)
sys.stdout.write("MusicBrainz lookup URL %s\n" %
self.ittoc.getMusicBrainzSubmitURL())
self.program.metadata = (
self.program.getMusicBrainz(self.ittoc, self.mbdiscid,
release=self.options.release_id,
country=self.options.country,
prompt=self.options.prompt)
)
if not self.program.metadata:
# fall back to FreeDB for lookup
cddbid = self.ittoc.getCDDBValues()
cddbmd = self.program.getCDDB(cddbid)
if cddbmd:
sys.stdout.write('FreeDB identifies disc as %s\n' % cddbmd)
# also used by rip cd info
if not getattr(self.options, 'unknown', False):
logger.critical("unable to retrieve disc metadata, "
"--unknown not passed")
return -1
self.program.result.isCdr = cdrdao.DetectCdr(self.device)
if (self.program.result.isCdr and
not getattr(self.options, 'cdr', False)):
logger.critical("inserted disc seems to be a CD-R, "
"--cdr not passed")
return -1
# now, read the complete index table, which is slower
self.itable = self.program.getTable(self.runner,
self.ittoc.getCDDBDiscId(),
self.ittoc.getMusicBrainzDiscId(),
self.device, self.options.offset)
assert self.itable.getCDDBDiscId() == self.ittoc.getCDDBDiscId(), \
"full table's id %s differs from toc id %s" % (
self.itable.getCDDBDiscId(), self.ittoc.getCDDBDiscId())
assert self.itable.getMusicBrainzDiscId() == \
self.ittoc.getMusicBrainzDiscId(), \
"full table's mb id %s differs from toc id mb %s" % (
self.itable.getMusicBrainzDiscId(),
self.ittoc.getMusicBrainzDiscId())
assert self.itable.accuraterip_path() == \
self.ittoc.accuraterip_path(), \
"full table's AR URL %s differs from toc AR URL %s" % (
self.itable.accuraterip_url(), self.ittoc.accuraterip_url())
if self.program.metadata:
self.program.metadata.discid = self.ittoc.getMusicBrainzDiscId()
# result
self.program.result.cdrdaoVersion = cdrdao.getCDRDAOVersion()
self.program.result.cdparanoiaVersion = \
cdparanoia.getCdParanoiaVersion()
info = drive.getDeviceInfo(self.device)
if info:
try:
self.program.result.cdparanoiaDefeatsCache = \
self.config.getDefeatsCache(*info)
except KeyError as e:
logger.debug('Got key error: %r' % (e, ))
self.program.result.artist = self.program.metadata \
and self.program.metadata.artist \
or 'Unknown Artist'
self.program.result.title = self.program.metadata \
and self.program.metadata.title \
or 'Unknown Title'
_, self.program.result.vendor, self.program.result.model, \
self.program.result.release = \
cdio.Device(self.device).get_hwinfo()
self.doCommand()
if self.options.eject in ('success', 'always'):
utils.eject_device(self.device)
def info_from_cdtext(disc):
"""
Extracts metadata from the CDText information if
it exists on the `disc`. `None` iis returned if
no CDText information is stored on the disc.
"""
try:
d = cdio.Device(driver_id=pycdio.DRIVER_UNKNOWN)
except IOError as err:
print("Problem finding a CD-ROM")
raise err
if d.get_disc_mode() != 'CD-DA':
raise NotCDDAError()
t = d.get_cdtext()
# Build the dictionnary for album info
album_info = {
pycdio.cdtext_field2str(i): t.get(i, 0)
for i in range(pycdio.MIN_CDTEXT_FIELD, pycdio.MAX_CDTEXT_FIELDS)
if t.get(i, 0) is not None
}
if "TITLE" in album_info:
disc_info = {"source": "CDText", "album": album_info["TITLE"]}
if "PERFORMER" in album_info:
disc_info["albumartist"] = album_info["PERFORMER"]
elif "COMPOSER" in album_info:
disc_info["albumartist"] = album_info["COMPOSER"]
elif "SONGWRITER" in album_info:
disc_info["albumartist"] = album_info["SONGWRITER"]
else:
return None
disc_info["discid"] = disc.id
disc_info["tracks"] = {}
tracks_info = disc_info["tracks"]
for track in itrack(disc):
track_info = {
pycdio.cdtext_field2str(i): t.get(i, int(track))
for i in range(pycdio.MIN_CDTEXT_FIELD, pycdio.MAX_CDTEXT_FIELDS)
if t.get(i, int(track)) is not None
}
tracks_info[track] = {
"track": track,
"album": disc_info["album"],
"name": "Track {}".format(track),
"title":
track_info["TITLE"] if "TITLE" in track_info else "Unknown"
}
if "GENRE" in track_info:
tracks_info[track]["genre"] = track_info["GENRE"]
if "COMPOSER" in track_info:
tracks_info[track]["composer"] = track_info["COMPOSER"]
if "ARRANGER" in track_info:
tracks_info[track]["conductor"] = track_info["ARRANGER"]
if "PERFORMER" in track_info:
tracks_info[track]["artist"] = track_info["PERFORMER"]
elif "SONGWRITER" in track_info:
tracks_info[track]["artist"] = track_info["SONGWRITER"]
elif "COMPOSER" in track_info:
tracks_info[track]["artist"] = track_info["COMPOSER"]
else:
tracks_info[track]["artist"] = "Unknown"
return disc_info
pass
print(s)
s = ''
i += 2
pass
print('')
return
opts, argv, read_mode = process_options()
# While sys.argv[0] is a program name and sys.argv[1] the first
# option, argv[0] is the first unprocessed option -- roughly
# the equivalent of sys.argv[1].
if argv[0:]:
try:
d = cdio.Device(argv[0])
except IOError:
print("Problem opening CD-ROM: %s" % argv[0])
sys.exit(1)
else:
try:
d = cdio.Device(driver_id=pycdio.DRIVER_UNKNOWN)
except IOError:
print("Problem finding a CD-ROM")
sys.exit(1)
## All this setup just to issue this one of these commands.
if read_mode == None:
blocks, data = d.read_data_blocks(opts.start, opts.number)
else:
blocks, data = d.read_sectors(opts.start, read_mode, opts.number)
cdName = '/dev/cdrom' #variable para localizacion de cdrom default: /dev/cdrom
format = 'wav' #variable para formato de salida default: wav
isTrackNum = False #variable para checkear si se aclaro un numero de track
faso_array = [] #array para guardar los diferentes tracks
help = """ Parameters:
-cd changes what cdrom cdriper uses. eg: -cd /dev/cdrom
-"num" selects a single track from the cd. eg: -2 (only converts second track)
-open opens cdrom
-format selects the output file format default: wav. eg: -format flac
-h displays help.
-? displays help.""" #string con toda la info de ayuda
d = cdio.Device(cdName) #Variable usada luego para abrir el cd
faso = str(sys.argv) #se chequea si hay argumentos
argument = faso.find('-') #se busca - para señalizar un comando
if argument != -1: #si hay un argumentos
faso = faso[argument:]
firstLine = faso.find("-")
secondLine = faso.rfind("-")
while True: #se comienza un loop para checkear argumentos
firstLine = faso.find("-")
secondLine = faso.rfind("-") # se checkea si hay mas de 1 argumento
def eject():
try:
d = cdio.Device(driver_id=pycdio.DRIVER_UNKNOWN)
d.eject_media()
except:
print_error()
class _CD(logcommand.LogCommand):
"""
@type program: L{program.Program}
@ivar eject: whether to eject the drive after completing
"""
eject = True
def addOptions(self):
# FIXME: have a cache of these pickles somewhere
self.parser.add_option(
'-T',
'--toc-pickle',
action="store",
dest="toc_pickle",
help="pickle to use for reading and writing the TOC")
self.parser.add_option(
'-R',
'--release-id',
action="store",
dest="release_id",
help="MusicBrainz release id to match to (if there are multiple)")
self.parser.add_option(
'-p',
'--prompt',
action="store_true",
dest="prompt",
help="Prompt if there are multiple matching releases")
self.parser.add_option('-c',
'--country',
action="store",
dest="country",
help="Filter releases by country")
def do(self, args):
self.program = program.Program(self.getRootCommand().config,
record=self.getRootCommand().record,
stdout=self.stdout)
self.runner = task.SyncRunner()
# if the device is mounted (data session), unmount it
self.device = self.parentCommand.options.device
self.stdout.write('Checking device %s\n' % self.device)
self.program.loadDevice(self.device)
self.program.unmountDevice(self.device)
# first, read the normal TOC, which is fast
self.ittoc = self.program.getFastToc(self.runner,
self.options.toc_pickle,
self.device)
# already show us some info based on this
self.program.getRipResult(self.ittoc.getCDDBDiscId())
self.stdout.write("CDDB disc id: %s\n" % self.ittoc.getCDDBDiscId())
self.mbdiscid = self.ittoc.getMusicBrainzDiscId()
self.stdout.write("MusicBrainz disc id %s\n" % self.mbdiscid)
self.stdout.write("MusicBrainz lookup URL %s\n" %
self.ittoc.getMusicBrainzSubmitURL())
self.program.metadata = self.program.getMusicBrainz(
self.ittoc,
self.mbdiscid,
release=self.options.release_id,
country=self.options.country,
prompt=self.options.prompt)
if not self.program.metadata:
# fall back to FreeDB for lookup
cddbid = self.ittoc.getCDDBValues()
cddbmd = self.program.getCDDB(cddbid)
if cddbmd:
self.stdout.write('FreeDB identifies disc as %s\n' % cddbmd)
# also used by rip cd info
if not getattr(self.options, 'unknown', False):
if self.eject:
self.program.ejectDevice(self.device)
return -1
# Hackish fix for broken commit
offset = 0
info = drive.getDeviceInfo(self.parentCommand.options.device)
if info:
try:
offset = self.getRootCommand().config.getReadOffset(*info)
except KeyError:
pass
# now, read the complete index table, which is slower
self.itable = self.program.getTable(self.runner,
self.ittoc.getCDDBDiscId(),
self.ittoc.getMusicBrainzDiscId(),
self.device, offset)
assert self.itable.getCDDBDiscId() == self.ittoc.getCDDBDiscId(), \
"full table's id %s differs from toc id %s" % (
self.itable.getCDDBDiscId(), self.ittoc.getCDDBDiscId())
assert self.itable.getMusicBrainzDiscId() == \
self.ittoc.getMusicBrainzDiscId(), \
"full table's mb id %s differs from toc id mb %s" % (
self.itable.getMusicBrainzDiscId(),
self.ittoc.getMusicBrainzDiscId())
assert self.itable.getAccurateRipURL() == \
self.ittoc.getAccurateRipURL(), \
"full table's AR URL %s differs from toc AR URL %s" % (
self.itable.getAccurateRipURL(), self.ittoc.getAccurateRipURL())
if self.program.metadata:
self.program.metadata.discid = self.ittoc.getMusicBrainzDiscId()
# result
self.program.result.cdrdaoVersion = cdrdao.getCDRDAOVersion()
self.program.result.cdparanoiaVersion = \
cdparanoia.getCdParanoiaVersion()
info = drive.getDeviceInfo(self.parentCommand.options.device)
if info:
try:
self.program.result.cdparanoiaDefeatsCache = \
self.getRootCommand().config.getDefeatsCache(*info)
except KeyError, e:
self.debug('Got key error: %r' % (e, ))
self.program.result.artist = self.program.metadata \
and self.program.metadata.artist \
or 'Unknown Artist'
self.program.result.title = self.program.metadata \
and self.program.metadata.title \
or 'Unknown Title'
try:
import cdio
_, self.program.result.vendor, self.program.result.model, \
self.program.result.release = \
cdio.Device(self.device).get_hwinfo()
except ImportError:
raise ImportError("Pycdio module import failed.\n"
"This is a hard dependency: if not "
"available please install it")
self.doCommand()
if self.eject:
self.program.ejectDevice(self.device)
def do(self):
self.config = config.Config()
self.program = program.Program(self.config,
record=self.options.record)
self.runner = task.SyncRunner()
# if the device is mounted (data session), unmount it
self.device = self.options.device
logger.info('checking device %s', self.device)
if self.options.drive_auto_close is True:
utils.load_device(self.device)
utils.unmount_device(self.device)
# Exit and inform the user if there's no CD in the disk drive
if drive.get_cdrom_drive_status(self.device) == 1: # rc 1 -> no disc
raise OSError("no CD detected, please insert one and retry")
# first, read the normal TOC, which is fast
self.ittoc = self.program.getFastToc(self.runner, self.device)
# already show us some info based on this
self.program.getRipResult()
print("CDDB disc id: %s" % self.ittoc.getCDDBDiscId())
self.mbdiscid = self.ittoc.getMusicBrainzDiscId()
print("MusicBrainz disc id %s" % self.mbdiscid)
print("MusicBrainz lookup URL %s" %
self.ittoc.getMusicBrainzSubmitURL())
self.program.metadata = (
self.program.getMusicBrainz(self.ittoc, self.mbdiscid,
release=self.options.release_id,
country=self.options.country,
prompt=self.options.prompt)
)
if not self.program.metadata:
# fall back to FreeDB for lookup
cddbid = self.ittoc.getCDDBValues()
cddbmd = self.program.getCDDB(cddbid)
if cddbmd:
logger.info('FreeDB identifies disc as %s', cddbmd)
# also used by rip cd info
if not getattr(self.options, 'unknown', False):
logger.critical("unable to retrieve disc metadata, "
"--unknown argument not passed")
return -1
self.program.result.isCdr = cdrdao.DetectCdr(self.device)
if (self.program.result.isCdr and
not getattr(self.options, 'cdr', False)):
logger.critical("inserted disc seems to be a CD-R, "
"--cdr not passed")
return -1
# Change working directory before cdrdao's task
if getattr(self.options, 'working_directory', False):
os.chdir(os.path.expanduser(self.options.working_directory))
if hasattr(self.options, 'output_directory'):
out_bpath = self.options.output_directory
# Needed to preserve cdrdao's tocfile
out_fpath = self.program.getPath(out_bpath,
self.options.disc_template,
self.mbdiscid,
self.program.metadata)
else:
out_fpath = None
# now, read the complete index table, which is slower
offset = getattr(self.options, 'offset', 0)
self.itable = self.program.getTable(self.runner,
self.ittoc.getCDDBDiscId(),
self.ittoc.getMusicBrainzDiscId(),
self.device, offset, out_fpath)
assert self.itable.getCDDBDiscId() == self.ittoc.getCDDBDiscId(), \
"full table's id %s differs from toc id %s" % (
self.itable.getCDDBDiscId(), self.ittoc.getCDDBDiscId())
assert self.itable.getMusicBrainzDiscId() == \
self.ittoc.getMusicBrainzDiscId(), \
"full table's mb id %s differs from toc id mb %s" % (
self.itable.getMusicBrainzDiscId(),
self.ittoc.getMusicBrainzDiscId())
if self.program.metadata:
self.program.metadata.discid = self.ittoc.getMusicBrainzDiscId()
# result
self.program.result.cdrdaoVersion = cdrdao.version()
self.program.result.cdparanoiaVersion = \
cdparanoia.getCdParanoiaVersion()
info = drive.getDeviceInfo(self.device)
if info:
try:
self.program.result.cdparanoiaDefeatsCache = \
self.config.getDefeatsCache(*info)
except KeyError as e:
logger.debug('got key error: %r', (e, ))
self.program.result.artist = self.program.metadata \
and self.program.metadata.artist \
or 'Unknown Artist'
self.program.result.title = self.program.metadata \
and self.program.metadata.releaseTitle \
or 'Unknown Title'
_, self.program.result.vendor, self.program.result.model, \
self.program.result.release = \
cdio.Device(self.device).get_hwinfo()
self.program.result.metadata = self.program.metadata
ret = self.doCommand()
if (self.options.eject == 'success' and self.eject or
self.options.eject == 'always'):
utils.eject_device(self.device)
return ret
for t in range(i_first_track, i_tracks + i_first_track):
for i in range(pycdio.MIN_CDTEXT_FIELD, pycdio.MAX_CDTEXT_FIELDS):
value = cdt.get(i, t)
# value can be empty but exist, compared to NULL values
if value is not None:
print("\t%s: %s" % (pycdio.cdtext_field2str(i), value))
pass
pass
pass
return
if sys.argv[1:]:
try:
drive_name = sys.argv[1]
d = cdio.Device(sys.argv[1])
except IOError:
print("Problem opening CD-ROM: %s" % drive_name)
sys.exit(1)
else:
try:
d = cdio.Device(driver_id=pycdio.DRIVER_UNKNOWN)
drive_name = d.get_device()
except IOError:
print("Problem finding a CD-ROM")
sys.exit(1)
if pycdio.VERSION_NUM < 83:
i_tracks = d.get_num_tracks()
i_first_track = pycdio.get_first_track_num(d.cd)
print_cdtext_track_info_old(d, 0, 'CD-Text for Disc:')
