Free 1 layer 3 software for linux

SYNOPSIS

#####
# Subroutines
#
use Tie::Layers qw(is_handle config);

$yes = is_handle( $file_handle );

($key, $old_value) = config(%options, $key);
($key, $old_value) = config(%options, $key => $new_value );

####
# Config default startup options
#
@old_options_list = config(%options, @option_list);
@old_options_list = config(%options, @option_list);
@old_options_list = config(%options, %option_list);

#####
# Class interface
#
require Tie::Layers;

#####
# Using support methods and file handle with
# the file subroutines such as open(), readline()
# print(), close()
#
tie *LAYERS_FILEHANDLE, Tie::Layers, @options
$layers = tied *LAYERS_FILEHANDLE;


#####
# Using support methods only, no file subroutines
#
$layers = Tie::Layers->TIEHANDLE(@options);

($key, $old_value) = $layers->config($key);
($key, $old_value) = $layers->config($key => $new_value );

@old_options_list = $layers->config(@option_list);
@old_options_list = $layers->config(@option_list);
@old_options_list = $layers->config(%option_list);

$data = $layers->fin($filename, @options);

$data = $layers->fout($filename, $data, @options);

$yes = $layers->is_handle( $file_handle );

If a subroutine or method will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}.

The Tie::Layers program module contains the tie file handle Tie::Layers package. The Tie::Layers package provides the ability to insert a stack of subroutines between file subroutines print and realine and the underlying $file. The syntax of the subroutines of each layer of the readline stack and the print stack must comply to the the requirements described herein below.

This is necessary so that the Tie::Layers READLINE and PRINT subroutines know how to transfer the output from one layer to the input of another layer. The stacks are setup by supplying options with a reference to the subroutine for each layer in the print stack and the readline stack. The Tie::Layers are line orientated and do not support any character file subrouintes.

The getc, read, and write file subroutines are supported by the Tie::Layers package. The seek routines are line oriented in that the seek and tell subroutine positions are the line in the underlying file and not the character position in the file.

Rotter is a Recording of Transmission / Audio Logger for JACK. The project was designed for use by radio stations, who are legally required to keep a recording of all their output. Rotter runs continuously, writing to a new file every hour. It is released under the GPL license.

Rotter can output files in two different strutures, either all files in a single directory or create a directory structure:

flat: /root_directory/YYYY-MM-DD-HH.suffix
hierarchy: /root_directory/YYYY/MM/DD/HH/archive.suffix

The advantage of using a folder hierarchy is that you can store related files in the hours directory.

Usage

rotter [options] < directory >
-a Automatically connect JACK ports
-f < format > Format of recording (see list below)
-b < bitrate > Bitrate of recording (bitstream formats only)
-c < channels > Number of channels
-n < name > Name for this JACK client
-d < hours > Delete files in directory older than this
-R < secs > Length of the ring buffer (in seconds)
-H Create folder hierarchy instead of flat files
-j Dont automatically start jackd
-v Enable verbose mode
-q Enable quiet mode

Supported audio output formats:

mp3 MPEG Audio Layer 3 [Default]
mp2 MPEG Audio Layer 2
aiff AIFF (Apple/SGI 16 bit PCM)
aiff32 AIFF (Apple/SGI 32 bit float)
au AU (Sun/Next 16 bit PCM)
au32 AU (Sun/Next 32 bit float)
caf CAF (Apple 16 bit PCM)
caf32 CAF (Apple 32 bit float)
flac FLAC 16 bit
wav WAV (Microsoft 16 bit PCM)
wav32 WAV (Microsoft 32 bit float)

Example:

rotter -a -f mp3 -d 1000 -b 160 -v /var/achives
[DEBUG] Wed Jun 21 22:54:19 2006 Root directory: /var/archives
[INFO] Wed Jun 21 22:54:19 2006 JACK client registered as rotter.
[DEBUG] Wed Jun 21 22:54:19 2006 Size of the ring buffers is 2.00 seconds (352800 bytes).
[INFO] Wed Jun 21 22:54:19 2006 Encoding using liblame version 3.96.1.
[DEBUG] Wed Jun 21 22:54:19 2006 Input: 44100 Hz, 2 channels
[DEBUG] Wed Jun 21 22:54:19 2006 Output: MPEG-1 Layer 3, 160 kbps, Joint Stereo
[INFO] Wed Jun 21 22:54:19 2006 Connecting alsa_pcm:capture_1 to rotter:left
[INFO] Wed Jun 21 22:54:19 2006 Connecting alsa_pcm:capture_2 to rotter:right
[INFO] Wed Jun 21 22:54:19 2006 Starting new archive file: /var/archives/2006/06/21/22/archive.mp3
[DEBUG] Wed Jun 21 22:54:19 2006 Opening MPEG Audio output file: /var/archives/2006/06/21/22/archive.mp3
[INFO] Wed Jun 21 23:00:00 2006 Starting new archive file: /var/archives/2006/06/21/23/archive.mp3
[DEBUG] Wed Jun 21 23:00:00 2006 Closing MPEG Audio output file.
[DEBUG] Wed Jun 21 23:00:00 2006 Opening MPEG Audio output file: /var/archives/2006/06/21/23/archive.mp3

