Free c and c drums software for linux

Drums++ is a programming language I designed for sequencing music through drum machines. Drums++ program uses simple C ideas, for example // and /* */ comments and { } to seperate sections. I tried to make it as simple as possible so even a non-programmer could use it. See the docs section for more info on the language. Drums++ can both directly control your MIDI device or it can create .midi files which can be played through programs such as Microsoft Media Player.
So you might wonder why I chose to do drum sequencing this way? Well, about 10 years ago I used to write drum sequences for my music using a program on my Amiga 500 called Dynamic Drums. Dynamic Drums is probably not a very powerful drum sequencing program, but it was so easy to use. I could write an entire song on that in about 10 minutes. The problem was the samples were very cheesy.
So anyway, a few years ago my friend Jeff Blevins sold me his old Dr. Rhythm drum machine, which had much better sounds, but it was so hard to write a song. I tried downloading some MIDI programs for Linux, but they were too complicated for an idiot like me. So I decided to write my own MIDI sequencing program strictly for drums :). I figured a GUI would take me longer to write than a parser for a new programming language, so this is why I chose to make Drums++. Eventually I plan to write a GUI in either Java or GTK/C.
Drums++ is based on the features of Dynamic Drums, the only difference is you dont click on a grid for where you want your beats, you type them in a text file. Eventually I might add new features to the language if they are requested.
Enhancements:
- I added the ability to select midi channels. In version 0.94 and below, Drums++ used only midi channel 9 (which was the drum sounds naturally). In version 0.95 and above you have the option to use other midi channels allowing you to use other instruments (pianos, guitars, etc).

C to C++ is a Python script that converts C code to C++ code.

The main program is ctocpp.py that performs successive stages for converting C to C++. A script, ctocpp gives it as parameter to the python interpreter with options you add.

The archive also includes scripts that may help you:

- mover.py changes the location of a project.
- search.py performs searches and replacements.
- mkheader.py corrects a header file.

The C to C++ program with all the python sources is under the GNU GPL license,
that minds you may use it and distribute it freely, providing the copyright is unchanged.

See at the COPYING file for details. This doesnt mean GNU encourages you to convert your C sources to C++. In fact, most of the tools here included may help C programmers outside C++ conversion.

Installing:

Type:
./configure
./setup
mkdoc ...this will generate an html and info manuals.

