Free manipulations software for linux

The General Stream Manipulation Platform (GSMP) aims to become for sound what The GIMP is for graphics.
Some years ago, there had been a lack of useable audio-software for Linux - especially for a good multitrack wave-editor - so we decided to write a gtk-- based one that is available under the terms of the GPL.
Now we focus on building a complete and open-source Virtual Studio environment for Linux:
GSMP Studio will feature both MIDI and DSP/Audio as well as beeing open for other kind of data.
It is intended to become a powerfull framework for the user to assemble his own "virtual studio" within the application from various components (like multitrack hd-recorder, midi-sequencer, synth and signalprocessors).
Other than most commercial applications of this kind, the hd-recorder and midi-sequencer will not be the neccessary components of this studio, and setups without them will be possible. For example GSMP can be used as a synthesizer or multi-effect-proccessor in live-setups.
Main features:
- Non-destructive editing: All action on the audio data can be made undone. So you can play around with the effects without modifying any bit of your original data file.
- Multi-threaded design: GSMP is multi-threaded. Especially the the wave-plots and the FXs are generated in a background thread and the UI keeps interactive!
- Internal sample-format: 24/8 bit fixed-point arithmetic is used to allow overflows with no acurrany loss.
- Internal sample-index: 64 bit indexes are used to allow live takes even at 96kHz DVD quality.
- Track count: The track count is not limitted. Also multi-track recording is supported, too. In fact we used GSMP-Editor to record 10 channels with the MIDIMAN Delta 1010 two month ago!!! (BTW: 2-8% CPU load on an Athlon 600Mhz ...)
- Realtime effect prehearing: Most effects can be pre-heared during playback!
- Supported import-formats: Currently MS-Wave, Ogg/Vorbis and MP3 (experimental!!!) are supported. Decompression is done on-the-fly!
- Supported export-formats: Currently only Wave is supported.
- Current effects: Fadings, graphical-eq, some IIR filters, compressor, noise-gate, de-click and reverb.
- The editor has multi-selections. This means you can select non-continous regions (that can be cutted or pasted) - like in The GIMP. You have to press the "Shift" or "Strg" key while moving the mouse for this.
- To enable the OSS plugin when ALSA is also compiled you have to add "--oss" on the command line. (The next release will contain a real dialog to change this ...)
- The two button in the lower-left corner of the main-window are "Follow Current Position" and "Follor IO Position" to let the view automatikally follow a marker ;-)
- When you load (import) a file the zoom is not changed. So you might not see a wave, because the zoom is still 1:1 -> simply zoom out a bit.
- To speed-up GSMP you should pipe all the debugging informations into the "null-device": "gsmp > /dev/null"

PG Calculator is a powerfull scientific skinable calculator. PG Calculator is an excellent replacement for standard Windows calculator.
PG Calculator works in algebraic and RPN mode. It recognizes real and complex numbers and allows simple vectors manipulations.
There are up to 120 recognized units of measure with possibility to make easy conversions between consistent units.
Enhancements:
- fixed to compile with GCC 4.1.1

Mail::Field is a base class for manipulation of mail header fields.

SYNOPSIS

use Mail::Field;

$field = Mail::Field->new(Subject, some subject text);
print $field->tag,": ",$field->stringify,"n";

$field = Mail::Field->subject(some subject text);

Mail::Field is a base class for packages that create and manipulate fields from Email (and MIME) headers. Each different field will have its own sub-class, defining its own interface.

This document describes the minimum interface that each sub-class should provide, and also guidlines on how the field specific interface should be defined.

Scalar::Properties is a Perl module package that contains run-time properties on scalar variables.

SYNOPSIS

use Scalar::Properties;
my $val = 0->true;
if ($val && $val == 0) {
print "yup, its true alright...n";
}

my @text = (
hello world->greeting(1),
forget it,
hi there->greeting(1),
);
print grep { $_->is_greeting } @text;

my $l = hello world->length;

Scalar::Properties attempts to make Perl more object-oriented by taking an idea from Ruby: Everything you manipulate is an object, and the results of those manipulations are objects themselves.

hello world->length
(-1234)->abs
"oh my god, its full of properties"->index(g)

The first example asks a string to calculate its length. The second example asks a number to calculate its absolute value. And the third example asks a string to find the index of the letter g.

