Free stream processing software for linux

Streamline is a high-speed networking subsystem for commodity operating systems. It increases performance by moving processing tasks to the fastest location. Streamline supports in-kernel execution, but also dedicated hardware (NICs) and even remote machines. An implementation of Streamline for Linux 2.6.13 and higher is made publicly available.
The goal of Streamline is to make fast network processing viable for common tasks. Many advanced processing schemes so far fail to make it into OSes, because they are difficult to combine with the socket(..) API or only applicable in a few situations. Our goal is to integrate known as well as develop new methods that replace sockets(..). without burdening application developers and end-users. Streamline achieves this by constructing a tailored dataplane for each application at runtime from an extensible set of functions.
Applications request information streams by specifying a series of abstract functions that need to be performed on incoming data (e.g., select tcp packets for port 80, reassemble into a stream, filter out known attacks). At runtime, streamline searches for implementations of these functions. These can be found in the kernel, in the application library, or in dedicated hardware such as programmable network cards or asymmetric multicores. When all functions are found, interconnecting datapaths are setup. Paths may need to cross the PCI bus, userspace/kernelspace barrier or even LANs. Optimisation of these paths is one of the factors that contributes to Streamlines performance.
The base system comes bundled with functions for pattern matching (Aho Corasick, RegEx), accounting, filtering (among others BPF), stream reassembly, rewriting, inspection, and more. Obvious uses are intrusion detection, network address translation, media streaming and realtime (pre)processing of scientific data.
Enhancements:
- This is mostly a stabilization release, which adds support for Linux kernels up to 2.6.22 and Fedora Core installations.
- The only truly new feature is a virtual filesystem interface (like sysfs) to streamline.
- With this "netmonfs" you can inspect live datastreams as if youre reading local files.
- Setting up streams and filters is easily accomplished through mkdir, open, and other well-known tools.
- Note that netmonfs is still beta quality software.

Process Raw Images is a service menu for processing many raw images at once. Supports output to Jpeg, Png and Tiff.

SoundTouch Sound Processing Library is an open-source audio processing library for changing the Tempo, Pitch and Playback Rates of audio streams or files:
- Tempo (time-stretch): Changes the sound to play at faster or slower speed than original, without affecting the sound pitch.
- Pitch (key) : Changes the sound pitch or key, without affecting the sound tempo or speed.
- Playback Rate : Changes both the sound tempo and pitch, as if an LP disc was played at wrong RPM rate.
Main features:
- Easy-to-use implementation of time-stretch, pitch-shift and sample rate transposing routines.
- High-performance object-oriented C++ implementation.
- Full source codes available for both the SoundTouch library and the example application.
- Clear and easy-to-use programming interface via a single C++ class.
- Supported audio data format : 16Bit integer or 32bit floating point PCM mono/stereo
- Capable of real-time audio stream processing:
- input/output latency max. ~ 100 ms.
- Processing 44.1kHz/16bit stereo sound in realtime requires a 133 Mhz Intel Pentium processor or better.
- Platform-independent implementation: The SoundTouch library can be compiled for any processor and OS platform supporting GNU C compiler (gcc) or Visual Studio, for example Win32, Linux, AIX.
- Additional assembler-level and Intel-MMX instruction set optimizations for Intel x86 compatible processors (Win32 & Linux platforms), offering several times increase in the processing performance.
- Compiled executable binaries available for Windows.
Enhancements:
- Add features/limitations/changes here

Stream::Reader is a stream reader Perl class.

SYNOPSIS

# Input stream can be reference to TYPEGLOB or SCALAR, output stream
# can be the same types or undefined

# Constructor
$stream = Stream::Reader->new( *IN,
{ Limit => $limit, BuffSize => $buffsize, Mode => UB } );

# Reading all before delimiter beginning from current position.
# Delimiter is SCALAR or reference to array with many SCALARs.
# Returns true value on succesfull matching or if end of stream
# expected at first time
$bool = $stream->readto( $delimiter,
{ Out => *OUT, Limit => $limit, Mode => AIE } );

# Reading fixed number of chars beginning from current position.
# Returns true value if was readed number of chars more then zero or
# end of stream was not expected yet
$bool = $stream->readsome( $limit, { Out => *OUT, Mode => A } );

# Mode is string, what can contains:
# U - modificator for constructor. disable utf-8 checking
# B - modificator for constructor. enable second buffer for speed up
# case insensitive search
# A - modificator for readto() and readsome(). appending data to
# output stream, if stream is SCALAR
# I - modificator for readto(). enable case insensitive search
# E - modificator for readto(). at end of input stream alltimes
# returns false value

