Free portable dvd player software for linux

Ogle is a real DVD player that supports DVD menus and navigation. It can access CSS-protected DVDs if you have libdvdcss installed, take screen shots, and view movies in fullscreen mode.
It handles angles correctly and automatically uses the correct aspect. You can switch subtitles and audio tracks. It runs on Linux, FreeBSD, NetBSD, OpenBSD, and Solaris.
Main features:
- Supports DVD menus and navigation.
- Reads from mounted, unmounted DVDs and hard drive.
- Reads encrypted and unencrypted DVDs using libdvdread/libdvdcss.
- A new MPEG2 decoder with MMX, Altivec and SUN Solaris mediaLib acceleration.
- Normal X11 and XFree86 Xvideo display support with subpicture overlay.
- Accelerated display on Sun FFB2+ cards.
- Audio and subpicture selection.
- Handles advanced subpicture commands such as fade/scroll and wipe.
- Detects and uses correct aspect for movie and menus.
- Possible to play AC3, DTS, MPEG, LPCM via S/PDIF.
- Hardware yuv2rgb on Sun FFB2+ (Creator3D).
- Fullscreen mode.
- Screenshots with and without subpicture overlay.
- Title/chapter search.
- Audio formats supported: AC-3, MPEG, LPCM (DTS only via SP/DIF).
Version restrictions:
- Reverse play not implemented.
- No angle selection during playback (angle selection in DVD menu works).
- No closed caption support (not the same as subpicture subtitling).
- DTS audio not supported (other than via SP/DIF).
- To play another DVD you have to restart the program.
- Karaoke mode is missing.

MP is a module player for Linux. It is able to play 18 module formats (such as mod, xm, s3m, and it).

MP is actually a single executable file (mp).

To install MP on your system, just type make and wait for the compilation process to end. Once compiled, you may test MP by typing ./mp . If it is working, and good enough for you, install MP on your system by typing make install. This will copy the binary file mp to the /usr/local/bin directory.

MPEG Audio/Video Player is a simple MPEG and AC3 player for Linux, BSD, and Windows systems.
It plays MPEG transport, program, and elementary stream files. It also has basic DVD support (using libdvdnav on Linux/BSD sytems only).
Main features:
- Runs on Windows, Linux, and BSD systems.
- Plays MPEG Transport Stream, Program Stream, and Elementary Stream files.
- Basic DVD support (with libdvdnav on Linux/BSD systems only).
- Decodes MPEG 1&2 Video, MPEG Layer 2 Audio, and AC3 audio.
- All decoders use only integer operations, for faster performance.
- Flexible, and easy to use decoders, that can decode streams in chunks as small as 1 byte (buffering is not necessary).

I like using Amarok for managing my podcasts but I wasnt able to play my video podcasts.

Amarok Video Player adds a PlayVideo/Play menu item to the context menu which runs KMPlayer.

Edit the script to change KMplayer to another video player.

YOLK XMMS PLAYER is a Xmms player control SuperKaramba theme.
I realized that Aqua is required in most desktop palletes.
It supports:
- Play
- Pause
- REW
- FWW

Ixion is a media player that uses wxWidgets and GStreamer. Its is just a simple video player that can play at double or half speed. It can be useful as an example of how to write a simple app based on wxWidgets and/or GStreamer.

Ixion is a media player written in C/C++ using wxWidgets and GStreamer. It is not a bleeding edge, full-featured, eye-candy, all-in-one application; Ixion exists only because I needed a video player that could play at double or half speed. However, it can be useful if you want to see how to write a simple app based in wxWidgets and/or GStreamer. Source code is available for download under the GPL license.

You can download the source code from the downloads section. It will compile on most *nix systems ig there are the required libraries, including GNU/Linux.

Alternatively, you can get the source code using anonymous CVS access:
$ cvs -d:ext:anonymous@cvs.lug.fi.uba.ar:/cvsroot/ixion co ixion

