Free jukebox software for linux

Jukebox4 is a collection of reusable components allowing to create a flexible server side middleware framework.

Save time for drinking coffee instead of architecting, designing and coding the same stuff again, and again, and again.

The project originated in 1990, when the first commercial C++ compiler became available. At that time, it was a combination of a collection framework a-la Smalltalk with the smart pointer infrastructure allowing not to bother with pointers any more.

In 1992, it was ported to MS Windows (3.x at that time). In 1993, a banking operations division support system was written using this projects codebase as a foundation. That was the first time the semaphores and multithreading were introduced.

In 1994, it was ported to OS/2, the semaphore model was redesigned, and true multithreading was achieved for the first time. A countrywide project tracking system was written using Jukebox as a foundation.

In late 1995, Java arrived. At that time it was a sad event, because with it came the realization of the fact that all the collection framework was no longer necessary, so was the smart pointer framework, and most of the semaphore and multithreading code. Well, theres no cloud without a silver lining, the thorough redesign was long overdue anyway, so the project was ported into Java during 1996. Another distributed system, this time related to securities trading, was created on top of Jukebox.

In 1998, Ive started working with Apache JServ team, and eventually sneaked my logging infrastructure into JServ, and got a nickname: "Captain Log" ;) At the same time it has become obvious that the attempt to make Jukebox a "multiprotocol distributed framework" failed, because Sun had more manpower and could release APIs much faster than I did.

In 2000, Jukebox was chosen to become the foundation for the project at American Express. That was the first take at high-load mission-critical application. Surprisingly, no major problems emerged, thus giving me some ego boost.

Then, starting in 2001, Jukebox was used at another Open Source project, DIY Zoning. This ongoing project is an attempt to scale the framework down, rather than up. The work is not yet finished, but the results, of course, will be visible.

jukebox-control project is a complete automation for Sony A/V components featuring S-Link (CD, DVD, MD, etc).
jukebox-control includes a Linux driver module for an easy/dirty cheap to build DIY parallel to the Sony S-Link interface, plus Perl modules with both control-A1 (II) and control-S protocol implementations.
Its actually-incomplete development state makes it interesting for developers mostly.
Enhancements:
- Bidirectional Control-A1 protocol fully supported
- Unidirectional Control-S protocol implemented, not fully supported yet.
- New object model that ties A1 and S devices together under the same base class.
- CDDB support has been removed temporarily. I am rewriting most of the modules at this time.
- No real user interface. Hey! This is a interim release.

MP3 Jukebox-Tk is an organizer/jukebox for local mp3 collections. MP3 Jukebox-Tk sorts your mp3 files by band and presents a jukebox style interface to let you choose which ones to play.

It then passes these off to XMMS for playing. It also keeps stats on what you listen to, and can use those stats to generate a weighted random playlist for you. Non-weighted (truly random) playlists are also available.

The Sajber Jukebox is a mpeg layer 3 player with a graphical user interface. Its based on Woo-jae Jungs splay for the audio and has a QT based graphical library for the interface.
Main features:
- Supports mpeg layer 3. The support for mpeg layer 1 & 2 and wav files is still in there, but untested.
- Playing of the net. By using normal http addresses, ie http://whatever.host.on.the.net/~someguy/song.mp3, you can play without having to first download.
- Forward, Rewind, Pause, Seek. The Sajber Jukebox allows for moving backwards and forwards in the song [unless its streaming, then rewind wont work]. By pressing on the progression bar you can make swift jumps to any place in the song of your liking.
- Mixer control. The Sajber Jukebox comes with a mixer control that allows you to change bass, treble, volume and pcm/dsp setting at any time without having to start a second program.
- Three types of browsers:
- File Browser. A local filemanager type of browser, which allows you to click around on your local system and select songs you wish to play.
- Standard Database. A database which allows you to recursively scan the harddisk or a directory structure in search for songs. The database is sorted by group, album and songname and makes it easy to keep track of your songs, unregardless of where on the harddisk they are located. It also supports http references in addition to ordinary files.
- Http Browser. This browser allows for playing songs of the net, and scanning home pages for songs. By giving the Http Browser an URL to a page, it will retrieve it and search it through for any references to playable files.
- Selections. You can select songs from any number of browsers, and play them with repeat and random.
- Configurability. The Sajber Jukebox is easy to configure, and provides a graphical interface instead of having to figure out how various options in the obscure rc files works.
- Saving. Selections, Standard Databases, Http Browsers and configurations can be saved to disk for easy retrieval, or autoloading at startup.
- Realtime threads. If youre a daredevil who believes that everything else on your machine oughta come second to the playing of audio, you can configure your player to use realtime scheduling.
- Bookmarks. You can save and edit bookmarks to various http or local locations for swift jumps around the filesystem or the world.
- Progression bar and timer to keep track of where in the song you are.
- Easily change between different databases and browsers.
- A smaller Players window, with the basic functions which wont cover the entire screen.