GNU ccRTP is an implementation of RTP, the real-time transport protocol from the IETF (see RFC 3550, RFC 3551 and RFC 3555). ccRTP is a C++ library based on GNU Common C++ which provides a high performance, flexible and extensible standards-compliant RTP stack with full RTCP support. The design and implementation of ccRTP make it suitable for high capacity servers and gateways as well as personal client applications.
In designing ccRTP, we have taken into account that RTP has been defined as an application level protocol framework rather than a typical Internet transport protocol such as TCP and UDP. Thus, RTP is hardly ever implemented as a layer separated from the application.
Consequently, RTP applications often must customize the adaptable RTP packet layout and processing rules, timing constraints, session membership rules as well as other RTP and RTCP mechanisms. ccRTP aims to provide a framework for the RTP framework, rather than being just an RTP packet manipulation library.
Support for both audio and video data is also considered in the design of ccRTP, that can do partial frame splits/re-assembly. Unicast, multi-unicast and multicast transport models are supported, as well as multiple active synchronization sources, multiple RTP sessions (SSRC spaces), and multiple RTP applications (CNAME spaces). This allows its use for building all forms of Internet standards based audio and visual conferencing systems.
GNU ccRTP is threadsafe and high performance. It uses packet queue lists for the reception and transmission of data packets. Both inter-media and intra-media synchronization is automatically handled within the incoming and outgoing packet queues. GNU ccRTP offers support for RTCP and many other standard and extended features that are needed for both compatible and advanced streaming applications.
It can mix multiple payload types in stream, and hence can be used to impliment RFC 2833 compliant signaling applications as well as other specialized things. GNU ccRTP also offers direct RTP and RTCP packet filtering.
GNU ccRTP uses templates to isolate threading and sockets related dependencies, so that it can be used to impliment realtime streaming with different threading models and underlying transport protocols, not just with IPV4 UDP sockets. For a more detailed list of ccRTP features you can have a look at the programmers manual.
At its highest level, ccRTP provides classes for the real-time transport of data through RTP sessions, as well as the control functions of RTCP.
The main concept in the ccRTP implementation of RTP sessions is the use of packet queues to handle transmission and reception of RTP data packets/application data units. In ccRTP, a data block is transmitted by putting it into the transmission (outgoing packets) queue, and received by getting it from the reception (incoming packets) queue.
Main features:
- Highly extensible to specialized stacks.
- Supports unicast, multi-unicast and multicast. Handles multiple sources (including synchronization sources and contributing sources) and destinations. Also supports symmetric RTP.
- Automatic RTCP functions handling, such as association of synchronization sources from the same participant or NTP-RTP timestamp mapping.
- Genericity as for underlying network and transport protocols through templates.
- It is threadsafe and supports almost any threading model.
- Generic and extensible RTP and RTCP header validity checks.
- Handles source states and information as well as statistics recording.
- Automatically handles SSRC collisions and performs loop detection.
- Implements timer reconsideration and reverse reconsideration.
- Provides good random numbers, based on /dev/urandom or, alternatively, on MD5.
There are several levels of interface (public interface, public or protected inheritance, etc) in ccRTP. For instance, the rtphello demo program distributed with ccRTP just uses the public interface of the RTPSession class and does not redefine the virtual method onGotSR, thus what this program knows about SR reports is the information conveyed in the last sender report from any source, which can be retrieved via the getMRSenderInfo method of the SyncSource class.
On the contrary, the rtplisten demo program redefines onGotSR by means of inheritance and could do specialized processing of these RTCP packets. Generally, both data and control packets are not directly accessible through the most external interface.
All this functions are performed through a few essential classes and types. The most basic ones are the enumerated type StaticPayloadType, and the classes StaticPayloadFormat and DynamicPayloadFormat.
The most important ones are the classes RTPSession, SyncSource, Participant and AppDataUnit, that represent RTP sessions, synchronization sources, participants in an RTP application, and application data units conveyed in RTP data packets, respectively.
When using ccRTP, both sending and receiving of data transported over RTP sessions is done through reception and transmission queues handled by the RTP stack. In the most common case, a separate execution thread for each RTP session handles the queues. This case is the threading model that we will generally assume throughout this document. Note however that ccRTP supports other threading models, particularly ccRTP supports the use of a single execution thread to serve a set of RTP sessions. It is also possible to not associate any separate thread with any RTP session, manually calling the main data and control service methods from whatever other thread.
The basic idea for packet reception with ccRTP is that the application does not directly read packets from sockets but gets them from a reception queue. The stack is responsible for inserting received packets in the reception queue and handling this queue. In general, a packet reception and insertion in the reception queue does not occur at the same time the application gets it from the queue.
Conversely, the basic idea for packet transmission with ccRTP is that packets are not directly written to sockets but inserted in a transmission queue handled by the stack. In general, packet insertion and transmission occur at different times, though it is not necessary.
In order to use ccRTP, you must include the main header (#include < ccrtp/rtp.h >. Two additional headers are provided by ccRTP:
#include < ccrtp/rtppool.h
Classes for pools of RTP service threads.
#include < ccrtp/rtpext.h >
Classes for RTP extensions which are not mature yet.
You must also link in the library, currently ccrtp1.
Enhancements:
- Brand new support has been introduced for Secure RTP Profile (srtp) as per RFC 3711.
- This release also supports a new add-on package, libzrtpcpp, that directly offers native zfone (zrtp) compatible encryption capabilities to Common C++ RTP based applications.
- This is the first softphone client to use both Common C++ RTP srtp and zrtp support.

AspeCt-oriented C project implements an aspect-oriented extension to C and offers one possible language design for an aspect-oriented C language.
Main features:
- an aspect-oriented extension to C, aspect-oriented software development for C, and an ACC language design option
- full ANSI-C compliance and gcc source-compatibility;
- compiler and generated code portability;
- seamless Linux, Solaris and Windows support;
- simple integration in existing builds and code transparency through source-to-source transformations;
- an open source license and compiler.
AspeCt-oriented C enables:
- modularization of crosscutting concerns for C-based software;
- research on concern separation tailored to C and imperative programming;
- research on aspect-orientation on C-based systems;
- development of highly customizable and easily configurable software in C;
- development of feature-rich software product lines in C.
Enhancements:
- set()/get() join point and pointcut support was added for global variables, and compiler options were added for manipulating join points.

Virtual Drum Machine is a simple drum machine.
It works for little endian/linux kind of machines. You may let it work on others machines, but you probably will get troubles with it.
You definitely need oss (or maybe alsa) for sound output, and a posix-like operating system. To let it work on a big endian machine should be painful.
You write a rhythm, then you compile it, then you are able to play it to your sound card or save it to a file.
The Virtual Drum Machine is made of
- the Rhythm Compiler,
- the runtime library.
The Virtual Drum Machine is in the public domain. Who needs a license? money makers? Protection against robbery? let me laugh... Read any text of law, you will see where the robbers reside.
A simple file would look like :
void main_rhythm(void)
{
tempo = 120;
- a
. b
. b
.
- a
.b
- a
.
. b
. b
- a c
. b
}
Install:
Do a "./configure" in the drums directory, then "make", then "make install", it should be alright. You can listen to some examples in the examples/ directory.
Who yo use it?
Write a rhythm. Compile it with "rc". Run the produced program. You are done.
See the examples/ directory to get the point.
When you run an example, try "-h" to get the available options.
It should be self-explanatory.
The rhythm compiler has several options. By running "rc --help", all should be clear.
Technical Details:
The compiler will parse the input file line by line.
If a line starts with "*" or "." (not counting leading white spaces), the whole line is seen as a rhythm line, and is transformed into C code. If not, it is passed as is to the C file.
Beware! You MUST NOT start any C code line by "*" or "."!
You can create as much functions as you want, write any C code you want. But remember that a line starting by "*" or "." is seen as a rhythm line and is translated by "rc" into C code.
You must provide a "void main_rhythm(void)" function, that will be called by the library. It is the starting point of your rhythm. It can be "void main_rhythm(int argc, char *argv[])" too, with common meaning for those parameters (non-C coders will have trouble with the Virtual Drum Machine).
You can change the tempo (ex. "tempo=100;") or the volume (ex "vol=0.4;") at any time. Each sample comes with its own volume and panning (ex. "a.vol = 0.1;" "a.pan=-0.8;"). Volumes range from 0 to what you want. 1 is for the normal volume. Panning ranges from -1 (left) to 1 (right). 0 is center. All values are double. You can use "volume" instead of "vol", and "panning" instead of "pan". There is no global panning, if you want all left, set all samples to left.
To run in stereo mode, dont forget "-s" when running the generated program. It is mono by default.
You absolutely need to compile and run the examples, and read them to get the point out of it!
The "rc.conf" file contains configuration informations. You specify the sample by "sample" followed by its name (the one you will use in your rhythm files), then the file that will be played. The name of the sample must start by a letter, followed by letters and/or numbers (it must be a valid C identifier, without "_" though). The configuration file contains the install directory, used by "rc" to compile your rhythms. Take a look at the one that is provided to see how to use it.
The sound files are simple wav files. They all should be of the same rate, which can be specified to the generated program, using the "-f" option (44100 is the default). (The library only handles very basic wav files, if yours dont work, you probably will have to modify the library for the program to handle it.)
When you add a sample, you must modify "rc.conf" for the changes to appear. The samples are hard-linked to the produced program, so if you change "sample a /some/dir/file1.wav" by "sample a /one/other/dir/file2.wav" in the configuration file, the previously generated programs will still use "/some/dir/file1.wav". You will have to compile them again to take the changes into account.
Enhancements:
- The code has been modified to let gcc 4 compile it.

TCLink provides a client for running credit card transactions over TCP/IP.
TCLink is a client for running credit card or ACH (electronic check) transactions over TCP/IP, via the TrustCommerce gateway. It features a simple, cross-platform protocol, fail-over server support, and encrypts communications using the OpenSSL library.
It includes a test merchant account, so that you can run demo transactions out of the box. PHP, Python, Perl, Ruby, and C language implementations are available as seperate archives from the project homepage.
Main features:
- A simple, cross-platform protocol
- Encryption via SSL and trusted server certificate authentication
- Fast transactions times (average about 1.2 seconds end-to-end)
- Fail-over to geographically distributed servers for extreme reliability
- Available for numerous platforms and languages

DigiBand is a full home version Drumming/Guitar simulator. It isnt just intended to be a simulator, but a uniquely refreshing new experience. The project is much different than simulators already out there.
Main features:
- DigiBand supports both GDA and DTX file formats using a "Prefered" option, which can be modified in the games settings.ini file.
- DigiBand can Support up to 3 players Simutaneously!
- Digiband has a unique "Jukebox" mode which allows you to hear the songs notes before you play it, as well as other surprises.
- DigiBand also supports theming for UI customization, and uses transparent PNG images, avis, mp3s, and Cabbit Models for its UI system.
- DigiBand plays and converts xa audio files for ease of song editing.
- Digiband saves your highscores with maxcombo so you can clock how well you are doing.
- DigiBand allows Multiple players, playing bass or guitar with a drum player to all have seperate difficulties and styles.
- DigiBand sorts songs in a categorized "DDR" style interface, with slight adjustments for ease of use!
- DigiBand uses the internal system clock to maintain audio to note synchronization thanks to SDL.
- DigiBand allows users to sync up their songs on the fly. If it feels like youre being rushed or delayed, just sync it up by pressing F11/F12.