musicbox 0.1

data/lib/musicbox/catalog/release_artist.rb

@@ -0,0 +1,59 @@
+class MusicBox
+
+  class Catalog
+
+    class ReleaseArtist
+
+      attr_accessor :active
+      attr_accessor :anv
+      attr_accessor :id
+      attr_accessor :join
+      attr_accessor :name
+      attr_accessor :resource_url
+      attr_accessor :role
+      attr_accessor :thumbnail_url
+      attr_accessor :tracks
+      attr_accessor :artist    # linked on load
+
+      def self.artists_to_s(artists)
+        artists.map do |artist|
+          artist.name + ((artist.join == ',') ? artist.join : (' ' + artist.join))
+        end.flatten.join(' ').squeeze(' ').strip
+      end
+
+      def initialize(params={})
+        params.each { |k, v| send("#{k}=", v) }
+      end
+
+      def to_s
+        @name
+      end
+
+      def canonical_name
+        name = (@@canonical_names[@name] || @name).sub(/\s\(\d+\)/, '')  # handle 'Nico (3)'
+        if @@personal_names.include?(name)
+          elems = name.split(/\s+/)
+          [elems[-1], elems[0..-2].join(' ')].join(', ')
+        else
+          name
+        end
+      end
+
+      def key
+        key = ''
+        tokens = canonical_name.tokenize
+        while (token = tokens.shift) && key.length < 4
+          if key.empty?
+            key << token[0..2].capitalize
+          else
+            key << token[0].upcase
+          end
+        end
+        key
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/catalog/releases.rb

@@ -0,0 +1,15 @@
+class MusicBox
+
+  class Catalog
+
+    class Releases < Group
+
+      def self.item_class
+        Release
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/catalog/tags.rb

@@ -0,0 +1,116 @@
+class MusicBox
+
+  class Catalog
+
+    class Tags
+
+      attr_accessor :current
+      attr_accessor :changes
+
+      TagFlags = {
+        album: 'A',         # album title
+        title: 's',         # track title
+        artist: 'a',        # artist name
+        album_artist: 'R',  # album artist name
+        composer: 'w',      # composer
+        grouping: 'G',      # grouping
+        disc: 'd',          # disc number
+        discs: 'D',         # total discs
+        track: 't',         # track number
+        tracks: 'T',        # total tracks
+        year: 'y',          # release year
+      }
+
+      def self.load(file)
+        new.tap { |t| t.load(file) }
+      end
+
+      def initialize(params={})
+        @current = {}
+        @changes = {}
+        params.each { |k, v| send("#{k}=", v) }
+      end
+
+      def [](key)
+        @changes.has_key?(key) ? @changes[key] : @current[key]
+      end
+
+      def []=(key, value)
+        raise unless TagFlags[key]
+        @changes[key] = value unless @current[key] == value
+      end
+
+      def changed?
+        !@changes.empty?
+      end
+
+      def update(hash)
+        hash.each { |k, v| self[k] = v }
+      end
+
+      def load(file)
+        cmd = [
+          'ffprobe',
+          '-loglevel', 'error',
+          '-show_entries', 'format',
+          '-i', file,
+        ].map(&:to_s)
+        IO.popen(cmd, 'r') do |pipe|
+          pipe.readlines.map(&:strip).each do |line|
+            if line =~ /^TAG:(.*?)=(.*?)$/
+              key, value = $1.to_sym, $2.strip
+              info = case key
+              when :date
+                { year: value.to_i }
+              when :track
+                track, tracks = value.split('/').map(&:to_i)
+                {
+                  track: track,
+                  tracks: tracks,
+                }
+              when :disc
+                disc, discs = value.split('/').map(&:to_i)
+                {
+                  disc: disc,
+                  discs: discs,
+                }
+              else
+                if TagFlags[key]
+                  { key => value }
+                else
+                  {}
+                end
+              end
+              @current.update(info)
+            end
+          end
+        end
+        @current[:track] ||= file.basename.to_s.to_i
+      end
+
+      def save(file, force: false)
+        return unless changed? || force
+        set_flags = {}
+        remove_flags = []
+        @current.merge(@changes).each do |key, value|
+          flag = TagFlags[key] or raise
+          if value
+            set_flags[flag] = value
+          else
+            remove_flags << flag
+          end
+        end
+        run_command('mp4tags',
+          set_flags.map { |c, v| ["-#{c}", v] },
+          !remove_flags.empty? ? ['-remove', remove_flags.join] : nil,
+          file)
+        run_command('mdimport',
+          '-i',
+          file)
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/catalog/track.rb