The Polar Jukebox System (PJS) is a set of curses and console applications that allow you to manage huge amounts of MP3 files. It stores all information in a PostgreSQL database for fast and reliable acces.
The reason I started this project is that I always wanted a easy-to-use music collection, and I reached that goal with the PJS. I started programming in late 1998 and kept programming from time to time. Now I think the PJS is ready for the public, even not everything that is possible has been done - but it works!
The PJS runs under the GPL (GNU Public License) an can be installed on computers running Debian GNU/Linux, other distributions are not supported till now, and I still need help for packing the PJS to others dists.
Main features:
- Riping/encoding of audio CDs (with CDDB support) into the PJS with jrec
- Easy management of a big CD Collections with jplay
- Playlistgeneration and -management
- Automatic playlists (alltime charts, newcomers, rarely played...)
- Special play modes (random, linear...)
- Export of CDs to CD-R
- Database (postgresql) storage of the track and CD information

POE::Component::NomadJukebox is an event-based contol of Nomad Jukebox players.

SYNOPSIS

use POE qw(COmponent::NomadJukebox);
use Data::Dumper;

POE::Session->create(
inline_states => {
_start => sub {
POE::Component::NomadJukebox->create({ alias => njb });
},
njb_started => sub {
$_[KERNEL]->post(njb => discover);
},
njb_discover => sub {
my ($kernel, $heap, $devlist) = @_[KERNEL, HEAP, ARG0];

unless (ref($devlist)) {
print "Failed to find Nomad Jukebox, is it on?n";
$kernel->post(njb => shutdown);
return;
}

# open the first device
# pass the device id to open
$kernel->post(njb => open => $devlist->[0]->{DEVID});
},
njb_opened => sub {
my $kernel = $_[KERNEL];
$kernel->post(njb => disk_usage);
$kernel->post(njb => track_list);
},
njb_disk_usage => sub {
my ($kernel, $heap, $info) = @_[KERNEL, HEAP, ARG0];

unless (ref($info) eq HASH) {
print "Failed to get disk usagen";
return;
}
my $used = $info->{TOTAL} - $info->{FREE};
print "Total:$info->{TOTAL} bytes Free:$info->{FREE} bytes Used:$used bytesn";
$kernel->post(njb => shutdown);
},
njb_track_list => sub {
my ($kernel, $heap, $tracks) = @_[KERNEL, HEAP, ARG0];

$kernel->post(njb => shutdown);

unless (ref($tracks) eq ARRAY) {
print "Failed to get track listn";
return;
}
print "There are ".scalar(@$tracks)." tracksn";

print Data::Dumper->Dump([$tracks]);
},
njb_closed => sub {
print "Nomad Jukebox closedn";
},
},
);

$poe_kernel->run();

POE::Component::NomadJukebox - Event-based contol of Nomad Jukebox players using the libnjb api located at http://libnjb.sourceforge.net/

This module _requires_ libnjb and you may need to be root, or change your usb device access permissions.

Juked is a daemon that acts as an audio jukebox. Juked project is free software and is made available under the terms of the GPL.
Juked is constantly under development and should not be considered stable in any way. Bug reports/fixes/patches are welcome.
Main features:
- database plugins for:
- standalone XML database
- digitaldj (http://nostatic.org/ddj)
- mp3kult (http://mp3kult.sourceforge.net).
- sample python client (pyjuke).
- playlist support.
- random track selection.

Julie is a music jukebox that supports MP3 and Ogg formats and is very configurable. It is split into a number of modules that allow the user interface to be run on a different machine from the playing daemon, etc. It is built around the idea of continuous playback, with a short songlist that is constantly filled. The upcoming playlist can be modified.

Julie was originally written as an MP3 player for parties. It was often the case that people wanted to add their own songs to the playlist and it took time to get to the machine to press skip when a bad track came on.

Julie was started with a number of simple design goals in mind:

1. Simplicity: Julie should be easy to use when youre drunk.
2. Glue Code: most of the tools are out there (MP3 players etc); we just want them to work together.
3. Flexibility: we want to cater for networks and multiple users.
4. Huge Music Collections: XMMS just doesnt cut it when you want to find a particular song in a 20GB collection.

And thus Julie was born. Originally it used mpg123 to play music (until we found out how horribly broken mpg123 and mpg321 were!) and Julie itself did very little. Thanks to Jaq, Julie now plays MP3s and OGGs natively.

Julie has a very simple interface to use, and allows text searches of songs which can be added the playlist. The playlist provides a preview of the next songs that will be played so you can see what will be playing, and add to, delete from, or re-arrange the selection.

Julie is built around the idea of continuous play. If you do not manually select any music it will just pick for you. You can always edit the playlist or skip tracks, however, and if the impulse takes you, you can play a song directly from the playlist or search results.

The random selection tries to be a bit intelligent: there is also a banish function for songs you never want to hear again, and there is a (configurable) delay within which it will not repeat a song. In the future we hope to add a more intelligent song rating system.

Julie also provides a per-song volume setting, which is stored in the database so you can manually adjust quiet and loud songs without changing the main volume level.