Acl

Acl Namespace Reference

Namespaces

Name
Acl::AclLog
A namespace for logging utilities.
Acl::ControlDataCommon
Acl::IngestUtils
Acl::TimeCommon

Classes

Name
structAcl::AlignedAudioFrame
AlignedAudioFrame is a frame of interleaved floating point audio samples with a given number of channels.
structAcl::AlignedFrame
A frame of aligned data that is passed to the rendering engine from the MediaReceiver. A DataFrame contains a time stamped frame of media, which might be video, audio and auxiliary data such as subtitles. A single DataFrame can contain one or multiple types of media. Which media types are included can be probed by nullptr-checking/size checking the data members. The struct has ownership of all data pointers included. The struct includes all logic for freeing the resources held by this struct and the user should therefore just make sure the struct itself is deallocated to ensure all resources are freed.
classAcl::ControlDataAddress
A class representing an address within the control protocol. The address consists of an internal list of UUIDs, which all represent a component that needs to be passed to reach the final address. An address might end with a wildcard, which is represented by the omni UUID (i.e. all digits set to 0xF) and will then match all addresses with the same UUID sequence in the start.
classAcl::ControlDataSender
A ControlDataSender can send control signals to one or more receivers using a network connection. A single ControlDataSender can connect to multiple receivers, all identified by a UUID. The class is controlled using an ISystemControllerInterface; this interface is responsible for setting up connections to receivers. The ControlDataSender can send asynchronous requests to (all) the receivers and get a response back. Each response is identified with a request ID as well as the UUID of the responding receiver. The ControlDataSender can also receive status messages from the receivers.
classAcl::DeviceMemory
RAII class for a CUDA memory buffer.
classAcl::IControlDataReceiver
IControlDataReceiver is the interface class for the control data receiver. An IControlDataReceiver can receive messages from a sender or other IControlDataReceivers using a network connection. It can also connect to and forward the incoming request messages to other receivers. The connections to the sender and the other receivers are controlled by an ISystemControllerInterface instance. The ControlDataReceiver has a receiving or listening side, as well as a sending side. The listening side can listen to one single network port and have multiple ControlDataSenders and ControlDataReceivers connected to that port to receive requests from them. On the sending side of the ControlDataReceiver, it can be connected to the listening side of other ControlDataReceivers, used to forward all incoming messages to that receiver, as well as sending its own requests.
classAcl::IMediaStreamer
IMediaStreamer is an interface class for MediaStreamers, that can take a single stream of uncompressed video and/or audio frames and encode and output it in some way. This output can either be a stream to a network or writing down the data to a file on the hard drive. This class is configured from two interfaces. The input configuration (input video resolution, frame rate, pixel format, number of audio channels…) is made through this C++ API. The output stream is then started from the System Controller. Any of these configurations can be made first. The actual stream to output will start once the first call to.
classAcl::IngestApplication
classAcl::ISystemControllerInterface
An ISystemControllerInterface is the interface between a component and the System controller controlling the component. The interface allows for two-way communication between the component and the system controller by means of sending requests and getting responses. Classes deriving from the ISystemControllerInterface should provide the component side implementation of the communication with the system controller. This interface can be inherited and implemented by developers to connect to custom system controllers, or to directly control a component programmatically, without the need for connecting to a remote server.
classAcl::MediaReceiver
A MediaReceiver contains the logic for receiving, decoding and aligning incoming media sources from the Ingests. The aligned data is then delivered to the Rendering Engine which is also responsible for setting up the MediaReceiver. The MediaReceiver has a builtin multi view generator, which can create output streams containing composited subsets of the incoming video sources. This class is controlled using an ISystemControllerInterface provided when starting it.
classAcl::SystemControllerConnection
An implementation of the ISystemControllerInterface for a System controller residing in a remote server. The connection to the server uses a Websocket.
classAcl::UUID
A class holding a UUID, stored as a sequence of bytes. This class only supports version 4 variant 1 of the UUID standard.

Types