CGI::Portable is a framework for server-generic web apps.

SYNOPSIS

Content of thin shell "startup_cgi.pl" for CGI or Apache::Registry env:

#!/usr/bin/perl
use strict;
use warnings;

require CGI::Portable;
my $globals = CGI::Portable->new();

use Cwd;
$globals->file_path_root( cwd() ); # let us default to current working directory
$globals->file_path_delimiter( $^O=~/Mac/i ? ":" : $^O=~/Win/i ? "" : "/" );

$globals->set_prefs( config.pl );
$globals->current_user_path_level( 1 );

require CGI::Portable::AdapterCGI;
my $io = CGI::Portable::AdapterCGI->new();

$io->fetch_user_input( $globals );
$globals->call_component( DemoAardvark );
$io->send_user_output( $globals );

1;

Content of thin shell "startup_socket.pl" for IO::Socket::INET:

#!/usr/bin/perl
use strict;
use warnings;

print "[Server $0 starting up]n";

require CGI::Portable;
my $globals = CGI::Portable->new();

use Cwd;
$globals->file_path_root( cwd() ); # let us default to current working directory
$globals->file_path_delimiter( $^O=~/Mac/i ? ":" : $^O=~/Win/i ? "" : "/" );

$globals->set_prefs( config.pl );
$globals->current_user_path_level( 1 );

require CGI::Portable::AdapterSocket;
my $io = CGI::Portable::AdapterSocket->new();

use IO::Socket;
my $server = IO::Socket::INET->new(
Listen => SOMAXCONN,
LocalAddr => 127.0.0.1,
LocalPort => 1984,
Proto => tcp
);
die "[Error: cant setup server $0]" unless $server;

print "[Server $0 accepting clients]n";

while( my $client = $server->accept() ) {
printf "%s: [Connect from %s]n", scalar localtime, $client->peerhost;

my $content = $globals->make_new_context();

$io->fetch_user_input( $content, $client );
$content->call_component( DemoAardvark );
$io->send_user_output( $content, $client );

close $client;

printf "%s http://%s:%s%s %sn", $content->request_method,
$content->server_domain, $content->server_port,
$content->user_path_string, $content->http_status_code;
}

1;

^The CGI::Portable class is a framework intended to support complex web applications that are easily portable across servers because common environment-specific details are abstracted away, including the file system type, the web server type, and your projects location in the file system or uri hierarchy.

Also abstracted away are details related to how users of your applications arrange instance config/preferences data across single or multiple files, so they get more flexability in how to use your application without you writing the code to support it. So your apps are easier to make data-controlled.

Application cores would use CGI::Portable as an interface to the server they are running under, where they receive user input through it and they return a response (HTML page or other data type) to the user through it. Since CGI::Portable should be able to express all of their user input or output needs, your application cores should run well under CGI or mod_perl or IIS or a Perl-based server or a command line without having code that supports each types individual needs.

That said, CGI::Portable doesnt contain any user input/output code of its own, but allows you to use whatever platform-specific code or modules you wish between it and the actual server. By using my module as an abstraction layer, your own program core doesnt need to know which platform-specific code it is talking to.

As a logical extension to the interfacing functionality, CGI::Portable makes it easier for you to divide your application into autonomous components, each of which acts like it is its own application core with user input and instance config data provided to it and a recepticle for its user output provided. This module would be an interface between the components.

This class has 5 main types of functionality, or sets of properties that exist in parallel but are fully/mostly independant from each other. As such, it could conceptually be split into 5 physical modules, some of which could be used on their own, but they are actually contained in this one module for simplicity of use (just one object for user code to keep track of). The 5 functionality sets could be called: Errors, Files, Request, Response, Misc.

aeon is a music player that is meant to look nice and have an interface that is as easy to use as possible.

In contrast to BMPx it is entirely library based, which means you cant add individual files to it, but you have rather to add them to the library beforehand.

You can only play files from the library (akin to RhythmBox/iTunes).