Agile Content Live C++ SDK reference.
This is the multi-page printable view of this section. Click here to print.
C++ SDK
- 1: Classes
- 1.1: AclLog::CommandLogFormatter
- 1.2: AclLog::FileLocationFormatterFlag
- 1.3: AclLog::ThreadNameFormatterFlag
- 1.4: AlignedAudioFrame
- 1.5: AlignedFrame
- 1.6: ControlDataCommon::ConnectionStatus
- 1.7: ControlDataCommon::Response
- 1.8: ControlDataCommon::StatusMessage
- 1.9: ControlDataSender
- 1.10: ControlDataSender::Settings
- 1.11: DeviceMemory
- 1.12: IControlDataReceiver
- 1.13: IControlDataReceiver::IncomingRequest
- 1.14: IControlDataReceiver::ReceiverResponse
- 1.15: IControlDataReceiver::Settings
- 1.16: IMediaStreamer
- 1.17: IMediaStreamer::Configuration
- 1.18: IMediaStreamer::Settings
- 1.19: IngestApplication
- 1.20: IngestApplication::Settings
- 1.21: ISystemControllerInterface
- 1.22: ISystemControllerInterface::Callbacks
- 1.23: ISystemControllerInterface::Response
- 1.24: MediaReceiver
- 1.25: MediaReceiver::NewStreamParameters
- 1.26: MediaReceiver::Settings
- 1.27: SystemControllerConnection
- 1.28: SystemControllerConnection::Settings
- 1.29: TimeCommon::TAIStatus
- 1.30: TimeCommon::TimeStructure
- 2: Files
- 2.1: include/AclLog.h
- 2.2: include/AlignedFrame.h
- 2.3: include/Base64.h
- 2.4: include/ControlDataCommon.h
- 2.5: include/ControlDataSender.h
- 2.6: include/DeviceMemory.h
- 2.7: include/IControlDataReceiver.h
- 2.8: include/IMediaStreamer.h
- 2.9: include/IngestApplication.h
- 2.10: include/IngestUtils.h
- 2.11: include/ISystemControllerInterface.h
- 2.12: include/MediaReceiver.h
- 2.13: include/PixelFormat.h
- 2.14: include/SystemControllerConnection.h
- 2.15: include/TimeCommon.h
- 2.16: include/UUIDUtils.h
- 3: Namespaces
- 3.1: ACL
- 3.2: AclLog
- 3.3: ControlDataCommon
- 3.4: IngestUtils
- 3.5: spdlog
- 3.6: TimeCommon
- 3.7: UUIDUtils
1 - Classes
Classes
- namespace ACL
- namespace AclLog
A namespace for logging utilities.- class CommandLogFormatter
This class is used to format log entries for Rendering Engine commands. - class FileLocationFormatterFlag
A custom flag formatter which logs the source file location between a par of “[]”, in case the location is provided with the log call. - class ThreadNameFormatterFlag
- class CommandLogFormatter
- struct AlignedAudioFrame
AlignedAudioFrame is a frame of interleaved floating point audio samples with a given number of channels. - struct 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. - namespace ControlDataCommon
- struct ConnectionStatus
Connection status struct containing information about a connection event. - struct Response
A response from a ControlDataReceiver to a request. The UUID tells which receiver the response is sent from. - struct StatusMessage
A status message from a ControlDataReceiver. The UUID tells which receiver the message is sent from.
- struct ConnectionStatus
- class 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.- struct Settings
Settings for a ControlDataSender.
- struct Settings
- class DeviceMemory
RAII class for a CUDA memory buffer. - class 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 areceiving
orlistening
side, as well as asending
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.- struct IncomingRequest
An incoming request to this ControlDataReceiver. - struct ReceiverResponse
A response message to a request. - struct Settings
Settings for a ControlDataReceiver.
- struct IncomingRequest
- class 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.- struct Configuration
The input configuration of the frames that will be sent to this MediaStreamer. The output stream configuration is made from the System controller via the ISystemControllerInterface. - struct Settings
Settings used when creating a new MediaStreamer.
- struct Configuration
- class 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. - class IngestApplication
- struct Settings
- namespace IngestUtils
- class 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.- struct NewStreamParameters
A struct containing information on the format of an incoming stream. - struct Settings
Settings for a MediaReceiver.
- struct NewStreamParameters
- class SystemControllerConnection
An implementation of the ISystemControllerInterface for a System controller residing in a remote server. The connection to the server uses a Websocket.- struct Settings
Settings for a SystemControllerConnection.
- struct Settings
- namespace TimeCommon
- struct TAIStatus
- struct TimeStructure
- namespace UUIDUtils
A namespace for UUID utility functions. - namespace spdlog
Updated on 2024-04-08 at 15:15:27 +0200
1.1 - AclLog::CommandLogFormatter
AclLog::CommandLogFormatter
This class is used to format log entries for Rendering Engine commands.
#include <AclLog.h>
Inherits from spdlog::formatter
Public Functions
Name | |
---|---|
CommandLogFormatter() | |
void | format(const spdlog::details::log_msg & msg, spdlog::memory_buf_t & dest) override |
std::unique_ptr< spdlog::formatter > | clone() const override |
Public Functions Documentation
function CommandLogFormatter
CommandLogFormatter()
function format
void format(
const spdlog::details::log_msg & msg,
spdlog::memory_buf_t & dest
) override
function clone
std::unique_ptr< spdlog::formatter > clone() const override
Updated on 2024-04-08 at 15:15:27 +0200
1.2 - AclLog::FileLocationFormatterFlag
AclLog::FileLocationFormatterFlag
A custom flag formatter which logs the source file location between a par of “[]”, in case the location is provided with the log call.
#include <AclLog.h>
Inherits from spdlog::custom_flag_formatter
Public Functions
Name | |
---|---|
void | format(const spdlog::details::log_msg & msg, const std::tm & , spdlog::memory_buf_t & dest) override |
std::unique_ptr< custom_flag_formatter > | clone() const override |
Public Functions Documentation
function format
inline void format(
const spdlog::details::log_msg & msg,
const std::tm & ,
spdlog::memory_buf_t & dest
) override
function clone
inline std::unique_ptr< custom_flag_formatter > clone() const override
Updated on 2024-04-08 at 15:15:27 +0200
1.3 - AclLog::ThreadNameFormatterFlag
AclLog::ThreadNameFormatterFlag
Inherits from spdlog::custom_flag_formatter
Public Functions
Name | |
---|---|
void | format(const spdlog::details::log_msg & , const std::tm & , spdlog::memory_buf_t & dest) override |
std::unique_ptr< custom_flag_formatter > | clone() const override |
Public Functions Documentation
function format
inline void format(
const spdlog::details::log_msg & ,
const std::tm & ,
spdlog::memory_buf_t & dest
) override
function clone
inline std::unique_ptr< custom_flag_formatter > clone() const override
Updated on 2024-04-08 at 15:15:27 +0200
1.4 - AlignedAudioFrame
AlignedAudioFrame
AlignedAudioFrame is a frame of interleaved floating point audio samples with a given number of channels.
#include <AlignedFrame.h>
Public Attributes
Name | |
---|---|
std::vector< float > | mSamples |
uint8_t | mNumberOfChannels |
uint32_t | mNumberOfSamplesPerChannel |
Public Attributes Documentation
variable mSamples
std::vector< float > mSamples;
variable mNumberOfChannels
uint8_t mNumberOfChannels = 0;
variable mNumberOfSamplesPerChannel
uint32_t mNumberOfSamplesPerChannel = 0;
Updated on 2024-04-08 at 15:15:27 +0200
1.5 - AlignedFrame
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.
#include <AlignedFrame.h>
Public Functions
Name | |
---|---|
AlignedFrame() =default | |
~AlignedFrame() =default | |
AlignedFrame(AlignedFrame const & ) =delete | |
AlignedFrame & | operator=(AlignedFrame const & ) =delete |
std::shared_ptr< AlignedFrame > | makeShallowCopy() const Make a shallow copy of this AlignedFrame (video and audio pointers will point to the same video and audio memory buffers as in the frame copied from) |
Public Attributes
Name | |
---|---|
int64_t | mCaptureTimestamp |
int64_t | mRenderingTimestamp |
std::shared_ptr< DeviceMemory > | mVideoFrame |
PixelFormat | mPixelFormat |
uint32_t | mFrameRateN |
uint32_t | mFrameRateD |
uint32_t | mWidth |
uint32_t | mHeight |
AlignedAudioFramePtr | mAudioFrame |
uint32_t | mAudioSamplingFrequency |
Public Functions Documentation
function AlignedFrame
AlignedFrame() =default
function ~AlignedFrame
~AlignedFrame() =default
function AlignedFrame
AlignedFrame(
AlignedFrame const &
) =delete
function operator=
AlignedFrame & operator=(
AlignedFrame const &
) =delete
function makeShallowCopy
std::shared_ptr< AlignedFrame > makeShallowCopy() const
Make a shallow copy of this AlignedFrame (video and audio pointers will point to the same video and audio memory buffers as in the frame copied from)
Return: A pointer to a new frame, which is a shallow copy of the old one, pointing to the same video and audio memory buffers
Public Attributes Documentation
variable mCaptureTimestamp
int64_t mCaptureTimestamp = 0;
The TAI timestamp in microseconds since the TAI epoch when this frame was captured by the ingest
variable mRenderingTimestamp
int64_t mRenderingTimestamp = 0;
The TAI timestamp in microseconds since the TAI epoch when this frame should be delivered to the rendering engine
variable mVideoFrame
std::shared_ptr< DeviceMemory > mVideoFrame = nullptr;
variable mPixelFormat
PixelFormat mPixelFormat = PixelFormat::kUnknown;
variable mFrameRateN
uint32_t mFrameRateN = 0;
variable mFrameRateD
uint32_t mFrameRateD = 0;
variable mWidth
uint32_t mWidth = 0;
variable mHeight
uint32_t mHeight = 0;
variable mAudioFrame
AlignedAudioFramePtr mAudioFrame = nullptr;
variable mAudioSamplingFrequency
uint32_t mAudioSamplingFrequency = 0;
Updated on 2024-04-08 at 15:15:27 +0200
1.6 - ControlDataCommon::ConnectionStatus
ControlDataCommon::ConnectionStatus
Connection status struct containing information about a connection event.
#include <ControlDataCommon.h>
Public Functions
Name | |
---|---|
ConnectionStatus() =default | |
ConnectionStatus(ConnectionType mConnectionType, const std::string & mIp, uint16_t mPort) |
Public Attributes
Name | |
---|---|
ConnectionType | mConnectionType |
std::string | mIP |
uint16_t | mPort |
Public Functions Documentation
function ConnectionStatus
ConnectionStatus() =default
function ConnectionStatus
inline ConnectionStatus(
ConnectionType mConnectionType,
const std::string & mIp,
uint16_t mPort
)
Public Attributes Documentation
variable mConnectionType
ConnectionType mConnectionType = ConnectionType::DISCONNECTED;
variable mIP
std::string mIP;
variable mPort
uint16_t mPort = 0;
Updated on 2024-04-08 at 15:15:27 +0200
1.7 - ControlDataCommon::Response
ControlDataCommon::Response
A response from a ControlDataReceiver to a request. The UUID tells which receiver the response is sent from.
#include <ControlDataCommon.h>
Public Attributes
Name | |
---|---|
std::vector< uint8_t > | mMessage |
uint64_t | mRequestId The actual message. |
std::string | mFromUUID The ID of the request this is a response to. |
Public Attributes Documentation
variable mMessage
std::vector< uint8_t > mMessage;
variable mRequestId
uint64_t mRequestId = 0;
The actual message.
variable mFromUUID
std::string mFromUUID;
The ID of the request this is a response to.
Updated on 2024-04-08 at 15:15:27 +0200
1.8 - ControlDataCommon::StatusMessage
ControlDataCommon::StatusMessage
A status message from a ControlDataReceiver. The UUID tells which receiver the message is sent from.
#include <ControlDataCommon.h>
Public Attributes
Name | |
---|---|
std::vector< uint8_t > | mMessage |
std::string | mFromUUID The actual message. |
Public Attributes Documentation
variable mMessage
std::vector< uint8_t > mMessage;
variable mFromUUID
std::string mFromUUID;
The actual message.
Updated on 2024-04-08 at 15:15:27 +0200
1.9 - ControlDataSender
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.
#include <ControlDataSender.h>
Public Classes
Name | |
---|---|
struct | Settings Settings for a ControlDataSender. |
Public Functions
Name | |
---|---|
ControlDataSender() Default constructor, creates an empty object. | |
~ControlDataSender() Destructor. Will disconnect from the connected receivers and close the System controller connection. | |
bool | configure(const std::shared_ptr< ISystemControllerInterface > & controllerInterface, const Settings & settings) Configure this ControlDataSender and connect it to the System Controller. This method will fail in case the ISystemControllerInterface has already been connected to the controller by another component, as such interface can only be used by one component. |
bool | sendRequestToReceivers(const std::vector< uint8_t > & request, uint64_t & requestId) Send a request to all the connected ControlDataReceivers asynchronously. The responses will be sent to the response callback. |
bool | sendMultiRequestToReceivers(const std::vector< std::vector< uint8_t » & request, uint64_t & requestId) Send a multi-message request to all the connected ControlDataReceivers asynchronously. The responses will be sent to the response callback. |
ControlDataSender(ControlDataSender const & ) =delete | |
ControlDataSender & | operator=(ControlDataSender const & ) =delete |
std::string | getVersion() Get application version. |
Public Functions Documentation
function ControlDataSender
ControlDataSender()
Default constructor, creates an empty object.
function ~ControlDataSender
~ControlDataSender()
Destructor. Will disconnect from the connected receivers and close the System controller connection.
function configure
bool configure(
const std::shared_ptr< ISystemControllerInterface > & controllerInterface,
const Settings & settings
)
Configure this ControlDataSender and connect it to the System Controller. This method will fail in case the ISystemControllerInterface has already been connected to the controller by another component, as such interface can only be used by one component.
Parameters:
- controllerInterface The interface to the System controller, used for communicating with this ControlDataSender
- settings The Settings to use for this ControlDataSender
Return: True on success, false otherwise
function sendRequestToReceivers
bool sendRequestToReceivers(
const std::vector< uint8_t > & request,
uint64_t & requestId
)
Send a request to all the connected ControlDataReceivers asynchronously. The responses will be sent to the response callback.
Parameters:
- request The request message
- requestId The unique identifier of this request. Used to identify the async responses.
Return: True if the request was successfully sent, false otherwise
function sendMultiRequestToReceivers
bool sendMultiRequestToReceivers(
const std::vector< std::vector< uint8_t >> & request,
uint64_t & requestId
)
Send a multi-message request to all the connected ControlDataReceivers asynchronously. The responses will be sent to the response callback.
Parameters:
- request The request message
- requestId The unique identifier of this request. Used to identify the async responses.
Return: True if the request was successfully sent, false otherwise
function ControlDataSender
ControlDataSender(
ControlDataSender const &
) =delete
function operator=
ControlDataSender & operator=(
ControlDataSender const &
) =delete
function getVersion
static std::string getVersion()
Get application version.
Return: a string with the current version, e.g. “6.0.0-39-g60a35937”
Updated on 2024-04-08 at 15:15:27 +0200
1.10 - ControlDataSender::Settings
ControlDataSender::Settings
Settings for a ControlDataSender.
#include <ControlDataSender.h>
Public Attributes
Name | |
---|---|
std::function< void(const ControlDataCommon::ConnectionStatus &)> | mConnectionStatusCallback |
std::function< void(const ControlDataCommon::Response &)> | mResponseCallback |
std::function< void(const ControlDataCommon::StatusMessage &)> | mStatusMessageCallback |
Public Attributes Documentation
variable mConnectionStatusCallback
std::function< void(const ControlDataCommon::ConnectionStatus &)> mConnectionStatusCallback;
variable mResponseCallback
std::function< void(const ControlDataCommon::Response &)> mResponseCallback;
variable mStatusMessageCallback
std::function< void(const ControlDataCommon::StatusMessage &)> mStatusMessageCallback;
Updated on 2024-04-08 at 15:15:27 +0200
1.11 - DeviceMemory
DeviceMemory
RAII class for a CUDA memory buffer.
#include <DeviceMemory.h>
Public Functions
Name | |
---|---|
DeviceMemory() =default Default constructor, creates an empty object, without allocating any memory on the device. | |
DeviceMemory(size_t numberOfBytes) Constructor allocating the required number of bytes. | |
DeviceMemory(size_t numberOfBytes, cudaStream_t cudaStream) Constructor allocating the required number of bytes by making an async allocation. The allocation will be put in the given CUDA stream. | |
DeviceMemory(void * deviceMemory) Constructor taking ownership of an already allocated CUDA memory pointer. This class will free the pointer once it goes out of scope. | |
bool | allocateMemory(size_t numberOfBytes) Allocates device memory. The memory allocated will automatically be freed by the destructor. |
bool | allocateMemoryAsync(size_t numberOfBytes, cudaStream_t cudaStream) Allocates device memory. The memory allocated will automatically be freed by the destructor. |
bool | reallocateMemory(size_t numberOfBytes) Reallocates device memory. Already existing memory allocation will be freed before the new allocation is made. In case this DeviceMemory has no earlier memory allocation, this method will just allocate new CUDA memory and return a success status. |
bool | reallocateMemoryAsync(size_t numberOfBytes, cudaStream_t cudaStream) Asynchronously reallocate device memory. Already existing memory allocation will be freed before the new allocation is made. In case this DeviceMemory has no earlier memory allocation, this method will just allocate new CUDA memory and return a success status. |
bool | allocateAndResetMemory(size_t numberOfBytes) Allocates device memory and resets all bytes to zeroes. The memory allocated will automatically be freed by the destructor. |
bool | allocateAndResetMemoryAsync(size_t numberOfBytes, cudaStream_t cudaStream) Allocates device memory and resets all bytes to zeroes. The memory allocated will automatically be freed by the destructor. |
bool | freeMemory() Free the device memory held by this class. Calling this when no memory is allocated is a no-op. |
bool | freeMemoryAsync(cudaStream_t cudaStream) Deallocate memory asynchronously, in a given CUDA stream. Calling this when no memory is allocated is a no-op. |
void | setFreeingCudaStream(cudaStream_t cudaStream) Set which CUDA stream to use for freeing this DeviceMemory. In case the DeviceMemory already holds a CUDA stream to use for freeing the memory, this will be overwritten. |
~DeviceMemory() Destructor, frees the internal CUDA memory. | |
template T * | getDevicePointer() const |
size_t | getSize() const |
DeviceMemory(DeviceMemory && other) | |
DeviceMemory & | operator=(DeviceMemory && other) |
void | swap(DeviceMemory & other) |
DeviceMemory(DeviceMemory const & ) =delete DeviceMemory is not copyable. | |
DeviceMemory | operator=(DeviceMemory const & ) =delete |
Public Functions Documentation
function DeviceMemory
DeviceMemory() =default
Default constructor, creates an empty object, without allocating any memory on the device.
function DeviceMemory
explicit DeviceMemory(
size_t numberOfBytes
)
Constructor allocating the required number of bytes.
Parameters:
- numberOfBytes Number of bytes to allocate
Exceptions:
- std::runtime_error In case the allocation failed
function DeviceMemory
explicit DeviceMemory(
size_t numberOfBytes,
cudaStream_t cudaStream
)
Constructor allocating the required number of bytes by making an async allocation. The allocation will be put in the given CUDA stream.
Parameters:
- size Number of bytes to allocate
- cudaStream The CUDA stream to put the async allocation in. A reference to this stream will also be saved internally to be used to asynchronously free them memory when the instance goes out of scope.
Exceptions:
- std::runtime_error In case the async allocation failed to be put in queue.
See: freeMemoryAsync method is not explicitly called, the memory will be freed synchronously when this DeviceMemory instance goes out of scope, meaning that the entire GPU is synchronized, which will impact performance negatively.
Note:
- The method will return as soon as the allocation is put in queue in the CUDA stream, i.e. before the actual allocation is made. Using this DeviceMemory is only valid as long as it is used in the same CUDA stream, or in case another stream is used, only if that stream is synchronized first with respect to
cudaStream
. - In case the
function DeviceMemory
explicit DeviceMemory(
void * deviceMemory
)
Constructor taking ownership of an already allocated CUDA memory pointer. This class will free the pointer once it goes out of scope.
Parameters:
- deviceMemory CUDA memory pointer to take ownership over.
function allocateMemory
bool allocateMemory(
size_t numberOfBytes
)
Allocates device memory. The memory allocated will automatically be freed by the destructor.
Parameters:
- numberOfBytes Number of bytes to allocate
Return: True on success, false if there is already memory allocated by this instance, or if the CUDA malloc failed.
function allocateMemoryAsync
bool allocateMemoryAsync(
size_t numberOfBytes,
cudaStream_t cudaStream
)
Allocates device memory. The memory allocated will automatically be freed by the destructor.
Parameters:
- numberOfBytes Number of bytes to allocate
- cudaStream The CUDA stream to use for the allocation. A reference to this stream will also be saved internally to be used to asynchronously free them memory when the instance goes out of scope.
Return: True on success, false if there is already memory allocated by this instance, or if the CUDA malloc failed.
function reallocateMemory
bool reallocateMemory(
size_t numberOfBytes
)
Reallocates device memory. Already existing memory allocation will be freed before the new allocation is made. In case this DeviceMemory has no earlier memory allocation, this method will just allocate new CUDA memory and return a success status.
Parameters:
- numberOfBytes Number of bytes to allocate in the new allocation
Return: True on success, false if CUDA free or CUDA malloc failed.
function reallocateMemoryAsync
bool reallocateMemoryAsync(
size_t numberOfBytes,
cudaStream_t cudaStream
)
Asynchronously reallocate device memory. Already existing memory allocation will be freed before the new allocation is made. In case this DeviceMemory has no earlier memory allocation, this method will just allocate new CUDA memory and return a success status.
Parameters:
- numberOfBytes Number of bytes to allocate in the new allocation
- cudaStream The CUDA stream to use for the allocation and freeing of memory. A reference to this stream will also be saved internally to be used to asynchronously free them memory when this instance goes out of scope.
Return: True on success, false if CUDA free or CUDA malloc failed.
function allocateAndResetMemory
bool allocateAndResetMemory(
size_t numberOfBytes
)
Allocates device memory and resets all bytes to zeroes. The memory allocated will automatically be freed by the destructor.
Parameters:
- numberOfBytes Number of bytes to allocate
Return: True on success, false if there is already memory allocated by this instance, or if any of the CUDA operations failed.
function allocateAndResetMemoryAsync
bool allocateAndResetMemoryAsync(
size_t numberOfBytes,
cudaStream_t cudaStream
)
Allocates device memory and resets all bytes to zeroes. The memory allocated will automatically be freed by the destructor.
Parameters:
- numberOfBytes Number of bytes to allocate
- cudaStream The CUDA stream to use for the allocation and resetting. A reference to this stream will also be saved internally to be used to asynchronously free them memory when the instance goes out of scope.
Return: True on success, false if there is already memory allocated by this instance, or if any of the CUDA operations failed.
function freeMemory
bool freeMemory()
Free the device memory held by this class. Calling this when no memory is allocated is a no-op.
See: freeMemoryAsync instead.
Return: True in case the memory was successfully freed (or not allocated to begin with), false otherwise.
Note: This method will free the memory in an synchronous fashion, synchronizing the entire CUDA context and ignoring the internally saved CUDA stream reference in case one exist. For async freeing of the memory, use
function freeMemoryAsync
bool freeMemoryAsync(
cudaStream_t cudaStream
)
Deallocate memory asynchronously, in a given CUDA stream. Calling this when no memory is allocated is a no-op.
Parameters:
- cudaStream The CUDA stream to free the memory asynchronously in
Return: True in case the memory deallocation request was successfully put in queue in the CUDA stream.
Note:
- The method will return as soon as the deallocation is put in queue in the CUDA stream, i.e. before the actual deallocation is made.
- It is the programmer’s responsibility to ensure this DeviceMemory is not used in another CUDA stream before this method is called. In case it is used in another CUDA stream, sufficient synchronization must be made before calling this method (and a very good reason given for not freeing the memory in that CUDA stream instead)
function setFreeingCudaStream
void setFreeingCudaStream(
cudaStream_t cudaStream
)
Set which CUDA stream to use for freeing this DeviceMemory. In case the DeviceMemory already holds a CUDA stream to use for freeing the memory, this will be overwritten.
Parameters:
- cudaStream The new CUDA stream to use for freeing the memory when the destructor is called.
Note: It is the programmer’s responsibility to ensure this DeviceMemory is not used in another CUDA stream before this instance is destructed. In case it is used in another CUDA stream, sufficient synchronization must be made before setting this as the new CUDA stream to use when freeing the memory.
function ~DeviceMemory
~DeviceMemory()
Destructor, frees the internal CUDA memory.
function getDevicePointer
template <typename T =uint8_t>
inline T * getDevicePointer() const
Template Parameters:
- T The pointer type to return
Return: the CUDA memory pointer handled by this class. Nullptr in case no memory is allocated.
function getSize
size_t getSize() const
Return: The size of the CUDA memory allocation held by this class.
function DeviceMemory
DeviceMemory(
DeviceMemory && other
)
function operator=
DeviceMemory & operator=(
DeviceMemory && other
)
function swap
void swap(
DeviceMemory & other
)
function DeviceMemory
DeviceMemory(
DeviceMemory const &
) =delete
DeviceMemory is not copyable.
function operator=
DeviceMemory operator=(
DeviceMemory const &
) =delete
Updated on 2024-04-08 at 15:15:27 +0200
1.12 - IControlDataReceiver
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. More…
#include <IControlDataReceiver.h>
Public Classes
Name | |
---|---|
struct | IncomingRequest An incoming request to this ControlDataReceiver. |
struct | ReceiverResponse A response message to a request. |
struct | Settings Settings for a ControlDataReceiver. |
Public Functions
Name | |
---|---|
virtual | ~IControlDataReceiver() =default Destructor. |
virtual bool | configure(const Settings & settings) =0 Configure this instance. |
virtual bool | sendStatusMessageToSender(const std::vector< uint8_t > & message) =0 Send a status message to the (directly or indirectly) connected ControlDataSender. In case this ControlDataReceiver has another ControlDataReceiver as sender, that receiver will forward the status message to the sender. |
virtual bool | sendRequestToReceivers(const std::vector< uint8_t > & request, uint64_t & requestId) =0 Send a request to the connected ControlDataReceivers asynchronously. This request will only be sent to ControlDataReceivers on the sending side of this receiver. In case a receiver is located between this ControlDataReceiver and the sender, neither of those will see this request. The response will be sent to the response callback asynchronously. |
virtual bool | sendMultiRequestToReceivers(const std::vector< std::vector< uint8_t » & request, uint64_t & requestId) =0 Send a multi-message request to the connected ControlDataReceivers asynchronously. This request will only be sent to ControlDataReceivers on the sending side of this receiver. In case a receiver is located between this ControlDataReceiver and the sender, neither of those will see this request. The response will be sent to the response callback asynchronously. |
Detailed Description
class 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.
Each ControlDataReceiver can be configured to have a certain message delay. This delay parameter is set when the System controller instructs the ControlDataReceiver to start listening for incoming connections from senders (or sending ControlDataReceiver). Each incoming request will then be delayed and delivered according to the parameter, compared to the send timestamp in the message. In case multiple receivers are chained, like sender->receiver1->receiver2, receiver1 will delay the incoming messages from the sender based on when they were sent from the sender. Furthermore, receiver2 will delay them compared to when they were sent from receiver1.
An IControlDataReceiver can send status messages back to the sender. In case of chained receivers, the message will be forwarded back to the sender. A user of the ControlDataReceiver can register callbacks to receive requests and status messages. There is also an optional “preview” callback that is useful in case the incoming messages are delayed (have a delay > 0). This callback will then be called as soon as the request message arrives, to allow the user to prepare for when the actual delayed request callback is called.
Public Functions Documentation
function ~IControlDataReceiver
virtual ~IControlDataReceiver() =default
Destructor.
function configure
virtual bool configure(
const Settings & settings
) =0
Configure this instance.
Parameters:
- settings The settings to use for this receiver
Return: True on success, false otherwise
function sendStatusMessageToSender
virtual bool sendStatusMessageToSender(
const std::vector< uint8_t > & message
) =0
Send a status message to the (directly or indirectly) connected ControlDataSender. In case this ControlDataReceiver has another ControlDataReceiver as sender, that receiver will forward the status message to the sender.
Parameters:
- message The status message
Return: True in case the message was sent successfully, false otherwise.
function sendRequestToReceivers
virtual bool sendRequestToReceivers(
const std::vector< uint8_t > & request,
uint64_t & requestId
) =0
Send a request to the connected ControlDataReceivers asynchronously. This request will only be sent to ControlDataReceivers on the sending side of this receiver. In case a receiver is located between this ControlDataReceiver and the sender, neither of those will see this request. The response will be sent to the response callback asynchronously.
Parameters:
- request The request message
- requestId The unique identifier of this request. Used to identify the async response.
Return: True if the request was successfully sent, false otherwise
function sendMultiRequestToReceivers
virtual bool sendMultiRequestToReceivers(
const std::vector< std::vector< uint8_t >> & request,
uint64_t & requestId
) =0
Send a multi-message request to the connected ControlDataReceivers asynchronously. This request will only be sent to ControlDataReceivers on the sending side of this receiver. In case a receiver is located between this ControlDataReceiver and the sender, neither of those will see this request. The response will be sent to the response callback asynchronously.
Parameters:
- request The request message
- requestId The unique identifier of this request. Used to identify the async response.
Return: True if the request was successfully sent, false otherwise
Updated on 2024-04-08 at 15:15:27 +0200
1.13 - IControlDataReceiver::IncomingRequest
IControlDataReceiver::IncomingRequest
An incoming request to this ControlDataReceiver.
#include <IControlDataReceiver.h>
Public Attributes
Name | |
---|---|
std::vector< std::vector< uint8_t > > | mMessages |
std::string | mSenderUUID The actual messages. |
std::string | mRequesterUUID UUID of the sender/forwarder that sent the request to this ControlDataReceiver. |
uint64_t | mRequestID UUID of the requester (the original sender, creating the request) |
int64_t | mSenderTimestampUs The requester’s unique id of this request. |
int64_t | mDeliveryTimestampUs The TAI timestamp when this message was sent from the sender/forwarder in micro sec since TAI epoch. |
Public Attributes Documentation
variable mMessages
std::vector< std::vector< uint8_t > > mMessages;
variable mSenderUUID
std::string mSenderUUID;
The actual messages.
variable mRequesterUUID
std::string mRequesterUUID;
UUID of the sender/forwarder that sent the request to this ControlDataReceiver.
variable mRequestID
uint64_t mRequestID = 0;
UUID of the requester (the original sender, creating the request)
variable mSenderTimestampUs
int64_t mSenderTimestampUs =
0;
The requester’s unique id of this request.
variable mDeliveryTimestampUs
int64_t mDeliveryTimestampUs =
0;
The TAI timestamp when this message was sent from the sender/forwarder in micro sec since TAI epoch.
Updated on 2024-04-08 at 15:15:27 +0200
1.14 - IControlDataReceiver::ReceiverResponse
IControlDataReceiver::ReceiverResponse
A response message to a request.
#include <IControlDataReceiver.h>
Public Attributes
Name | |
---|---|
std::vector< uint8_t > | mMessage |
Public Attributes Documentation
variable mMessage
std::vector< uint8_t > mMessage;
Updated on 2024-04-08 at 15:15:27 +0200
1.15 - IControlDataReceiver::Settings
IControlDataReceiver::Settings
Settings for a ControlDataReceiver.
#include <IControlDataReceiver.h>
Public Attributes
Name | |
---|---|
std::string | mProductionPipelineUUID |
std::function< void(const IncomingRequest &)> | mPreviewIncomingRequestCallback |
std::function< ReceiverResponse(const IncomingRequest &)> | mIncomingRequestCallback |
std::function< void(const ControlDataCommon::ConnectionStatus &)> | mConnectionStatusCallback |
std::function< void(const ControlDataCommon::Response &)> | mResponseCallback Callback for connection events. |
Public Attributes Documentation
variable mProductionPipelineUUID
std::string mProductionPipelineUUID;
variable mPreviewIncomingRequestCallback
std::function< void(const IncomingRequest &)> mPreviewIncomingRequestCallback;
UUID of the Production Pipeline component this Receiver is a part of Callback called as soon as this ControlDataReceiver gets the request, as a “preview” of what requests will be delivered.
variable mIncomingRequestCallback
std::function< ReceiverResponse(const IncomingRequest &)> mIncomingRequestCallback;
The actual callback used when this ControlDataReceiver gets a request and wants a response back. This callback will delay and deliver the request according to this receiver’s configured delay.
variable mConnectionStatusCallback
std::function< void(const ControlDataCommon::ConnectionStatus &)> mConnectionStatusCallback;
variable mResponseCallback
std::function< void(const ControlDataCommon::Response &)> mResponseCallback;
Callback for connection events.
Updated on 2024-04-08 at 15:15:27 +0200
1.16 - IMediaStreamer
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. More…
#include <IMediaStreamer.h>
Public Classes
Name | |
---|---|
struct | Configuration The input configuration of the frames that will be sent to this MediaStreamer. The output stream configuration is made from the System controller via the ISystemControllerInterface. |
struct | Settings Settings used when creating a new MediaStreamer. |
Public Functions
Name | |
---|---|
virtual | ~IMediaStreamer() =default Destructor. |
virtual bool | configure(const std::string & uuid, const Settings & settings, CUcontext cudaContext) =0 Configure this MediaStreamer. This must be called before any call to the. |
virtual bool | setInputFormatAndStart(const Configuration & configuration) =0 Set the input format of this MediaStreamer and start the streamer. The. |
virtual bool | stopAndResetFormat() =0 Stop streaming and reset the format. A call to this method will stop any output streams set up by the ISystemControllerInterface and reset the input format set by the. |
virtual bool | hasFormatAndIsRunning() const =0 |
virtual bool | hasOpenOutputStream() const =0 |
virtual bool | outputData(const AlignedFramePtr & frame) =0 Output data through this streamer. The AlignedFrame::mRenderingTimestamp of the frame will be used as PTS when encoding the uncompressed frame. |
Detailed Description
class 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.
See: outputData is made.
Public Functions Documentation
function ~IMediaStreamer
virtual ~IMediaStreamer() =default
Destructor.
function configure
virtual bool configure(
const std::string & uuid,
const Settings & settings,
CUcontext cudaContext
) =0
Configure this MediaStreamer. This must be called before any call to the.
Parameters:
- uuid UUID of this MediaStreamer
- settings Settings for this MediaStreamer
- cudaContext The CUDA context to use for this MediaStreamer. The frames passed to this instance should be valid in this CUDA context. The streamer will use this context for preprocessing and encoding.
See:
Return: True if the streamer was successfully configured
function setInputFormatAndStart
virtual bool setInputFormatAndStart(
const Configuration & configuration
) =0
Set the input format of this MediaStreamer and start the streamer. The.
Parameters:
- configuration The configuration with the format of the frames that will be sent to this MediaReceiver
See:
- configure method must be called before this method is called. This method must be called before any call to
- outputData. If the format should be reset, the
- stopAndResetFormat method should be called first and then this method can be called again to reset the format.
Return: True if the streamer was successfully started, false otherwise
function stopAndResetFormat
virtual bool stopAndResetFormat() =0
Stop streaming and reset the format. A call to this method will stop any output streams set up by the ISystemControllerInterface and reset the input format set by the.
See: setInputFormatAndStart method. The connection to the ISystemControllerInterface will be kept.
Return: True if the stream was successfully stopped and the format reset, or if the format was not set before this method was called, false on error.
function hasFormatAndIsRunning
virtual bool hasFormatAndIsRunning() const =0
Return: True if the input format is set and the OutputStreamer is running, false otherwise
function hasOpenOutputStream
virtual bool hasOpenOutputStream() const =0
See:
- outputData will be discarded without being encoded, as there is no stream to output them to. This method can be used to check if the frame even needs to be produced by the rendering engine. Note however, that the
- outputData method will still log the frames sent to it as received, even if they are not encoded when the output stream is closed.
Return: True if the output stream of the MediaStreamer is currently open and outputting the data, false otherwise. In case this returns false all frames passed to
function outputData
virtual bool outputData(
const AlignedFramePtr & frame
) =0
Output data through this streamer. The AlignedFrame::mRenderingTimestamp of the frame will be used as PTS when encoding the uncompressed frame.
Parameters:
- frame The data frame to output, with video data in CUDA memory
See: setInputFormatAndStart method, or if the format has not been set by a call to that method.
Return: True if the frame was accepted (but not necessarily streamed, in case the output stream has not been set up by the ISystemControllerInterface), false in case the frame did not match the configuration made in the
Note: The DeviceMemory in the AlignedFrame passed to this method must not be in use by any CUDA stream. In case the memory has been used in kernels in another CUDA stream, make sure to first synchronize with the stream, before passing it over to the MediaStreamer.
Updated on 2024-04-08 at 15:15:27 +0200
1.17 - IMediaStreamer::Configuration
IMediaStreamer::Configuration
The input configuration of the frames that will be sent to this MediaStreamer. The output stream configuration is made from the System controller via the ISystemControllerInterface.
#include <IMediaStreamer.h>
Public Attributes
Name | |
---|---|
PixelFormat | mIncomingPixelFormat |
uint32_t | mWidth |
uint32_t | mHeight |
uint32_t | mFrameRateN |
uint32_t | mFrameRateD |
uint32_t | mAudioSampleRate |
uint32_t | mNumAudioChannels |
Public Attributes Documentation
variable mIncomingPixelFormat
PixelFormat mIncomingPixelFormat = PixelFormat::kUnknown;
variable mWidth
uint32_t mWidth = 0;
variable mHeight
uint32_t mHeight = 0;
variable mFrameRateN
uint32_t mFrameRateN = 0;
variable mFrameRateD
uint32_t mFrameRateD = 0;
variable mAudioSampleRate
uint32_t mAudioSampleRate = 0;
variable mNumAudioChannels
uint32_t mNumAudioChannels = 0;
Updated on 2024-04-08 at 15:15:27 +0200
1.18 - IMediaStreamer::Settings
IMediaStreamer::Settings
Settings used when creating a new MediaStreamer.
#include <IMediaStreamer.h>
Public Attributes
Name | |
---|---|
std::string | mName |
Public Attributes Documentation
variable mName
std::string mName;
Updated on 2024-04-08 at 15:15:27 +0200
1.19 - IngestApplication
IngestApplication
Public Classes
Name | |
---|---|
struct | Settings |
Public Functions
Name | |
---|---|
IngestApplication() Constructor, creates an empty IngestApplication without starting it. | |
~IngestApplication() Destructor. | |
bool | start(const std::shared_ptr< ISystemControllerInterface > & controllerInterface, const Settings & settings) Start this IngestApplication given an interface to the System Controller and an UUID. |
bool | stop() Stop this IngestApplication. |
std::string | getVersion() Get application version. |
std::string | getLibraryVersions() Get the versions of the libraries available at runtime, among others, CUDA version, BMD and NDI versions. |
Public Functions Documentation
function IngestApplication
IngestApplication()
Constructor, creates an empty IngestApplication without starting it.
function ~IngestApplication
~IngestApplication()
Destructor.
function start
bool start(
const std::shared_ptr< ISystemControllerInterface > & controllerInterface,
const Settings & settings
)
Start this IngestApplication given an interface to the System Controller and an UUID.
Parameters:
- controllerInterface The interface for communication with the System Controller
- settings The settings for the IngestApplication
Return: True if the IngestApplication was successfully started, false otherwise
function stop
bool stop()
Stop this IngestApplication.
Return: True if the IngestApplication was successfully stopped, false otherwise
function getVersion
static std::string getVersion()
Get application version.
Return: a string with the current version, e.g. “6.0.0-39-g60a35937”
function getLibraryVersions
static std::string getLibraryVersions()
Get the versions of the libraries available at runtime, among others, CUDA version, BMD and NDI versions.
Return: a string with the currently found versions of the libraries used by this application
Updated on 2024-04-08 at 15:15:27 +0200
1.20 - IngestApplication::Settings
IngestApplication::Settings
Updated on 2024-04-08 at 15:15:27 +0200
1.21 - ISystemControllerInterface
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.
#include <ISystemControllerInterface.h>
Inherited by SystemControllerConnection
Public Classes
Name | |
---|---|
struct | Callbacks A struct containing the callbacks that needs to be registered by the component using this interface. |
struct | Response A response to a request, consists of a status code and an (optional) parameters JSON object. |
Public Types
Name | |
---|---|
enum class uint32_t | StatusCode { SUCCESS = 3001, TOO_MANY_REQUESTS = 3101, UUID_ALREADY_REGISTERED = 3201, FORMAT_ERROR = 3202, ALREADY_CONFIGURED = 3203, OUT_OF_RESOURCES = 3204, NOT_FOUND = 3205, INTERNAL_ERROR = 3206, CONNECTION_FAILED = 3207, TIMEOUT_EXCEEDED = 3208, KEY_MISMATCH = 3209, UNKNOWN_REQUEST = 3210, MALFORMED_REQUEST = 3211, ALREADY_IN_USE = 3212, VERSION_MISMATCH = 3213} Status codes used in JSON response messages for Websockets. These are starting at 3000 since the 1000 - 2000 range is taken up by the Spec: https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1. |
Public Functions
Name | |
---|---|
virtual | ~ISystemControllerInterface() =default Virtual destructor. |
virtual std::optional< std::string > | sendMessage(const std::string & messageTitle, const nlohmann::json & parameters) =0 Send a message containing a JSON object to the controller. |
virtual bool | registerRequestCallback(const Callbacks & callbacks) =0 Register the callbacks to call for events in this class. |
virtual bool | connect() =0 Connect to the System controller. |
virtual bool | disconnect() =0 Disconnect from the System controller. |
virtual bool | isConnected() const =0 |
virtual std::string | getUUID() const =0 |
Public Types Documentation
enum StatusCode
Enumerator | Value | Description |
---|---|---|
SUCCESS | 3001 | 3000-3099 Info/Notifications |
TOO_MANY_REQUESTS | 3101 | 3100-3199 Warnings |
UUID_ALREADY_REGISTERED | 3201 | 3200-3299 Error |
FORMAT_ERROR | 3202 | |
ALREADY_CONFIGURED | 3203 | |
OUT_OF_RESOURCES | 3204 | |
NOT_FOUND | 3205 | |
INTERNAL_ERROR | 3206 | |
CONNECTION_FAILED | 3207 | |
TIMEOUT_EXCEEDED | 3208 | |
KEY_MISMATCH | 3209 | |
UNKNOWN_REQUEST | 3210 | |
MALFORMED_REQUEST | 3211 | |
ALREADY_IN_USE | 3212 | |
VERSION_MISMATCH | 3213 |
Status codes used in JSON response messages for Websockets. These are starting at 3000 since the 1000 - 2000 range is taken up by the Spec: https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1.
Public Functions Documentation
function ~ISystemControllerInterface
virtual ~ISystemControllerInterface() =default
Virtual destructor.
function sendMessage
virtual std::optional< std::string > sendMessage(
const std::string & messageTitle,
const nlohmann::json & parameters
) =0
Send a message containing a JSON object to the controller.
Parameters:
- messageTitle The title of the status type or request
- parameters The parameters part of the JSON message
Return: Optional containing an error message on error, else nullopt in case the message was successfully sent
Reimplemented by: SystemControllerConnection::sendMessage
function registerRequestCallback
virtual bool registerRequestCallback(
const Callbacks & callbacks
) =0
Register the callbacks to call for events in this class.
Parameters:
- callbacks The callbacks to use when events in this class happen
Return: True on successful registration, false if some callback is not set or if already connected
Reimplemented by: SystemControllerConnection::registerRequestCallback
function connect
virtual bool connect() =0
Connect to the System controller.
Return: True on successful connection, false on error or if already connected
Reimplemented by: SystemControllerConnection::connect
function disconnect
virtual bool disconnect() =0
Disconnect from the System controller.
Return: True on successful disconnection, false on error or if not connected
Reimplemented by: SystemControllerConnection::disconnect
function isConnected
virtual bool isConnected() const =0
Return: True if connected to the System controller, false otherwise
Reimplemented by: SystemControllerConnection::isConnected
function getUUID
virtual std::string getUUID() const =0
Return: The UUID of this interface to the System controller
Reimplemented by: SystemControllerConnection::getUUID
Updated on 2024-04-08 at 15:15:27 +0200
1.22 - ISystemControllerInterface::Callbacks
ISystemControllerInterface::Callbacks
A struct containing the callbacks that needs to be registered by the component using this interface.
#include <ISystemControllerInterface.h>
Public Attributes
Name | |
---|---|
std::function< Response(const std::string &, const nlohmann::json &)> | mRequestCallback |
std::function< void(uint32_t, const std::string &, const std::error_code &)> | mConnectionClosedCallback |
Public Attributes Documentation
variable mRequestCallback
std::function< Response(const std::string &, const nlohmann::json &)> mRequestCallback;
variable mConnectionClosedCallback
std::function< void(uint32_t, const std::string &, const std::error_code &)> mConnectionClosedCallback;
Updated on 2024-04-08 at 15:15:27 +0200
1.23 - ISystemControllerInterface::Response
ISystemControllerInterface::Response
A response to a request, consists of a status code and an (optional) parameters JSON object.
#include <ISystemControllerInterface.h>
Public Attributes
Name | |
---|---|
StatusCode | mCode |
nlohmann::json | mParameters |
Public Attributes Documentation
variable mCode
StatusCode mCode;
variable mParameters
nlohmann::json mParameters;
Updated on 2024-04-08 at 15:15:27 +0200
1.24 - MediaReceiver
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.
#include <MediaReceiver.h>
Public Classes
Name | |
---|---|
struct | NewStreamParameters A struct containing information on the format of an incoming stream. |
struct | Settings Settings for a MediaReceiver. |
Public Types
Name | |
---|---|
enum class uint32_t | TallyBorderColor { kNone, kRed, kGreen, kYellow} Available colors for tally border in multi view. |
Public Functions
Name | |
---|---|
MediaReceiver() Default constructor. | |
~MediaReceiver() Default destructor. | |
bool | start(const std::shared_ptr< ISystemControllerInterface > & controllerInterface, CUcontext cudaContext, const Settings & settings, const ControlDataReceiver::Settings & receiverSettings) Start the MediaReceiver. This method will call connect on the System controller interface and set up the callbacks from the interface to call internal methods. |
void | stop() Stop the MediaReceiver. |
std::function< void(const AlignedFramePtr &)> | getCustomMultiViewSourceInput(uint32_t inputSlot, const std::string & name ="") This method allows the Rendering Engine to provide custom input sources to the Multi-view generator to send video streams that can be added to the multi-views. This could for instance be used for adding a “preview” of the video stream the rendering engine is about to cut to. |
bool | removeCustomMultiViewSourceInput(uint32_t inputSlot) Remove a custom multi-view generator source input earlier registered using the getCustomMultiViewSourceInput method. |
std::shared_ptr< IMediaStreamer > | createMediaStreamerOutput(const MediaStreamer::Settings & settings) Create a new MediaStreamer instance to output data from this MediaReceiver. |
bool | removeMediaStreamerOutput(const std::string & uuid) Remove an MediaStreamer created via the. |
std::shared_ptr< IControlDataReceiver > | getControlDataReceiver() Get a pointer to the ControlDataReceiver instance of this MediaReceiver. A call to this method will always return the same instance. |
void | setTallyBorder(uint32_t inputSlot, TallyBorderColor color) Set tally border color in the multi-views for a specific input slot. |
void | clearTallyBorder(uint32_t inputSlot) Remove tally border in the multi-views for a specific input slot. |
void | clearAllTallyBorders() Remove all tally borders. |
MediaReceiver::TallyBorderColor | getTallyBorder(uint32_t inputSlot) const get tally border color for an input slot |
MediaReceiver(MediaReceiver const & ) =delete MediaReceiver is neither copyable nor movable. | |
MediaReceiver(MediaReceiver && ) =delete | |
MediaReceiver & | operator=(MediaReceiver const & ) =delete |
MediaReceiver & | operator=(MediaReceiver && ) =delete |
std::string | getVersion() Get application version. |
std::string | getLibraryVersions() Get versions of the libraries available at runtime, among others, CUDA runtime and driver versions. |
Public Types Documentation
enum TallyBorderColor
Enumerator | Value | Description |
---|---|---|
kNone | ||
kRed | ||
kGreen | ||
kYellow |
Available colors for tally border in multi view.
Public Functions Documentation
function MediaReceiver
MediaReceiver()
Default constructor.
function ~MediaReceiver
~MediaReceiver()
Default destructor.
function start
bool start(
const std::shared_ptr< ISystemControllerInterface > & controllerInterface,
CUcontext cudaContext,
const Settings & settings,
const ControlDataReceiver::Settings & receiverSettings
)
Start the MediaReceiver. This method will call connect on the System controller interface and set up the callbacks from the interface to call internal methods.
Parameters:
- controllerInterface The ISystemControllerInterface to use for this MediaReceiver. The interface should be configured (Such as setting the IP address and port of the System Controller if a server based System Controller is used) but not connected before passed to this method. This method will internally set the callbacks before connecting to the controller. If the controller is already connected or if the controller is not configured, this method will return false. This class will take ownership of the smart pointer.
- cudaContext The CUDA context to use for this MediaReceiver. The frames will delivered as CUDA pointers, valid in this context, and the multi-view generator will use this context for rendering and encoding.
- settings The settings to use for the MediaReceiver.
- receiverSettings The settings to use for the ControlDataReceiver.
Return: True if the MediaReceiver was started successfully, false otherwise.
function stop
void stop()
Stop the MediaReceiver.
function getCustomMultiViewSourceInput
std::function< void(const AlignedFramePtr &)> getCustomMultiViewSourceInput(
uint32_t inputSlot,
const std::string & name =""
)
This method allows the Rendering Engine to provide custom input sources to the Multi-view generator to send video streams that can be added to the multi-views. This could for instance be used for adding a “preview” of the video stream the rendering engine is about to cut to.
Parameters:
- inputSlot The input slot this source will be “plugged in” to. The custom input sources share the input slots with the streams connected from Ingests. This means that it is probably a good idea to use higher numbered slots for these custom inputs, such as numbers from 1000, so that the lower numbers, 1 and up, can be used by the connected video cameras, as the input slot number will also be used when cutting.
- name Optional human readable name of this stream, to be presented to the System Controller.
See: MediaReceiver::Settings::mDecodedFormat.
Return: A function to where the Rendering Engine should send the frames. In case the requested inputSlot is already used by another custom input source, or a stream from an ingest, the returned function will be nullptr.
Note: Make sure no CUDA stream will write to the DeviceMemory in the AlignedFrame passed to the function. Failing to do so will lead to undefined behavior. In case another CUDA stream has written to the DeviceMemory, make sure to synchronize with the stream before passing the AlignedFrame.
Precondition: The AlignedFrame sent to this function must have the same pixel format as this MediaReceiver is configured to deliver to the Rendering Engine,
function removeCustomMultiViewSourceInput
bool removeCustomMultiViewSourceInput(
uint32_t inputSlot
)
Remove a custom multi-view generator source input earlier registered using the getCustomMultiViewSourceInput
method.
Parameters:
- inputSlot The input slot the custom multi-view source input is connected to, that should be removed
Return: True if the custom multi-view source input was successfully removed, false in case there was no custom input registered for the given input slot, or in case of an internal error.
function createMediaStreamerOutput
std::shared_ptr< IMediaStreamer > createMediaStreamerOutput(
const MediaStreamer::Settings & settings
)
Create a new MediaStreamer instance to output data from this MediaReceiver.
Parameters:
- settings The settings for the new MediaStreamer
Return: A shared pointer to the MediaStreamer instance in case of a successful creation, otherwise nullptr
function removeMediaStreamerOutput
bool removeMediaStreamerOutput(
const std::string & uuid
)
Remove an MediaStreamer created via the.
Parameters:
- uuid The UUID of the MediaStreamer to remove
See: createMediaStreamerOutput method by its UUID.
Return: True if the MediaStreamer was successfully removed, false in case no MediaStreamer with the given UUID was found.
function getControlDataReceiver
std::shared_ptr< IControlDataReceiver > getControlDataReceiver()
Get a pointer to the ControlDataReceiver instance of this MediaReceiver. A call to this method will always return the same instance.
See: start.
Return: Pointer to the ControlDataReceiver instance. Nullptr if called before a successful call to
function setTallyBorder
void setTallyBorder(
uint32_t inputSlot,
TallyBorderColor color
)
Set tally border color in the multi-views for a specific input slot.
Parameters:
- inputSlot the input slot for a source
- color the color to set
function clearTallyBorder
void clearTallyBorder(
uint32_t inputSlot
)
Remove tally border in the multi-views for a specific input slot.
Parameters:
- inputSlot the input slot for a source
function clearAllTallyBorders
void clearAllTallyBorders()
Remove all tally borders.
function getTallyBorder
MediaReceiver::TallyBorderColor getTallyBorder(
uint32_t inputSlot
) const
get tally border color for an input slot
Parameters:
- inputSlot the input slot to get color for
Return: the tally border color for the given input slot
function MediaReceiver
MediaReceiver(
MediaReceiver const &
) =delete
MediaReceiver is neither copyable nor movable.
function MediaReceiver
MediaReceiver(
MediaReceiver &&
) =delete
function operator=
MediaReceiver & operator=(
MediaReceiver const &
) =delete
function operator=
MediaReceiver & operator=(
MediaReceiver &&
) =delete
function getVersion
static std::string getVersion()
Get application version.
Return: a string with the current version, e.g. “6.0.0-39-g60a35937”
function getLibraryVersions
static std::string getLibraryVersions()
Get versions of the libraries available at runtime, among others, CUDA runtime and driver versions.
Return: a string with the currently found versions of the libraries used by this application
Updated on 2024-04-08 at 15:15:27 +0200
1.25 - MediaReceiver::NewStreamParameters
MediaReceiver::NewStreamParameters
A struct containing information on the format of an incoming stream.
#include <MediaReceiver.h>
Public Attributes
Name | |
---|---|
uint32_t | mVideoHeight |
uint32_t | mVideoWidth |
uint32_t | mFrameRateN |
uint32_t | mFrameRateD |
uint32_t | mAudioSampleRate |
Public Attributes Documentation
variable mVideoHeight
uint32_t mVideoHeight = 0;
variable mVideoWidth
uint32_t mVideoWidth = 0;
variable mFrameRateN
uint32_t mFrameRateN = 0;
variable mFrameRateD
uint32_t mFrameRateD = 1;
variable mAudioSampleRate
uint32_t mAudioSampleRate = 0;
Updated on 2024-04-08 at 15:15:27 +0200
1.26 - MediaReceiver::Settings
MediaReceiver::Settings
Settings for a MediaReceiver.
#include <MediaReceiver.h>
Public Attributes
Name | |
---|---|
PixelFormat | mDecodedFormat The pixel format delivered to the rendering engine. |
std::function< std::function< void(const AlignedFramePtr &)>uint32_t inputSlot, const std::string &streamID, const NewStreamParameters &newStreamParameters)> | mNewConnectionCallback |
std::function< void(uint32_t inputSlot)> | mClosedConnectionCallback |
std::function< std::optional< std::string >)> | mResetCallback |
bool | mUseMultiViewer |
bool | mDeliverOld Set to true if this MediaReceiver should have a multi-view generator. |
CUstream | mAlignedFrameFreeStream |
Public Attributes Documentation
variable mDecodedFormat
PixelFormat mDecodedFormat = PixelFormat::kRgba64Le;
The pixel format delivered to the rendering engine.
variable mNewConnectionCallback
std::function< std::function< void(const AlignedFramePtr &)>uint32_t inputSlot, const std::string &streamID, const NewStreamParameters &newStreamParameters)> mNewConnectionCallback;
Parameters:
- inputSlot can be seen as a virtual SDI input on a hardware mixer and should be used by the Rendering engine to identify sources. For example, if a source is connected to input slot 5, the button “Cut to camera 5” on the control panel ought to cut to this stream. The MediaReceiver is responsible for making sure only one stream can be connected to an input slot at a time. This callback might be called multiple times with the same input slot, however, in case the stream has been disconnected and the mClosedConnectionCallback has been called for that input slot earlier.
- streamID is the identification string of the video/audio source on the Ingest. A Rendering engine might have the same StreamID connected multiple times (for instance if two different alignments are used for the same source) so this should not be used as an unique identifier for the stream.
- newStreamParameters contains information on the pending incoming stream to allow the Rendering engine to decide if it can receive it or not.
Note: The internal CUDA stream is synchronized before delivering the AlignedFrames, meaning the DeviceMemory in the AlignedFrame will always contain the written data; no further synchronization is needed before the rendering engine can read the data.
A callback called by the MediaReceiver whenever a new connection from an Ingest is set up. The callback should return a function to which the data will be delivered. In case the Rendering engine does not want to accept the pending incoming stream (due to a format not supported, etc) the Rendering engine can return nullptr.
variable mClosedConnectionCallback
std::function< void(uint32_t inputSlot)> mClosedConnectionCallback;
Parameters:
- inputSlot The input slot that was disconnected
A callback called whenever a connection from an Ingest has been stopped. When receiving this callback, the callback function returned by the mNewConnectionCallback will not be called anymore and can be discarded if required by the application. After this function has been called, the input slot might be reused by another incoming stream after a call to the mNewConnectionCallback.
variable mResetCallback
std::function< std::optional< std::string >)> mResetCallback;
See: mNewConnectionCallback should be kept, however).
Return: True on successful reset, false in case something unexpected happened
A callback called whenever the System Controller has requested that the Rendering Engine should be reset to its initial state (connections made via the
variable mUseMultiViewer
bool mUseMultiViewer = false;
variable mDeliverOld
bool mDeliverOld = false;
Set to true if this MediaReceiver should have a multi-view generator.
variable mAlignedFrameFreeStream
CUstream mAlignedFrameFreeStream = nullptr;
Set to true if the media frames should be delivered, even if the delivery time has already passed, otherwise they are discarded The CUDA stream to use for asynchronously freeing the AlignedFrames’ DeviceMemory. Set this to the rendering engine’s CUDA stream, to ensure memory is not freed before the rendering engine is done using it asynchronously in its CUDA stream. Note that the MediaReceiver instance and all AlignedFrames delivered from it must be destroyed before the CUDA stream can be destroyed.
Updated on 2024-04-08 at 15:15:27 +0200
1.27 - SystemControllerConnection
SystemControllerConnection
An implementation of the ISystemControllerInterface for a System controller residing in a remote server. The connection to the server uses a Websocket.
#include <SystemControllerConnection.h>
Inherits from ISystemControllerInterface
Public Classes
Name | |
---|---|
struct | Settings Settings for a SystemControllerConnection. |
Public Types
Name | |
---|---|
enum class uint32_t | ComponentType { kIngest, kPipeline, kControlPanel} Enumeration of component types the component using this SystemControllerConnection can tell the System Controller to be seen as. |
Public Functions
Name | |
---|---|
SystemControllerConnection() | |
~SystemControllerConnection() override | |
bool | configure(const Settings & settings) Configure this connection. This method should be called before calling. |
virtual bool | connect() override Connect to the server using the settings set with the. |
virtual bool | isConnected() const override |
virtual std::string | getUUID() const override |
virtual std::optional< std::string > | sendMessage(const std::string & messageTitle, const nlohmann::json & parameters) override Send a message containing a JSON object to the system controller server. |
virtual bool | disconnect() override Disconnect from the server. |
virtual bool | registerRequestCallback(const Callbacks & callbacks) override Register callbacks to call when getting requests from the server or the server connection is lost. |
SystemControllerConnection(SystemControllerConnection const & ) =delete | |
SystemControllerConnection(SystemControllerConnection && ) =delete | |
SystemControllerConnection & | operator=(SystemControllerConnection const & ) =delete |
SystemControllerConnection & | operator=(SystemControllerConnection && ) =delete |
Additional inherited members
Public Classes inherited from ISystemControllerInterface
Name | |
---|---|
struct | Callbacks A struct containing the callbacks that needs to be registered by the component using this interface. |
struct | Response A response to a request, consists of a status code and an (optional) parameters JSON object. |
Public Types inherited from ISystemControllerInterface
Name | |
---|---|
enum class uint32_t | StatusCode { SUCCESS, TOO_MANY_REQUESTS, UUID_ALREADY_REGISTERED, FORMAT_ERROR, ALREADY_CONFIGURED, OUT_OF_RESOURCES, NOT_FOUND, INTERNAL_ERROR, CONNECTION_FAILED, TIMEOUT_EXCEEDED, KEY_MISMATCH, UNKNOWN_REQUEST, MALFORMED_REQUEST, ALREADY_IN_USE, VERSION_MISMATCH} Status codes used in JSON response messages for Websockets. These are starting at 3000 since the 1000 - 2000 range is taken up by the Spec: https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1. |
Public Functions inherited from ISystemControllerInterface
Name | |
---|---|
virtual | ~ISystemControllerInterface() =default Virtual destructor. |
Public Types Documentation
enum ComponentType
Enumerator | Value | Description |
---|---|---|
kIngest | ||
kPipeline | ||
kControlPanel |
Enumeration of component types the component using this SystemControllerConnection can tell the System Controller to be seen as.
Public Functions Documentation
function SystemControllerConnection
SystemControllerConnection()
function ~SystemControllerConnection
~SystemControllerConnection() override
function configure
bool configure(
const Settings & settings
)
Configure this connection. This method should be called before calling.
Parameters:
- settings The settings to use when connecting to the server
See: connect.
Return: True if successfully configured, false otherwise
function connect
virtual bool connect() override
Connect to the server using the settings set with the.
See: configure method.
Return: True if connection was successful, false otherwise
Reimplements: ISystemControllerInterface::connect
function isConnected
virtual bool isConnected() const override
Return: True if this class is connected to the server, false otherwise
Reimplements: ISystemControllerInterface::isConnected
function getUUID
virtual std::string getUUID() const override
Return: The UUID of this interface to the System controller
Reimplements: ISystemControllerInterface::getUUID
function sendMessage
virtual std::optional< std::string > sendMessage(
const std::string & messageTitle,
const nlohmann::json & parameters
) override
Send a message containing a JSON object to the system controller server.
Parameters:
- messageTitle The title of the status type or request
- parameters The parameters part of the JSON message
Return: Optional containing an error message on error, else nullopt in case the message was successfully sent
Reimplements: ISystemControllerInterface::sendMessage
function disconnect
virtual bool disconnect() override
Disconnect from the server.
Return: True if successfully disconnected, false on internal error
Reimplements: ISystemControllerInterface::disconnect
function registerRequestCallback
virtual bool registerRequestCallback(
const Callbacks & callbacks
) override
Register callbacks to call when getting requests from the server or the server connection is lost.
Parameters:
- callbacks The callbacks to set
Return: True if successfully registered, false if a callback is not set, or if already connected to the server
Reimplements: ISystemControllerInterface::registerRequestCallback
function SystemControllerConnection
SystemControllerConnection(
SystemControllerConnection const &
) =delete
function SystemControllerConnection
SystemControllerConnection(
SystemControllerConnection &&
) =delete
function operator=
SystemControllerConnection & operator=(
SystemControllerConnection const &
) =delete
function operator=
SystemControllerConnection & operator=(
SystemControllerConnection &&
) =delete
Updated on 2024-04-08 at 15:15:27 +0200
1.28 - SystemControllerConnection::Settings
SystemControllerConnection::Settings
Settings for a SystemControllerConnection.
#include <SystemControllerConnection.h>
Public Attributes
Name | |
---|---|
std::string | mSystemControllerIP |
uint16_t | mSystemControllerPort |
std::string | mSystemControllerPostfix |
std::string | mPSK |
std::string | mUUID |
ComponentType | mType |
std::string | mName |
std::string | mMyIP |
std::chrono::milliseconds | mConnectTimeout |
bool | mEnableHTTPS |
bool | mInsecureHTTPS |
std::string | mCustomCaCertFile |
Public Attributes Documentation
variable mSystemControllerIP
std::string mSystemControllerIP;
variable mSystemControllerPort
uint16_t mSystemControllerPort;
variable mSystemControllerPostfix
std::string mSystemControllerPostfix;
variable mPSK
std::string mPSK;
variable mUUID
std::string mUUID;
variable mType
ComponentType mType;
variable mName
std::string mName;
variable mMyIP
std::string mMyIP;
variable mConnectTimeout
std::chrono::milliseconds mConnectTimeout {
3000};
variable mEnableHTTPS
bool mEnableHTTPS;
variable mInsecureHTTPS
bool mInsecureHTTPS;
variable mCustomCaCertFile
std::string mCustomCaCertFile;
Updated on 2024-04-08 at 15:15:27 +0200
1.29 - TimeCommon::TAIStatus
TimeCommon::TAIStatus
Public Attributes
Name | |
---|---|
StratumLevel | mStratum |
bool | mHasLock |
double | mTimeDiffS |
Public Attributes Documentation
variable mStratum
StratumLevel mStratum = StratumLevel::UnknownStratum;
variable mHasLock
bool mHasLock = false;
variable mTimeDiffS
double mTimeDiffS = 0.0;
Updated on 2024-04-08 at 15:15:27 +0200
1.30 - TimeCommon::TimeStructure
TimeCommon::TimeStructure
Public Attributes
Name | |
---|---|
uint64_t | t1 |
uint64_t | t2 |
uint64_t | t3 |
uint64_t | t4 |
uint64_t | token |
uint64_t | dummy1 |
uint64_t | dummy2 |
uint64_t | dummy3 |
Public Attributes Documentation
variable t1
uint64_t t1 = 0;
variable t2
uint64_t t2 = 0;
variable t3
uint64_t t3 = 0;
variable t4
uint64_t t4 = 0;
variable token
uint64_t token = 0;
variable dummy1
uint64_t dummy1 = 0;
variable dummy2
uint64_t dummy2 = 0;
variable dummy3
uint64_t dummy3 = 0;
Updated on 2024-04-08 at 15:15:27 +0200
2 - Files
Files
- dir build
- dir install
- dir include
- file include/AclLog.h
- file include/AlignedFrame.h
- file include/Base64.h
- file include/ControlDataCommon.h
- file include/ControlDataSender.h
- file include/DeviceMemory.h
- file include/IControlDataReceiver.h
- file include/IMediaStreamer.h
- file include/ISystemControllerInterface.h
- file include/IngestApplication.h
- file include/IngestUtils.h
- file include/MediaReceiver.h
- file include/PixelFormat.h
- file include/SystemControllerConnection.h
- file include/TimeCommon.h
- file include/UUIDUtils.h
- dir include
- dir install
Updated on 2024-04-08 at 15:15:27 +0200
2.1 - include/AclLog.h
include/AclLog.h
Namespaces
Name |
---|
AclLog A namespace for logging utilities. |
Classes
Name | |
---|---|
class | AclLog::CommandLogFormatter This class is used to format log entries for Rendering Engine commands. |
class | AclLog::ThreadNameFormatterFlag |
class | AclLog::FileLocationFormatterFlag A custom flag formatter which logs the source file location between a par of “[]”, in case the location is provided with the log call. |
Source code
// Copyright (c) 2022, Edgeware AB. All rights reserved.
#pragma once
#include <filesystem>
#include <string>
#include <spdlog/details/log_msg.h>
#include <spdlog/fmt/fmt.h>
#include <spdlog/formatter.h>
#include <spdlog/pattern_formatter.h>
#include <sys/prctl.h>
namespace AclLog {
enum class Level {
kTrace, // Detailed diagnostics (for development only)
kDebug, // Messages intended for debugging only
kInfo, // Messages about normal behavior (default log level)
kWarning, // Warnings (functionality intact)
kError, // Recoverable errors (functionality impaired)
kCritical, // Unrecoverable errors (application must stop)
kOff // Turns off all logging
};
void init(const std::string& name);
void initCommandLog(const std::string& name);
void setLevel(Level level);
void logCommand(const std::string& origin, const std::string& command);
AclLog::Level getLogLevel();
size_t getMaxFileSize();
size_t getMaxLogRotations();
std::filesystem::path getLogFileFullPath(const std::string& name);
class CommandLogFormatter : public spdlog::formatter {
public:
CommandLogFormatter();
void format(const spdlog::details::log_msg& msg, spdlog::memory_buf_t& dest) override;
[[nodiscard]] std::unique_ptr<spdlog::formatter> clone() const override;
private:
std::unique_ptr<spdlog::pattern_formatter> mCommandLogPattern;
};
inline std::string getThreadName() {
static const size_t RECOMMENDED_BUFFER_SIZE = 20;
static thread_local std::string name;
if (name.empty()) {
char buffer[RECOMMENDED_BUFFER_SIZE];
int retval = prctl(PR_GET_NAME, buffer);
if (retval == -1) {
throw spdlog::spdlog_ex("Failed to get thread name: ", errno);
}
name = std::string(buffer);
}
return name;
}
class ThreadNameFormatterFlag : public spdlog::custom_flag_formatter {
public:
void format(const spdlog::details::log_msg&, const std::tm&, spdlog::memory_buf_t& dest) override {
std::string threadName = getThreadName();
dest.append(threadName.data(), threadName.data() + threadName.size());
}
[[nodiscard]] std::unique_ptr<custom_flag_formatter> clone() const override {
return spdlog::details::make_unique<ThreadNameFormatterFlag>();
}
};
class FileLocationFormatterFlag : public spdlog::custom_flag_formatter {
public:
void format(const spdlog::details::log_msg& msg, const std::tm&, spdlog::memory_buf_t& dest) override {
if (!msg.source.empty()) {
using namespace spdlog::details;
dest.push_back('[');
const char* filename = short_filename_formatter<null_scoped_padder>::basename(msg.source.filename);
fmt_helper::append_string_view(filename, dest);
dest.push_back(':');
fmt_helper::append_int(msg.source.line, dest);
dest.push_back(']');
}
}
[[nodiscard]] std::unique_ptr<custom_flag_formatter> clone() const override {
return spdlog::details::make_unique<FileLocationFormatterFlag>();
}
};
} // namespace AclLog
Updated on 2024-04-08 at 15:15:27 +0200
2.2 - include/AlignedFrame.h
include/AlignedFrame.h
Classes
Name | |
---|---|
struct | AlignedAudioFrame AlignedAudioFrame is a frame of interleaved floating point audio samples with a given number of channels. |
struct | 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. |
Types
Name | |
---|---|
using std::shared_ptr< AlignedAudioFrame > | AlignedAudioFramePtr |
using std::shared_ptr< const AlignedAudioFrame > | AlignedAudioFrameConstPtr |
using std::shared_ptr< AlignedFrame > | AlignedFramePtr |
Functions
Name | |
---|---|
AlignedAudioFramePtr | createAlignedAudioFrame(uint8_t numberOfChannels, uint32_t numberOfSamplesPerChannel) Create a new AudioFrame with a given amount of samples allocated and all samples initialized to 0.0f. |
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. |
Types Documentation
using AlignedAudioFramePtr
using AlignedAudioFramePtr = std::shared_ptr<AlignedAudioFrame>;
using AlignedAudioFrameConstPtr
using AlignedAudioFrameConstPtr = std::shared_ptr<const AlignedAudioFrame>;
using AlignedFramePtr
using AlignedFramePtr = std::shared_ptr<AlignedFrame>;
Functions Documentation
function createAlignedAudioFrame
AlignedAudioFramePtr createAlignedAudioFrame(
uint8_t numberOfChannels,
uint32_t numberOfSamplesPerChannel
)
Create a new AudioFrame 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 AudioFrame
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
Source code
// Copyright (c) 2022, Edgeware AB. All rights reserved.
#pragma once
#include <array>
#include <iostream>
#include <memory>
#include <vector>
#include <cuda_runtime_api.h>
#include "DeviceMemory.h"
#include "PixelFormat.h"
struct AlignedAudioFrame {
// The samples interleaved
std::vector<float> mSamples;
uint8_t mNumberOfChannels = 0;
uint32_t mNumberOfSamplesPerChannel = 0;
};
using AlignedAudioFramePtr = std::shared_ptr<AlignedAudioFrame>;
using AlignedAudioFrameConstPtr = std::shared_ptr<const AlignedAudioFrame>;
AlignedAudioFramePtr createAlignedAudioFrame(uint8_t numberOfChannels, uint32_t numberOfSamplesPerChannel);
AlignedAudioFramePtr extractChannel(AlignedAudioFrameConstPtr sourceFrame, uint8_t channelIndex);
struct AlignedFrame {
AlignedFrame() = default;
~AlignedFrame() = default;
AlignedFrame(AlignedFrame const&) = delete; // Copy construct
AlignedFrame& operator=(AlignedFrame const&) = delete; // Copy assign
[[nodiscard]] std::shared_ptr<AlignedFrame> makeShallowCopy() const;
int64_t mCaptureTimestamp = 0;
int64_t mRenderingTimestamp = 0;
// Video
std::shared_ptr<DeviceMemory> mVideoFrame = nullptr;
PixelFormat mPixelFormat = PixelFormat::kUnknown;
uint32_t mFrameRateN = 0;
uint32_t mFrameRateD = 0;
uint32_t mWidth = 0;
uint32_t mHeight = 0;
// Audio
AlignedAudioFramePtr mAudioFrame = nullptr;
uint32_t mAudioSamplingFrequency = 0;
};
using AlignedFramePtr = std::shared_ptr<AlignedFrame>;
Updated on 2024-04-08 at 15:15:27 +0200
2.3 - include/Base64.h
include/Base64.h
Functions
Name | |
---|---|
std::string | encodeBase64(const uint8_t * data, size_t size) Base64 encode some data. |
std::string | encodeBase64(const std::vector< uint8_t > & data) Base64 encode some data. |
std::vector< uint8_t > | decodeBase64(const std::string & data) Decode some Base64 encoded data. |
Functions Documentation
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
Source code
// Copyright (c) 2022, Edgeware AB. All rights reserved.
#pragma once
#include <string>
#include <vector>
std::string encodeBase64(const uint8_t* data, size_t size);
std::string encodeBase64(const std::vector<uint8_t>& data);
std::vector<uint8_t> decodeBase64(const std::string& data);
Updated on 2024-04-08 at 15:15:27 +0200
2.4 - include/ControlDataCommon.h
include/ControlDataCommon.h
Namespaces
Name |
---|
ControlDataCommon |
Classes
Name | |
---|---|
struct | ControlDataCommon::ConnectionStatus Connection status struct containing information about a connection event. |
struct | ControlDataCommon::Response A response from a ControlDataReceiver to a request. The UUID tells which receiver the response is sent from. |
struct | ControlDataCommon::StatusMessage A status message from a ControlDataReceiver. The UUID tells which receiver the message is sent from. |
Source code
// Copyright (c) 2022, Edgeware AB. All rights reserved.
#pragma once
#include <cstdint>
#include <string>
#include <vector>
namespace ControlDataCommon {
enum class ConnectionType { CONNECTED, DISCONNECTED };
struct ConnectionStatus {
ConnectionStatus() = default;
ConnectionStatus(ConnectionType mConnectionType, const std::string& mIp, uint16_t mPort)
: mConnectionType(mConnectionType)
, mIP(mIp)
, mPort(mPort) {
}
ConnectionType mConnectionType = ConnectionType::DISCONNECTED;
std::string mIP;
uint16_t mPort = 0;
};
struct Response {
std::vector<uint8_t> mMessage;
uint64_t mRequestId = 0;
std::string mFromUUID;
};
struct StatusMessage {
std::vector<uint8_t> mMessage;
std::string mFromUUID;
};
} // namespace ControlDataCommon
Updated on 2024-04-08 at 15:15:27 +0200
2.5 - include/ControlDataSender.h
include/ControlDataSender.h
Classes
Name | |
---|---|
class | 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. |
struct | ControlDataSender::Settings Settings for a ControlDataSender. |
Source code
// Copyright (c) 2022, Edgeware AB. All rights reserved.
#pragma once
#include <functional>
#include <memory>
#include <vector>
#include <ISystemControllerInterface.h>
#include "ControlDataCommon.h"
class ControlDataSender final {
public:
struct Settings {
std::function<void(const ControlDataCommon::ConnectionStatus&)>
mConnectionStatusCallback; // Callback for receiver connection/disconnection events
std::function<void(const ControlDataCommon::Response&)>
mResponseCallback; // Callback for response messages from receivers
std::function<void(const ControlDataCommon::StatusMessage&)>
mStatusMessageCallback; // Callback for status messages from receivers
};
ControlDataSender();
~ControlDataSender();
bool configure(const std::shared_ptr<ISystemControllerInterface>& controllerInterface, const Settings& settings);
bool sendRequestToReceivers(const std::vector<uint8_t>& request, uint64_t& requestId);
bool sendMultiRequestToReceivers(const std::vector<std::vector<uint8_t>>& request, uint64_t& requestId);
static std::string getVersion();
// ControlDataSender is not copyable
ControlDataSender(ControlDataSender const&) = delete; // Copy construct
ControlDataSender& operator=(ControlDataSender const&) = delete; // Copy assign
private:
class Impl;
std::unique_ptr<Impl> pImpl;
};
Updated on 2024-04-08 at 15:15:27 +0200
2.6 - include/DeviceMemory.h
include/DeviceMemory.h
Classes
Name | |
---|---|
class | DeviceMemory RAII class for a CUDA memory buffer. |
Types
Name | |
---|---|
using std::shared_ptr< DeviceMemory > | DeviceMemoryPtr |
Types Documentation
using DeviceMemoryPtr
using DeviceMemoryPtr = std::shared_ptr<DeviceMemory>;
Source code
// Copyright (c) 2022, Edgeware AB. All rights reserved.
#pragma once
#include <cstddef>
#include <cstdint>
#include <memory>
#include <cuda_runtime.h>
class DeviceMemory {
public:
DeviceMemory() = default;
explicit DeviceMemory(size_t numberOfBytes);
explicit DeviceMemory(size_t numberOfBytes, cudaStream_t cudaStream);
explicit DeviceMemory(void* deviceMemory) noexcept;
bool allocateMemory(size_t numberOfBytes);
bool allocateMemoryAsync(size_t numberOfBytes, cudaStream_t cudaStream);
bool reallocateMemory(size_t numberOfBytes);
bool reallocateMemoryAsync(size_t numberOfBytes, cudaStream_t cudaStream);
bool allocateAndResetMemory(size_t numberOfBytes);
bool allocateAndResetMemoryAsync(size_t numberOfBytes, cudaStream_t cudaStream);
bool freeMemory();
bool freeMemoryAsync(cudaStream_t cudaStream);
void setFreeingCudaStream(cudaStream_t cudaStream);
~DeviceMemory();
template <typename T = uint8_t> [[nodiscard]] T* getDevicePointer() const {
return reinterpret_cast<T*>(dMemory);
}
[[nodiscard]] size_t getSize() const;
DeviceMemory(DeviceMemory&& other) noexcept;
DeviceMemory& operator=(DeviceMemory&& other) noexcept;
void swap(DeviceMemory& other) noexcept;
DeviceMemory(DeviceMemory const&) = delete;
DeviceMemory operator=(DeviceMemory const&) = delete;
private:
uint8_t* dMemory = nullptr;
size_t mAllocatedBytes = 0;
cudaStream_t mCudaStream = nullptr; // Stream to use for Async free
};
using DeviceMemoryPtr = std::shared_ptr<DeviceMemory>;
Updated on 2024-04-08 at 15:15:27 +0200
2.7 - include/IControlDataReceiver.h
include/IControlDataReceiver.h
Classes
Name | |
---|---|
class | 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. |
struct | IControlDataReceiver::IncomingRequest An incoming request to this ControlDataReceiver. |
struct | IControlDataReceiver::ReceiverResponse A response message to a request. |
struct | IControlDataReceiver::Settings Settings for a ControlDataReceiver. |
Source code
// Copyright (c) 2024, Edgeware AB. All rights reserved.
#pragma once
#include <memory>
#include <ISystemControllerInterface.h>
#include "ControlDataCommon.h"
class IControlDataReceiver {
public:
struct IncomingRequest {
std::vector<std::vector<uint8_t>> mMessages;
std::string mSenderUUID;
std::string mRequesterUUID;
uint64_t mRequestID = 0;
int64_t mSenderTimestampUs =
0;
int64_t mDeliveryTimestampUs =
0;
};
struct ReceiverResponse {
std::vector<uint8_t> mMessage;
};
struct Settings {
std::string mProductionPipelineUUID;
std::function<void(const IncomingRequest&)> mPreviewIncomingRequestCallback;
std::function<ReceiverResponse(const IncomingRequest&)> mIncomingRequestCallback;
std::function<void(const ControlDataCommon::ConnectionStatus&)>
mConnectionStatusCallback;
std::function<void(const ControlDataCommon::Response&)>
mResponseCallback;
};
virtual ~IControlDataReceiver() = default;
virtual bool configure(const Settings& settings) = 0;
virtual bool sendStatusMessageToSender(const std::vector<uint8_t>& message) = 0;
virtual bool sendRequestToReceivers(const std::vector<uint8_t>& request, uint64_t& requestId) = 0;
virtual bool sendMultiRequestToReceivers(const std::vector<std::vector<uint8_t>>& request, uint64_t& requestId) = 0;
};
Updated on 2024-04-08 at 15:15:27 +0200
2.8 - include/IMediaStreamer.h
include/IMediaStreamer.h
Classes
Name | |
---|---|
class | 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. |
struct | IMediaStreamer::Settings Settings used when creating a new MediaStreamer. |
struct | IMediaStreamer::Configuration The input configuration of the frames that will be sent to this MediaStreamer. The output stream configuration is made from the System controller via the ISystemControllerInterface. |
Source code
// Copyright (c) 2024, Edgeware AB. All rights reserved.
#pragma once
#include <memory>
#include <ISystemControllerInterface.h>
#include <cuda.h>
#include "AlignedFrame.h"
class IMediaStreamer {
public:
struct Settings {
std::string mName; // Human-readable name, presented in the REST API
};
struct Configuration {
// Video
PixelFormat mIncomingPixelFormat = PixelFormat::kUnknown;
uint32_t mWidth = 0; // Width of the incoming video frames in pixels
uint32_t mHeight = 0; // Height of the incoming video frames in pixels
uint32_t mFrameRateN = 0; // Frame rate numerator of the incoming video frames
uint32_t mFrameRateD = 0; // Frame rate denominator of the incoming video frames
// Audio
uint32_t mAudioSampleRate = 0; // Audio sample rate of the incoming frames in Hz
uint32_t mNumAudioChannels = 0; // Number of audio channels in the incoming frames
};
virtual ~IMediaStreamer() = default;
virtual bool configure(const std::string& uuid, const Settings& settings, CUcontext cudaContext) = 0;
virtual bool setInputFormatAndStart(const Configuration& configuration) = 0;
virtual bool stopAndResetFormat() = 0;
[[nodiscard]] virtual bool hasFormatAndIsRunning() const = 0;
[[nodiscard]] virtual bool hasOpenOutputStream() const = 0;
virtual bool outputData(const AlignedFramePtr& frame) = 0;
};
Updated on 2024-04-08 at 15:15:27 +0200
2.9 - include/IngestApplication.h
include/IngestApplication.h
Classes
Name | |
---|---|
class | IngestApplication |
struct | IngestApplication::Settings |
Source code
// Copyright (c) 2022, Edgeware AB. All rights reserved.
#pragma once
#include <memory>
#include "ISystemControllerInterface.h"
class IngestApplication {
public:
struct Settings {};
IngestApplication();
~IngestApplication();
bool start(const std::shared_ptr<ISystemControllerInterface>& controllerInterface, const Settings& settings);
bool stop();
static std::string getVersion();
static std::string getLibraryVersions();
private:
class Impl;
std::unique_ptr<Impl> pImpl;
};
Updated on 2024-04-08 at 15:15:27 +0200
2.10 - include/IngestUtils.h
include/IngestUtils.h
Namespaces
Name |
---|
IngestUtils |
Source code
// Copyright (c) 2022, Edgeware AB. All rights reserved.
#pragma once
namespace IngestUtils {
bool isRunningWithRootPrivileges();
} // namespace IngestUtils
Updated on 2024-04-08 at 15:15:27 +0200
2.11 - include/ISystemControllerInterface.h
include/ISystemControllerInterface.h
Classes
Name | |
---|---|
class | 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. |
struct | ISystemControllerInterface::Response A response to a request, consists of a status code and an (optional) parameters JSON object. |
struct | ISystemControllerInterface::Callbacks A struct containing the callbacks that needs to be registered by the component using this interface. |
Source code
// Copyright (c) 2022, Edgeware AB. All rights reserved.
#pragma once
#include <functional>
#include <json.hpp>
#include <optional>
#include <string>
class ISystemControllerInterface {
public:
enum class StatusCode : uint32_t {
SUCCESS = 3001, // Accept / Success
TOO_MANY_REQUESTS = 3101, // Too many requests, try again later
UUID_ALREADY_REGISTERED = 3201, // UUID is already registered
FORMAT_ERROR = 3202, // Message formatting error
ALREADY_CONFIGURED = 3203, // The requested thing to configure is already configured
OUT_OF_RESOURCES = 3204, // Out of resources (CPU/GPU close to max utilization, all available slots used, etc.)
NOT_FOUND = 3205, // The requested thing was not found
INTERNAL_ERROR = 3206, // Internal error when trying to serve the request
CONNECTION_FAILED = 3207, // Connection failure
TIMEOUT_EXCEEDED = 3208, // Timeout exceeded
KEY_MISMATCH = 3209, // Key mismatch (might be a timeout, 3007 in the future)
UNKNOWN_REQUEST = 3210, // The name of the request was not known
MALFORMED_REQUEST = 3211, // The request is not correctly formatted
ALREADY_IN_USE = 3212, // The requested resource is already in use
VERSION_MISMATCH = 3213, // The version of the request is not supported
// None, yet
};
struct Response {
StatusCode mCode;
nlohmann::json mParameters; // Can be empty
};
struct Callbacks {
std::function<Response(const std::string&, const nlohmann::json&)>
mRequestCallback; // Callback called when then controller has sent a request
std::function<void(uint32_t, const std::string&, const std::error_code&)>
mConnectionClosedCallback; // Callback called when the connection to the controller is closed
};
virtual ~ISystemControllerInterface() = default;
virtual std::optional<std::string> sendMessage(const std::string& messageTitle,
const nlohmann::json& parameters) = 0;
virtual bool registerRequestCallback(const Callbacks& callbacks) = 0;
virtual bool connect() = 0;
virtual bool disconnect() = 0;
[[nodiscard]] virtual bool isConnected() const = 0;
[[nodiscard]] virtual std::string getUUID() const = 0;
};
Updated on 2024-04-08 at 15:15:27 +0200
2.12 - include/MediaReceiver.h
include/MediaReceiver.h
Classes
Name | |
---|---|
class | 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. |
struct | MediaReceiver::NewStreamParameters A struct containing information on the format of an incoming stream. |
struct | MediaReceiver::Settings Settings for a MediaReceiver. |
Source code
// Copyright (c) 2022, Edgeware AB. All rights reserved.
#pragma once
#include <memory>
#include <utility>
#include <cuda.h>
#include "AlignedFrame.h"
#include "ControlDataReceiver.h"
#include "ISystemControllerInterface.h"
#include "MediaStreamer.h"
class MediaReceiver {
public:
struct NewStreamParameters {
uint32_t mVideoHeight = 0; // Height of the video in pixels. 0 if the stream does not contain any video
uint32_t mVideoWidth = 0; // Width of the video in pixels. 0 if the stream does not contain any video
uint32_t mFrameRateN = 0; // Frame rate numerator
uint32_t mFrameRateD = 1; // Frame rate denominator
uint32_t mAudioSampleRate = 0; // Sample rate of the audio in Hz. 0 if the stream does not contain any audio
};
struct Settings {
PixelFormat mDecodedFormat = PixelFormat::kRgba64Le;
std::function<std::function<void(const AlignedFramePtr&)>(uint32_t inputSlot,
const std::string& streamID,
const NewStreamParameters& newStreamParameters)>
mNewConnectionCallback;
std::function<void(uint32_t inputSlot)> mClosedConnectionCallback;
std::function<std::optional<std::string>()> mResetCallback;
bool mUseMultiViewer = false;
bool mDeliverOld = false;
CUstream mAlignedFrameFreeStream = nullptr;
};
enum class TallyBorderColor : uint32_t { kNone, kRed, kGreen, kYellow };
MediaReceiver();
~MediaReceiver();
bool start(const std::shared_ptr<ISystemControllerInterface>& controllerInterface,
CUcontext cudaContext,
const Settings& settings,
const ControlDataReceiver::Settings& receiverSettings);
void stop();
std::function<void(const AlignedFramePtr&)> getCustomMultiViewSourceInput(uint32_t inputSlot,
const std::string& name = "");
bool removeCustomMultiViewSourceInput(uint32_t inputSlot);
std::shared_ptr<IMediaStreamer> createMediaStreamerOutput(const MediaStreamer::Settings& settings);
bool removeMediaStreamerOutput(const std::string& uuid);
std::shared_ptr<IControlDataReceiver> getControlDataReceiver();
void setTallyBorder(uint32_t inputSlot, TallyBorderColor color);
void clearTallyBorder(uint32_t inputSlot);
void clearAllTallyBorders();
[[nodiscard]] MediaReceiver::TallyBorderColor getTallyBorder(uint32_t inputSlot) const;
MediaReceiver(MediaReceiver const&) = delete; // Copy construct
MediaReceiver(MediaReceiver&&) = delete; // Move construct
MediaReceiver& operator=(MediaReceiver const&) = delete; // Copy assign
MediaReceiver& operator=(MediaReceiver&&) = delete; // Move assign
static std::string getVersion();
static std::string getLibraryVersions();
private:
class Impl;
std::unique_ptr<Impl> pImpl;
};
Updated on 2024-04-08 at 15:15:27 +0200
2.13 - include/PixelFormat.h
include/PixelFormat.h
Namespaces
Name |
---|
ACL |
Types
Name | |
---|---|
enum uint32_t | PixelFormat { 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. |
Functions
Name | |
---|---|
std::ostream & | operator«(std::ostream & stream, PixelFormat pixelFormat) Add the string representation of a PixelFormat to the output stream. |
Types Documentation
enum PixelFormat
Enumerator | Value | Description |
---|---|---|
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.
Functions Documentation
function operator«
std::ostream & operator<<(
std::ostream & stream,
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
Source code
// Copyright (c) 2023, Edgeware AB. All rights reserved.
#pragma once
#include <cstdint>
#include <ostream>
namespace ACL {
constexpr uint32_t makeFourCC(char a, char b, char c, char d) {
return static_cast<uint32_t>(a) + (static_cast<uint32_t>(b) << 8) + (static_cast<uint32_t>(c) << 16) +
(static_cast<uint32_t>(d) << 24);
}
} // namespace ACL
enum PixelFormat : uint32_t {
kUnknown = 0, // Unknown format
kNv12 = ACL::makeFourCC('N', 'V', '1', '2'), // 4:2:0 format with Y plane followed by UVUVUV.. plane
kUyvy = ACL::makeFourCC('U', 'Y', 'V', 'Y'), // 4:2:2 format with packed UYVY macropixels
kP010 = ACL::makeFourCC('P', '0', '1', '0'), // 4:2:0 P016 with data in the 10 MSB
kP016 = ACL::makeFourCC('P', '0', '1', '6'), // 4:2:0 format with 16 bit words, Y plane followed by UVUVUV.. plane
kP210 = ACL::makeFourCC('P', '2', '1', '0'), // 4:2:2 P216 with data in the 10 MSB
kP216 = ACL::makeFourCC('P', '2', '1', '6'), // 4:2:2 format with 16 bit words, Y plane followed by UVUVUV.. plane
kRgba =
ACL::makeFourCC('R', 'G', 'B', 'A'), // 4:4:4:4 RGB format, 8 bit per channel, ordered RGBARGBARG.. in memory
kV210 = ACL::makeFourCC('V', '2', '1', '0'), // 4:2:2 packed format with 10 bit per component
kRgba64Le =
ACL::makeFourCC('R', 'G', 'B', 64) // 16 bit per component, ordered as RGBA in memory with little endian words.
};
std::ostream& operator<<(std::ostream& stream, PixelFormat pixelFormat);
Updated on 2024-04-08 at 15:15:27 +0200
2.14 - include/SystemControllerConnection.h
include/SystemControllerConnection.h
Classes
Name | |
---|---|
class | SystemControllerConnection An implementation of the ISystemControllerInterface for a System controller residing in a remote server. The connection to the server uses a Websocket. |
struct | SystemControllerConnection::Settings Settings for a SystemControllerConnection. |
Source code
// Copyright (c) 2022, Edgeware AB. All rights reserved.
#pragma once
#include <chrono>
#include "ISystemControllerInterface.h"
#include "json.hpp"
class SystemControllerConnection final : public ISystemControllerInterface {
public:
enum class ComponentType : uint32_t {
kIngest,
kPipeline,
kControlPanel,
};
struct Settings {
std::string mSystemControllerIP; // IP of the server
uint16_t mSystemControllerPort; // Port of the server
std::string mSystemControllerPostfix; // Postfix of the address that the backend uses if any
std::string mPSK; // The pre shared key used for authorization with the system controller server
std::string mUUID; // The UUID of the device using this library
ComponentType mType; // The component type of the component using this SystemControllerConnection
std::string mName; // The component name (optional)
std::string mMyIP; // The external IP of the system the component is running on. Will be sent to the system
// controller server in the announce message (optional)
std::chrono::milliseconds mConnectTimeout{
3000}; // Max time to wait on an announcement response from the server during connection
bool mEnableHTTPS; // Enable the communication between the system controller and a component encrypted
bool mInsecureHTTPS; // Disable the verification of the TLS certificate if requested.
std::string mCustomCaCertFile; // Custom CA certificate
};
SystemControllerConnection();
~SystemControllerConnection() override;
bool configure(const Settings& settings);
bool connect() override;
[[nodiscard]] bool isConnected() const override;
[[nodiscard]] std::string getUUID() const override;
std::optional<std::string> sendMessage(const std::string& messageTitle, const nlohmann::json& parameters) override;
bool disconnect() override;
bool registerRequestCallback(const Callbacks& callbacks) override;
SystemControllerConnection(SystemControllerConnection const&) = delete; // Copy construct
SystemControllerConnection(SystemControllerConnection&&) = delete; // Move construct
SystemControllerConnection& operator=(SystemControllerConnection const&) = delete; // Copy assign
SystemControllerConnection& operator=(SystemControllerConnection&&) = delete; // Move assign
private:
class Impl;
std::unique_ptr<Impl> pImpl;
};
Updated on 2024-04-08 at 15:15:27 +0200
2.15 - include/TimeCommon.h
include/TimeCommon.h
Namespaces
Name |
---|
TimeCommon |
Classes
Name | |
---|---|
struct | TimeCommon::TAIStatus |
struct | TimeCommon::TimeStructure |
Source code
// Copyright (c) 2022, Edgeware AB. All rights reserved.
#pragma once
#include <chrono>
#include <cstdint>
#include <fstream>
#include <sstream>
#include "expected.hpp"
namespace TimeCommon {
enum class StratumLevel {
UnknownStratum,
stratum0,
stratum1,
stratum2,
stratum3,
stratum4,
};
struct TAIStatus {
StratumLevel mStratum = StratumLevel::UnknownStratum;
bool mHasLock = false;
double mTimeDiffS = 0.0; // Time diff vs NTP in seconds, +/- value means slow/faster than NTP time
};
// Little endian
// Minimum size packet is 64 - bytes
struct TimeStructure {
uint64_t t1 = 0; // 8-bytes / Total 8-bytes == Client time T1
uint64_t t2 = 0; // 8-bytes / Total 16-bytes == Server
uint64_t t3 = 0; // 8-bytes / Total 24-bytes
uint64_t t4 = 0; // 8-bytes / Total 32-bytes
uint64_t token = 0; // 8-bytes / Total 40-bytes == t1 ^ key
uint64_t dummy1 = 0; // 8-bytes / Total 48-bytes == for future use
uint64_t dummy2 = 0; // 8-bytes / Total 56-bytes == for future use
uint64_t dummy3 = 0; // 8-bytes / Total 64-bytes == for future use
};
uint64_t getMonotonicClockMicro();
tl::expected<TimeCommon::TAIStatus, std::string> getStatus();
int64_t getTAIMicro();
std::string taiMicroToString(int64_t taiTimestamp);
} // namespace TimeCommon
Updated on 2024-04-08 at 15:15:27 +0200
2.16 - include/UUIDUtils.h
include/UUIDUtils.h
Namespaces
Name |
---|
UUIDUtils A namespace for UUID utility functions. |
Source code
// Copyright (c) 2022, Edgeware AB. All rights reserved.
#pragma once
#include <string>
namespace UUIDUtils {
std::string generateRandomUUID();
bool isValidUUIDString(const std::string& uuid);
} // namespace UUIDUtils
Updated on 2024-04-08 at 15:15:27 +0200
3 - Namespaces
Namespaces
- namespace ACL
- namespace AclLog
A namespace for logging utilities. - namespace ControlDataCommon
- namespace IngestUtils
- namespace TimeCommon
- namespace UUIDUtils
A namespace for UUID utility functions. - namespace spdlog
Updated on 2024-04-08 at 15:15:27 +0200
3.1 - ACL
ACL
Functions
Name | |
---|---|
constexpr uint32_t | makeFourCC(char a, char b, char c, char d) Helper function to create a FourCC code out of four characters. |
Functions Documentation
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.
Updated on 2024-04-08 at 15:15:27 +0200
3.2 - AclLog
AclLog
A namespace for logging utilities.
Classes
Name | |
---|---|
class | AclLog::CommandLogFormatter This class is used to format log entries for Rendering Engine commands. |
class | AclLog::ThreadNameFormatterFlag |
class | AclLog::FileLocationFormatterFlag A custom flag formatter which logs the source file location between a par of “[]”, in case the location is provided with the log call. |
Types
Name | |
---|---|
enum class | Level { kTrace, kDebug, kInfo, kWarning, kError, kCritical, kOff} Log levels. |
Functions
Name | |
---|---|
void | init(const std::string & name) Initialize logging. |
void | initCommandLog(const std::string & name) Init the Rendering Engine command log. |
void | setLevel(Level level) Set global logging level. |
void | logCommand(const std::string & origin, const std::string & command) Log a command to the command log. |
AclLog::Level | getLogLevel() Internal helper function for getting the setting for the log level. |
size_t | getMaxFileSize() Internal helper function for getting the setting for the maximum size for a log file. |
size_t | getMaxLogRotations() Internal helper function for getting the setting for the maximum number of rotated log files. |
std::filesystem::path | getLogFileFullPath(const std::string & name) Internal helper function for constructing the full path name for the log file. |
std::string | getThreadName() |
Types Documentation
enum Level
Enumerator | Value | Description |
---|---|---|
kTrace | ||
kDebug | ||
kInfo | ||
kWarning | ||
kError | ||
kCritical | ||
kOff |
Log levels.
Functions Documentation
function init
void init(
const std::string & name
)
Initialize logging.
Parameters:
- name The name of the component (used for log prefix and filename)
By default two sinks are created. The first sink writes messages to the console. The second sink attempts to create a log file in the path set by the environment variable ACL_LOG_PATH (’/tmp’ if unset). The name of the log file is ’name-
function initCommandLog
void initCommandLog(
const std::string & name
)
Init the Rendering Engine command log.
Parameters:
- name The name of the Rendering Engine (used for filename)
function setLevel
void setLevel(
Level level
)
Set global logging level.
Parameters:
- level Logging level to set
function logCommand
void logCommand(
const std::string & origin,
const std::string & command
)
Log a command to the command log.
Parameters:
- origin The origin of the command to log, usually the UUID of the control panel sending the command
- command The command to log
function getLogLevel
AclLog::Level getLogLevel()
Internal helper function for getting the setting for the log level.
Return: The wanted log level fetched from an environment variable if set, or else a default value
function getMaxFileSize
size_t getMaxFileSize()
Internal helper function for getting the setting for the maximum size for a log file.
Return: The wanted maximum size of the log file fetched from an environment variable if set, or else a default value
function getMaxLogRotations
size_t getMaxLogRotations()
Internal helper function for getting the setting for the maximum number of rotated log files.
Return: The wanted number of log files to rotate fetched from an environment variable if set, or else a default value
function getLogFileFullPath
std::filesystem::path getLogFileFullPath(
const std::string & name
)
Internal helper function for constructing the full path name for the log file.
Parameters:
- name The name of the component
Return: The full path to the log file
function getThreadName
inline std::string getThreadName()
Updated on 2024-04-08 at 15:15:27 +0200
3.3 - ControlDataCommon
ControlDataCommon
Classes
Name | |
---|---|
struct | ControlDataCommon::ConnectionStatus Connection status struct containing information about a connection event. |
struct | ControlDataCommon::Response A response from a ControlDataReceiver to a request. The UUID tells which receiver the response is sent from. |
struct | ControlDataCommon::StatusMessage A status message from a ControlDataReceiver. The UUID tells which receiver the message is sent from. |
Types
Name | |
---|---|
enum class | ConnectionType { CONNECTED, DISCONNECTED} The connection types. |
Types Documentation
enum ConnectionType
Enumerator | Value | Description |
---|---|---|
CONNECTED | ||
DISCONNECTED |
The connection types.
Updated on 2024-04-08 at 15:15:27 +0200
3.4 - IngestUtils
IngestUtils
Functions
Name | |
---|---|
bool | isRunningWithRootPrivileges() |
Functions Documentation
function isRunningWithRootPrivileges
bool isRunningWithRootPrivileges()
Return: true if this application is executing with root privileges, false otherwise
Updated on 2024-04-08 at 15:15:27 +0200
3.5 - spdlog
spdlog
Updated on 2024-04-08 at 15:15:27 +0200
3.6 - TimeCommon
TimeCommon
Classes
Name | |
---|---|
struct | TimeCommon::TAIStatus |
struct | TimeCommon::TimeStructure |
Types
Name | |
---|---|
enum class | StratumLevel { UnknownStratum, stratum0, stratum1, stratum2, stratum3, stratum4} |
Functions
Name | |
---|---|
uint64_t | getMonotonicClockMicro() Get current time since epoch. |
tl::expected< TimeCommon::TAIStatus, std::string > | getStatus() Get TAI status. |
int64_t | getTAIMicro() Get current TAI time. |
std::string | taiMicroToString(int64_t taiTimestamp) Converts the input TAI timestamp to a human readable string. Timestamp is converted to local time including leap seconds. |
Types Documentation
enum StratumLevel
Enumerator | Value | Description |
---|---|---|
UnknownStratum | ||
stratum0 | ||
stratum1 | ||
stratum2 | ||
stratum3 | ||
stratum4 |
Functions Documentation
function getMonotonicClockMicro
uint64_t getMonotonicClockMicro()
Get current time since epoch.
Return: Return current time since epoch in microseconds
function getStatus
tl::expected< TimeCommon::TAIStatus, std::string > getStatus()
Get TAI status.
Return: Expected with the TAI status if successful or an error string in case something went wrong
function getTAIMicro
int64_t getTAIMicro()
Get current TAI time.
Return: Return current TAI time in microseconds
function taiMicroToString
std::string taiMicroToString(
int64_t taiTimestamp
)
Converts the input TAI timestamp to a human readable string. Timestamp is converted to local time including leap seconds.
Parameters:
- taiTimestamp A TAI timestamp with microseconds resolution
Return: Return a human readable timestamp
Updated on 2024-04-08 at 15:15:27 +0200
3.7 - UUIDUtils
UUIDUtils
A namespace for UUID utility functions.
Functions
Name | |
---|---|
std::string | generateRandomUUID() Generates a completely randomized UUID string. |
bool | isValidUUIDString(const std::string & uuid) Checks if a string is a valid UUID string. |
Functions Documentation
function generateRandomUUID
std::string generateRandomUUID()
Generates a completely randomized UUID string.
Return: A random generated UUID string
function isValidUUIDString
bool isValidUUIDString(
const std::string & uuid
)
Checks if a string is a valid UUID string.
Parameters:
- uuid The string to check
Return: True if uuid is a valid UUID string, otherwise false
Updated on 2024-04-08 at 15:15:27 +0200