Classes
Classes
- namespace AclLog
A namespace for logging utilities. - 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
- class ControlDataReceiver
A ControlDataReceiver can receive messages from a sender or another ControlDataReceiver 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. - 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. - class DeviceMemory
RAII class for a CUDA memory buffer. - 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. An ISystemControllerInterface can have a parent-child relationship with other interfaces, where the children are aware of which their parent interface is. This is useful for components that provides extra features for another component, but where the components are still to be considered as two separate entities with separate connections to the System controller.- 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.
- class IngestApplication
- 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. - class MediaStreamer
MediaStreamer is a class that can take a single stream of uncompressed video and/or audio frames and encode and output it in some way to some interface. This interface 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. - class PipelineSystemControllerInterfaceFactory
- class SystemControllerConnection
An implementation of the ISystemControllerInterface for a System controller residing in a remote server. The connection to the server uses a Websocket. - namespace TimeCommon
- namespace UUIDUtils
A namespace for UUID utility functions.
Updated on 2022-11-17 at 15:40:06 +0100
1 - 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 Types
Public Functions
Public Attributes
Public Types Documentation
Enumerator | Value | Description |
---|
kAvc | | |
kHevc | | |
Enumerator | Value | Description |
---|
kUnknown | | |
kNv12 | | |
kP016 | | |
kUyvy | | |
kRgba | | |
kRgba64Le | | |
typedef AudioSampleRow
typedef std::array<float, 16> AlignedFrame::AudioSampleRow;
One audio sample in 16 channels.
Public Functions Documentation
function AlignedFrame
function ~AlignedFrame
function AlignedFrame
AlignedFrame(
AlignedFrame const &
) =delete
function operator=
AlignedFrame & operator=(
AlignedFrame const &
) =delete
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;
PixelFormat mPixelFormat = PixelFormat::kUnknown;
variable mFrameRateN
uint32_t mFrameRateN = 0;
variable mFrameRateD
uint32_t mFrameRateD = 0;
variable mWidth
variable mHeight
variable mAudioData
std::vector< AudioSampleRow > mAudioData;
variable mAudioChannels
uint32_t mAudioChannels = 0;
variable mAudioSamplingFrequency
uint32_t mAudioSamplingFrequency = 0;
Updated on 2022-11-17 at 15:40:06 +0100
2 - ControlDataCommon::ConnectionStatus
ControlDataCommon::ConnectionStatus
Connection status struct containing information about a connection event.
#include <ControlDataCommon.h>
Public Functions
Public Attributes
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;
variable mIP
variable mPort
Updated on 2022-11-17 at 15:40:06 +0100
3 - 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
The actual message.
variable mFromUUID
The ID of the request this is a response to.
Updated on 2022-11-17 at 15:40:06 +0100
4 - 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
Public Attributes Documentation
variable mMessage
std::vector< uint8_t > mMessage;
variable mFromUUID
The actual message.
Updated on 2022-11-17 at 15:40:06 +0100
5 - ControlDataReceiver
ControlDataReceiver
A ControlDataReceiver can receive messages from a sender or another ControlDataReceiver 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 <ControlDataReceiver.h>
Public Classes
Public Functions
Detailed Description
class ControlDataReceiver;
A ControlDataReceiver can receive messages from a sender or another ControlDataReceiver 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.
A ControlDataReceiver 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 ControlDataReceiver
Default constructor, creates an empty object.
function ~ControlDataReceiver
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 ControlDataReceiver 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:
Return: True on success, false otherwise
function sendStatusMessageToSender
bool sendStatusMessageToSender(
const std::vector< uint8_t > & message
)
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
bool sendRequestToReceivers(
const std::vector< uint8_t > & request,
uint64_t & requestId
)
Send a request to the connected ControlDataReceivers asynchronously. This request will only be sent to ControlDataReceivers on the receiving 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 ControlDataReceiver
ControlDataReceiver(
ControlDataReceiver const &
) =delete
function operator=
ControlDataReceiver & operator=(
ControlDataReceiver const &
) =delete
function getVersion
static std::string getVersion()
Get application version.
Return: a string with the current version, e.g. “1.0.0”
function getBuildInfo
static std::string getBuildInfo()
Get application build information.
Return: a string with the current build information such as git hashes of all direct dependencies
Updated on 2022-11-17 at 15:40:06 +0100
6 - ControlDataReceiver::IncomingRequest
ControlDataReceiver::IncomingRequest
An incoming request to this ControlDataReceiver.
#include <ControlDataReceiver.h>
Public Attributes
Public Attributes Documentation
variable mMessage
std::vector< uint8_t > mMessage;
variable mSenderUUID
The actual message.
variable mRequesterUUID
std::string mRequesterUUID;
UUID of the sender/forwarder that sent the request to this ControlDataReceiver.
variable mRequestID
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 2022-11-17 at 15:40:06 +0100
7 - ControlDataReceiver::ReceiverResponse
ControlDataReceiver::ReceiverResponse
A response message to a request.
#include <ControlDataReceiver.h>
Public Attributes
Public Attributes Documentation
variable mMessage
std::vector< uint8_t > mMessage;
Updated on 2022-11-17 at 15:40:06 +0100
8 - ControlDataReceiver::Settings
ControlDataReceiver::Settings
Settings for a ControlDataReceiver.
#include <ControlDataReceiver.h>
Public Attributes
Public Attributes Documentation
variable mPreviewIncomingRequestCallback
std::function< void(const IncomingRequest &)> mPreviewIncomingRequestCallback;
Callback called as soon as this ControlDataReceiver gets the request, as a “preview” of what requests will be delievered.
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 2022-11-17 at 15:40:06 +0100
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
Public Functions
Public Functions Documentation
function ControlDataSender
Default constructor, creates an empty object.
function ~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.
Parameters:
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 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. “1.0.0”
function getGitRevision
static std::string getGitRevision()
Get git revision which application was built on.
Return: a string with the current git revision, e.g. “v2.1.0-231-gcd012ab”, followed by “-dirty” in case there are changes made to the Git repo.
function getBuildInfo
static std::string getBuildInfo()
Get application build information.
Return: a string with the current build information such as git hashes of all direct dependencies
Updated on 2022-11-17 at 15:40:06 +0100
10 - ControlDataSender::Settings
ControlDataSender::Settings
Settings for a ControlDataSender.
#include <ControlDataSender.h>
Public Attributes
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 2022-11-17 at 15:40:06 +0100
11 - DeviceMemory
DeviceMemory
RAII class for a CUDA memory buffer.
#include <DeviceMemory.h>
Public Functions
Public Functions Documentation
function DeviceMemory
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
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 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 freeMemory
Free the device memory held by this class. Calling this when no memory is allocated is a no-op.
Return: True in case the memory was successfully freed (or not allocated to begin with), false otherwise.
function ~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 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 2022-11-17 at 15:40:06 +0100
12 - IngestApplication
IngestApplication
Public Classes
Public Functions
Public Functions Documentation
function IngestApplication
Constructor, creates an empty IngestApplication without starting it.
function ~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
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. “1.0.0”
function getGitRevision
static std::string getGitRevision()
Get git revision which application was built on.
Return: a string with the current git revision, e.g. “v1.0.0”, or “v2.1.0-231-gcd012ab”
function getBuildInfo
static std::string getBuildInfo()
Get application build information.
Return: a string with the current build information such as git hashes of all direct dependencies
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 2022-11-17 at 15:40:06 +0100
13 - IngestApplication::Settings
IngestApplication::Settings
Public Attributes
Public Attributes Documentation
variable mDebugAudio
bool mDebugAudio = false;
variable mDebugVideo
bool mDebugVideo = false;
Updated on 2022-11-17 at 15:40:06 +0100
14 - 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. An ISystemControllerInterface can have a parent-child relationship with other interfaces, where the children are aware of which their parent interface is. This is useful for components that provides extra features for another component, but where the components are still to be considered as two separate entities with separate connections to the System controller.
#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} 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
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 | |
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 sendRequest
virtual Response sendRequest(
const std::string & request,
const nlohmann::json & parameters
) =0
Send a request with some JSON parameters to the controller and await the response.
Parameters:
- request The name of the request command
- parameters The parameters part of the JSON message
Return: The response from the controller.
Reimplemented by: SystemControllerConnection::sendRequest
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
function hasParent
virtual bool hasParent() const =0
Return: True if this component has a parent ISystemControllerInterface, false otherwise
Reimplemented by: SystemControllerConnection::hasParent
function getParentInterface
virtual std::shared_ptr< ISystemControllerInterface > getParentInterface() const =0
Return: A pointer to parent’s ISystemControllerInterface, if any. Returns nullptr in case there is no parent
Reimplemented by: SystemControllerConnection::getParentInterface
Updated on 2022-11-17 at 15:40:06 +0100
15 - 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
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 2022-11-17 at 15:40:06 +0100
16 - 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
Public Attributes Documentation
variable mCode
variable mParameters
nlohmann::json mParameters;
Updated on 2022-11-17 at 15:40:06 +0100
17 - 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
Public Types
| Name |
---|
enum class | TallyBorderColor { kNone, kRed, kGreen, kYellow} Available colors for tally border in multi view. |
Public Functions
Public Types Documentation
enum TallyBorderColor
Enumerator | Value | Description |
---|
kNone | | |
kRed | | |
kGreen | | |
kYellow | | |
Available colors for tally border in multi view.
Public Functions Documentation
Default constructor.
Default destructor.
function start
bool start(
const std::shared_ptr< ISystemControllerInterface > & controllerInterface,
const Settings & settings
)
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.
- settings The settings to use for the MediaReceiver.
Return: True if the MediaReceiver was started successfully, false otherwise.
function 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.
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.
Precondition: The DataFrames sent to this function must have the same pixel format as this MediaReceiver is configured to deliver to the Rendering Engine,
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
MediaReceiver(
MediaReceiver const &
) =delete
MediaReceiver is neither copyable nor movable.
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. “1.0.0”
function getBuildInfo
static std::string getBuildInfo()
Get application build information.
Return: a string with the current build information such as git hashes of all direct dependencies
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 2022-11-17 at 15:40:06 +0100
18 - MediaReceiver::NewStreamParameters
A struct containing information on the format of an incoming stream.
#include <MediaReceiver.h>
Public Attributes
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 2022-11-17 at 15:40:06 +0100
19 - MediaReceiver::Settings
Settings for a MediaReceiver.
#include <MediaReceiver.h>
Public Attributes
Public Attributes Documentation
AlignedFrame::PixelFormat mDecodedFormat = AlignedFrame::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.
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 mUseMultiViewer
bool mUseMultiViewer = false;
variable mDebugAudio
bool mDebugAudio = false;
Set to true if this MediaReceiver should have a multi-view generator.
variable mDebugVideo
bool mDebugVideo = false;
Insert a 1500 Hz sound at every other turn to a new second according to TAI.
variable mDeliverOld
bool mDeliverOld = false;
Print the timestamp in the picture.
Updated on 2022-11-17 at 15:40:06 +0100
20 - MediaStreamer
MediaStreamer is a class that can take a single stream of uncompressed video and/or audio frames and encode and output it in some way to some interface. This interface 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 <MediaStreamer.h>
Public Classes
Public Functions
Detailed Description
MediaStreamer is a class that can take a single stream of uncompressed video and/or audio frames and encode and output it in some way to some interface. This interface 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
Default constructor.
Destructor. This will stop the output stream if not already done by calling.
See: stop.
bool configure(
const std::shared_ptr< ISystemControllerInterface > & controllerInterface
)
Configure this MediaStreamer and connect it to the System controller. This must be called before any call to the.
Parameters:
- controllerInterface The interface to the System controller, used for communicating with this MediaStreamer
See:
Return: True if the streamer was successfully connected to the System controller
bool setInputFormatAndStart(
const Configuration & configuration
)
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
bool stopAndResetFormat()
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 the format reset, or if the format was not set before this method was called, false on error.
bool hasFormatAndIsRunning() const
Return: True if the input format is set and the OutputStreamer is running, false otherwise
function hasOpenOutputStream
bool hasOpenOutputStream() const
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
bool outputData(
const AlignedFramePtr & frame
)
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
function getVersion
static std::string getVersion()
Get application version.
Return: a string with the current version, e.g. “1.0.0”
function getBuildInfo
static std::string getBuildInfo()
Get application build information.
Return: a string with the current build information such as git hashes of all direct dependencies
Updated on 2022-11-17 at 15:40:06 +0100
21 - MediaStreamer::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 <MediaStreamer.h>
Public Attributes
Public Attributes Documentation
AlignedFrame::PixelFormat mIncomingPixelFormat = AlignedFrame::PixelFormat::kUnknown;
variable mWidth
variable mHeight
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 2022-11-17 at 15:40:06 +0100
22 - PipelineSystemControllerInterfaceFactory
PipelineSystemControllerInterfaceFactory
Public Functions
Public Functions Documentation
function PipelineSystemControllerInterfaceFactory
PipelineSystemControllerInterfaceFactory(
const std::string & systemControllerIP,
uint16_t systemControllerPort,
const std::string & systemControllerPostfix,
const std::string & psk,
const std::string & myIP,
bool useHTTPS,
bool allowInsecureHTTPS
)
Constructor.
Parameters:
- systemControllerIP The IP address of the System controller to connect to.
- systemControllerPort The network port of the System controller to connect to.
- systemControllerPostfix The postfix of the System controller’s address, to chose which API endpoints to use.
- psk The Pre-shared key used for authorization at the System controller.
- myIP The public IP address of the pipeline, i.e. the external IP used to connect to the pipeline.
- useHTTPS If HTTPS should be used instead of HTTP
- allowInsecureHTTPS Set to true to allow self-signed HTTPS certificates. Should normally be false.
function PipelineSystemControllerInterfaceFactory
PipelineSystemControllerInterfaceFactory(
PipelineSystemControllerInterfaceFactory const &
) =delete
function PipelineSystemControllerInterfaceFactory
PipelineSystemControllerInterfaceFactory(
PipelineSystemControllerInterfaceFactory const &&
) =delete
function operator=
PipelineSystemControllerInterfaceFactory & operator=(
PipelineSystemControllerInterfaceFactory const &
) =delete
function operator=
PipelineSystemControllerInterfaceFactory & operator=(
PipelineSystemControllerInterfaceFactory const &&
) =delete
std::shared_ptr< SystemControllerConnection > getMediaReceiverInterface(
const std::string & name
)
Get the interface to the MediaReceiver. Multiple calls to this method will return the same interface. Internally the UUID is randomly generated and the correct type is set.
Parameters:
- name The human readable name of the MediaReceiver to provide to the System controller
Return: A configured connection on success, otherwise nullptr
std::shared_ptr< SystemControllerConnection > createMediaStreamerInterface(
const std::string & name
)
Create a new SystemControllerInterface to a MediaStreamer. Multiple calls to this method will return new interfaces each time. Internally the UUID is randomly generated, the correct type is set and the MediaReceiver is set as parent. The.
Parameters:
- name The human readable name of the MediaStreamer to provide to the System controller
See: getMediaReceiverInterface must be called before this method is called
Return: A configured connection on success, otherwise nullptr
function createControlReceiverInterface
std::shared_ptr< SystemControllerConnection > createControlReceiverInterface(
const std::string & name
)
Create a new SystemControllerInterface to a ControlReceiver. Multiple calls to this method will return new interfaces each time. Internally the UUID is randomly generated, the correct type is set and the MediaReceiver is set as parent. The.
Parameters:
- name The human readable name of the ControlReceiver to provide to the System controller
See: getMediaReceiverInterface must be called before this method is called to generate the parent interface.
Return: A configured connection on success, otherwise nullptr
Updated on 2022-11-17 at 15:40:06 +0100
23 - 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
Public Types
| Name |
---|
enum class uint32_t | ComponentType { kIngest, kMediaReceiver, kMediaStreamer, kControlDataReceiver, kControlDataSender} Enumeration of component types the component using this SystemControllerConnection can tell the System Controller to be seen as. |
Public Functions
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} 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
Public Types Documentation
enum ComponentType
Enumerator | Value | Description |
---|
kIngest | | |
kMediaReceiver | | |
kMediaStreamer | | |
kControlDataReceiver | | |
kControlDataSender | | |
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
bool configure(
const Settings & settings,
const std::shared_ptr< ISystemControllerInterface > & parentInterface =nullptr
)
Configure this connection. This method should be called before calling.
Parameters:
- settings The settings to use when connecting to the server
- parentInterface Optional parent interface that this interface is a child of. Setting this to nullptr means that this interface does not have a parent interface
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 sendRequest
virtual Response sendRequest(
const std::string & request,
const nlohmann::json & parameters
) override
Send a JSON object to the system controller server and awaits the response.
Parameters:
- request The name of the request command
- parameters The parameters part of the JSON message
Return: The response from the controller
Note: The status code might be TIMEOUT in case no response was received within the timeframe
Reimplements: ISystemControllerInterface::sendRequest
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 hasParent
virtual bool hasParent() const override
Return: True if this component has a parent ISystemControllerInterface, false otherwise
Reimplements: ISystemControllerInterface::hasParent
function getParentInterface
virtual std::shared_ptr< ISystemControllerInterface > getParentInterface() const override
Return: A pointer to parent’s ISystemControllerInterface, if any. Returns nullptr in case there is no parent
Reimplements: ISystemControllerInterface::getParentInterface
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 2022-11-17 at 15:40:06 +0100
24 - SystemControllerConnection::Settings
SystemControllerConnection::Settings
Settings for a SystemControllerConnection.
#include <SystemControllerConnection.h>
Public Attributes
Public Attributes Documentation
variable mSystemControllerIP
std::string mSystemControllerIP;
variable mSystemControllerPort
uint16_t mSystemControllerPort;
variable mSystemControllerPostfix
std::string mSystemControllerPostfix;
variable mPSK
variable mUUID
variable mType
variable mName
variable mMyIP
variable mConnectTimeout
std::chrono::milliseconds mConnectTimeout {
3000};
variable mEnableHTTPS
variable mInsecureHTTPS
Updated on 2022-11-17 at 15:40:06 +0100
25 - TimeCommon::TAIStatus
TimeCommon::TAIStatus
Public Attributes
Public Attributes Documentation
variable mStratum
StratumLevel mStratum = StratumLevel::UnknownStratum;
variable mHasLock
Updated on 2022-11-17 at 15:40:06 +0100
26 - TimeCommon::TimeStructure
TimeCommon::TimeStructure
Public Attributes
Public Attributes Documentation
variable t1
variable t2
variable t3
variable t4
variable token
variable dummy1
variable dummy2
variable dummy3
Updated on 2022-11-17 at 15:40:06 +0100