Free simple machines software for linux

Simple Meeting Website project is a simple TurboGears Web site that can track RSVPs for a series of meetings.
Enhancements:
- Emailed meeting reminders have been added (activated by a cron job).
- The site now validates as HTML 4.01 Strict.

Simple Timetracker provides an application for keeping a record of time vs tasks.

Timetracker is a Java application for recording time spent on projects and activities.

Simple Invoices is a clean, simple, and basic Web-based invoicing system.

Simple Invoices is meant for personal invoices, home office invoicing, small organization invoicing, and basic POS (point of sale) systems for light usage.

Its goals are to be easy to use, simple and clean, and focused on its task. It is not meant for heavy-use POS applications, nor is it meant to be enterprise ready.

Simple Multitrack contains a set of programs that allows the simultaneous recording of an audio track while listening to a monitor mix of other tracks.

This software uses the OSS audio drivers found in the Linux kernel or the
CoreAudio API on Mac OS X. It has been tested on

Linux 2.4.20 on a Pentium III 1.4GHz with a SBLive soundcard, and
Linux 2.4.20 on a Pentium I 120MHz laptop with a Crystal soundcard.
Mac OS 10.3.3 on a PowerBook G4.

Both Linux machines are running Slackware, so please tell me about your successes or problems on other distros.

Please read the BUGS section of this document. If you have bug reports, bug fixes, questions, comments, criticism, improvements, or documentation corrections please e-mail me.

OVERVIEW:

./build
cd bin;
source shellsetup;

This will compile the programs and put them in your path.
It will also make your shell prompt shorter, so you have room.
It will also define a little function that is explained below.

to record initial track:
srp < /dev/zero > my_file

to listen to a track:
mix 2 1 1 1 my_file | srp > /dev/null

to listen to one track while recording a new track:
mix 2 1 1 1 file_1 | srp > file_2

to listen to two tracks while recording a new track:
mix 2 1 .5 .5 file_1 .5 .5 file_2 | srp > file_3

Simple Multitrack is basically two programs. They were designed to be used together, but they might be useful on their own. I will describe each program separately before discussing them together.

mix is a command line program. It mixes one or more monophonic audio files into a single output stream. The output stream can have any number of channels: mono, stereo, quad, whatever you like. The output stream is written to standard out.

The input files are specified as command line arguments, as are the gain settings for each input. Invocation goes like this (in stereo mode):

mix nocs mgain l_gain_1 r_gain_1 file_1 l_gain_2 r_gain_2 file_2 ...

where nocs is the number of output channels, and mgain is the master gain.

Command line arguments to mix after the nocs and mgain arguments are the channels. For N output channels, you will have N gain arguments and then the name of the file. Therefore, the arguments after nocs and mgain must appear in (nocs+1)-tuples.

mix will continue to pump out an endless stream of silence after the end of the input files is reached. This behavior is different from most UNIX command line programs, which exit at the end of their input data, which closes their stdout.

mix can be exited with the keyboard interrupt, ctrl-c. The input files must be 16-bit 44100 samples/sec monophonic raw signed word files. The output stream is in 16-bit 44100 samples/sec stereo raw signed word format. (Thank God, its in word format!) The program sox can be used to convert from most audio formats to and from most other audio formats.

EXAMPLES:

mix 2 1 0 1 my_file
This pans my_file completely to the right.

mix 2 1 1 1 my_file
This centers my_file.

mix 2 .5 1 0 flute 0 1 viola
This puts the flute completely to the left and viola completely to the right.
The master_gain is set to .5 to reduce the overall level of the mix by 3dB.

mix 2 .5 1 .3 flute .2 .9 viola
This is similar but gentler.

mix 2 .5 2 .6 flute .2 .9 viola
This is the same but the flute is louder.

mix 2 1 2 .6 flute .2 .9 viola .3 .3 violin
The violin is added in the center.

Note: If you get clipping errors when using mix, you can lower the mgain factor instead of adjusting all of the individual channel gains, although that works too.

srp is a command line program. It enables simultaneous recording and playback of audio using a sound card. It will only work if your sound card and its driver support full-duplex operation correctly.

srp reads a stream of stereo 16-bit 44100 samples/sec raw signed word data on standard in and plays that stream out on the soundcard. Meanwhile, it reads from the left channel of the soundcard and writes a mono 16-bit 44100 samp/sec stream on standard out.