Using this module you can have run-time properties on initialized scalar variables and literal values. The word properties is used in the Perl 6 sense: out-of-band data, little sticky notes that are attached to the value. While attributes (as in Perl 5s attribute pragma, and see the Attribute::* family of modules) are handled at compile-time, properties are handled at run-time.
Internally properties are implemented by making their values into objects with overloaded operators. The actual properties are then simply hash entries.
Most properties are simply notes you attach to the value, but some may have deeper meaning. For example, the true and false properties plays a role in boolean context, as the first example of the Synopsis shows.

Properties can also be propagated between values. For details, see the EXPORTS section below. Here is an example why this might be desirable:

pass_on(approximate);
my $pi = 3->approximate(1);
my $circ = 2 * $rad * $pi;

# now $circ->approximate indicates that this value was derived
# from approximate values

Please dont use properties whose name start with an underscore; these are reserved for internal use.

You can set and query properties like this:

$var->myprop(1)

sets the property to a true value.

$var->myprop(0)

sets the property to a false value. Note that this doesnt delete the property (to do so, use the del_props method described below).

$var->is_myprop, $var->has_myprop

returns a true value if the property is set (i.e., defined and has a true value). The two alternate interfaces are provided to make querying attributes sound more natural. For example:

$foo->is_approximate;
$bar->has_history;

Genuts project is a consistent Java framework for game development.

It contains a library with classes primarily intended for sprite-based games, including functions for sprite manipulation and collision detection.

Additionally, Genuts API will provide a level of abstraction for some of Javas game-related API, such as images manipulations and event handling.

Target devices are:
- Web games (Windows, MacOS, *nix)
- Mobile phones
- PDA

Genuts API is compatible with Java 1.1, Java 2 & Java ME (MIDP 1.0).

Genuts is not a game construction kit for non-programmers. In order to use Genuts, you need to know Java, including object-oriented design and how to compile and run Java Archive (JAR) files.

System.FilePath is a Haskell library from Yhc originally, now with added tweaks. Pure Haskell 98 (with Hierarchical libraries), no preprocessor. It has a nice interface for doing file manipulations, and works portably between Windows and Unix. [Not the same as http://darcs.haskell.org/~lemmih/FilePath/]

The interface is still changing, for that reason please use System.FilePath.Version_0_10 or System.FilePath.Version_0_11 which will be guaranteed to work unmodified in future releases.

I have written a System.FilePath module in part based on the one in
Yhc, and in part based on the one in Cabal (thanks to Lemmih). The aim
is to try and get this module into the base package, as FilePaths are
something many programs use, but its all too easy to hack up a little
function that gets it right most of the time on most platforms, and
there lies a source of bugs.

This module is Posix (Linux) and Windows capable - just import
System.FilePath and it will pick the right one. Of course, if you
demand Windows paths on all OSs, then System.FilePath.Windows will
give you that (same with Posix). Written in Haskell 98 + Heirarchical
Modules.

Haddock:
http://www-users.cs.york.ac.uk/~ndm/projects/filepath/System-FilePath.html
Darcs: darcs get http://www.cs.york.ac.uk/fp/darcs/filepath
Source: http://www.cs.york.ac.uk/fp/darcs/filepath/System/FilePath.hs
Homepage: http://www-users.cs.york.ac.uk/~ndm/projects/libraries.php

If you go to the haddock page there are a few little examples at the
top of the file.

Acknowledgements

Thanks to Marc Webber, shapr, David House, Lemmih, others...

Competitors

System.FilePath from Cabal, by Lemmih
FilePath.hs and NameManip.hs from MissingH

The one from Cabal and FilePath.hs in MissingH are both very similar, I
stole lots of good ideas from those two.

NameManip seems to be more unix specific, but all functions in that module
have equivalents in this new System.FilePath module.

Hopefully this new module can be used without noticing any lost functions,
and certainly adds new features/functions to the table.

Should FilePath by an abstract data type?

The answer for this library is no. This is a deliberate design decision.

In Haskell 98 the definition is type FilePath = String, and all functions
operating on FilePaths, i.e. readFile/writeFile etc take FilePaths. The
only way to introduce an abstract type is to provide wrappers for these
functions or casts between Strings and FilePathAbstracts.

There are also additional questions as to what constitutes a FilePath, and
what is just a pure String. For example, "/path/file.ext" is a FilePath. Is
"/" ? "/path" ? "path" ? "file.ext" ? ".ext" ? "file" ?

With that being accepted, it should be trivial to write
System.FilePath.ByteString which has the same interface as System.FilePath
yet operates on ByteStrings.