Free elecard avc streaming plugin for wmp 1.2 software for linux

xSocket provides a Java nio-based server framework.
xSocket is based on the Java NIO package. It handles low level I/O operations, and implements a thread, buffer and connection management in a very efficiency way. The underlying threading and synchronization management ensures high performance and high scalability by using multithreading.
Main features:
- client side blocking and non-blocking connections
- server side non-blocking connections
- a dynamic callback handler architecture to provide asynchronous communication approaches
- SSL (which can also be activated in a ad-hoc manner),
- QualityOfService management by providing a dynamic data transfer rate control,
- TCP and UDP transport protocol
Enhancements:
New features:
- [*] read/writeShort method has been added for IDataSink/IDataSource
- [*] getOption() method has been added for IEndpoint and IConnection ( SocketConfiguration has been deprecated)
- [stream] IConnection: suspendRead & resumeRead methods has been added
- [stream] IServerContext: getWorkerpool method has been added
- [stream] all read by delimiter methods now supports a (overloaded) signature with encoding
- [stream] getPendingWriteDataSize() method has been added for the IConnection interface
- [stream] an SPI interface has been defined to plugin external nio providers
- [stream] handler support for NonblockingConnectionPool has been added
Bug fix/Implementation changes:
- [*] IWorkerPool has been deprecated/replaced by java.util.concurrent.Executor
- [*] DynamicWorkerPool has been deprecated. Use java.util.concurrent.Executor implementation instead
- [stream] MultithreadedServer: by default host address "0.0.0.0" will be used instead of getLocalHost()
- [stream] the MultithreadedServerMBeanProxyFactory and ConnectionPoolMBeanProxyFactory class have been moved to the stream package
- [stream] some low level related settter and getter methods of the IMultithreadedServer has been deprecated
- [stream] internal performance/thread optimizations (especially for non multithreaded server mode (workerpool == null))
- [stream] BUG onDataHandler call loops by using the read mark-methods has been fixed
- [stream] BUG throwing of an io exception by handling method (onData, onConnect, ...) doesnt close the connection
- [stream] BUG read by delimiter in a readMarked mode swallows the delimiter has been fixed as suggested by Karsten Ohme. Thanks!
- [stream] BUG closing of a closed Connection throws an io exception has been fixed. If the connection is already closed then invoking of this method will have no effect
- [stream] the low level io classes of xSocket has been moved to a dedicated io package (which implements the SPI)
- [stream] ThrottlingWriteHandler (which supports the setWriteTransferRate method) has been rewritten
- [stream] IoSocketHandler: performance optimization: close will only initiate a write loop if there really remaining data to write

GStreamer Python Bindings project provide Python bindings for the GStreamer project. These bindings provide access to almost all of the GStreamer C API through an object oriented Python API.
GStreamer is a library that allows the construction of graphs of media-handling components, ranging from simple Ogg/Vorbis playback to complex audio (mixing) and video (non-linear editing) processing.
Applications can take advantage of advances in codec and filter technology transparently. Developers can add new codecs and filters by writing a simple plugin with a clean, generic interface.
GStreamer is released under the LGPL.
Main features:
Multiplatform
- GStreamer has been ported to a wide range of operating systems, processors and compilers. This include but are not limited to Linux on i86,PPC, ARM using GCC. Solaris on x86 and SPARC using both GCC and Forte, MacOSX, Microsoft Windows using MS Visual Developer and IBM OS/400.
Comprehensive Core Library
- Graph-based structure allows arbitrary pipeline construction
- Based on GLib 2.0 object model for object-oriented design and inheritance
- Small core library of less than 150KB, about 10 K lines of code
- Pluggable scheduling system capable of dealing with most pipeline structures
- Multi-threaded pipelines are trivial and transparent to construct
- Clean and simple API for both plugin and application developers
- Extremely lightweight data passing means very high performance/low latency
- Complete debugging system for both core and plugin/app developers
- Clocking to ensure global inter-stream synchronization
Intelligent Plugin Architecture
- Dynamically loaded plugins provide elements and media types, demand-loaded via an XML registry, similar to ld.so.cache
- Element interface handles all known types of sources, filters, sinks
- Capabilities system allows verification of element compatibility using MIME types and media-specific properties
- Autoplugging uses capabilities system to complete complex paths automatically
- Pipelines can be saved to XML and loaded back to working state
- Resource friendly plugins dont waste RAM
Extensive Development Tools
- Graphical editor allows pipelines to be built quickly, run, and saved as XML
- gst-launch command-line tool enables even quicker prototyping and testing, similar to ecasound
- All tools written as libraries to allow easy reuse
- A lot of documentation, including partially completed manual and plugin writers guide
- Large selection of test programs and example code
- Access to GStreamer API with various programming language