@@ -0,0 +1,43 @@
+class MusicBox
+
+  class Catalog
+
+    class Track
+
+      attr_accessor :type
+      attr_accessor :position
+      attr_accessor :title
+      attr_accessor :duration
+      attr_accessor :extraartists
+      attr_accessor :artists
+      attr_accessor :sub_tracks
+
+      def initialize(params={})
+        params.each { |k, v| send("#{k}=", v) }
+      end
+
+      def type_=(type)
+        self.type = type
+      end
+
+      def artists=(artists)
+        @artists = artists.map { |a| ReleaseArtist.new(a) }
+      end
+
+      def extraartists=(artists)
+        @extraartists = artists.map { |a| ReleaseArtist.new(a) }
+      end
+
+      def sub_tracks=(sub_tracks)
+        @sub_tracks = sub_tracks.map { |t| Track.new(t) }
+      end
+
+      def artist
+        @artists ? ReleaseArtist.artists_to_s(@artists) : nil
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/cover_maker.rb

@@ -0,0 +1,49 @@
+class MusicBox
+
+  class CoverMaker
+
+    def self.make_covers(*releases, output_file:)
+      cover_maker = new
+      cover_maker.make_covers(releases)
+      cover_maker.write(output_file)
+    end
+
+    def initialize
+      @pdf = Prawn::Document.new
+    end
+
+    def make_covers(releases)
+      size = 4.75.in
+      top = 10.in
+      releases.each_with_index do |release, i|
+        album = release.album
+        unless album&.has_cover?
+          puts "Release #{release.id} has no cover"
+          next
+        end
+        @pdf.start_new_page if i > 0
+        @pdf.fill do
+          @pdf.rectangle [0, top],
+            size,
+            size
+        end
+        @pdf.image album.cover_file.to_s,
+          at: [0, top],
+          width: size,
+          fit: [size, size],
+          position: :center
+        @pdf.stroke do
+          @pdf.rectangle [0, top],
+            size,
+            size
+        end
+      end
+    end
+
+    def write(output_file)
+      @pdf.render_file(output_file.to_s)
+    end
+
+  end
+
+end

data/lib/musicbox/discogs.rb

@@ -0,0 +1,53 @@
+class MusicBox
+
+  class Discogs
+
+    AppName = 'musicbox-discogs'
+    ResultsPerPage = 100
+
+    def initialize(catalog:)
+      @catalog = catalog
+      @user, @token = @catalog.config.values_at('user', 'token')
+      @discogs = ::Discogs::Wrapper.new(AppName, user_token: @token)
+    end
+
+    def update
+      @catalog.collection.destroy!
+      page = 1
+      loop do
+        result = discogs_do(:get_user_collection, @user, page: page, per_page: ResultsPerPage)
+        result.releases.each do |release|
+          begin
+            update_release(release)
+          rescue Error => e
+            warn "Error: #{e}"
+          end
+        end
+        page = result.pagination.page + 1
+        break if page > result.pagination.pages
+      end
+    end
+
+    def update_release(release)
+      @catalog.collection.save_item(id: release.id, item: release)
+      info = release.basic_information
+      @catalog.releases.save_item_if_new(id: info.id) { discogs_do(:get_release, info.id) }
+      if info.master_id && info.master_id > 0
+        @catalog.masters.save_item_if_new(id: info.master_id) { discogs_do(:get_master_release, info.master_id) }
+      end
+      info.artists.each do |artist|
+        @catalog.artists.save_item_if_new(id: artist.id) { discogs_do(:get_artist, artist.id) }
+      end
+    end
+
+    def discogs_do(command, *args)
+      sleep(1)
+;;pp(command: command, args: args)
+      result = @discogs.send(command, *args)
+      raise Error, "Bad result: #{result.inspect}" if result.nil? || result.message
+      result
+    end
+
+  end
+
+end

data/lib/musicbox/equalizer.rb

