Free stdin stdout software for linux

Softgun is a Software ARM. Softgun is intended to help Embedded System developers. Softgun is known to run linux-2.6.10 with a patch for the Netsilicon NS9750.
Main features:
- ARM926-ejs 32Bit Instruction Set with DSP Extensions. Speed is 21 MHz per Intel GHz. Thumb and Jazelle are missing
- Little and Big Endian CPU mode
- MMU with 3 entry first level TLB and 3 * 128 entry second level TLB
- Emulation of AMD Flash compatible Chips (AM29LV640ML, AM29LV256ML ...). Uniform and non uniform sector devices
- NS9750 AHB to PCI bridge (Currently no Address translation)
- NS9750 Serial Interface emulation redirected to stdin/stdout or to a real serial device
- NS9750 Vectored interrupt Controller
- NS9750 OHCI USB module (yet without device and not fully working)
- NS9750 Watchdog and Timers in 32 Bit mode with Interrupt support
- NS9750 builtin I2C master and slave controller
- I2C-Bus emulation using GPIO-Ports
- Ethernet emulation through Linux TUN/TAP device
- STE10/100 Tulip compatible PCI Ethernet controller Emulation
- Davicom DM9000 Ethernet Controller
- NS9750 builtin Ethernet Controller Emulation
- m93c46 Microwire EEPROM connected to STE10/100
- Philips SJA1000 CAN controller connected to TCP socket
- General Purpose IO emulation on logical signal level
- M24Cxx I2C-EEProms
- PCF8563 I2C-Realtime clock emulation
- PCF8575 and PCF8574 I2C 16/8 Bit IO-Expanders
- Intel Hex and Motorola S-Record loader
- Precompiled Linux System available as Flash image
- Multiple Boards selectable from configuration file
- Loading devices or boards as shared library
- Debugging with gdb using the gdb remote protocol
Enhancements:
- This release adds HP Deskjet 460 emulation with a PCL3GUI interpreter, many high capacity SD cards, and ZRLE compression to the built-in VNC server.

3D Spatialization of Sound is a Linux/X11 port of the 3D spatializer library from the CRC.

This program creates "directional" stereo sound from mono source. CRC folks told me I shouldnt have raised the sampling frequency without adjusting other stuff.

Oh well. This was a proof-of-concept type project anyway. I think to get correct 3D effect, you need to drop sampling rate back to 11025.

To Build the X11 implementation:

1. make
2. cp audio-filter /usr/local/bin
3. mpg123 -m -s some_music.mp3 | audio-filter | aplay -S -s 44100 -f s16l -

audio-filter is implemented as a filter, it reads signed 16 bit mono input at 44100 khz from stdin, and outputs signed 16 bit stereo, 44100 khz output to stdout. You can replace mpg123 with any sound source generating signed 16 bit 44100 khz mono signal. "aplay" is a sound player utility which comes with ALSA linux sound driver. You can use "play" from the sox package, or "ampctl", or any other sound player that would read 44100 khz, signed 16 bit stereo raw data from stdin. For "sox" play script, you would replace "aplay" command line with "play -c 2 -f s -r 44100 -s w -t raw -"

If everything is good, a 640x480 window will come up, with some cryptic writing on the top, a filled circle with an arrow pointing right, and a empty circle slightly to the right of the circle with arrow.

NOTE, that just like in the original Windows implementation, the axiss are reversed. The arrow on the "head" is pointing "forward". So, in the default startup configuration, the sound is located in front of the listener. Moving the sound source "up" moves it to the left of the listener, and "down", to the right. You can visualize this well if you turn your monitor 90 degrees counter
clock wise.

The filled circle with an arrow is your "head"
The empty circle is the "sound source"

You can move the "sound source" around by clicking the mouse at any position in the window, or by clicking on the "sound source" circle, and dragging it to the desired position. Soundfield will be dynamically updated as you do this.

You can move the "head" by moving the mouse to desired position, and right-clicking. The "head" icon will move to the new position and soundfield will be updated.