camsource project grabs images from a video4linux device and makes them available to various plugins for processing or handling. It features a modularized and multithreaded design to offer a large amount of flexibility.
A server plugin runs in its own thread, which makes it possible to use the same grabbed frame for several purposes at the same time.
There are also filter plugins, which can be daisychained to create useful and no-so-useful effects in images. The configuration happens through an xml config file, hopefully making configuring camsource an easy task.
Main features:
- The video4linux input plugin. This functionality was built into camsource in versions 0.6.0 and earlier, but has been modularized in 0.7.0 and up. New in 0.7.0 is also the capability to automatically adjust the cameras brightness level (thanks to Nigel Roberts and Stefan Meyer).
- A plugin "wc_serv" providing compatibility with webcam_server 0.30. You can use its java applet to view the image stream from this plugin.
- A http mini-server plugin "http", which can serve the current still frame to a web browser, as well as serve a Mozilla/Netscape compatible multipart jpeg stream. This stream can be viewed without plugins in said browsers, or with a java applet such as Cambozola in any browser (read: IE). This multipart jpeg stream is compatible to what Camserv 0.5.0 produces. Camserv also includes a javascript snippet to turn a still image into an animation. The http server also supports basic http authentication, so you can password-protect those important live pictures (new in 0.7.0).
- A "filewrite" module, which periodically saves a new snapshot jpeg to a local file.
- The "ftpup" module, which works like the filewrite module, only that the snapshot is uploaded to an ftp site.
- The "flip" image filter, which lets you flip an image horizontally or vertically. Useful if your webcam produces mirrored images like mine.
- The "resize" image filter, doing simple nearest-neighbor image resizing. The idea is to make the hardware grab images at the maximum size, and use the resize filter to scale the image down to the required size. This lets you create several versions of the same image stream, at different sizes.
- An image filter capable of rotating the image left or right by 90 degrees. If you want to rotate the image by 180 degrees, use the "flip" filter.
- A text overlay module, which is able to display either a fixed text (possibly containing a timestamp) in the image, or read the text to display from a local file or from a commands stdout.
- In case your camera produces frames in an BGR palette while the driver detects an RGB palette (or the other way round, haw haw), theres the "rgbbgr" filter to fix this. Also includes the "bw" filter to convert a color image to grayscale.
- (New in 0.7.0) A module to feed the current image data back to a vloopback device. This feature should still be considered experimental. Credits go to Cyril Rocheteau for this.
- (New in 0.7.0) An x11/xwd input plugin. This lets you use an x11 display as an input source to camsource, making it possible to serve live screenshots to viewers, possibly even as a live stream. When combined with the http authentication feature of the http module, you could use this to see whats going on on your desktop at home from anywhere in the world. The external "xwd" program is required to do this though (which is part of the core xfree86 distribution).

MP3 Streaming DownSampler for PHP is written with cable modem/DSL users with low upstream caps in mind. Using LAME, it dynamically downsamples a requested MP3 to a bitrate which can be streamed.

It doesnt use temporary files, so you dont have to take the time to do any batching, and you just give it a directory with symlinks to your music in a place the Web server can reach. The interface is simplistic and fast, meant for immediate plug and play access.

Template::Plugin::XML::Simple is a plugin interface to XML::Simple.

SYNOPSIS

# load plugin and specify XML file to parse
[% USE xml = XML.Simple(xml_file_or_text) %]

This is a Template Toolkit plugin interfacing to the XML::Simple module.

Taverna is a collection of workflow enactment and description components, including a high level language for workflows called Scufl (Simple Conceptual Unified Flow Language), a pure Java object model, parser to populate the model, and a set of views and controllers (including some Swing components to drop into your workflow-enabled applications). In order to actually run workflows you also need the myGrid workflow enactment engine.

Taverna core data models include the object representations of the workflow itself, all entities within the workflow (processors, ports, data links etc) and the model for the data values flowing along data links during a workflow enactment.

Taverna task extensions sit within an enactment engine - in this case FreeFluo - and provide concrete implementations of the abstract tasks specified by Processor objects within the workflow object model. It is these tasks which contain the logic required to contact web services, run local java classes and perform the other actions associated with their Processor entities.

Instances of the task extensions are created when a workflow and associated input objects are submitted through the Workflow Submission Interface. This interface may be an in process java method call or may be invoked across some transport such as SOAP in the case of a remote service based enactment engine. FreeFluo is capable of acting in both modes, the Taverna workbench incorporates an instance of the FreeFluo enactor to provide basic enactment services to users without a central workflow engine server.

The graphical user interface classes sit on a client machine and allow interaction with the core data model classes as well as with running workflow instance objects within an enactment engine. This allows workflow construction, editing and visualisation as well as enactor management and data browsing across the results and intermediate values within a workflow instance.

The storage interface is a plugable framework that allows external data and metadata stores to observe events within the workflow enactment service and collection information about those events. This could include a provenance collection plugin which watches the workflow enactment and records metadata about it in RDF form, or a storage plugin which streams results back to a relation database, possibly a Life Science Identifier (LSID) authority, as the enactment runs.

The LSID authority interface is a read only access point to data stored within a data store, and can potentially be used by the Taverna graphical user interface components to fetch results of previous workflows and make use of them as inputs to successive ones.