rwdaddresses 0.97 → 0.98

data/extras/mp3controld

@@ -0,0 +1,289 @@
+#!/usr/bin/ruby
+
+# ---    MP3 Control    ---
+# 
+# Author: 	Magnus Engstr�m
+# Email:		magnus@gisab.se
+# File:		mp3controld
+#
+# Description
+# -----------
+# An application which manages
+# mp3 songs on the poor users
+# computer.
+# -------------------------
+
+# --- External files ---
+# Change directory to find all functions
+#Dir::chdir("/usr/lib/mp3control")
+
+load "extras/config_file"		# Handles the mp3controld.conf configuration file
+load "extras/cmdline_parse"	# Provides the Commandline::parse which returns an hash of the commandline
+load "extras/showHelp"			# Hmmm... guess what? This function shows the help message =)
+load "extras/errorMsg"			# Outputs error messages to the admin
+load "extras/playlist"			# Core playlist functionality
+
+# --- MP3Control - the main class ---
+class MP3Control
+  # --- Core functions ---
+  # initialize() reads the config files and daemonizes! 
+  def initialize()
+	 # Parse the commandline
+	 $commandline = Commandline::parse()
+	 
+	 # Display help if the commandline sucks
+	 if($commandline == -1)
+		showHelp()
+		Kernel::exit(-1)
+	 end
+
+	 # Make this class instance a background daemon
+	 daemonize() if($commandline["--daemon"] != 'no' && $commandline["-D"] != 'no')
+
+	 # Read the configuration file
+	 configfile = ( $commandline["--configfile"] ? $commandline["--configfile"] : 'configuration/mp3controld.conf' ) # Use the --configfile if supplied, else use the default /etc/mp3controld/mp3controld.conf
+	 $configFile = ConfigFile::parse(configfile) # Create an new config file object
+	 errorMsg("Configuration file #{configfile} isn't readable or doesn't exist!", 137) if($configFile == -1)
+	 
+	 # Find the default playlist (or use the user supplied one from the commandline)
+	 defaultPlaylist = $configFile.getParam("programConfig", "defaultPlaylist")
+	 defaultPlaylist = $commandline["--playlist"] if($commandline["--playlist"])
+	 if( $configFile.getParam(defaultPlaylist, 'listFile').type == String) # Make sure the listFile contains a value
+		if(FileTest.readable_real?( $configFile.getParam(defaultPlaylist, 'listFile') )) # Make sure this file is readable
+		  # Cool. Everything looks alright. Lets create a playlist!
+		  errorMsg("Loading playlist '#{defaultPlaylist}' from #{$configFile.getParam(defaultPlaylist, 'listFile')}...") if($commandline['--verbose'] == 'on')
+		  $current_playlist = Playlist::create_from_file($configFile.getParam(defaultPlaylist, 'listFile'))
+		  $current_playlist_name = defaultPlaylist
+		  
+		  # Errorhandling
+		  errorMsg("Playlist creation from #{$current_playlist.filename} failed.", 1) if($current_playlist == -1) # Quit and complain if it didn't work
+		  errorMsg("Playlist #{defaultPlaylist} (#{$current_playlist.filename}) doesn't contain any entries.", 1) if($current_playlist.length() < 1)
+		  errorMsg("Playlist '#{defaultPlaylist}' loaded successfully.") if($commandline["--verbose"] == 'on')
+
+		  # Fix wrap/repeat and shuffle the playlist if the configfile says so
+		  $current_playlist.wrap = true	if($configFile.getParam(defaultPlaylist, 'repeat') == 'true')
+		  $current_playlist.shuffle()		if($configFile.getParam(defaultPlaylist, 'random') == 'true')
+		  $current_playlist.goto(0)		# Rewind the playlist
+		else
+		  errorMsg("The default playlist doesn't appear to exist, or has the wrong permissions. That's not good.", 1)
+		end
+	 else # listFile returns other than string, that's baaaaad
+		errorMsg("the listFile value for '#{defaultPlaylist}' doesn't appear to exist in your #{$configFile.filename}. That's not good.", 1)
+	 end
+
+	 # Check for the existence of our mpg123 instance
+	 errorMsg("Trying to find the mp3 player...") if($commandline["--verbose"] == 'on')
+	 @mpg123 = $configFile.getParam('programConfig', 'application') # Get the application name, path, and possible arguments
+	 mpg123_application = @mpg123.scan(/^\S+/)
+	 if(mpg123_application.type == Array)
+		mpg123_application = mpg123_application[0] 
+	 else
+		errorMsg("Please check your ProgramConfig/application setting in the configuration file. It seems weird.", 1)
+	 end
+
+	 # Do some nice errorhandling
+	 if( !FileTest::executable_real?(mpg123_application) )
+		errorMsg("#{mpg123_application} doesn't appear to exist. Please do something about it (no, not \"touch #{mpg123_application}\"! Stupid!).", 1)
+	 else
+		errorMsg("Found #{mpg123_application}!") if($commandline["--verbose"] == 'on')
+	 end
+
+	 # Open an instance of mpg123, our high-performance mp3 player
+	 @@mpg123 = IO::popen("#{@mpg123} -R -", 'r+')
+
+	 # Start all plugins
+	 load_plugins()
+
+	 # Start the mp3 player
+	 mpg123_control()
+
+  end
+
+  # mpg123_control() gets the input from the mpg123 process and handles it hopefully correctly :)
+  def mpg123_control()
+
+	 # Initialize class variables
+	 @@stopped = false
+
+	 # Start playing if the configfile says so
+	 if( $configFile.getParam('programConfig', 'playOnStartup') == 'true' )
+		MP3Control::play()
+	 else
+		puts("Dont want to play!")
+	 end
+	 
+	 # The infinite 5 second loop =)
+	 while(true)
+		begin
+		  input = @@mpg123.readline.chop()
+		rescue EOFError
+		  errorMsg("mpg123 error! Probably just a file that didn't exist (#{$current_playlist.song_info["filename"]}).")
+		  @@mpg123 = IO::popen("#{@mpg123} -R -", 'r+') # Just start it again...
+		  MP3Control::next_song() # Next song, so it doesn't die again...
+		end
+
+		# Song stopped
+		MP3Control::next_song() if(input == '@P 0' && @@stopped != true) # Change to the next song if current song stops and the user didn't told it to
+		@@stopped = false if(input == '@P 0' && @@stopped == true) # Reset the stop-flag if the user ordered the stop
+
+		# Time left
+		if(input[0,2] == '@F')
+		  input =~ /^@F\s+\S+\s+\S+\s+(\S+)\s+(\S+)$/
+		  @@time			= $1
+		  @@timeleft	= $2
+		end
+
+	 end
+  end
+
+  # start() creates a new instance. Just like .new, but a nicer name. 
+  def MP3Control::start()
+	 MP3Control::new()
+  end
+
+ # daemonize() daemonizes this process. Cool =) 
+  def daemonize()
+	 if(child_pid = fork) # Parent code
+		puts("PID #{child_pid}")
+		Kernel::exit(0) # We dont want this parent process any more. Too bad.
+	 end
+
+	 # Child code. And child wants to be free from parent
+	 Process.setsid()
+  end
+
+  # load_plugins() loads all plugins that can be found in the plugins directory
+  def load_plugins()
+	 Dir::entries('extras/plugins/').each { |plugin|
+		# Try to load every plugin except all files that begins with a dot
+		if(plugin[0].chr() != '.')
+		  retval = 0
+		  # Do some errorhandling
+		  begin
+			 load("extras/plugins/#{plugin}") # Load the files
+			 errorMsg("Loaded plugin '#{plugin}'") if($commandline['--verbose'] == 'no')
+		  rescue SyntaxError
+			 errorMsg("Plugin '#{plugin}' has syntax errors.")
+		  end
+
+		  # Run the plugin in a separate thread
+		  # Try to start the class with the same name as the plugin
+		  eval("
+		    Thread::new() {
+				start_again = true
+				while(start_again)
+				  puts(\"Plugin starting...\")
+				  begin
+					 retval = #{plugin}::start()
+				  rescue
+					 error = $!
+					 puts(error)
+					 puts(error.backtrace)
+					 puts(\"Error in plugin #{plugin}! Waiting for 5 seconds before attempting to start again...\")
+					 sleep(5)
+				  end
+				  if(retval == -1) 
+					 errorMsg(\"Plugin 'plugins/#{plugin}' failed to load...\")
+					 start_again = false
+				  end
+				end
+		    }
+		  ") 
+
+		end
+	 }
+  end
+
+  # exit_mpg123() terminates the current mpg123 session
+  def MP3Control::exit_mpg123()
+	 #system("kill `pidof mpg123`") # Yes, I know this isn't a nice way to do it in, please fix this and send me a patch :)
+  end
+
+  # mpg123_command() sends a command to mpg123 
+  def MP3Control::mpg123_command(command)
+	 errorMsg("mpg123 command: '#{command}'") if($commandline['--verbose'] == 'on')
+	 @@mpg123.write("#{command}\n")
+	 @@mpg123.flush()
+  end
+
+
+  # --- play functions ---
+  # play() plays the current index of the current playlist 
+  def MP3Control::play()
+	 @@stopped = false
+	 mpg123_command("LOAD #{$current_playlist.song_info["filename"]}")
+  end
+
+  # stop() stops playing 
+  def MP3Control::stop()
+	 mpg123_command("PAUSE")
+	 @@stopped = true # Set the stop-status to true
+  end
+
+  # pause() pauses playing 
+  def MP3Control::pause()
+	 @@stopped = false
+	 mpg123_command("PAUSE")
+  end
+
+  # next_song() loads the next song. Yay... 
+  def MP3Control::next_song()
+	 retval = $current_playlist.next()
+	 if(retval == -1)
+		errorMsg("Error while changing to the next song.") # Tell him/her
+	 else
+		MP3Control::play() if(@@stopped == false)
+	 end
+  end
+
+  # prev_song() loads the previous song. Yay... 
+  def MP3Control::prev_song()
+	 retval = $current_playlist.prev()
+	 if(retval == -1)
+		errorMsg("Error while changing to the previous song.") # Tell him/her
+	 else
+		MP3Control::play() if(@@stopped == false)
+	 end
+  end
+
+  # forward(sec) jumps sec seconds forward
+  def MP3Control::forward(sec)
+	 mpg123_command("JUMP +#{sec*38}")
+  end
+
+  # backward(sec) jumps sec seconds backward
+  def MP3Control::backward(sec)
+	 mpg123_command("JUMP -#{sec*38}")
+  end
+
+
+  #  --- Misc functions ---
+  # getTime() - Get the current song time information. getTime(true) for time left 
+  def MP3Control::getTime(whichTime = 'elapsed')
+	 case whichTime
+	 when 'elapsed'
+		parsed	= Time::at(@@time.to_i)
+	 when 'left'
+		parsed	= Time::at(@@timeleft.to_i)
+	 when 'total'
+		parsed	= Time::at( (@@time.to_f + @@timeleft.to_f).to_i )
+	 end
+
+	 hour	= (parsed.hour - 1).to_s
+	 min	= parsed.min.to_s
+	 sec	= parsed.sec.to_s
+
+	 hour	= "0#{hour}"	if(hour.length == 1)
+	 min	= "0#{min}"		if(min.length == 1)
+	 sec	= "0#{sec}"		if(sec.length == 1)
+
+	 hour = (hour == '00' ? '' : "#{hour}:")
+
+	 # Return the now formatted time
+	 "#{hour}#{min}:#{sec}"
+  end
+
+end
+
+# Create an instance of the MP3Control class and start the application
+MP3Control::start()

data/extras/playlist

@@ -0,0 +1,186 @@
+#!ruby
+
+# --- Playlist class ---
+#
+# Author:	Magnus Engstr�m
+# Email:		magnus@gisab.se
+# File:		playlist
+#
+# Description
+# -----------
+# The Playlist class handles everything a playlist should be able to manage.
+# Shuffle it, unshuffle it, wrap it if desired, add new songs, find songs and
+# so on. Cool huh? :)
+# ----------------------
+
+class Playlist
+  # create_from_file() creates a playlist from a file and returns either a Playlist instance or -1 in case of error
+  # This function should be used instead of the ::new, because this one
+  # returns -1 on file read errors, which the ::new doesn't.
+  def Playlist::create_from_file(filename)
+	 # Check that the file is readable
+	 if(FileTest::readable_real?(filename))
+		new(filename) # Return the Playlist class instance
+	 else
+		-1 # Return -1 on error
+	 end
+  end
+
+  # initialize reads the playlist from a file and returns the Playlist instance 
+  def initialize(filename)
+
+	 @filename	= filename		# Store the filename for later use
+	 @playlist	= Array::new()	# This hash contains the whole playlist
+	 @index		= 0				# Playlist's current position
+	 @wrap		= false			# Don't repeat the list as default
+
+	 # Parse these fields, separated with double pipes (||) (songname, artist, album, year, comment, tracknum, genre_id, genre)
+	 File::foreach(filename) { |line| # Iterate through every line in the file
+		foo = line.split(/\|\|/)
+		@playlist << { "filename" => foo[0], "songname" => foo[1], "artist" => foo[2], "album" => foo[3], "year" => foo[4], "comment" => foo[5], "tracknum" => foo[6], "genre_id" => foo[7], "genre" => foo[8] } # Add a hash to the @playlist array with all values found in the playlist file
+	 }
+	 
+  end
+
+  def insert(song, placement = 0)
+	 # Check song information
+	 return -1 if(song.type != Hash)
+	 song = { "filename" => song["filename"], "songname" => song["songname"], "artist" => song["artist"], "album" => song["album"], "year" => song["year"], "comment" => song["comment"], "tracknum" => song["tracknum"], "genre_id" => song["genre_id"], "genre" => song["genre"] }
+	 
+	 # Check minimum and maximum values
+	 placement = 0 if(placement < 0)
+	 placement = @playlist.length() if(placement > @playlist.length() )
+
+	 # Retrieve the two parts of the split playlist
+	 first		= @playlist[0...placement]
+	 second		= @playlist[placement...@playlist.length()]
+	 
+	 # Put it together again
+	 @playlist	= Array::new()
+	 @playlist	= first
+	 @playlist	<< song
+	 @playlist.concat(second)
+
+  end
+
+  def remove(placement = 0)
+	 # Check boundaries
+	 placement = 0 if(placement < 0)
+	 placement = @playlist.length()-1 if( placement >= @playlist.length() )
+
+	 # Delete the item
+	 @playlist.delete_at(placement)
+  end
+
+  def find(search_string, case_insensitive = false, fields = ["songname", "filename"])
+	 case_insensitive = nil if(case_insensitive == false)
+
+	 results	= Array::new()
+	 regex	= Regexp::new(search_string, case_insensitive) # The regex that will be matched
+
+	 # Iterate through the playlist to find one or more matching songs
+	 @playlist.length().times { |index|
+		# Iterate through the user supplied list of fields to be searched
+		fields.each { |field|
+		  # Make sure this is a hash, so we don't go and crash, or make someone's dog sick :)
+		  if(@playlist[index].type == Hash)
+			 results << index if( regex.match(@playlist[index][field]) && !(results.include?(index)) ) # If it matches, and if it doesn't already is in the results. We don't want duplicates :)
+		  end
+		}
+	 }
+
+	 results # Return the results
+
+  end
+
+  def shuffle()
+	 # Iterate through the playlist
+	 ( 0...@playlist.length() ).each { |i|
+	  	j = rand @playlist.length() # Grab a random value between 0 and @playlist.length()
+
+		# Maintain index
+		if(@index == j)
+		  @index = i 
+		elsif(@index == i)
+		  @index = j
+		end
+
+	  	@playlist[i], @playlist[j] = @playlist[j], @playlist[i]
+	 }
+  end
+
+  def re_read()
+	 # Maintain index
+	 current_filename = @playlist[@index]["filename"]
+
+	 # Create a new playlist array
+	 @playlist	= Array::new()
+	 @index		= 0
+	 foo_index	= 0 # Just to keep the count while adding all songs to the @playlist
+
+	 # Parse these fields, separated with double pipes (||) (songname, artist, album, year, comment, tracknum, genre_id, genre)
+	 # Iterate through every line in the file
+	 File::foreach(@filename) { |line|
+		foo = line.split(/\|\|/) # Separate the fields with double pipes (||)
+		@playlist << { "filename" => foo[0], "songname" => foo[1], "artist" => foo[2], "album" => foo[3], "year" => foo[4], "comment" => foo[5], "tracknum" => foo[6], "genre_id" => foo[7], "genre" => foo[8] } # Add a hash to the @playlist array with all values found in the playlist file
+
+		# Maintain index
+		@index = foo_index if(foo[0] == current_filename)
+		foo_index += 1
+	 }
+	 
+  end
+
+  def next()
+	 # Increase the counter and return -1 if the playlist went to far, and wrap isn't true
+	 @index += 1
+	 if( @index >= @playlist.length() )
+		if(@wrap)
+		  @index = 0
+		else
+		  @index -= 1
+		  -1 # Return an error
+		end
+	 else
+		@index
+	 end
+  end
+
+  def prev()
+	 # Decrease the counter and return -1 if the playlist went to far, and wrap isn't true
+	 @index -= 1
+	 if( @index < 0 )
+		if(@wrap)
+		  @index = @playlist.length() -1
+		else
+		  @index += 1
+		  -1 # Return an error
+		end
+	 else
+		@index
+	 end
+  end
+
+  def song_info(index = @index)
+	 @playlist[index]
+  end
+
+  def goto(index = 0)
+	 if( index >= 0 && index < @playlist.length() )
+		@index = index
+	 else
+		return -1
+	 end
+  end
+
+  def length()
+	 @playlist.length()
+  end
+
+  def each()
+	 @playlist.each { |song| yield(song) }
+  end
+
+  attr_reader	:wrap, :index, :filename
+  attr_writer	:wrap
+end