Free midi interface software for linux

MIDI Data Miner uses a neural network to learn correlations between notes and control changes in a MIDI file.

After training MDM can augment a live MIDI stream, adding control changes based on notes received.

Briefly: use MDM by connecting a MIDI device, open preferences and set MIDI input and output ports. Open a MIDI file, create a new neural net and train. Now play notes on your MIDI device, MDM will automatically add control changes.

MDM creates a collection of note and controller pairs from the file and uses them to train a net. The notes are used as inputs and the controls as outputs. The window is the number of previous notes considered when determining the output for the current note. Larger windows give less predictable more interesting responses. Enter a number in the window box and press enter to set the window size.

This is an early alpha release, buggy and incomplete. Please send feedback! Note that this alpha version only reads from the first track in a MIDI file, and only uses the first controller. Look at the included MIDI file in the working/midi folder for details.

GnuPG::Interface is a Perl interface to GnuPG.

SYNOPSIS

# A simple example
use IO::Handle;
use GnuPG::Interface;

# settting up the situation
my $gnupg = GnuPG::Interface->new();
$gnupg->options->hash_init( armor => 1,
homedir => /home/foobar );

# Note you can set the recipients even if you arent encrypting!
$gnupg->options->push_recipients( ftobin@cpan.org );
$gnupg->options->meta_interactive( 0 );

# how we create some handles to interact with GnuPG
my $input = IO::Handle->new();
my $output = IO::Handle->new();
my $handles = GnuPG::Handles->new( stdin => $input,
stdout => $output );

# Now well go about encrypting with the options already set
my @plaintext = ( foobar );
my $pid = $gnupg->encrypt( handles => $handles );

# Now we write to the input of GnuPG
print $input @plaintext;
close $input;

# now we read the output
my @ciphertext = ;
close $output;

waitpid $pid, 0;

GnuPG::Interface and its associated modules are designed to provide an object-oriented method for interacting with GnuPG, being able to perform functions such as but not limited to encrypting, signing, decryption, verification, and key-listing parsing.

How Data Member Accessor Methods are Created

Each module in the GnuPG::Interface bundle relies on Class::MethodMaker to generate the get/set methods used to set the objects data members. This is very important to realize. This means that any data member which is a list has special methods assigned to it for pushing, popping, and clearing the list.

Understanding Bidirectional Communication

It is also imperative to realize that this package uses interprocess communication methods similar to those used in IPC::Open3 and "Bidirectional Communication with Another Process" in perlipc, and that users of this package need to understand how to use this method because this package does not abstract these methods for the user greatly. This package is not designed to abstract this away entirely (partly for security purposes), but rather to simply help create proper, clean calls to GnuPG, and to implement key-listing parsing. Please see "Bidirectional Communication with Another Process" in perlipc to learn how to deal with these methods.

Using this package to do message processing generally invovlves creating a GnuPG::Interface object, creating a GnuPG::Handles object, setting some options in its options data member, and then calling a method which invokes GnuPG, such as clearsign. One then interacts with with the handles appropriately, as described in "Bidirectional Communication with Another Process" in perlipc.

GNOME Interface for YUM is a graphical frame-program for easier use and setup the YUM install program.

Displays the accessible packages on the package service sites with filter. Manage the settings of package services.

Manage the cache used by YUM: free up disk space, manual install and transfer of downloaded packages. Displays detailed package information about the installed packages or package files. Displays the files in the packages with a program chosen by user.

MIDI Controller is a program that connects Glade UI files to MIDI parameters.

This is a small program that lets you set MIDI controller values using sliders and buttons in a GTK+ window. The GUI is an XML-based Glade file which can be replaced without rebuilding the program, so you can build your own controller GUIs in Glade.

Realtime Application Interface project allows applications with strict timing constraints to be run on Linux.
A real time system is able to guarantee the timing requirements of the processes under its control.
RTAI provides an API and the necessary kernel modifications to accommodate such requirements.
Enhancements:
- Improvements were made to netrpc.
- Context switching between hard and soft real-time, handling of TSC errors, and POSIX compatibility have been improved.
- There are numerous minor bugfixes.

PHP Database Interface is an easy to use PHP database interface meant to give applications universal support across many databases, including several flat file formats.
Installation
These are just a few notes installation notes regarding DBi and using it with your project
txtSQL support requires the following files from the release archive (currently 3.0 Beta is Supported) :
txtSQL.class.php, txtSQL.parser.php & txtSQL.core.php To be placed in the 3rdparty/txtsql/ directory or the location of your choice
fileSQL support requires the the following file from the release archive (currently 1.0 RC4 is Supported) :
fileSQL.php To be placed in the 3rdparty/fql/ directory of the location of your choice
Test data and a demo script is available in the demo/ directory
Simple Example
// The filesystem root path to DBi needs to be defined before the include
define(PHP_DBI_ROOT, C:/program files/apache group/apache2/htdocs2/modules/dbi/);
define(PHP_DBI_FQL, PHP_DBI_ROOT.3rdparty/fql/fileSQL.php); //Required for FQL Support
define(PHP_DBI_TXTSQL, PHP_DBI_ROOT.3rdparty/txtsql/); //Required for txtSQL Support
include_once("../dbi.php");
$interface = dbi::factoryControllerConstruction(); //create a new dbi object
// open a connection to the database (this will example will work with any
// of the interfaced databases
$interface->open_connection_now_persistent("fql&".PHP_DBI_ROOT."3rdparty/fql/data&demo");
//Select the entire contents of test2 table and store the first row
$inteface->ExecuteQueryAndReturnRow?(array(select => *, from => test2));
$results = $interface->fetchRowThenGetAnotherrow();
//Display the first row of results
print "First Row: ";
print_r($results);
print "< br >";
$interface->disconnect_fromDatabase(); // Closes connection to the database
Enhancements:
- The tableInfo function was added to return the schema.
- LIMIT was added to select functions for supporting databases.
- LIMIT emulation is available to all database types.
- Support for the Firebird database was added.

General Package/Module Interface (GPMI) is a lightweight library that assists with modularizing applications.
It includes prewritten script interpreter modules in addition to timers, events, and package dependencies.
Enhancements:
- This version features many bugfixes and memory leak cleanups.
- It is now possible to compile the code on Windows using mingw.

midi pong is an implementation of the pong game that works as a MIDI instrument.

Seen it before? As a MIDI instrument? As a VST plugin? When you play pong, you play music. You can try it here as an applet, though thats not half as cute as connecting it to a nice soft-synth sound, adding a few effects (arpeggiator, anyone?) and letting it play some loops for you.

Dont believe me? Try it. If youre too chicken then listen to this sample: pong (1.4mb). Its made up of three voices played by pong - no meddling with the MIDI output, this is pure pong power!

For your incidental compositions you can choose computer, keyboard or mouse control (or gamecontroller if you get the source) for the left and right rackets. You can choose the scale that pong plays notes from when the ball is hit. You can choose the tempo of the performance. The MIDI output device. The MIDI channel. This pong uses Swing and requires Java 1.4 or newer.

Usage:

Download and run with java -jar pong.jar