ektoplayer 0.1.0

data/lib/ektoplayer/models/browser.rb

@@ -0,0 +1,127 @@
+require_relative 'model'
+
+module Ektoplayer
+   module Models
+      class Browser < Model
+         PARENT_DIRECTORY = '..'.freeze
+
+         PATHS = {
+            style:          [:style      ].freeze,
+            artist:         [:artist     ].freeze,
+            album:          [:album      ].freeze,
+            released_by:    [:released_by].freeze,
+            posted_by:      [:posted_by  ].freeze,
+            tracks:         [].freeze
+         }.freeze
+
+         def initialize(client)
+            super()
+            @events.register(:changed)
+            @stack = []
+            @stack << BrowserRoot.new(client.database)
+         end
+
+         def current
+            @stack[-1]
+         end
+
+         def tracks(index)
+            current.tracks(index)
+         end
+
+         def reload
+            current.reload
+            @events.trigger(:changed)
+         end
+
+         def enter(index)
+            return unless (sub = current.enter(index))
+            return back() if sub == :parent
+            @stack.push(sub)
+            @events.trigger(:changed)
+         end
+
+         def back
+            return unless @stack.size > 1
+            @stack.pop
+            @events.trigger(:changed)
+         end
+
+         class BrowsableCollection
+            include Enumerable
+            def each(&block)  @contents.each(&block)  end
+            def [](*args)     @contents[*args]        end
+            def empty?;       @contents.empty?        end
+
+            def initialize(database, filters, tag_hierarchy)
+               @database, @tag_hierarchy = database, tag_hierarchy
+               @filters = filters
+               @tag = @tag_hierarchy.shift(1)[0]
+               reload
+            end
+
+            def reload
+               @contents = [PARENT_DIRECTORY]
+
+               if @tag
+                  @contents.concat(
+                     @database.select(
+                        columns: @tag,
+                        filters: @filters, 
+                        group_by: @tag,
+                        order_by: [@tag] + @filters.map { |f| f[:tag] }
+                     ).map { |r| r[0] }
+                  )
+               else
+                  @contents.concat(
+                     @database.select(filters: @filters)
+                  )
+               end
+            end
+
+            def enter(index)
+               return :parent if index == 0
+               return unless @tag
+               BrowsableCollection.new(@database, new_filters(index), @tag_hierarchy)
+            end
+
+            def tracks(index)
+               if not @tag
+                  return [] if index == 0
+                  return [ @contents[index] ]
+               else
+                  @database.select(filters: new_filters(index)).map.to_a
+               end
+            end
+
+            private def new_filters(index)
+               @filters.dup << { tag: @tag, operator: :==, value: @contents[index] }
+            end
+         end
+ 
+         class BrowserRoot
+            CONTENTS = PATHS.keys.freeze
+
+            include Enumerable
+            def each(&block)  CONTENTS.each(&block)  end
+            def [](*args)     CONTENTS[*args]        end
+            def empty?;       CONTENTS.empty?        end
+
+            def initialize(database)
+               @database = database
+            end
+
+            def reload; end
+
+            def enter(index)
+               fail unless path = PATHS[CONTENTS[index]]
+               BrowsableCollection.new(@database, [], path.dup)
+            end
+
+            def tracks(index)
+               @database.select()
+            end
+         end
+      end
+   end
+end

data/lib/ektoplayer/models/database.rb

@@ -0,0 +1,49 @@
+require_relative 'model'
+require_relative '../updater'
+
+module Ektoplayer
+   module Models
+      # This model represents the state of the database.
+      # Events:
+      # _changed_:: the database has been modified
+      # _update_started_:: database update has been started
+      # _update_finished_:: database update has been finished
+      
+      class Database < Model
+         attr_reader :events
+
+         def initialize(client)
+            super()
+            @client = client
+            @client.database.events.on(:changed) { @events.trigger(:changed) }
+            @events.register(:update_started, :changed, :update_finished)
+         end
+
+         def track_count; @client.database.track_count  end
+         def album_count; @client.database.album_count  end
+       
+         def updating?
+            @update_thread and @update_thread.alive?
+         end
+        
+         def stop!
+            @update_thread and @update_thread.kill
+            @update_thread = nil
+         end
+         
+         def update(**opts)
+            unless updating?
+               db_updater = DatabaseUpdater.new(@client.database)
+               @update_thread = Thread.new do
+                  @events.trigger(:update_started)
+                  db_updater.update(**opts)
+                  @events.trigger(:update_finished)
+               end
+            else
+               Application.log(self, 'already updating')
+            end
+         end
+      end
+   end
+end
+