Name
enum uint32_tPixelFormat { kUnknown = 0, kNv12 = Acl::makeFourCC(‘N’, ‘V’, ‘1’, ‘2’), kUyvy = Acl::makeFourCC(‘U’, ‘Y’, ‘V’, ‘Y’), kP010 = Acl::makeFourCC(‘P’, ‘0’, ‘1’, ‘0’), kP016 = Acl::makeFourCC(‘P’, ‘0’, ‘1’, ‘6’), kP210 = Acl::makeFourCC(‘P’, ‘2’, ‘1’, ‘0’), kP216 = Acl::makeFourCC(‘P’, ‘2’, ‘1’, ‘6’), kRgba =
Acl::makeFourCC(‘R’, ‘G’, ‘B’, ‘A’), kV210 = Acl::makeFourCC(‘V’, ‘2’, ‘1’, ‘0’), kRgba64Le =
Acl::makeFourCC(‘R’, ‘G’, ‘B’, 64)}
Enumeration of FourCC formats.
enum class uint8_tFieldOrder { kProgressive, kTopFieldFirst, kBottomFieldFirst}
Enumeration of Field orders for interlaced video.
enum class uint16_tAudioFormat { kInt16, kInt24In32, kFloat32}
The format of the stored samples.
enum class uint8_tAudioChannelLayout { kPlanar, kInterleaved}
Channel layout of the samples.
using std::shared_ptr< AlignedAudioFrame >AlignedAudioFramePtr
using std::shared_ptr< const AlignedAudioFrame >AlignedAudioFrameConstPtr
using std::shared_ptr< AlignedFrame >AlignedFramePtr
using std::shared_ptr< DeviceMemory >DeviceMemoryPtr

Functions

Name
AlignedAudioFramePtrcreateAlignedAudioFrame(uint8_t numberOfChannels, uint32_t numberOfSamplesPerChannel)
Create a new AlignedAudioFrame with a given amount of samples allocated and all samples initialized to 0.0f.
AlignedAudioFramePtrcopyAlignedAudioFrame(AlignedAudioFrameConstPtr audioFrame)
Copy an AlignedAudioFrame including its samples.
AlignedAudioFramePtrextractChannel(AlignedAudioFrameConstPtr sourceFrame, uint8_t channelIndex)
Extract one channel from an AlignedAudioFrame as a new AlignedAudioFrame. The new AlignedAudioFrame will share no data with the original frame, meaning the new frame can be edited without corrupting the old one.
std::stringencodeBase64(const uint8_t * data, size_t size)
Base64 encode some data.
std::stringencodeBase64(const std::vector< uint8_t > & data)
Base64 encode some data.
std::vector< uint8_t >decodeBase64(const std::string & data)
Decode some Base64 encoded data.
std::ostream &operator«(std::ostream & stream, const ControlDataAddress & address)
Print this ControlDataAddress to an output stream, UUIDs separated with ‘:’.
constexpr uint32_tmakeFourCC(char a, char b, char c, char d)
Helper function to create a FourCC code out of four characters.
std::ostream &operator«(std::ostream & stream, const PixelFormat & pixelFormat)
Add the string representation of a PixelFormat to the output stream.
std::ostream &operator«(std::ostream & stream, const FieldOrder & fieldOrder)
Add the string representation of a FieldOrder to the output stream.
std::ostream &operator«(std::ostream & stream, const AudioFormat & audioFormat)
Add the string representation of an AudioFormat to the output stream.
std::ostream &operator«(std::ostream & stream, const AudioChannelLayout & audioChannelLayout)
Add the string representation of an AudioChannelLayout to the output stream.
std::ostream &operator«(std::ostream & stream, const UUID & uuid)
Print this UUID to an output stream.

Types Documentation

enum PixelFormat

EnumeratorValueDescription
kUnknown0
kNv12Acl::makeFourCC(‘N’, ‘V’, ‘1’, ‘2’)
kUyvyAcl::makeFourCC(‘U’, ‘Y’, ‘V’, ‘Y’)
kP010Acl::makeFourCC(‘P’, ‘0’, ‘1’, ‘0’)
kP016Acl::makeFourCC(‘P’, ‘0’, ‘1’, ‘6’)
kP210Acl::makeFourCC(‘P’, ‘2’, ‘1’, ‘0’)
kP216Acl::makeFourCC(‘P’, ‘2’, ‘1’, ‘6’)
kRgba=
Acl::makeFourCC(‘R’, ‘G’, ‘B’, ‘A’)
kV210Acl::makeFourCC(‘V’, ‘2’, ‘1’, ‘0’)
kRgba64Le=
Acl::makeFourCC(‘R’, ‘G’, ‘B’, 64)

Enumeration of FourCC formats.

enum FieldOrder

EnumeratorValueDescription
kProgressive
kTopFieldFirst
kBottomFieldFirst

Enumeration of Field orders for interlaced video.

enum AudioFormat

EnumeratorValueDescription
kInt16
kInt24In32
kFloat32

The format of the stored samples.

enum AudioChannelLayout

EnumeratorValueDescription
kPlanar
kInterleaved