Start logging audio to hourly files in /var/archives. Rotter will automatically connect itself to the first two JACK output ports it finds and encode to MPEG Layer 3 audio at 128kbps. Each hour it will delete files older than 1000 hours (42 days). Verbose mode means it will display more informational messages.

Lestat provides a connection/port scan monitoring system.

Lestat is a simple system which is designed to allow trends in port scans to be identified and displayed in a simple manner. The system comprises a Perl agent which collects packets and logs them to a database, and a presentation layer which draws graphs and presents a GUI via PHP.

Open Tranquera is a repository of reusable components for J2EE application development.

There are UI extensions, Services, and a Persistence layer, integrated with existing open source frameworks.

PHP MySQL Database Layer Class is a php class providing some very useful methods to work with a mySQL database.
Main features:
- connects you to a mySQL host and select a database in a single call (opposed to PHPs native functions which requires two steps)
- has a "query" method that has the same role as PHPs mysql_query but this one will tell you about the affected rows (through the "affectedRows" property) when executing an INSERT, UPDATE, DELETE query and about the found rows (through the "foundRows" property) when executing a SELECT query - the "foundRows" property tells you how many records would the query return if there was no LIMIT applied to it - very useful when creating listing so you dont have to do a query to determine how many records you have in a database and the again a query to show only the records from a page
- has an "escape_string" method that will "mysql_real_escape_string" your string weather the magic_quotes are on or not
- has a "dlookup" method that i am sure you will find VERY useful once you get to know it: it return data from a single table cell based on standard mySQL WHERE criteria - see the manual for detailed info! (yes, it acts exactly like the function with the same name from microsft access)
- provides you with a very useful debug interface which shows you each query your script is running, for how long, the total number of queries made, the total execution time of your queries, errors of your queries and what are the values of $_GET, $_POST, $_COOKIES and $_SERVER superglobal variables. The debug interface is template driven and supports localisation.
- it will notify you if a specific query is executed more than once and will advise you to optimize the script
- you can instruct it to send you an email if a query runs longer then a specified time
- the code is heavily documented so you can easily understand every aspect of it and even maybe use it as a php tutorial
Enhancements:
- the state of $_FILES and $_SESSION superglobals are now also shown in the debug window
- better integration with XTemplate (previously, there was a variable assigned to each entry in the language file now the XTemplates feature to handle arrays is used)
- properties will now have default values in PHP 4

Simple DirectMedia Layer project is a library that gives portable low-level access for multimedia applications.
Simple DirectMedia Layer is a cross-platform multimedia library designed to provide low level access to audio, keyboard, mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer. It is used by MPEG playback software, emulators, and many popular games, including the award winning Linux port of "Civilization: Call To Power."
SDL supports Linux, Windows, Windows CE, BeOS, MacOS, Mac OS X, FreeBSD, NetBSD, OpenBSD, BSD/OS, Solaris, IRIX, and QNX. The code contains support for AmigaOS, Dreamcast, Atari, AIX, OSF/Tru64, RISC OS, SymbianOS, and OS/2, but these are not officially supported.
SDL is written in C, but works with C++ natively, and has bindings to several other languages, including Ada, C#, Eiffel, Erlang, Euphoria, Guile, Haskell, Java, Lisp, Lua, ML, Objective C, Pascal, Perl, PHP, Pike, Pliant, Python, Ruby, and Smalltalk.
SDL is distributed under GNU LGPL version 2. This license allows you to use SDL freely in commercial programs as long as you link with the dynamic library.
Enhancements:
- Dynamic X11 loading is only enabled with gcc 4 supporting -fvisibility=hidden. This fixes crashes related to symbol collisions, and allows building on Solaris and IRIX.
- Fixed building SDL with Xinerama disabled.
- Fixed DRI OpenGL library loading, using RTLD_GLOBAL in dlopen().
- Added pkgconfig configuration support.

EZ Improver works well to improve dull, dingy images.

Leaving the Merge Layers option un-checked allows you to tweak the layer opacities if desired.

Common Media Input Layer (CMIL) is an C++ OO framework designed to improve the state of cross-platform input handling in games and other similar applications.
CMIL was created out of the belief that the methods used in most media APIs perform input handling in a confusing, difficult, inflexible fashion. CMILs goal is to address this issue by establishing a flexible, easy to use, human readible, OO abstraction layer. This layer specifically allows for media and input device abstraction.
Main features:
- easiliy build complex input sequences, including timed inputs, which do not impose restrictive notions of what is and isnt a moderator on the user
- custom input device configurations, IE: Users can swap input device configurations on the fly and create their own representation of a custom device using the framework facilities