Virtual Drum Machine is a simple drum machine.
It works for little endian/linux kind of machines. You may let it work on others machines, but you probably will get troubles with it.
You definitely need oss (or maybe alsa) for sound output, and a posix-like operating system. To let it work on a big endian machine should be painful.
You write a rhythm, then you compile it, then you are able to play it to your sound card or save it to a file.
The Virtual Drum Machine is made of
- the Rhythm Compiler,
- the runtime library.
The Virtual Drum Machine is in the public domain. Who needs a license? money makers? Protection against robbery? let me laugh... Read any text of law, you will see where the robbers reside.
A simple file would look like :
void main_rhythm(void)
{
tempo = 120;
- a
. b
. b
.
- a
.b
- a
.
. b
. b
- a c
. b
}
Install:
Do a "./configure" in the drums directory, then "make", then "make install", it should be alright. You can listen to some examples in the examples/ directory.
Who yo use it?
Write a rhythm. Compile it with "rc". Run the produced program. You are done.
See the examples/ directory to get the point.
When you run an example, try "-h" to get the available options.
It should be self-explanatory.
The rhythm compiler has several options. By running "rc --help", all should be clear.
Technical Details:
The compiler will parse the input file line by line.
If a line starts with "*" or "." (not counting leading white spaces), the whole line is seen as a rhythm line, and is transformed into C code. If not, it is passed as is to the C file.
Beware! You MUST NOT start any C code line by "*" or "."!
You can create as much functions as you want, write any C code you want. But remember that a line starting by "*" or "." is seen as a rhythm line and is translated by "rc" into C code.
You must provide a "void main_rhythm(void)" function, that will be called by the library. It is the starting point of your rhythm. It can be "void main_rhythm(int argc, char *argv[])" too, with common meaning for those parameters (non-C coders will have trouble with the Virtual Drum Machine).
You can change the tempo (ex. "tempo=100;") or the volume (ex "vol=0.4;") at any time. Each sample comes with its own volume and panning (ex. "a.vol = 0.1;" "a.pan=-0.8;"). Volumes range from 0 to what you want. 1 is for the normal volume. Panning ranges from -1 (left) to 1 (right). 0 is center. All values are double. You can use "volume" instead of "vol", and "panning" instead of "pan". There is no global panning, if you want all left, set all samples to left.
To run in stereo mode, dont forget "-s" when running the generated program. It is mono by default.
You absolutely need to compile and run the examples, and read them to get the point out of it!
The "rc.conf" file contains configuration informations. You specify the sample by "sample" followed by its name (the one you will use in your rhythm files), then the file that will be played. The name of the sample must start by a letter, followed by letters and/or numbers (it must be a valid C identifier, without "_" though). The configuration file contains the install directory, used by "rc" to compile your rhythms. Take a look at the one that is provided to see how to use it.
The sound files are simple wav files. They all should be of the same rate, which can be specified to the generated program, using the "-f" option (44100 is the default). (The library only handles very basic wav files, if yours dont work, you probably will have to modify the library for the program to handle it.)
When you add a sample, you must modify "rc.conf" for the changes to appear. The samples are hard-linked to the produced program, so if you change "sample a /some/dir/file1.wav" by "sample a /one/other/dir/file2.wav" in the configuration file, the previously generated programs will still use "/some/dir/file1.wav". You will have to compile them again to take the changes into account.
Enhancements:
- The code has been modified to let gcc 4 compile it.

XML::SAX::Machine is a Perl module that can manage a collection of SAX processors.

SYNOPSIS

## Note: See XML::SAX::Pipeline and XML::SAX::Machines first,
## this is the gory, detailed interface.

use My::SAX::Machines qw( Machine );
use My::SAX::Filter2;
use My::SAX::Filter3;

my $filter3 = My::SAX::Filter3->new;

## A simple pipeline. My::SAX::Filter1 will be autoloaded.
my $m = Machine(
#
# Name => Class/object => handler(s)
#
[ Intake => "My::SAX::Filter1" => "B" ],
[ B => My::SAX::Filter2->new() => "C" ],
[ C => $filter3 => "D" ],
[ D => *STDOUT ],
);

## A parser will be created unless My::SAX::Filter1 can parse_file
$m->parse_file( "foo.revml" );

my $m = Machine(
[ Intake => "My::SAX::Filter1" => qw( Tee ) ],
[ Tee => "XML::Filter::SAXT" => qw( Foo Bar ) ],
[ Foo => "My::SAX::Filter2" => qw( Out1 ) ],
[ Out1 => $log ],
[ Bar => "My::SAX::Filter3" => qw( Exhaust ) ],
);

WARNING: This API is alpha!!! It will be changing.

A generic SAX machine (an instance of XML::SAX::Machine) is a container of SAX processors (referred to as "parts") connected in arbitrary ways.

Each parameter to Machine() (or XML::SAX::Machine-new()>) represents one top level part of the machine. Each part has a name, a processor, and one or more handlers (usually specified by name, as shown in the SYNOPSIS).

Since SAX machines may be passed in as single top level parts, you can also create nested, complex machines ($filter3 in the SYNOPSIS could be a Pipeline, for example).

A SAX machines can act as a normal SAX processors by connecting them to other SAX processors:

my $w = My::Writer->new();
my $m = Machine( ...., { Handler => $w } );
my $g = My::Parser->new( Handler => $w );

Simple Xmms Control is a a simple SuperKaramba theme that provides XMMS control. Icons are from nuoveXT icon theme.

All suggestions are welcome!

LJ::Simple is a Perl module to provide a simple OOP-based API for accessing the LiveJournal system.
Main features:
- Log into LiveJournal
- Post a journal entry
- Edit a journal entry
- Delete a journal entry
Example
The following example posts a simple message into the test LiveJournal using the LJ::Simple::QuickPost method.
use LJ::Simple;
LJ::Simple::QuickPost(
user => "test",
pass => "test",
entry => "Just a simple entry",
) || die "$0: Failed to post entry: $LJ::Simple::errorn";
The next example shows how to post an entry into the test LiveJournal using the complete, object-based, interface:
use LJ::Simple;
my $lj = new LJ::Simple ({
user => "test",
pass => "test",
});
(defined $lj)
|| die "$0: Failed to log into LiveJournal: $LJ::Simple::errorn";
my %Event=();
$lj->NewEntry(%Event) ||
die "$0: Failed to create new entry: $LJ::Simple::errorn";
my $entry=SetMood(%Event,"happy")
|| die "$0: Failed to set mood: $LJ::Simple::errorn";
$lj->Setprop_nocomments(%Event,1);
my ($item_id,$anum,$html_id)=$lj->PostEntry(%Event);
(defined $item_id)
|| die "$0: Failed to post journal entry: $LJ::Simple::errorn";