def do(self, args):
try:
url = args[0]
except IndexError:
self.stdout.write('Please specify an accuraterip URL.\n')
return 3
cache = accurip.AccuCache()
responses = cache.retrieve(url)
count = responses[0].trackCount
self.stdout.write("Found %d responses for %d tracks\n\n" %
(len(responses), count))
for (i, r) in enumerate(responses):
if r.trackCount != count:
self.stdout.write(
"Warning: response %d has %d tracks instead of %d\n" %
(i, r.trackCount, count))
# checksum and confidence by track
for track in range(count):
self.stdout.write("Track %d:\n" % (track + 1))
checksums = {}
for (i, r) in enumerate(responses):
if r.trackCount != count:
continue
assert len(r.checksums) == r.trackCount
assert len(r.confidences) == r.trackCount
entry = {}
entry["confidence"] = r.confidences[track]
entry["response"] = i + 1
checksum = r.checksums[track]
if checksum in checksums:
checksums[checksum].append(entry)
else:
checksums[checksum] = [
entry,
]
# now sort track results in checksum by highest confidence
sortedChecksums = []
for checksum, entries in checksums.items():
highest = max(d['confidence'] for d in entries)
sortedChecksums.append((highest, checksum))
sortedChecksums.sort()
sortedChecksums.reverse()
for highest, checksum in sortedChecksums:
self.stdout.write(" %d result(s) for checksum %s: %s\n" %
(len(checksums[checksum]), checksum,
str(checksums[checksum])))
def do(self, args):
prog = program.Program(self.getRootCommand().config)
runner = task.SyncRunner()
cache = accurip.AccuCache()
for arg in args:
arg = arg.decode('utf-8')
cueImage = image.Image(arg)
cueImage.setup(runner)
url = cueImage.table.getAccurateRipURL()
responses = cache.retrieve(url)
# FIXME: this feels like we're poking at internals.
prog.cuePath = arg
prog.result = result.RipResult()
for track in cueImage.table.tracks:
tr = result.TrackResult()
tr.number = track.number
prog.result.tracks.append(tr)
prog.verifyImage(runner, responses)
print "\n".join(prog.getAccurateRipResults()) + "\n"
class Rip(_CD):
summary = "rip CD"
# see morituri.common.program.Program.getPath for expansion
description = """
Rips a CD.
%s
Paths to track files referenced in .cue and .m3u files will be made
relative to the directory of the disc files.
All files will be created relative to the given output directory.
Log files will log the path to tracks relative to this directory.
""" % rcommon.TEMPLATE_DESCRIPTION
def addOptions(self):
_CD.addOptions(self)
loggers = result.getLoggers().keys()
self.parser.add_option('-L',
'--logger',
action="store",
dest="logger",
default='morituri',
help="logger to use "
"(default '%default', choose from '" +
"', '".join(loggers) + "')")
# FIXME: get from config
self.parser.add_option(
'-o',
'--offset',
action="store",
dest="offset",
help="sample read offset (defaults to configured value, or 0)")
self.parser.add_option(
'-x',
'--force-overread',
action="store_true",
dest="overread",
help="Force overreading into the lead-out portion of the disc. "
"Works only if the patched cdparanoia package is installed "
"and the drive supports this feature. "
"The default value is: %default",
default=False)
self.parser.add_option(
'-O',
'--output-directory',
action="store",
dest="output_directory",
help="output directory; will be included in file paths in result "
"files "
"(defaults to absolute path to current directory; set to "
"empty if you want paths to be relative instead; "
"configured value: %default) ")
self.parser.add_option(
'-W',
'--working-directory',
action="store",
dest="working_directory",
help="working directory; morituri will change to this directory "
"and files will be created relative to it when not absolute "
"(configured value: %default) ")
rcommon.addTemplate(self)
default = 'flac'
# here to avoid import gst eating our options
from morituri.common import encode
self.parser.add_option(
'',
'--profile',
action="store",
dest="profile",
help="profile for encoding (default '%%default', choices '%s')" %
("', '".join(encode.PROFILES.keys())),
default=default)
self.parser.add_option(
'-U',
'--unknown',
action="store_true",
dest="unknown",
help="whether to continue ripping if the CD is unknown (%default)",
default=False)
def handleOptions(self, options):
options.track_template = options.track_template.decode('utf-8')
options.disc_template = options.disc_template.decode('utf-8')
if options.offset is None:
info = drive.getDeviceInfo(self.parentCommand.options.device)
if info:
try:
options.offset = self.getRootCommand(
).config.getReadOffset(*info)
self.stdout.write("Using configured read offset %d\n" %
options.offset)
except KeyError:
pass
if options.offset is None:
raise ValueError("Drive offset is unconfigured.\n"
"Please install pycdio and run 'rip offset "
"find' to detect your drive's offset or set it "
"manually in the configuration file. It can "
"also be specified at runtime using the "
"'--offset=value' argument")
if self.options.output_directory is None:
self.options.output_directory = os.getcwd()
else:
self.options.output_directory = os.path.expanduser(
self.options.output_directory)
if self.options.working_directory is not None:
self.options.working_directory = os.path.expanduser(
self.options.working_directory)
if self.options.logger:
try:
klazz = result.getLoggers()[self.options.logger]
except KeyError:
self.stderr.write("No logger named %s found!\n" %
(self.options.logger))
raise command.CommandError("No logger named %s" %
self.options.logger)
self.logger = klazz()
def doCommand(self):
# here to avoid import gst eating our options
from morituri.common import encode
profile = encode.PROFILES[self.options.profile]()
self.program.result.profileName = profile.name
self.program.result.profilePipeline = profile.pipeline
elementFactory = profile.pipeline.split(' ')[0]
self.program.result.gstreamerVersion = gstreamer.gstreamerVersion()
self.program.result.gstPythonVersion = gstreamer.gstPythonVersion()
self.program.result.encoderVersion = gstreamer.elementFactoryVersion(
elementFactory)
self.program.setWorkingDirectory(self.options.working_directory)
self.program.outdir = self.options.output_directory.decode('utf-8')
self.program.result.offset = int(self.options.offset)
self.program.result.overread = self.options.overread
self.program.result.logger = self.options.logger
### write disc files
disambiguate = False
while True:
discName = self.program.getPath(self.program.outdir,
self.options.disc_template,
self.mbdiscid,
0,
profile=profile,
disambiguate=disambiguate)
dirname = os.path.dirname(discName)
if os.path.exists(dirname):
self.stdout.write("Output directory %s already exists\n" %
dirname.encode('utf-8'))
logs = glob.glob(os.path.join(dirname, '*.log'))
if logs:
self.stdout.write(
"Output directory %s is a finished rip\n" %
dirname.encode('utf-8'))
if not disambiguate:
disambiguate = True
continue
return
else:
break
else:
self.stdout.write("Creating output directory %s\n" %
dirname.encode('utf-8'))
os.makedirs(dirname)
break
# FIXME: say when we're continuing a rip
# FIXME: disambiguate if the pre-existing rip is different
# FIXME: turn this into a method
def ripIfNotRipped(number):
self.debug('ripIfNotRipped for track %d' % number)
# we can have a previous result
trackResult = self.program.result.getTrackResult(number)
if not trackResult:
trackResult = result.TrackResult()
self.program.result.tracks.append(trackResult)
else:
self.debug('ripIfNotRipped have trackresult, path %r' %
trackResult.filename)
path = self.program.getPath(self.program.outdir,
self.options.track_template,
self.mbdiscid, number,
profile=profile, disambiguate=disambiguate) \
+ '.' + profile.extension
self.debug('ripIfNotRipped: path %r' % path)
trackResult.number = number
assert type(path) is unicode, "%r is not unicode" % path
trackResult.filename = path
if number > 0:
trackResult.pregap = self.itable.tracks[number - 1].getPregap()
# FIXME: optionally allow overriding reripping
if os.path.exists(path):
if path != trackResult.filename:
# the path is different (different name/template ?)
# but we can copy it
self.debug('previous result %r, expected %r' %
(trackResult.filename, path))
self.stdout.write('Verifying track %d of %d: %s\n' %
(number, len(self.itable.tracks),
os.path.basename(path).encode('utf-8')))
if not self.program.verifyTrack(self.runner, trackResult):
self.stdout.write('Verification failed, reripping...\n')
os.unlink(path)
if not os.path.exists(path):
self.debug('path %r does not exist, ripping...' % path)
tries = 0
# we reset durations for test and copy here
trackResult.testduration = 0.0
trackResult.copyduration = 0.0
extra = ""
while tries < MAX_TRIES:
tries += 1
if tries > 1:
extra = " (try %d)" % tries
self.stdout.write('Ripping track %d of %d%s: %s\n' %
(number, len(self.itable.tracks), extra,
os.path.basename(path).encode('utf-8')))
try:
self.debug('ripIfNotRipped: track %d, try %d', number,
tries)
self.program.ripTrack(
self.runner,
trackResult,
offset=int(self.options.offset),
device=self.parentCommand.options.device,
profile=profile,
taglist=self.program.getTagList(number),
overread=self.options.overread,
what='track %d of %d%s' %
(number, len(self.itable.tracks), extra))
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))
raise RuntimeError(
"track can't be ripped. "
"Rip attempts number is equal to 'MAX_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: {:.2%} \n'.format(
trackResult.peak))
self.stdout.write('Rip quality: {:.2%}\n'.format(
trackResult.quality))
# overlay this rip onto the Table
if number == 0:
# HTOA goes on index 0 of track 1
# ignore silence in PREGAP
if trackResult.peak <= SILENT:
self.debug(
'HTOA peak %r is below SILENT threshold, disregarding',
trackResult.peak)
self.itable.setFile(1, 0, None,
self.ittoc.getTrackStart(1), number)
self.debug('Unlinking %r', trackResult.filename)
os.unlink(trackResult.filename)
trackResult.filename = None
self.stdout.write(
'HTOA discarded, contains digital silence\n')
else:
self.itable.setFile(1, 0, trackResult.filename,
self.ittoc.getTrackStart(1), number)
else:
self.itable.setFile(number, 1, trackResult.filename,
self.ittoc.getTrackLength(number), number)
self.program.saveRipResult()
# check for hidden track one audio
htoapath = None
htoa = self.program.getHTOA()
if htoa:
start, stop = htoa
self.stdout.write(
'Found Hidden Track One Audio from frame %d to %d\n' %
(start, stop))
# rip it
ripIfNotRipped(0)
htoapath = self.program.result.tracks[0].filename
for i, track in enumerate(self.itable.tracks):
# FIXME: rip data tracks differently
if not track.audio:
self.stdout.write(
'WARNING: skipping data track %d, not implemented\n' %
(i + 1, ))
# FIXME: make it work for now
track.indexes[1].relative = 0
continue
ripIfNotRipped(i + 1)
### write disc files
discName = self.program.getPath(self.program.outdir,
self.options.disc_template,
self.mbdiscid,
0,
profile=profile,
disambiguate=disambiguate)
dirname = os.path.dirname(discName)
if not os.path.exists(dirname):
os.makedirs(dirname)
self.debug('writing cue file for %r', discName)
self.program.writeCue(discName)
# write .m3u file
self.debug('writing m3u file for %r', discName)
m3uPath = u'%s.m3u' % discName
handle = open(m3uPath, 'w')
handle.write(u'#EXTM3U\n')
def writeFile(handle, path, length):
targetPath = common.getRelativePath(path, m3uPath)
u = u'#EXTINF:%d,%s\n' % (length, targetPath)
handle.write(u.encode('utf-8'))
u = '%s\n' % targetPath
handle.write(u.encode('utf-8'))
if htoapath:
writeFile(handle, htoapath,
self.itable.getTrackStart(1) / common.FRAMES_PER_SECOND)
for i, track in enumerate(self.itable.tracks):
if not track.audio:
continue
path = self.program.getPath(
self.program.outdir,
self.options.track_template,
self.mbdiscid,
i + 1,
profile=profile,
disambiguate=disambiguate) + '.' + profile.extension
writeFile(
handle, path,
self.itable.getTrackLength(i + 1) / common.FRAMES_PER_SECOND)
handle.close()
# verify using accuraterip
url = self.ittoc.getAccurateRipURL()
self.stdout.write("AccurateRip URL %s\n" % url)
accucache = accurip.AccuCache()
try:
responses = accucache.retrieve(url)
except urllib2.URLError, e:
if isinstance(e.args[0], socket.gaierror):
if e.args[0].errno == -2:
self.stdout.write("Warning: network error: %r\n" %
(e.args[0], ))
responses = None
else:
raise
else:
raise
class Rip(logcommand.LogCommand):
summary = "rip CD"
description = """
Rips a CD.
Tracks are named according to the track template, filling in the variables
and expanding the file extension. Variables are:
- %t: track number
- %a: track artist
- %n: track title
- %s: track sort name
Disc files (.cue, .log, .m3u) are named according to the disc template,
filling in the variables and expanding the file extension. Variables are:
- %A: album artist
- %S: album sort name
- %d: disc title
"""
def addOptions(self):
# FIXME: get from config
default = 0
self.parser.add_option('-o',
'--offset',
action="store",
dest="offset",
help="sample read offset (defaults to %d)" %
default,
default=default)
self.parser.add_option(
'-O',
'--output-directory',
action="store",
dest="output_directory",
help="output directory (defaults to current directory)")
# 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",
default=default)
# FIXME: get from config
self.parser.add_option(
'',
'--track-template',
action="store",
dest="track_template",
help="template for track file naming (default %default)",
default=DEFAULT_TRACK_TEMPLATE)
self.parser.add_option(
'',
'--disc-template',
action="store",
dest="disc_template",
help="template for disc file naming (default %default)",
default=DEFAULT_DISC_TEMPLATE)
self.parser.add_option(
'-R',
'--release-id',
action="store",
dest="release",
help="MusicBrainz release id to match to (if there are multiple)")
default = 'flac'
# here to avoid import gst eating our options
from morituri.common import encode
self.parser.add_option(
'',
'--profile',
action="store",
dest="profile",
help="profile for encoding (default '%s', choices '%s')" %
(default, "', '".join(encode.PROFILES.keys())),
default=default)
self.parser.add_option(
'-U',
'--unknown',
action="store_true",
dest="unknown",
help="whether to continue ripping if the CD is unknown (%default)",
default=False)
def handleOptions(self, options):
options.track_template = options.track_template.decode('utf-8')
options.disc_template = options.disc_template.decode('utf-8')
slashCountT = len(options.track_template.split(os.path.sep))
slashCountD = len(options.disc_template.split(os.path.sep))
if slashCountT != slashCountD:
raise command.CommandError(
"The number of path separators in the templates " \
"should be the same.")
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()
# check for hidden track one audio
htoapath = None
htoa = prog.getHTOA()
if htoa:
start, stop = htoa
self.stdout.write(
'Found Hidden Track One Audio from frame %d to %d\n' %
(start, stop))
# rip it
ripIfNotRipped(0)
htoapath = prog.result.tracks[0].filename
for i, track in enumerate(itable.tracks):
# FIXME: rip data tracks differently
if not track.audio:
self.stdout.write(
'WARNING: skipping data track %d, not implemented\n' %
(i + 1, ))
# FIXME: make it work for now
track.indexes[1].relative = 0
continue
ripIfNotRipped(i + 1)
### write disc files
discName = prog.getPath(prog.outdir, self.options.disc_template,
mbdiscid, 0)
dirname = os.path.dirname(discName)
if not os.path.exists(dirname):
os.makedirs(dirname)
self.debug('writing cue file for %r', discName)
prog.writeCue(discName)
# write .m3u file
self.debug('writing m3u file for %r', discName)
m3uPath = u'%s.m3u' % discName
handle = open(m3uPath, 'w')
handle.write(u'#EXTM3U\n')
def writeFile(handle, path, length):
u = u'#EXTINF:%d,%s\n' % (length, os.path.basename(path))
handle.write(u.encode('utf-8'))
u = '%s\n' % os.path.basename(path)
handle.write(u.encode('utf-8'))
if htoapath:
writeFile(handle, htoapath,
itable.getTrackStart(1) / common.FRAMES_PER_SECOND)
for i, track in enumerate(itable.tracks):
if not track.audio:
continue
path = prog.getPath(prog.outdir, self.options.track_template,
mbdiscid, i + 1) + '.' + profile.extension
writeFile(handle, path,
itable.getTrackLength(i + 1) / common.FRAMES_PER_SECOND)
handle.close()
# verify using accuraterip
url = ittoc.getAccurateRipURL()
self.stdout.write("AccurateRip URL %s\n" % url)
cache = accurip.AccuCache()
responses = cache.retrieve(url)
if not responses:
self.stdout.write('Album not found in AccurateRip database\n')
if responses:
self.stdout.write('%d AccurateRip reponses found\n' %
len(responses))
if responses[0].cddbDiscId != itable.getCDDBDiscId():
self.stdout.write(
"AccurateRip response discid different: %s\n" %
responses[0].cddbDiscId)
prog.verifyImage(runner, responses)
self.stdout.write("\n".join(prog.getAccurateRipResults()) + "\n")
# write log file
logger = result.getLogger()
prog.writeLog(discName, logger)
prog.ejectDevice(device)