Free audio m4p 0.30 software for linux

Audio::M4P is a Perl module that provides M4P/MP4/M4A QuickTime audio music format modules.

M4P is a QuickTime protected audio file format.

SYNOPSIS

use Audio::M4P::QuickTime;

my $mp4file = "file.m4p";
my $qt = new Audio::M4P::QuickTime(file => $mp4file);
my $tags = $qt->GetMetaInfo;
print "Artist is $tags->{ARTIST}n" if $tags->{ARTIST};


use Audio::M4P::Decrypt;

my $outfile = mydecodedfile;
my $deDRMS = new Audio::M4P::Decrypt;
$deDRMS->DeDRMS($mp4file, $outfile);

See also the individual pod documentation for Audio::M4P::QuickTime
and Audio::M4P::Decrypt.

Audio::MPD is a class for talking to MPD (Music Player Daemon) servers.

SYNOPSIS

use Audio::MPD;

my $mpd = new Audio::MPD();
$mpd->play();
sleep 10;
$mpd->next();

Audio::MPD gives a clear object-oriented interface for talking to and controlling MPD (Music Player Daemon) servers. A connection to the MPD server is established as soon as a new Audio::MPD object is created. Commands are then send to the server as the classs methods are called.

Audio::M4P::QuickTime is a Perl module for m4p/mp4/m4a Quicktime audio files.

Perl manipulation of Quicktime Audio files, including protected audio M4P files. Allows extraction and modification of meta information in Apple QuickTime AAC/m4a music files.

About QuickTime File Structure and Atoms

M4P is a QuickTime protected audio file format. It is composed of a linear stream of bytes which are segmented into units called atoms. Some atoms may be containers for other atoms. iTunes Music Store M4P music files are Quicktime audio files which are encrypted using a combination of information in the files drms atom and information which is commonly stored on the computer or audio player.

SYNOPSIS

use Audio::M4P::QuickTime;

my $mp4file = "file.m4p";

my $qt = new Audio::M4P::QuickTime(file => $mp4file);

my $tags = $qt->GetMetaInfo;

print "Artist is $tags->{ARTIST}n" if $tags->{ARTIST};

Audio::SPX is a Perl interface to the Sphinx-II audio library.

SYNOPSIS

use Audio::SPX;
my $ad = Audio::SPX->open_sps(16000);

$ad->start_rec or die "start_rec failed";
$ad->stop_rec or die "stop_rec failed";
my $samples = $ad->read($buf, $max);

my $cad = Audio::SPX::Continuous->init($ad);
my $cad = Audio::SPX::Continuous->init_nbfh($fh, $sps);
my $cad = Audio::SPX::Continuous->init_raw($fh, $sps);

$cad->calib;
$cad->calib_loop($buf);
$cad->set_thresh($sil, $sp);
$cad->set_params($delta_sil, $delta_speech, $min_noise,
$max_noise, $winsize, $speech_onset,
$sil_onset, $leader, $trailer);
my ($delta_sil, $delta_speech, $min_noise, $max_noise,
$winsize, $speech_onset, $sil_onset, $leader, $trailer)
= $cad->get_params;

# If init_raw was used, this will consume the data in $buf, then
# write back any non-slience data. Yes, this feature is
# undocumented in the Sphinx-II headers. Yes, its very useful.
my $samples = $cad->read($buf, $max);

$cad->reset;
$cad->detach;
$cad->attach($ad);
$cad->read_ts;
$cad->set_logfp(*FH);

Warning! This interface is suboptimal and is therefore probably going to change, both in the Perl module and the underlying library.

BUGS

The only supported sample rate for Audio::SPX is 16kHz (Audio::SPX::Continuous should be fine with others). init_sps() will simply fail rudely if you try something else... which means it isnt really very useful. I suggest either opening the audio device yourself, setting non-blocking mode (beware, some sound drivers dont like this...) and passing it to the init_nbfh method in Audio::SPX::Continuous, or using init_raw and managing the audio device yourself.