@@ -0,0 +1,86 @@
+class MusicBox
+
+  # https://ffmpeg.org/ffmpeg-filters.html
+  # https://github.com/jaakkopasanen/AutoEq
+  
+  class Equalizer
+
+    attr_accessor :name
+    attr_accessor :volume_filter
+    attr_accessor :equalizer_filters
+
+    include SetParams
+
+    def self.load_equalizers(dir:, name:)
+      dir.glob("**/*#{name}*/*ParametricEQ.txt").map do |file|
+        name = '%s (%s)' % [file.dirname.basename, file.dirname.dirname.basename]
+        new(name: name).tap { |e| e.load(file) }
+      end.sort
+    end
+
+    def initialize(params={})
+      @equalizer_filters = []
+      set(params)
+    end
+
+    def load(file)
+      file.readlines.map { |l| l.sub(/#.*/, '') }.map(&:strip).reject(&:empty?).each do |line|
+        key, value = line.split(/:\s+/, 1)
+        case key
+        when /^Preamp: ([-.\d]+) dB$/
+          @volume_filter = VolumeFilter.new(volume: $1.to_f)
+        when /^Filter \d+: ON PK Fc (\d+) Hz Gain ([-.\d]+) dB Q ([-.\d]+)$/
+          @equalizer_filters << EqualizerFilter.new(
+            frequency: $1.to_i,
+            gain: $2.to_f,
+            width: $3.to_f,
+            type: 'q')
+        else
+          warn "Ignoring eq line: #{line.inspect}"
+        end
+      end
+    end
+
+    def <=>(other)
+      @name <=> other.name
+    end
+
+    def to_s(enabled: true)
+      [@volume_filter, enabled ? @equalizer_filters : nil].flatten.compact.join(',')
+    end
+
+    class VolumeFilter
+
+      attr_accessor :volume
+
+      include SetParams
+
+      def to_s
+        "volume=#{@volume}dB"
+      end
+
+    end
+
+    class EqualizerFilter
+
+      attr_accessor :frequency
+      attr_accessor :gain
+      attr_accessor :width
+      attr_accessor :type
+
+      include SetParams
+
+      def to_s
+        "equalizer=%s" % {
+          f: @frequency,
+          g: @gain,
+          w: @width,
+          t: @type,
+        }.map { |kv| kv.join('=') }.join(':')
+      end
+
+    end
+
+  end
+
+end

data/lib/musicbox/error.rb

@@ -0,0 +1,5 @@
+class MusicBox
+
+  class Error < Exception; end
+
+end

data/lib/musicbox/exporter.rb

@@ -0,0 +1,76 @@
+class MusicBox
+
+  class Exporter
+
+    def initialize(catalog:, dir:, compress: false, force: false, parallel: false)
+      @catalog = catalog
+      @dir = Path.new(dir).expand_path
+      @compress = compress
+      @force = force
+      @parallel = parallel
+    end
+
+    def export_album(album)
+      raise Error, "Must specify destination directory" unless @dir
+      name = '%s - %s (%s)' % [album.artist, album.title, album.year]
+      export_dir = @dir / name
+      export_dir.mkpath unless export_dir.exist?
+      threads = []
+      album.tracks.each do |track|
+        src_file = track.path
+        dst_file = export_dir / src_file.basename
+        if @force || !dst_file.exist? || dst_file.mtime != src_file.mtime
+          if @parallel
+            threads << Thread.new do
+              export_track(src_file, dst_file)
+            end
+          else
+            export_track(src_file, dst_file)
+          end
+        end
+      end
+      threads.map(&:join)
+    end
+
+    def export_track(src_file, dst_file)
+      if @compress
+        warn "compressing #{src_file}"
+        compress_track(src_file, dst_file)
+      else
+        warn "copying #{src_file}"
+        src_file.cp(dst_file)
+      end
+    end
+
+    def compress_track(src_file, dst_file)
+      begin
+        tags = Catalog::Tags.load(src_file)
+        caf_file = dst_file.replace_extension('.caf')
+        run_command('afconvert',
+          src_file,
+          caf_file,
+          '--data', 0,
+          '--file', 'caff',
+          '--soundcheck-generate')
+        run_command('afconvert',
+          caf_file,
+          '--data', 'aac',
+          '--file', 'm4af',
+          '--soundcheck-read',
+          '--bitrate', 256000,
+          '--quality', 127,
+          '--strategy', 2,
+          dst_file)
+        tags.save(dst_file, force: true)
+        dst_file.utime(src_file.atime, src_file.mtime)
+      rescue => e
+        dst_file.unlink if dst_file.exist?
+        raise e
+      ensure
+        caf_file.unlink if caf_file.exist?
+      end
+    end
+
+  end
+
+end