data/lib/ektoplayer/models/model.rb

@@ -0,0 +1,15 @@
+require_relative '../events'
+
+module Ektoplayer
+   module Models
+      # Base class for all other models.
+      class Model
+         attr_reader :events
+
+         def initialize
+            @events = Events.new
+            @events.no_auto_create
+         end
+      end
+   end
+end

data/lib/ektoplayer/models/player.rb

@@ -0,0 +1,28 @@
+require_relative 'model'
+require_relative '../mp3player'
+
+module Ektoplayer
+   module Models
+      class Player < Model
+         def initialize(client)
+            super()
+            @client = client
+            @player = Mp3Player.new
+            @events.register(:position_change, :track_completed, :pause, :stop, :play)
+            @player.events.on_all(&@events.method(:trigger))
+
+            %w(pause toggle stop forward backward seek
+            length position position_percent level).each do |m|
+               self.define_singleton_method(m, &@player.method(m))
+            end
+         end
+
+         def play(file)
+            Application.log(self, 'playing', file)
+            @player.play(file) rescue Application.log(self, $!)
+         end
+
+         def close;  @player.close  end
+      end
+   end
+end

data/lib/ektoplayer/models/playlist.rb

@@ -0,0 +1,72 @@
+require 'set'
+
+require_relative 'model'
+
+module Ektoplayer
+   module Models
+      class Playlist < Model
+         REPEAT_MODES = Set.new([:none, :playlist, :track]).freeze
+
+         attr_reader :current_playing, :repeat
+
+         def initialize(list: [])
+            super()
+            @events.register(:current_changed, :changed)
+            @playlist = list
+            @current_playing = nil
+            @repeat = :none
+         end
+
+         include Enumerable
+         def each(&block) @playlist.each(&block)   end
+         def [](*args)    @playlist[*args]         end
+         def empty?;      @playlist.empty?         end
+         def size;        @playlist.size           end
+
+         def current_playing=(new)
+            new = new.clamp(0, @playlist.size - 1) if new
+
+            if @current_playing != new
+               @current_playing = new
+               events.trigger(:current_changed)
+            end
+         end
+
+         def get_next_pos
+            if @current_playing
+               if @repeat == :track
+                  return @current_playing
+               elsif @current_playing + 1 >= @playlist.size
+                  return 0 if @repeat == :playlist
+               else
+                  return @current_playing + 1
+               end
+            end
+         end
+
+         def repeat=(new)
+            raise ArgumentError unless REPEAT_MODES.include? new
+            if @repeat != new
+               @repeat = new
+               events.trigger(:repeat_changed)
+            end
+         end
+
+         def add(*tracks)
+            @playlist.concat(tracks)
+            events.trigger(:changed, added: tracks)
+            Application.log(self, "added #{tracks.count} tracks to playlist")
+         end
+
+         def clear
+            @playlist.clear
+            events.trigger(:changed)
+         end
+
+         def delete(index)
+            @playlist.delete_at(index) rescue return
+            events.trigger(:changed, deleted: index)
+         end
+      end
+   end
+end

data/lib/ektoplayer/models/search.rb

@@ -0,0 +1,42 @@
+require_relative 'model'
+
+module Ektoplayer
+   module Models
+      class Search < Model
+         include Enumerable
+         def each(&block)  @contents.each(&block)  end
+         def [](*args)     @contents[*args]        end
+
+         def initialize(client, sort: 'date')
+            super()
+            @params = { sort: 'date' }
+            @db = client.database
+            @events.register(:changed)
+            #reload { sort: 'date' }.update(params)
+         end
+
+         def reload(new_params)
+            return if new_params == @params
+            @params = new_params
+
+            @contents = @db.select(
+               order_by:  "#{@params[:sort]}, album, number",
+               filters: todo #TODO
+            )
+            @events.trigger(:changed)
+         end
+
+         def completion_for(tag)
+            @db.select(columns: tag, group_by: tag, order_by: tag)
+         end
+
+         def sort(new)
+            reload @param.dup.update(sort: new)
+         end
+
+         def by_tag(tag, operator, value)
+            reload @param.dup.update()
+         end
+      end
+   end
+end

data/lib/ektoplayer/models/trackloader.rb