There isnt enough documentation yet, partly because the API is somewhat in flux, and partly because I havent figured out what some of this stuff does either.

Audio::CD is a Perl interface to libcdaudio (cd + cddb).

SYNOPSIS

use Audio::CD ();
my $cd = Audio::CD->init;

Audio::CD provides a Perl interface to libcdaudio by Tony Arcieri, available from http://cdcd.undergrid.net/

Several classes provide glue for the libcdaudio functions and data structures.

Audio::CD Class ^

init

Initialize the Audio::CD object:
my $cd = Audio::CD->init;

stat

Stat the Audio::CD object, returns an Audio::CD::Info object.
my $info = $cd->stat;

cddb

Returns an Audio::CDDB object.
my $cddb = $cd->cddb;

play

Play the given cd track (defaults to 1).
$cd->play(1);

stop

Stop the cd.
$cd->stop;

pause

Pause the cd.
$cd->pause;

resume

Resume the cd.
$cd->resume;

eject

Eject the cd.
$cd->eject;

close

Close the cd tray.
$cd->close;

play_frames

$cd->play_frames($startframe, $endframe);

play_track_pos

$cd->play_track_pos($strarttrack, $endtrack, $startpos);

play_track

$cd->play_track($strarttrack, $endtrack);

track_advance

$cd->track_advance($endtrack, $minutes, $seconds);

advance

$cd->advance($minutes, $seconds);

get_volume

Returns an Audio::CD::Volume object.

my $vol = $cd->get_volume;

set_volume

$cd->set_volume($vol);

Rudiments is a C++ class library providing base classes for things such as daemons, clients, and servers, and wrapper classes for the standard C functions for things like semaphores, regular expressions, and signal handling.
In the early days of SQL Relay and Groundwork, some of the classes being developed for each project didnt exactly fit. Or more precisely, could concievably be useful in other projects. Some of these classes were very generic base classes, others were utilities. The older the projects got, the more obvious it became that these classes should be extracted and assembled into a library of their own.
Rudiments was born.
As a result, some of the rudiments classes are fairly full featured and others very incomplete; containing only the functions that were required by the project they were derived from.
Rudiments is very much a work in progress, and not extremely well defined at that. Currently though, the objective of the project is to develop a set of utility classes that provide the functionality of the standard C libraries through an object oriented interface and a set of useful base classes for some standard kinds of programs.
Enhancements:
- This release fixes several memory leaks, a vulnerability in readdir_r, and a few additional methods in several classes.

Audio::Moosic is a Moosic client library for Perl.

SYNOPSIS

use Audio::Moosic;

$moo = Audio::Moosic::Unix->new();

$moosic->append(/home/me/somewhat.ogg);
$moosic->play;
print $moosic->current, "n";
$moosic->pause;
...

Audio::Moosic acts as a client for the musical jukebox programm Moosic (http://nanoo.org/~daniel/moosic/) by Daniel Pearson.

Using Audio::Moosic you can connect to a moosic server either via an UNIX socket or an INET socket.

Implements a LADSPA 1.1 host.

SYNOPSIS

use Audio::LADSPA;

for my $class (Audio::LADSPA->plugins) {
print "t",$class->name," (",$class->id,"/",$class->label,")";
}

LADSPA plugins are objects in shared libraries that can generate or transform audio signals (like VST or Direct-X plugins on Mac and Win32 systems). Most of the existing LADSPA plugins are pretty low-level compared to VST plugins (you get seperate oscilator, ADSR and delay plugins instead of "complete" virtual synthesizers etc). See also http://www.ladspa.org/

With these modules you can create a LADSPA host, which can load the plugins, query their capabilities, connect them together in a network, and run audio streams through them.

The LADSPA API was developed for linux but should be platform independent, so you might be able to compile these modules and the nessisary plugins on win32 systems (please let me know if it works or not).