Apple TV for Music

#!/usr/bin/env ruby
require 'shellwords'
require 'fileutils'

# Script options, called below.
# fmt refers to audio codec, container refers to file suffix.
# i.e. opus stored in ogg, aac/alac stored in m4a.
Opts = Struct.new(:workers,
                  :src_dir, :dst_dir,
                  :src_fmt, :src_container,
                  :dst_fmt, :dst_container)

# An album, within a genre, containing tracks. Initialisation triggers
# population of the conversion_queue.
# Shellwords.escape is used when processing any pathstring that
# ends up in a command, as track titles are unpredictable.
class Album
  attr_accessor :genre, :in_files, :out_files, :src_art, :dst_art

  def initialize(opts, genre, album, conversion_queue)
    @opts = opts
    @genre = genre
    @album = album
    @path = "#{@opts.src_dir}/#{@genre}/#{@album}"
    @in_files = gather_tracks(@path)
    @out_files = @in_files.map { |f| resolve_track_destination(f) }
    @src_art = "#{@opts.src_dir}/#{genre}/#{album}/folder.jpg"
    @dst_art = "#{@opts.dst_dir}/#{genre}/#{album}/folder.jpg"
    enqueue!(conversion_queue)
  end

  # Resolve an album to its children.
  # Notably, we do not escape the path at this point, as we use the path
  # when we resolve the destination of the transcode.
  def gather_tracks(album_path)
    tracks = Dir.open(album_path).children.select { |f| f.end_with? @opts.src_container }
    tracks.map { |t| "#{album_path}/#{t}" }
  end

  # Resolve a track to its destination post-conversion
  # ALAC files are stored in M4A containers, so correct the destination
  # suffix while we're at it.
  def resolve_track_destination(file_path)
    file_path = file_path.gsub(@opts.src_dir, @opts.dst_dir)
    file_path.gsub!(@opts.src_container, @opts.dst_container)
    Shellwords.escape(file_path)
  end

  def copy_art!(resize)
    puts 'TODO: resize with magick' if resize
    FileUtils.copy_file(@src_art, @dst_art) unless File.exist?(@dst_art)
  end

  # Add to the provided conversion queue a series of shell commands to execute.
  # We handle art ahead of time.
  def enqueue!(queue)
    FileUtils.mkdir_p("#{@opts.dst_dir}/#{@genre}/#{@album}")
    copy_art!(false)
    @out_files.reject! { |f| File.exist?(f) }
    @out_files.each_with_index do |_, i|
      queue << "ffmpeg -i #{Shellwords.escape(@in_files[i])} -acodec #{@opts.dst_fmt} -map a #{@out_files[i]}"
    end
  end
end

# A music library, structured <group>/<genre>/<album>/<tracks>
class Library
  attr_accessor :conversion_queue, :genres, :albums, :active_workers

  def initialize(opts)
    @opts = opts
    puts "Converting files in #{@opts.src_dir} from #{@opts.src_fmt} to #{@opts.dst_fmt} (.#{@opts.dst_container})"
    @conversion_queue = Queue.new
    @genres = Dir.open(@opts.src_dir).children
    @albums = @genres.map do |genre|
      puts "Enumerating #{genre}"
      gather_albums(genre)
      puts "Finished with #{genre} -- #{@conversion_queue.length} tracks in conversion queue"
    end
    @active_workers = []
  end

  # Resolve a genre to its constituent Album objects.
  def gather_albums(genre)
    genre_albums = Dir.open("#{@opts.src_dir}/#{genre}").children
    genre_albums.reject! { |a| a.start_with? '.' }
    genre_albums.map { |album| Album.new(@opts, genre, album, @conversion_queue) }
  end

  # Spawn workers to consume and execute commands from the
  # conversion queue. Wait until all workers have returned.
  def convert_parallel!
    @opts.workers.times { |_| spawn_worker! }
    @active_workers.each(&:join)
  end

  def convert_one!
    spawn_worker!
    @active_workers.each(&:join)
  end

  # Start a thread (worker) to pop from the queue until empty.
  def spawn_worker!
    @active_workers << Thread.new do
      until @conversion_queue.empty?
        command = @conversion_queue.pop(true)
        puts command unless command.nil?
      end
    end
  end
end

options = Opts.new(workers: 10,
                   src_dir: '/mnt/XS1/music/flac',
                   dst_dir: '/mnt/XS1/music/alac',
                   src_fmt: 'flac',
                   src_container: 'flac',
                   dst_fmt: 'alac',
                   dst_container: 'm4a')

library = Library.new(options)
library.convert_parallel!