Test::Cmd is a Perl module for portable testing of commands and scripts.

SYNOPSIS

use Test::Cmd;

$test = Test::Cmd->new(prog => program_or_script_to_test,
interpreter => script_interpreter,
string => identifier_string,
workdir => ,
subdir => dir,
match_sub => $code_ref,
verbose => 1);

$test->verbose(1);

$test->prog(program_or_script_to_test);

$test->basename(@suffixlist);

$test->interpreter(script_interpreter);

$test->string(identifier string);

$test->workdir(prefix);

$test->workpath(subdir, file);

$test->subdir(subdir, ...);
$test->subdir([sub, dir], ...);

$test->write(file, read($contents, [subdir, file]);
$test->read(@lines, [subdir, file]);

$test->writable(dir);
$test->writable(dir, $rwflag);
$test->writable(dir, $rwflag, %errors);

$test->preserve(condition, ...);

$test->cleanup(condition);

$test->run(prog => program_or_script_to_test,
interpreter => script_interpreter,
chdir => dir, args => arguments, stdin => pass(condition, &func);

$test->fail(condition);
$test->fail(condition, &func);
$test->fail(condition, &func, $caller);

$test->no_result(condition);
$test->no_result(condition, &func);
$test->no_result(condition, &func, $caller);

$test->stdout;
$test->stdout($run_number);

$test->stderr;
$test->stderr($run_number);

$test->match(@lines, @matches);
$test->match($lines, $matches);

$test->match_exact(@lines, @matches);
$test->match_exact($lines, $matches);

$test->match_regex(@lines, @regexes);
$test->match_regex($lines, $regexes);

$test->diff_exact(@lines, @matches, @output);
$test->diff_exact($lines, $matches, @output);

$test->diff_regex(@lines, @regexes, @output);
$test->diff_regex($lines, $regexes, @output);

sub func {
my ($self, $lines, $matches) = @_;
# code to match $lines and $matches
}
$test->match_sub(&func);
$test->match_sub(sub { code to match $_[1] and $_[2] });

$test->here;

The Test::Cmd module provides a low-level framework for portable automated testing of executable commands and scripts (in any language, not just Perl), especially commands and scripts that interact with the file system.

The Test::Cmd module makes no assumptions about what constitutes a successful or failed test. Attempting to read a file that doesnt exist, for example, may or may not be an error, depending on the software being tested.

Consequently, no Test::Cmd methods (including the new() method) exit, die or throw any other sorts of exceptions (but they all do return useful error indications). Exceptions or other error status should be handled by a higher layer: a subclass of Test::Cmd, or another testing framework such as the Test or Test::Simple Perl modules, or by the test itself.
(That said, see the Test::Cmd::Common module if you want a similar module that provides exception handling, either to use directly in your own tests, or as an example of how to use Test::Cmd.)

In addition to running tests and evaluating conditions, the Test::Cmd module manages and cleans up one or more temporary workspace directories, and provides methods for creating files and directories in those workspace directories from in-line data (that is, here-documents), allowing tests to be completely self-contained. When used in conjunction with another testing framework, the Test::Cmd module can function as a fixture (common startup code for multiple tests) for simple management of command execution and temporary workspaces.

The Test::Cmd module inherits File::Spec methods (file_name_is_absolute(), catfile(), etc.) to support writing tests portably across a variety of operating and file systems.

A Test::Cmd environment object is created via the usual invocation:

$test = Test::Cmd->new();

Arguments to the Test::Cmd::new method are keyword-value pairs that may be used to initialize the object, typically by invoking the same-named method as the keyword.

GINS a.k.a. Gtk INterface for Script is a way to add GTK interfaces to scrpit languages that doesnt have any GTK bindigs, like BASH scripts. GINS load a GLADE xml file, using libglade. Then run the script, linking to his stdin & stdout.
Now script can communicate to GINS simply writting to stdin and reading from stdinput.
GINS pass to script every events that occours to gtk widgets, and script can react.
Enhancements:
- BradC: This version of GINS adds the ability to get boolean and double and the ability to set ints. So we can both get and set; int, str, double and boolean.

vobstripper is a program that copies a .VOB file from stdin to stdout, discarding subtitles and all but one AC3 audio channel. The practical effect is to make the .VOB file smaller by throwing away unused extra information without requiring the .VOB file to be remultiplexed.
This program does not adjust pointers and other information in the .VOB file to cleanly delete the discarded streams. However, the resulting .VOB files are acceptable for input to a program such as dvdauthor that expects to be responsible for filling in the VOBs.
Since vobstripper invalidates the pointers in the .VOB file, a .VOB file that is to be processed by both vobstripper and vobwalker must be processed by vobwalker first.
vobstripper is in the public domain (GPL license).
Enhancements:
- Multiple private stream 1 subchannels can be specified as keepers on the command line.
- Discards MPEG program stream end codes. Ive seen several files on which tools like mpeg2dec and bbdmux silently stop before processing the entire file because of a rogue MPEG program stream end code embedded in the middle of the file.
- Slightly more sophisticated Makfile contributed by a user.

streamixer contains an audio stream mixer server, tools for monitoring and feeding the server, and a stream resampling tool with various different interpolation models.
mixer is a stream mixing server.
resample v1.20.0 - Copyright (C) 1992,2006 Bisqwit (http://iki.fi/bisqwit/)
Portions copyright (C) 2001 ImageMagick Studio.
This program is under GPL. streamixer-1.20.0.tar.{gz,bz2}
are available at the homepage of the author.
Usage: /usr/local/bin/resample [ ...]
Reads stdin, writes stdout.
input- and outputspec:
b=8-bit, m=mono, rxxx=xxx Hz, examples:
"" = 16-bit 44100 Hz stereo
m = 16-bit 44100 Hz mono
b = 8-bit 44100 Hz stereo
mb = 8-bit 44100 Hz mono
mr22050 = 16-bit 22050 Hz mono
br22050 = 8-bit 22050 Hz stereo
etc. - must not be used.
Options:
--help, -h Help
--version, -V Version information
--blur, -b Blur: 0=normal, >0=blur (cpu intensive)
--lflip, -L Flip left channel
--rflip, -R Flip right channel
--ldouble Multiply left channel amplitude by 2
--rdouble Multiply right channel amplitude by 2
--sharpen, -s Equivalent to giving negative number to --blur
--filter, -f Select filter (interpolation scheme)
Available filters:
none, linear, triangle, hermite, hanning, hamming,
blackman, gaussian, quadratic, cubic, catrom, mitchell,
lanczos, bessel, sinc
Recommended filters: linear, lanczos, none
Enhancements:
- This release fixes the programs to work on the x86_64 architecture.
- The latency of the resample program was decreased by decreasing the buffer sizes.

slookup is a simple program to do parallelized DNS lookups in a convenient way (useful for log parsing scripts and one-liners).
slookup project reads names (A/MX/NS lookups) or addresses (in dotted-quad format for PTR) on stdin and writes the results on stdout. One record per line. It can run up to 128 parallel DNS lookup processes (easily overloading a slow DNS server) which makes for Really Fast lookups for a large number of records.
Beware, output is written in the order the DNS replies are received, which is usually different from the input order if parallel lookups are done.
It has been tested on the following platforms:
Solaris 2.6 / UltraSparc / gcc 2.7.2.3
RedHat Linux 7.0 / 2.2.17 / glibc-2.1.94 / gcc 2.96
Debian sarge / 2.6.8.1 / glibc-2.3.2 / gcc 3.3.5
Debian etch / 2.6.15 / glibc-2.3.6 / gcc 4.0.3
FreeBSD 5.3-RELEASE / gcc 3.4.2
FreeBSD 6.0-RELEASE / gcc 3.4.4
Enhancements:
- Support for looking up NS records was added.