All Classes and Interfaces
Class
Description
Red5 audio codec for the AAC audio format.
RTMP Abort event.
Abstract base for client streams
Base class for all Flex compatibility messages.
Abstract base for all messages
Abstract pipe that books providers/consumers and listeners.
Base scope handler implementation.
Abstract base implementation of IStream.
Access denied
Flex compatibility message that is returned to the client.
An externalizable version of a given AcknowledgeMessage.
Interface to handle completion of addIceCandidate
Sample application that uses the client manager.
Aggregate data event
Simple allocation debugger for Event reference counting.
Information on references count
These are the core AMF data types supported by Red5.
AMF3 data type definitions.
Annotation for classes that should be serialized without their class name.
Appender for logback in charge of sending the logged events to a Firebase analytic server.
This class is used to configure the applications.
Base class for applications, takes care that callbacks are executed single-threaded.
JMX mbean for Application.
This class can be used to initialize Quartz for a Red5 application.
Application Settings for each application running in Ant Media Server.
Flex
ArrayCollection compatibility class.Base class for for asynchronous Flex compatibility messages.
An externalizable version of a given AsyncMessage.
Base interface for all API objects with attributes
Audio codecs that Red5 supports.
Factory for audio codecs.
Implementations of this interface can create a native
webrtc::AudioDecoderFactory.This interface is a thin wrapper on top of a native C++ webrtc::AudioDeviceModule (ADM).
Implementations of this interface can create a native
webrtc::AudioEncoderFactory.Factory for creating webrtc::AudioProcessing instances.
Java wrapper for a C++ AudioSourceInterface.
Java wrapper for a C++ AudioTrackInterface
Added to support flex.messaging.messages.AuthenticationMessage as noted in http://jira.red5.org/browse/APPSERVER-176
Red5 video codec for the AVC (h264) video format.
BitrateAdjuster that tracks bitrate and framerate but does not adjust them.
Base abstract class for connections.
Base abstract class for all RTMP events
BaseInput represents a way to map input to a HashMap.
BaseOutput represents a way to map input to a HashMap.
Base class for all RTMP handlers.
Base class for streamable file services.
Generalizations of one of main Red5 object types, Scope.
Object that adjusts the bitrate of a hardware codec.
Boot-straps Red5 using the latest available jars found in red5.home/lib directory.
Scope type for publishing that deals with pipe connection events, like async message listening in JMS
This is like a clone of Broadcast object.
Buffer types (auto, direct or heap).
Buffer Utility class which reads/writes integers to the input/output buffer
Creates a native
webrtc::AudioDecoderFactory with the builtin audio decoders.This class creates a native
webrtc::AudioEncoderFactory with the builtin audio encoders.Red5 version of the Flex ByteArray class.
Bytes read event
Provides an implementation of a cacheable object.
Provides a means for storage of RTMP events.
Provides an implementation of an object cache.
Basic service call (remote call) implementation
Representation of a change in selected ICE candidate pair.
Interface for observering a capturer.
Identified connection that transfers packets.
RTMP chunk header
Chunk size event
Client is an abstraction representing user connected to Red5 application.
Represents live stream broadcasted from client.
Represents live stream broadcasted from client.
Client bandwidth event.
Exception class than contains additional parameters to return to the client.
Represents an invoke to be executed on a connected client.
Client list, implemented using weak references to prevent memory leaks.
MBean for Client.
Client not found
Represents an notify to be executed on a connected client.
Registry for clients, wherein clients are mapped by their id.
An MBean interface for the client registry.
The client is not allowed to connect.
Command message as sent by the
mx:RemoteObject tag.An externalizable version of a given CommandMessage.
Deprecated, for removal: This API element is subject to removal in a future version.
Provides configuration details for Applications.
RTMP connection consumer.
The connection object.
Provides connection via pipe
Constants for the flex compatibility messages.
Class for AMF and RTMP marker values constants
Basic consumer service implementation.
This is basic context implementation used by Red5.
Red5 applications loader
Red5 applications loader
A servlet context listener that puts this contexts LoggerContext into a static map of logger contexts within an overall singleton log context selector.
This is basic context implementation used by Red5.
Resolve services that have been configured in the context of a scope.
Class for storing the application context and retrieving it in a static context.
Misc utils for conversions
Base IScopeHandler implementation
Base IScopeHandler implementation
This filter is implemented in order to make easy to develop angular app
CryptoOptions defines advanced cryptographic settings for native WebRTC.
Java wrapper for a C++ DataChannelInterface.
Java version of C++ DataBuffer.
Java wrapper for WebIDL RTCDataChannel.
Java version of C++ DataChannelObserver.
Keep in sync with DataChannelInterface::DataState.
Implementation of the IDataInput interface.
Message containing data update requests.
Implementation of the IDataOutput interface.
This class just logs the data transfered for http requests to
The core datatypes supported by red5, I have left out undefined (this is up for debate).
Annotation for public methods that should not be callable through RTMP, RTMPT or Remoting.
Annotation for public methods that should be protected by a named permission when called through RTMP, RTMPT or Remoting.
Default filename generator for streams.
Can be returned to delay returning the result of invoked methods.
Stream security handler that denies access to all streams.
The Deserializer class reads data input and handles the data according to the core data types
This class is a utility to serialize a DOM node as XML.
Annotation for fields that should not be serialized when sending objects to a client.
Java wrapper for a C++ DtmfSenderInterface.
BitrateAdjuster that tracks the bandwidth produced by an encoder and dynamically adjusts the
bitrate.
Dynamic playlist item implementation
Extension of Tomcat's Tomcat class, tailored for Red5.
Empty class for use in libjingle_peerconnection_java because all targets require at least one
Java file.
An encoded frame from a video stream.
Compatibility flex error message to be returned to the client.
An extension of
PropertyPlaceholderConfigurer.Factory for creating webrtc::FecControllerFactory instances.
Consumer that pushes messages to file.
Queued data wrapper.
File-based keyframe metadata cache.
Pullable provider for files
Represents stream source that is file
Generic file utility containing useful file or directory manipulation functions.
Serial flag options.
Flex method invocation.
AMF3 stream send message.
A FLVImpl implements the FLV api
FLVHeader parses out the contents of a FLV video file and returns the Header data
A Reader is used to read the contents of a FLV file.
A FLVServiceImpl sets up the service and hands out FLV objects to its callers.
A Writer is used to write the contents of a FLV file
A class to manage the data of audio and video frames.
Constants defining data type in the frame.
The FrameDecryptor interface allows Java API users to provide a
pointer to their native implementation of the FrameDecryptorInterface.
The FrameEncryptor interface allows Java API users to provide a pointer to
their native implementation of the FrameEncryptorInterface.
BitrateAdjuster that adjusts the bitrate to compensate for changes in the framerate.
Example post-processor implementation which counts data types in a given file.
Global scope is a top level scope.
An MBean interface for the scope object.
Container for static helper functions related to dealing with H264 codecs.
Allow scope handlers to create service handlers dynamically.
RTMP packet header
ISO/IEC 14496-15, 8.3.3.1.2 Syntax
aligned(8) class HEVCDecoderConfigurationRecord {
unsigned int(8) configurationVersion = 1;
unsigned int(2) general_profile_space;
unsigned int(1) general_tier_flag;
unsigned int(5) general_profile_idc;
unsigned int(32) general_profile_compatibility_flags;
unsigned int(48) general_constraint_indicator_flags;
unsigned int(8) general_level_idc;
bit(4) reserved = ‘1111’b;
unsigned int(12) min_spatial_segmentation_idc;
bit(6) reserved = ‘111111’b;
unsigned int(2) parallelismType;
bit(6) reserved = ‘111111’b;
unsigned int(2) chromaFormat;
bit(5) reserved = ‘11111’b;
unsigned int(3) bitDepthLumaMinus8;
bit(5) reserved = ‘11111’b;
unsigned int(3) bitDepthChromaMinus8;
bit(16) avgFrameRate;
bit(2) constantFrameRate;
bit(3) numTemporalLayers;
bit(1) temporalIdNested;
unsigned int(2) lengthSizeMinusOne;
unsigned int(8) numOfArrays;
for (j=0; j < numOfArrays; j) {
bit(1) array_completeness;
unsigned int(1) reserved = 0;
unsigned int(6) NAL_unit_type;
unsigned int(16) numNalus;
for (i=0; i< numNalus; i) {
unsigned int(16) nalUnitLength;
bit(8*nalUnitLength) nalUnit;
}
}
}
Red5 video codec for the AVC (h264) video format.
HEVC Video codec complaint with Enhanced RTMP
There is another HEVCVideo that uses codec id as 12.
This was borrowed from the Soupdragon base64 library.
Hexadecimal byte dumper
Class for holding the native pointer of a histogram.
IApplication provides lifecycle methods that most communication applications will use.
Interface that wraps the application server context.
Interface for servers that can load new applications.
Base interface for all API objects with attributes
Represents an Audio codec and its associated decoder configuration.
Base interface for all scope objects, including SharedObjects.
Broadcast scope is marker interface that represents object that works as basic scope and has pipe connection event dispatching capabilities.
A broadcast stream is a stream source to be subscribed to by clients.
Base interface for objects that can be made cacheable.
Storage for cacheable objects.
Attribute storage with automatic object casting support.
Representation of a single ICE Candidate, mirroring
IceCandidateInterface in the C++ API.The client object represents a single client.
A broadcast stream that comes from client.
Statistical informations about a stream that is broadcasted by a client.
Provides a registry of client objects.
A stream that is bound to a client.
Represents a "command" sent to or received from an end-point.
The connection object.
Encoding type.
Queue of connection events
Interface for listeners to connection events.
Signature for the message consumer.
Service for consumer objects, used to get pushed messages at consumer endpoint.
The current context, this object basically wraps the Spring context or in the case of the .Net version, any similar system.
Base marker interface for all core objects.
Cue point type
Interface for objects that know how to serialize their contents.
Interface implemented by classes that provide a way to load custom objects.
Interface implemented by classes that provide a way to store custom objects.
The listener interface to update the Endpoint status.
IEvent interfaces is the essential interface every Event should implement
Event decoder decodes event objects from incoming byte buffer.
IEventDispatcher interface implementations dispatch events
Encodes events to byte buffer.
IEventObservable hold functionality of the well-known Observer pattern, that is it has a list of objects that listen to events.
Interface that needs to be implemented by classes that serialize / deserialize themselves.
Filter marker interface groups consumer and provider interfaces
Represents FLV file
A FLVService sets up the service and hands out FLV objects to its callers
Interface for classes that implement logic to drop frames.
The global scope that acts as root for all applications in a host.
Base interface for Handshake classes.
Analyzes key frame data.
Keyframe metadata.
Interface defining a cache for keyframe metadata informations.
This interface encapsulates the mapping strategy used by the context.
Common interface for all messages.
Message component handles out-of-band control messages
Input Endpoint for a consumer to connect.
Output Endpoint for a provider to connect.
IMeta is a Marker Interface CuePoint and MetaData both implement this interface
ICuePoint defines contract methods for use with cuepoints
FLV MetaData interface
IMetaService Defines the MetaData Service API
An ImmutableTag represents immutable encapsulation of flash media data.
Performs handshaking for server connections.
Custom property editor for java.net.InetAddress class
A simple in-memory version of pull-pull pipe.
A simple in-memory version of push-push pipe.
Input for Red5 data types
Input for Red5 data (AMF3) types
Interface for Input which defines the contract methods which are to be implemented.
Holds informations about already deserialized classes.
Dummy class that is stored as reference for objects currently being deserialized that reference themselves.
Class used to collect AMF3 references.
Remote invocation event
Constants found in FLV files / streams.
Extends stream to add methods for on demand access.
Miscellaneous I/O utility methods
Signature to mark a provider/consumer never actively providers/consumers messages.
IPendingServiceCall is a call that have a list of callbacks.
Callback that will be executed when the result of a pending service call has been received.
Base interface for objects that can be made persistent.
Storage for persistent objects.
A pipe is an object that connects message providers and message consumers.
A listener that wants to listen to events when provider/consumer connects to or disconnects from a specific pipe.
Playlist item.
Playlist
A play list controller that controls the order of play items.
IPlaylistSubscriberStream has methods of both ISubscriberStream and IPlaylist but adds nothing new
Statistical informations about a stream that is subscribed by a client.
Post processes media.
Pre-processes media.
Signature for message provider.
Central unit to get access to different types of provider inputs
A provider that supports passive pulling of messages.
A consumer that supports event-driven message handling and message pushing through pipes.
Recording listener interface.
Base interface for a Red5 server Plug-in.
Base interface for handlers originating from plug-ins.
Connection coming from Remoting clients.
A Remoting header.
RTMP events handler
Interface that must be implemented by classes that can be scheduled for periodic execution.
Service that supports periodic execution of jobs, adding, removing and getting their name as list.
The scope object.
Maker interface for all objects that are aware of the scope they are located in.
The scope handler controls actions performed against a scope object, and also is notified of all events.
Interface for listeners to scope events.
Resolve the scope from given a host and path.
Provides an interface for scope security handling.
Base marker interface for all scope services.
Statistical informations about a scope.
Provider that is seekable
Stream source that can be seeked in timeline
The interface that represents the Red5 server.
IServerStream has both IPlaylist and IBroadcastStream methods but add nothing new.
Container for a Service Call
Connection that has options to invoke and handle remote calls
Supports registration and lookup of service handlers.
Class that knows about objects which can provide service handlers.
Interface for objects that execute service calls (remote calls from client).
Interface for objects that resolve service names to services.
Represents the most basic type of "Session", loosely modeled after the HTTP Session used in J2EE applications.
A subscriber stream that has only one item for play.
Base class for all statistics informations.
Statistics methods for Red5.
Base interface for stream objects.
Interface represents streamable file with tag reader and writers (one for plain mode and one for append)
Interface represents streamable file with tag reader and writers (one for plain mode and one for append)
Scope service extension that provides method to get streamable file services set
Provides access to files that can be streamed.
A scope handler that is stream aware.
A connection that supports streaming.
Stream codec information
Stream Control Event.
Stream data packet
A class that can generate filenames for streams.
Possible filename generation types.
Listener that is notified about packets received from a stream.
Packet containing stream data.
Interface for handlers that control access to stream playback.
Interface for handlers that control access to stream publishing.
Service that supports protecting access to streams.
Service that supports protecting access to streams.
This interface represents the stream methods that can be called throug RTMP.
Source for streams
Base class for all stream statistics.
Interface for providers that know if they contain video frames.
ISubscriberStream is a stream from subscriber's point of view.
A Tag represents the contents or payload of a streamable file.
Writes tags to a file
Basically token bucket is used to control the bandwidth used by a stream or a connection or a client.
Callback for tocket bucket
A service used to create and manage token buckets.
Represents a Video codec and its associated decoder configuration.
Holder for video frame data.
AudioDeviceModule implemented using android.media.AudioRecord as input and
android.media.AudioTrack as output.
Called when audio recording starts and stops.
Contains audio sample information.
Called when audio playout starts and stops.
Called when new audio samples are ready.
Implementation of VideoFrame.I420Buffer backed by Java direct byte buffers.
Helper methods for working with ObjectName or MBean instances.
Class with static JNI helper functions that are used in many places.
This class is only used from jni_helper.cc to give some Java functionality that were not possible
to generate in other ways due to bugs.webrtc.org/8606 and bugs.webrtc.org/8632.
Just keep this class for compatibility.
Launches Red5.
Base class for all JEE application loaders.
Simple mbean interface for J2EE container loaders.
Java interface for WebRTC logging.
A servlet filter that puts this contexts LoggerContext into a Threadlocal variable.
Java wrapper for WebRTC logging.
Deprecated.
A class that allows the LoggerFactory to access an web context based LoggerContext.
Basic mapping strategy implementation.
Description of media constraints for
MediaStream and
PeerConnection.Simple String key/value pair.
Java wrapper for a C++ MediaSourceInterface.
Tracks MediaSourceInterface.SourceState
Java wrapper for a C++ MediaStreamInterface.
Java wrapper for a C++ MediaStreamTrackInterface.
Tracks MediaStreamTrackInterface.TrackState
Factory for creating webrtc::MediaTransportFactory instances.
Cue point is metadata marker used to control and accompany video playback with client-side application events.
MetaData Implementation
MetaService represents a MetaData service in Spring
Thrown if service method is not found so call throws exception
Class holding histogram information.
This class is used to mock the webrtc adaptor in community edition
Red5 audio codec for the MP3 audio format.
ApplicationAdapter class serves as a base class for your Red5 applications.
PLEASE READ HERE BEFORE YOU IMPLEMENT A MUXER THAT INHERITS THIS CLASS
One muxer can be used by multiple encoder so some functions(init,
writeTrailer) may be called multiple times, save functions with guards and
sync blocks
Muxer MUST NOT changed packet content somehow, data, stream index, pts, dts,
duration, etc.
This class is used generally to send direct video buffer to muxer
This class is meant to be a simple layer that only handles the JNI wrapping of a C++
AndroidVideoTrackSource, that can easily be mocked out in Java unit tests.
Used from native api and implements a simple VideoCapturer.CapturerObserver that feeds frames to
a webrtc::jni::AndroidVideoTrackSource.
Interface for loading native libraries.
Factory for creating webrtc::jni::OwnedPeerConnection instances.
Implementations of this interface can create a native
webrtc::NetEqFactory.Factory for creating webrtc::NetworkControllerFactory instances.
Network dump filter, performs raw data and headers dump on message receive
Factory for creating webrtc::NetworkStatePredictorFactory instances.
Provides an implementation of an object cache which actually does not provide a cache.
Thrown when a client is not allowed to execute a method.
Stream notification event.
Map that should be transmitted as object through RTMP.
Flex
ObjectProxy compatibility class.Out-of-band control message used by inter-components communication which are connected with pipes.
The requested operation is not supported by the stream.
AMF3 output writer
Output interface which defines contract methods to be implemented
Output stream that consists of audio, video and data channels
RTMP packet.
Java-land version of the PeerConnection APIs; wraps the C++ API
http://www.webrtc.org/reference/native-apis, which in turn is inspired by the
JS APIs: http://dev.w3.org/2011/webrtc/editor/webrtc.html and
http://www.w3.org/TR/mediacapture-streams/
Java version of PeerConnectionInterface.BundlePolicy
Java version of PeerConnectionInterface.CandidateNetworkPolicy
Java version of PeerConnectionInterface.ContinualGatheringPolicy
Tracks PeerConnectionInterface::IceConnectionState
Tracks PeerConnectionInterface::IceGatheringState
Java version of PeerConnectionInterface.IceServer.
Java version of PeerConnectionInterface.IceTransportsType
Java version of rtc::KeyType
Java version of PeerConnectionObserver.
Tracks PeerConnectionInterface::PeerConnectionState
Java version of webrtc::PortPrunePolicy
Java version of PeerConnectionInterface.RTCConfiguration
Java version of PeerConnectionInterface.RtcpMuxPolicy
Java version of webrtc::SdpSemantics.
Tracks PeerConnectionInterface::SignalingState
Java version of PeerConnectionInterface.TcpCandidatePolicy
Tracks PeerConnectionInterface::TlsCertPolicy
PeerConnectionDependencies holds all PeerConnection dependencies that are
applied per PeerConnection.
Java wrapper for a C++ PeerConnectionFactoryInterface.
Helper class holding both Java and C++ thread info.
Pending call is remote call operation that is in pending state.
Persistable attributes store.
Helper class for persistence.
Ping event, actually combination of different events.
Event object corresponds to the connect/disconnect events among providers/consumers on pipes.
Pipe connection event type
Helper class for pipe structure.
A Play buffer for sending VOD.
A play engine for playing a IPlayItem.
Builder pattern
Stream of playlist subscriber
Simple descriptor for plug-ins.
Creates the plug-in environment and cleans up on shutdown.
Central registry for Red5 plug-ins.
Represents a predicate (boolean-valued function) of one argument.
Converter for properties originating from properties files.
Proxy filter
Scheduling service that uses Quartz as backend.
Scheduled job that is registered in the Quartz scheduler.
Scheduling service that uses Quartz as backend.
Wraps processing of incoming messages.
Contains queue of tasks for processing messages in the specified channel.
Stream listener for recording stream events to a file.
Read only RecordSet object that might be received through remoting calls.
Result of paged data request, one page of data.
Utility class for accessing Red5 API objects.
LoggerFactory to simplify requests for Logger instances within Red5 applications.
JMX interface for accessing Red5 API objects
Provides more features to the plug-in system.
Implementation of RefCounted that executes a Runnable once the ref count reaches zero.
Interface for ref counted objects in WebRTC.
Provides a means for locating methods within service classes using reflection.
Annotation for classes that should be serialized with a different classname.
Flex compatibility message that is sent by the
mx:RemoteObject mxml tag.To notify the client to reset the playing state.
This filter forwards incoming requests to the origin node that is responsible for that stream.
Represents a subscope to other scopes.
Easily storable/serializable version of a native C++ RTCCertificatePEM.
Java version of webrtc::RTCStats.
Interface for receiving stats reports (see webrtc::RTCStatsCollectorCallback).
Java version of webrtc::RTCStatsReport.
RTMP is the RTMP protocol state representation.
RTMP codec factory creates RTMP encoders/decoders.
RTMP connection.
Responsible for management and creation of RTMP based connections.
Represents current decode state of the protocol.
RTMPE IO filter - Server version.
RTMP events handler.
Generates and validates the RTMP handshake response for Flash Players.
RTMP message
RTMP codec factory.
Represents an RTMP connection using Mina.
Handles all RTMP protocol events fired by the MINA framework.
RTMP protocol decoder.
Mina protocol encoder for RTMP.
Output data chunker.
Transport setup class configures socket acceptor and thread pools for RTMP in Mina.
RTMP protocol decoder.
RTMP protocol encoder encodes RTMP messages and packets to byte buffers.
Default RtmpSampleAccess bean
RTMPS IO filter - Server version.
Handles Native RTMPS protocol events fired by the MINA framework.
Enum for RTMP types.
RTMP utilities class.
The parameters for an
RtpSender, as defined in
http://w3c.github.io/webrtc-pc/#rtcrtpsender-interface.Java wrapper for a C++ RtpReceiverInterface.
Java wrapper for a C++ RtpReceiverObserverInterface
Java wrapper for a C++ RtpSenderInterface.
Java wrapper for a C++ RtpTransceiverInterface.
Java version of webrtc::RtpTransceiverDirection - the ordering must be kept in sync.
Tracks webrtc::RtpTransceiverInit.
Runtime status object
The scope object.
Builder pattern
Generic Scope exception.
Scope handler not found.
An MBean interface for the scope object.
Scope not found, thrown when child scope wasn't found.
Resolves scopes from path
Scope security handler providing positive results to any allow request.
Resolves service names in custom configured services of a scope.
Scope is currently shutting down.
Represents all the supported scope types.
Collection of utilities for working with scopes
Interface for observing SDP-related events.
Response to
DataMessage requests.The Serializer class writes data output and handles the data according to the core data types
The utility class provides conversion methods to ease the use of byte arrays, Mina IoBuffers, and NIO ByteBuffers.
Red5 server core class implementation.
Server bandwidth event.
Filters jar files
Calculates the bandwidth between the client and server.
Simple JEE server detector, based on an idea created by Brian Wing Shun Chan.
An implementation for server side stream.
The ServiceAdapter class is the base definition of a service adapter.
Makes remote calls, invoking services, resolves service handlers
Thrown when server can't be found
Thrown when service can't be found thus remote call throws an exception
Utility functions to invoke methods on connections.
Represents the most basic type of "Session", loosely modeled after the HTTP Session used in J2EE applications.
Description of an RFC 4566 Session.
Java-land enum version of SessionDescriptionInterface's type() string.
Manages sessions.
Quartz job to kill off old sessions
Control message used to set a buffer.
Base for all shared object-related exceptions
Provides a means to cleanly shutdown an instance from the command line.
Red5 shutdown hook
Server/service to perform orderly and controlled shutdown and clean up of Red5.
Simple playlist item implementation
Simple playlist controller implementation
Stream of a single play item for a subscriber
Class for representing size of an object.
SPS parser parses the AnnexB SPS and finds some codec parameters
This is a mock SRT Adaptor.
The SSLCertificateVerifier interface allows API users to provide custom
logic to verify certificates.
StatefulScopeWrappingAdapter class wraps stateful IScope functionality.
Counts numbers used by the statistics.
Implementation of the statistics service.
Interface for observing Stats reports (see webrtc::StatsObservers).
Java version of webrtc::StatsReport.
Java version of webrtc::StatsReport::Value.
Represents status object that are transferred between server and client
Collection of commonly used constants with status codes.
Status object that is sent to client with every status event
Service that works with status objects.
Builds a DOM
Document using a XMLStreamReader.Creates streamable file services
Represents all the actions which may be permitted on a stream.
Represents a stream action occurring on a connection or stream.
Controls stream bandwidth
Stream control exception
Thrown on stream data exception
Organizes and checks stream fetcher and restarts them if it is required
Throw when stream can't be found
Stream service
Represents all the states that a stream may be in at a requested point in time.
Stream helper methods.
Deprecated.
Control message used in response to a SWF verification request.
This utility is designed for accessing server's
system information more easier.
A Tag represents the contents or payload of a FLV file.
Utility interface to be used with executeUninterruptibly() to wait for blocking operations
to complete without getting interrupted..
Utility class to be used for checking that a method is called on the correct thread.
The TimestampAligner class helps translating camera timestamps into the same timescale as is
used by rtc::TimeNanos().
Class that wraps a Tomcat webapp context.
Class that can load new applications in Tomcat.
Model object to contain a connector, socket address, and connection properties for a Tomcat connection.
Red5 loader for Tomcat.
Filters directory content
Red5 loader for Tomcat virtual hosts.
Simple mbean interface for Tomcat container virtual host loaders.
Java wrapper for a C++ TurnCustomizer.
Unknown event
The UnsignedByte class wraps a value of and unsigned 8 bits number.
The UnsignedInt class wraps a value of an unsigned 32 bits number.
The UnsignedLong class wraps a value of an unsigned 64 bits number.
The UnsignedByte class wraps a value of an unsigned 16 bits number.
Simple query string to map converter.
Provides information about the version of Red5 being used.
Video codecs that Red5 supports.
Factory for video codecs.
Represent a video codec as encoded in SDP.
Enumeration of supported video codec types.
Status codes reported by video encoding/decoding components.
Enumeration of supported video codec types.
Video data event
Videoframe type
Interface for a video decoder that can be used in WebRTC.
Additional info for decoding.
Settings passed to the decoder by WebRTC.
Factory for creating VideoDecoders.
A combined video decoder that falls back on a secondary decoder if the primary decoder fails.
This class contains the Java glue code for JNI generation of VideoDecoder.
Interface for a video encoder that can be used with WebRTC.
Represents bitrate allocated for an encoder to produce frames.
Capabilities (loss notification, etc.) passed to the encoder by WebRTC.
Codec specific information about the encoded frame.
Additional info for encoding.
Metadata about the Encoder.
Rate control parameters.
Bitrate limits for resolution.
Settings for WebRTC quality based scaling.
Settings passed to the encoder by WebRTC.
Factory for creating VideoEncoders.
A combined video encoder that falls back on a secondary encoder if the primary encoder fails.
This class contains the Java glue code for JNI generation of VideoEncoder.
Java version of webrtc::VideoFrame and webrtc::VideoFrameBuffer.
Implements image storage medium.
Interface for I420 buffers.
State machine for video frame dropping in live streams.
Lightweight abstraction for an object that can receive video frames, process them, and pass them
on to another object.
Java version of rtc::VideoSinkInterface.
Java wrapper of native AndroidVideoTrackSource.
Simple aspect ratio clas for use in constraining output format.
Java version of VideoTrackInterface.
Logback appender for the Extended W3C format.
This service provides the means to auto-deploy a war.
The servlet to download the war file of the application
When an app is created, the war file is created in the tmp directory
This servlet just checks if the war file exists on the tmp directory and if it exists, it sends the war file to the client(another node in the cluster)
It's used in app distribution in the cluster
Entry point from which the server config file is loaded while running within a J2EE application container.
Event received from player.
This class contains static functions to query sample rate and input/output audio buffer sizes.
This class provides a ClassLoader that is capable of loading WebRTC Java classes regardless of
what thread it's called from.
Deprecated, for removal: This API element is subject to removal in a future version.
Use subscriber class and rest methods, it will be deleted in coming versions
Web scope is special scope that is aware of servlet context and represents scope of a Red5 application within a servlet container (or application server) such as Tomcat, Jetty or JBoss.
An MBean interface for the web scope object.
This class wraps a webrtc::I420BufferInterface into a VideoFrame.I420Buffer.
Wraps a native webrtc::VideoDecoder.
Wraps a native webrtc::VideoEncoder.
Misc XML utils
Wraps libyuv methods to Java.