Channel layout of the samples.

using AlignedAudioFramePtr

using Acl::AlignedAudioFramePtr = typedef std::shared_ptr<AlignedAudioFrame>;

using AlignedAudioFrameConstPtr

using Acl::AlignedAudioFrameConstPtr = typedef std::shared_ptr<const AlignedAudioFrame>;

using AlignedFramePtr

using Acl::AlignedFramePtr = typedef std::shared_ptr<AlignedFrame>;

using DeviceMemoryPtr

using Acl::DeviceMemoryPtr = typedef std::shared_ptr<DeviceMemory>;

Functions Documentation

function createAlignedAudioFrame

AlignedAudioFramePtr createAlignedAudioFrame(
    uint8_t numberOfChannels,
    uint32_t numberOfSamplesPerChannel
)

Create a new AlignedAudioFrame with a given amount of samples allocated and all samples initialized to 0.0f.

Parameters:

  • numberOfChannels Number of channels to allocate space for
  • numberOfSamplesPerChannel Number of samples per channel to allocate space for

Return: Shared pointer to the new AlignedAudioFrame

function copyAlignedAudioFrame

AlignedAudioFramePtr copyAlignedAudioFrame(
    AlignedAudioFrameConstPtr audioFrame
)

Copy an AlignedAudioFrame including its samples.

Parameters:

Return: Shared pointer to the new AlignedAudioFrame

function extractChannel

AlignedAudioFramePtr extractChannel(
    AlignedAudioFrameConstPtr sourceFrame,
    uint8_t channelIndex
)

Extract one channel from an AlignedAudioFrame as a new AlignedAudioFrame. The new AlignedAudioFrame will share no data with the original frame, meaning the new frame can be edited without corrupting the old one.

Parameters:

  • sourceFrame The frame to extract a channel from
  • channelIndex The zero-based channel index to extract

Return: Shared pointer to a new mono AlignedAudioFrame, or nullptr if channel is out of bounds

function encodeBase64

std::string encodeBase64(
    const uint8_t * data,
    size_t size
)

Base64 encode some data.

Parameters:

  • data Pointer to the data to encode with Base64
  • size The length of the data to encode with Base64

Return: The resulting Base64 encoded string

function encodeBase64

std::string encodeBase64(
    const std::vector< uint8_t > & data
)

Base64 encode some data.

Parameters:

  • data The data to encode with Base64

Return: The resulting Base64 encoded string

function decodeBase64

std::vector< uint8_t > decodeBase64(
    const std::string & data
)

Decode some Base64 encoded data.

Parameters:

  • data The Base64 encoded string to decode

Return: The resulting decoded data

function operator«

std::ostream & operator<<(
    std::ostream & stream,
    const ControlDataAddress & address
)

Print this ControlDataAddress to an output stream, UUIDs separated with ‘:’.

Parameters:

  • stream The stream to print to
  • address The address to print

Return: Reference to the output stream

function makeFourCC

constexpr uint32_t makeFourCC(
    char a,
    char b,
    char c,
    char d
)

Helper function to create a FourCC code out of four characters.

Return: The characters a-d encoded as a 32 bit FourCC code.

function operator«

std::ostream & operator<<(
    std::ostream & stream,
    const PixelFormat & pixelFormat
)

Add the string representation of a PixelFormat to the output stream.

Parameters:

  • pixelFormat The PixelFormat to get as a string

Return: The ostream with the string representation of the PixelFormat appended

function operator«

std::ostream & operator<<(
    std::ostream & stream,
    const FieldOrder & fieldOrder
)

Add the string representation of a FieldOrder to the output stream.

Parameters:

  • fieldOrder The FieldOrder to get as a string

Return: The ostream with the string representation of the FieldOrder appended

function operator«

std::ostream & operator<<(
    std::ostream & stream,
    const AudioFormat & audioFormat
)

Add the string representation of an AudioFormat to the output stream.

Parameters:

  • audioFormat The AudioFormat to get as a string

Return: The ostream with the string representation of the AudioFormat appended

function operator«

std::ostream & operator<<(
    std::ostream & stream,
    const AudioChannelLayout & audioChannelLayout
)

Add the string representation of an AudioChannelLayout to the output stream.

Parameters:

  • audioChannelLayout The AudioChannelLayout to get as a string

Return: The ostream with the string representation of the AudioChannelLayout appended

function operator«

std::ostream & operator<<(
    std::ostream & stream,
    const UUID & uuid
)

Print this UUID to an output stream.

Parameters:

  • stream The stream to print to

Return: Reference to the output stream