$number = $stream->{Total}; # total number of readed chars
$number = $stream->{Readed}; # number of readed chars at last
# operation (without matched string
# length at readto() method)
$number = $stream->{Stored}; # number of succesfully stored chars
# at last operation
$string = $stream->{Match}; # matched string at last operation
# (actually for readto() only)
$bool = $stream->{Error}; # error status. true on error

METHODS

OBJ = Stream::Reader->new( INPUT, { ... Params ... } )

The constructor method instantiates a new Stream::Reader object.

INPUT - is a reference to file stream, opened for reading, or reference to defined string. This is an obligatory parameter.

Params (all optionaly):

Limit - limit size of input stream data in characters. If this parameter is absent, not defined or less then zero, then all data from input stream will be available for reading.

BuffSize - size of buffer in characters. If this parameter is absent, not defined or less then zero, then will be used default buffer size 32768 characters.

Mode - is string with letters-modificators:

B - use second buffer. Can really speed up search in case insensitive mode.
U - disable UTF-8 data check in UTF-8 mode. Use this flag if you are absolutely sure, that your UTF-8 data is valid.

RESULT = OBJ->readto( DELIMITER, { ... Params ... } )

This method reads all data from input stream before first found delimiter, beginning from current position.

RESULT - boolean value. True value if successfuly found delimeter or and of input stream has expected at first time. False value otherwise, or in case of reading error.

DELIMETER - is a string-delimeter or reference to array with many delimeters. This is an obligatory parameter and must be defined.

Remember! In case of many delimiters, left delimiter alltimes have more priority then right!

Params (all optionaly):

Out - is a reference to file stream, opened for writing, or reference to string. If this parameter is absent then data will not stored.
Limit - size in characters. Defines, the maximum number of characters that must be stored in Out. If this paramter is absent, not defined or less then zero, then this method will be trying to store all readed data.
Mode - is string with letters-modificators:
A - appendig data to Out if Out is a reference to string.
I - search in case insensitive mode.
E - at the end of input stream returns only false value. Without this modificator, if end of stream expected at first time, then will be returned true value.

RESULT = OBJ->readsome( LIMIT, { ... Params ... } )
This method reads fixed number of characters from input stream beginning from current position.

RESULT - boolean value. True value, if any characters were read or end of input stream is not expected yet. False value otherwise, or in case of reading error.

LIMIT - limit size in characters, how many it is necessary to read. If this parameter is absent, not defined or less then zero, then will be read all available data from input stream.

Params (all optionaly):

Out - the same as in readto() method.
Mode - is string with letters-modificators:
A - the same as in readto() method.

Statistics:

OBJ->{Total} - total number of readed characters. Warning! This module using block reading and real position in stream is different.
OBJ->{Readed} - number of readed characters at last operation (without matched string length at readto() method).
OBJ->{Stored} - number of succesfully stored chars at last operation
OBJ->{Match} - matched string at last operation (actually for readto() only)
OBJ->{Error} - boolen error status. At any reading erorrs all operations will be stopes and this flag turned to true value.

FFmpeg::Stream is an audio or video stream from a (multi)media file.

SYNOPSIS

$ff = FFmpeg->new(); #see FFmpeg
#...
$sg = $ff->create_streamgroup(); #see FFmpeg
$st = ($sg->streams())[0]; #this is a FFmpeg::Stream

FFmpeg::Stream objects are not instantiated. Rather, objects are instantiated from FFmpeg::Streams subclasses FFmpeg::Stream::Video for video streams, FFmpeg::Stream::Audio for audio streams, and FFmpeg::Stream::Data for streams containing neither audio nor video data. Streams identified in the file whose content type cannot be determined are represented by FFmpeg::Stream::Unknown objects.

Access FFmpeg::Stream objects using methods in FFmpeg::StreamGroup. See FFmpeg::StreamGroup for more information.

This class has attributes applicable to any stream type in a multimedia stream, or stream group. FFmpeg-Perl represents multimedia stream group information in a FFmpeg::StreamGroup object, which is a composite of FFmpeg::Stream objects.

FFmpeg::Stream objects dont do much. They just keep track of the media streams ID within the multimedia stream group, and hold an instance to a FFmpeg::Codec object if the codec of the stream was deducible. See FFmpeg::Codec for more information about how codecs are represented.

Audio::Mad::Stream is a Perl interface to mad_stream structure.

SYPNOSIS

my $stream = new Audio::Mad::Stream ($options);
$stream->buffer($scalar);

my $remain = substr($scalar, $stream->next_frame);
my $position = $stream->this_frame;

$stream->skip($position + 400);
$stream->sync();

$options = $stream->options();
$options |= MAD_OPTION_IGNORECRC;
$stream->options($options);

unless ($stream->err_ok()) {
print "error code was: " . $stream->error() . "n";
}

This package provides an interface to the underlying mad_stream structure used in the decoder library. Almost all of the methods from the library are implemented, and work on regualar perl data types.