Free lame rtp software for linux

This is a unified diff (you probably need GNU patch to apply it) to lame 3.58. Please note that this diff is now obsolete as recent beta versions of lame include a version of this code. Just type "make mp3rtp". The code was broken, but the CVS code is reported to work (and interoperate with playRTPMPEG) as of Feb 21 2000.

Please note that the output stream will only have the correct speed if the input is live recorded stream from your sound card or lame encodes exactly in real-time on your CPU!

RTP is the Realtime Transport Protocol as defined in RFC 1889. It is the transport mechanism of your choice to multicast an mp3 stream.

TwoLAME is an optimised MPEG Audio Layer 2 (MP2) encoder based on tooLAME by Mike Cheng, which in turn is based upon the ISO dist10 code and portions of LAME.
TwoLAME includes libtwolame, a fully thread-safe shared library with an API very similar to LAMEs.
Main features:
- Fully thread-safe
- Static and shared library (libtwolame)
- API very similar to LAMEs (for easy porting)
- Frontend supports wider range of input files (using libsndfile)
- automake/libtool/pkgconfig based build system
Enhancements:
- This release adds win32/winutil.h to the tarball, fixes bug #1629945, fixes presentation of --enable-debug in the configure script, adds twolame_encode_buffer_float32_interleaved(), fixes a bug that was losing stereo in twolame_encode_buffer_float32(), fixes twolame_set_mode() to accept TWOLAME_AUTO_MODE, adds source file IDs to the top of every file, and adds -pedantic to CFLAGS for the debug build.

libSRTP library is an open-source implementation of the Secure Real-time Transport Protocol (SRTP) originally authored by Cisco Systems, Inc. It is available under a BSD-style license.
SRTP is a security profile for RTP that adds confidentiality, message authentication, and replay protection to that protocol. It is specified in RFC 3711. More information on the SRTP protocol itself can be found on the Secure RTP Page.
Installation:
./configure [ options ] # GNU autoconf script
make # or gmake if needed; use GNU make
The configure script accepts the following options:
--help provides a usage summary
--disable-debug compile without the runtime debugging system
--enable-syslog use syslog for error reporting
--disable-stdout use stdout for error reporting
--enable-console use /dev/console for error reporting
--gdoi use GDOI key management (disabled at present)
By default, debbuging is enabled and stdout is used for debugging. You can use the above configure options to have the debugging output sent to syslog or the system console. Alternatively, you can define ERR_REPORTING_FILE in include/conf.h to be any other file that can be opened by libSRTP, and debug messages will be sent to it.
This package has been tested on Mac OS X (powerpc-apple-darwin1.4),
Cygwin (i686-pc-cygwin), and Sparc (sparc-sun-solaris2.6). Previous
versions have been tested on Linux and OpenBSD on both x86 and sparc
platforms.
Enhancements:
- Release 1.4.4 is a snapshot of the code in CVS, which has been slowly accumulating minor fixes and extensions.

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.

The SR-RTP library enables real-time streaming applications (such as streaming MPEG-4 video) to cope with packet loss, variable bandwidth, and variable delay on the Internet.

It provides a means for selective retransmission of lost packets in a fashion that is backwards-compatible with RTP. Additionally, it provides integration with the Congestion Manager to provide a system capable of performing TCP- friendly streaming of real-time data.

Installation:

The `configure shell script attempts to guess correct values for various system-dependent variables used during compilation.

It uses those values to create a `Makefile in each directory of the package. It may also create one or more `.h files containing system-dependent definitions.

Finally, it creates a shell script `config.status that you can run in the future to recreate the current configuration, a file `config.cache that saves the results of its tests to speed up reconfiguring, and a file `config.log containing compiler output (useful mainly for debugging `configure).

If you need to do unusual things to compile the package, please try to figure out how `configure could check whether to do them, and mail diffs or instructions to the address given in the `README so they can be considered for the next release.

If at some point `config.cache contains results you dont want to keep, you may remove or edit it.

The file `configure.in is used to create `configure by a program called `autoconf. You only need `configure.in if you want to change it or regenerate `configure using a newer version of `autoconf.

The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system. If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute
`configure itself.

Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

3. Optionally, type `make check to run any self-tests that come with the package.

4. Type `make install to install the programs and any data files and documentation.

5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean.

There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.

oRTP is a library implementing the Real-time Transport Protocol (RFC3550), written in C.
oRTP project is easy to use and provides a packet scheduler for sending and receiving packets on time, adaptive jitter compensation, and automatic sending of RTCP compound packets. It works with IPv6.
Main features:
- Written in C
- Implement the RFC3550 (RTP) with a easy to use API with high and low level access.
- Includes support for multiples profiles, AV profile (RFC1890) being the one by default.
- Includes a packet scheduler for synchronizing rtp recv and send. Scheduling is optionnal, rtp sessions can remain not scheduled.
- Implements blocking and non blocking IO for RTP sessions.
- Supports mutiplexing IO, so that hundreds of RTP sessions can be managed by a single thread.
- Supports part of RFC2833 for telephone events over RTP.
- The API is well documented using gtk-doc.
- Licensed under the Lesser Gnu Public License.
- RTCP messages sent periodically since 0.7.0 (compound packet including sender report or receiver report + SDES)
Enhancements:
- This version includes new API documentation built with Doxygen and integrates minor patches and optimizations.

NeMeSI is a streaming client that allows user to enjoy playback of multimedia files with low latency transport over IP-based networks. This software is fully compliant with IETFs standards for real-time streaming of multimedia contents over Internet.
NeMeSI implements RTSP - Real-Time Streaming Protocol (RFC2326) and RTP/RTCP - Real-Time Transport Protocol/RTP Control Protocol (RFC3550) supporting the RTP Profile for Audio and Video Conferences with Minimal Control (RFC3551).
NeMeSI supports the following decoding standards:
Audio
- MP3 (MPEG-1 Layer III) (RFC3119)
- GSM-AMR (3rd generation GSM) (RFC3267)
- OGG/Vorbis (work in progress)
Video
- MPEG-1/2 (RFC2250)
- MPEG-4 (RFC3016, RFC3640) (work in progress)
- OGG/Theora (work in progress)
The main characteristic of NeMeSI is that it is adaptable to the state of the network gotten through the technique of the dynamic coding change.
NeMeSI is the worlds first streaming client supporting Creative Commons licensing meta-data for audio/video streaming.
Enhancements:
- A CLI option was added to force RTP/RTCP UDP ports.
- IPv6 compatibility was improved.
- Preliminary support for MPEG4 was added.
- Conversion to a library was started.
- Fenice is GCC4 compatible.
- Bugfixes were made.