@@ -0,0 +1,17 @@
+require_relative 'model'
+
+module Ektoplayer
+   module Models
+      class Trackloader < Model
+         def initialize(client)
+            super()
+            @trackloader = client.trackloader
+
+            %w(get_track_file download_album downloads
+            ).each do |m|
+               self.define_singleton_method(m, &@trackloader.method(m))
+            end
+         end
+      end
+   end
+end

data/lib/ektoplayer/mp3player.rb

@@ -0,0 +1,151 @@
+require 'thread'
+require 'mpg123'
+require 'portaudio'
+
+require_relative 'events'
+
+class Mpg123
+   alias :samples_per_frame :spf
+   alias :time_per_frame :tpf
+
+   def samples_to_frames(samples)
+      samples / samples_per_frame
+   end
+
+   def seconds_to_frames(seconds)
+      seconds / time_per_frame
+   end
+
+   def seconds_to_samples(seconds)
+      seconds_to_frames(seconds) * samples_per_frame
+   end
+
+   def samples_to_seconds(samples)
+      samples_to_frames(samples) * time_per_frame
+   end
+
+   def length_in_seconds
+      samples_to_frames(length) * time_per_frame
+   end
+
+   def tell_in_seconds
+      samples_to_frames(tell) * time_per_frame
+   end
+
+   def seek_in_seconds(seconds)
+      samples = seconds_to_samples(seconds)
+      seek(samples) if (0..length).include?(samples)
+   end
+end
+
+class Mp3Player
+   attr_reader :events
+
+   def initialize(buffer_size = 2**12)
+      @events = Events.new(:play, :pause, :stop, :position_change)
+      @portaudio = Portaudio.new(buffer_size)
+      @lock = Mutex.new
+   end
+
+   def play(song=nil)
+      @lock.synchronize do
+         @mp3 = Mpg123.new(song) if song
+         return unless @mp3
+
+         @portaudio.start if @portaudio.stopped?
+         @portaudio_thr ||= Thread.new do
+            begin
+               while @mp3
+                  status = @portaudio.write_from_mpg(@mp3)
+                  @events.trigger(:position_change)
+                  break if status == :done or status == :need_more
+                  @portaudio.wait
+               end
+            rescue
+               Application.log(self, $!)
+            ensure
+               @portaudio_thr = nil
+               if status == :done or status == :need_more
+                  @events.trigger(:stop, :track_completed)
+               elsif stopped?
+                  @events.trigger(:stop)
+               elsif paused?
+                  @events.trigger(:pause)
+               end
+            end
+         end
+
+         @events.trigger(:position_change)
+         @events.trigger(:play)
+      end
+   end
+
+   def pause
+      @lock.synchronize do
+         @portaudio_thr.kill rescue nil
+         @events.trigger(:position_change)
+         @events.trigger(:pause)
+      end
+   end
+
+   def stop
+      @lock.synchronize do
+         @portaudio_thr.kill rescue nil
+         (@mp3.seek(0) rescue nil) if @mp3
+         @events.trigger(:position_change)
+         @events.trigger(:stop)
+      end
+   end
+
+   def file;     @mp3.file if @mp3         end
+   def level;    @portaudio.rms            end
+   def toggle;   playing? ? pause : play   end
+   def playing?; @portaudio_thr            end
+   
+   def paused?
+      not @portaudio_thr and (@mp3 and @mp3.tell.to_i != 0)
+   end
+
+   def stopped?
+      not @portaudio_thr and (!@mp3 or @mp3.tell_in_seconds.to_i == 0)
+   end
+
+   def status
+      return :playing if playing?
+      return :paused  if paused?
+      return :stopped if stopped?
+   end
+
+   # Returns current song position in seconds
+   def position
+      @mp3 ? @mp3.tell_in_seconds : 0
+   end
+
+   # Returns current song position as percentual value to song length
+   def position_percent
+      @mp3 ? (Float(@mp3.tell) / @mp3.length) : 0
+   end
+
+   # Returns current song length in seconds
+   def length
+      @mp3 ? @mp3.length_in_seconds : 0
+   end
+
+   # Seeks the current song to position in seconds
+   def seek(seconds)
+      return unless @mp3
+      @lock.synchronize do
+         @mp3.seek_in_seconds(seconds) rescue nil
+         events.trigger(:position_change, position)
+      end
+   end
+
+   def rewind(seconds = 2)
+      seek(position - seconds)
+   end
+   alias :backward :rewind
+
+   def forward(seconds = 2)
+      seek(position + seconds)
+   end
+end