superrip.rb: Get basic track ripping working

[cmccabe-bin] / superrip.rb

#!/usr/bin/ruby -w

#
# superrip.rb
#
# Advanced CD-ROM ripping program
# 
# Copyright 2010, Colin McCabe
#

require 'fileutils'
require 'optparse'
require 'optparse/time'
require 'ostruct'

#-----------------------------------------------------------------
# constants
#-----------------------------------------------------------------
$cd_dev = "/dev/cdrom"

#-----------------------------------------------------------------
# functions
#-----------------------------------------------------------------
def my_system(cmd)
  puts cmd
  system(cmd) unless $opts.dry_run == true
  ($?.exitstatus == 0) or raise "#{cmd} failed"
end

def die_unless_installed(cmd)
  system("which #{cmd} > /dev/null")
  ($?.exitstatus == 0) or raise "you need to install the #{cmd} program"
end

def get_number_of_tracks_on_cd
  look_for_tracks = false
  IO.popen("cdda2wav -v summary -J dev=#{$cd_dev} 2>&1", "r") do |io|
    io.readlines.each do |line|
      line.chomp!
      if (line =~ /^AUDIOtrack/) then
        look_for_tracks = true
      elsif (look_for_tracks == true) then
        look_for_tracks = false
        line =~ /[ \t]*1-([1234567890][1234567890]*)[^1234567890]/ \
          or raise "couldn't understand cdda2wav output!"
        return $1.to_i
      end
    end
  end
  raise "couldn't find what we were looking for in cdda2wav output!"
end

def audiorip(tnum, track)
  begin
    my_system("nice -1 cdparanoia -w -d #{$cd_dev} #{tnum}")
  rescue
    raise "failed to rip track #{tnum} (#{track.name})"
  end
  # cdparanoia always outputs to cdda.wav
  FileUtils.mv("cdda.wav", track.wav_file_name, $fu_args)

  # TODO: spawn a thread to do this stuff in the background
  FileUtils.mkdir_p(track.flac_dir, $fu_args)
  my_system("flac -f '#{track.wav_file_name}' --output-name='#{track.flac_file_name}'")
  begin
    my_system("flac --test '#{track.flac_file_name}'")
  rescue
    raise "failed to encode #{track.flac_file_name}"
  end
  FileUtils.mkdir_p(track.mp3_dir, $fu_args)
  my_system("lame -q 1 -b 192 '#{track.wav_file_name}' '#{track.mp3_file_name}'")
  FileUtils.rm_f(track.wav_file_name, $fu_args)
end

#-----------------------------------------------------------------
# classes
#-----------------------------------------------------------------
class MyOptions
  def self.parse(args)
    opts = OpenStruct.new
    opts.dry_run = false
    $fu_args = { :verbose => true }

    # Fill in opts values
    parser = OptionParser.new do |myparser|
      myparser.banner = "Usage: #{ File.basename($0) } [opts]"
      myparser.separator("Specific options:")
      myparser.on("--dry-run", "-d",
            "Show what would be done, without doing it.") do |a|
        opts.dry_run = true
        $fu_args = { :verbose => true, :noop => true }
      end
      myparser.on("--tracklist [FILE]", "-t",
            "Provide a list of tracks to use.") do |file|
        opts.manifest_file = file
        opts.partial = false
      end
      myparser.on("--partial-tracklist [FILE]", "-T",
            "Provide a partial list of tracks to use.") do |file|
        opts.manifest_file = file
        opts.partial = true
      end
    end
    parser.parse!(args)

    raise "you must provide a tracklist" unless opts.manifest_file != nil
    return opts
  end
end

class Track
  attr_accessor :name, :flac_dir, :flac_file_name, :mp3_dir, :mp3_file_name,
    :wav_file_name
  def initialize(name)
    if name =~ /\[LL\]/ then
      raise "you can't include [LL] in a track name" 
    end
    if name =~ /\.mp3/ then
      raise "don't include .mp3 in the track name; that will be added"
    end
    if name =~ /\.flac/ then
      raise "don't include .flac in the track name; that will be added"
    end
    (name =~ /([^\/][^\/]*)\/([^\/]*[^\/])/) or \
      raise "track name must be of the form 'foo/bar'"
    @name = name
    @flac_dir = "#{$1} [LL]"
    @flac_file_name = "#{@flac_dir}/#{$2}.flac"
    @mp3_dir = "#{$1}"
    @mp3_file_name = "#{@mp3_dir}/#{$2}.mp3"
    @wav_file_name = "#{$1}__#{$2}.wav"
  end

  def inspect
    "track(\"#{@name}\")"
  end
end

class Manifest
  def initialize(filename)
    @t = Hash.new
    eval(File.new(filename).read)
    @t.each do |key, val|
      @t[key] = Track.new(val)
    end
    # TODO: implement some shortcuts that make manifests easier to type.
    # Probably avoiding the necessity to continue typing the album name if it is the same as the
    # previous track's name would make things a lot easier without complicating everything too much.
  end

  def validate(num_tracks)
    if (@t.empty?) then
      raise "you must define some tracks"
    end
    @t.each { |t| t.validate }
    if (not $opts.partial) then
      (1..num_tracks).each do |t|
        if not @t[t].defined?
          raise "don't know what to do with track #{t}"
        end
      end
    end
    # TODO: make sure that tracks inside albums are in order
    # i.e. we don't map track 2 to a name that sorts to before track 1
  end

  def rip(num_tracks)
    (1..num_tracks).each do |tnum|
      next unless @t.has_key?(tnum)
      audiorip(tnum, @t[tnum])
    end
  end

  def inspect
    ret = ""
    @t.keys.sort.each do |key|
      ret = "#{ret}#{key}:'#{@t[key].inspect()}'\n"
    end
    return ret
  end
end

#-----------------------------------------------------------------
# main
#-----------------------------------------------------------------
# Parse options.
begin
  begin
    $opts = MyOptions.parse(ARGV)
  rescue ArgumentError => msg
  $stderr.puts("#{msg} Type --help to see usage information.\n")
  exit 1
  end
end

die_unless_installed("lame")
die_unless_installed("flac")
die_unless_installed("cdparanoia")
die_unless_installed("cdda2wav")

manifest = Manifest.new($opts.manifest_file)
puts manifest.inspect
num_tracks = get_number_of_tracks_on_cd()
puts "found #{num_tracks} tracks"
manifest.rip(num_tracks)
exit 0