View on GitHub

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2022-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef NVNMOS_H
#define NVNMOS_H
 
#define NVNMOS_VERSION_MAJOR 0
#define NVNMOS_VERSION_MINOR 2
#define NVNMOS_VERSION_PATCH 0
#define NVNMOS_VERSION_PRERELEASE "alpha"
#define NVNMOS_VERSION_STRING "0.2.0-alpha"
 
#if defined(NVNMOS_EXPORTS)
 
#if defined(_WIN32) || defined(__CYGWIN__)
#define NVNMOS_API __declspec(dllexport)
#elif defined(__GNUC__) && (__GNUC__ >= 4)
#define NVNMOS_API __attribute__ ((visibility("default")))
#else
#define NVNMOS_API
#endif
 
#elif defined(NVNMOS_STATIC)
 
#define NVNMOS_API
 
#else
 
#if defined(_WIN32) || defined(__CYGWIN__)
#define NVNMOS_API __declspec(dllimport)
#elif defined(__GNUC__) && (__GNUC__ >= 4)
#define NVNMOS_API
#else
#define NVNMOS_API
#endif
 
#endif
 
#include <stdbool.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
typedef struct _NvNmosVersion
{
    unsigned int major;
    unsigned int minor;
    unsigned int patch;
    const char *prerelease;
    const char *string;
} NvNmosVersion;
 
NVNMOS_API
bool nmos_get_version(
    NvNmosVersion *version);
 
static inline bool nmos_is_compatible_version(
    const NvNmosVersion *version)
{
    return version->major == NVNMOS_VERSION_MAJOR
        && (NVNMOS_VERSION_MAJOR == 0
            ? version->minor == NVNMOS_VERSION_MINOR
            : version->minor >= NVNMOS_VERSION_MINOR);
}
 
#define NVNMOS_ID_LEN 37
 
typedef struct _NvNmosNodeServer NvNmosNodeServer;
 
typedef enum _NvNmosTransport
{
    NVNMOS_TRANSPORT_RTP = 0,
    NVNMOS_TRANSPORT_MXL = 1
} NvNmosTransport;
 
typedef enum _NvNmosSide
{
    NVNMOS_SIDE_SENDER = 0,
    NVNMOS_SIDE_RECEIVER = 1
} NvNmosSide;
 
typedef enum _NvNmosResourceType
{
    NVNMOS_RESOURCE_NODE = 0,
    NVNMOS_RESOURCE_DEVICE = 1,
    NVNMOS_RESOURCE_SOURCE = 2,
    NVNMOS_RESOURCE_FLOW = 3,
    NVNMOS_RESOURCE_SENDER = 4,
    NVNMOS_RESOURCE_RECEIVER = 5
} NvNmosResourceType;
 
typedef bool (* nmos_connection_activation_callback)(
    NvNmosNodeServer *server,
    NvNmosSide side,
    const char *name,
    const char *transport_file);
 
typedef struct _NvNmosChannelMappingActiveMapEntry NvNmosChannelMappingActiveMapEntry;
 
typedef bool (* nmos_channelmapping_activation_callback)(
    NvNmosNodeServer *server,
    const char *name,
    const char *output_id,
    const NvNmosChannelMappingActiveMapEntry *active_map,
    size_t num_active_map);
 
typedef enum _NvNmosUpdate
{
    NVNMOS_UPDATE_UNCHANGED = 0,
    NVNMOS_UPDATE_SET = 1,
    NVNMOS_UPDATE_RESET = 2
} NvNmosUpdate;
 
typedef struct _NvNmosTag
{
    const char *key;
    NvNmosUpdate values_update;
    const char **values;
    unsigned int num_values;
} NvNmosTag;
 
typedef struct _NvNmosAnnotation
{
    NvNmosUpdate label_update;
    const char *label;
    NvNmosUpdate description_update;
    const char *description;
    NvNmosUpdate tags_update;
    const NvNmosTag *tags;
    unsigned int num_tags;
} NvNmosAnnotation;
 
typedef bool (* nmos_annotation_update_callback)(
    NvNmosNodeServer *server,
    NvNmosResourceType type,
    const char *name,
    const NvNmosAnnotation *annotation);
 
enum {
    NVNMOS_LOG_DEVEL = -40,
    NVNMOS_LOG_VERBOSE = -10,
    NVNMOS_LOG_INFO = 0,
    NVNMOS_LOG_WARNING = 10,
    NVNMOS_LOG_ERROR = 20,
    NVNMOS_LOG_SEVERE = 30,
    NVNMOS_LOG_FATAL = 40
};
 
typedef void (* nmos_logging_callback)(
    NvNmosNodeServer *server,
    const char *categories,
    int level,
    const char *message);
 
typedef struct _NvNmosAssetConfig NvNmosAssetConfig;
typedef struct _NvNmosReceiverConfig NvNmosReceiverConfig;
typedef struct _NvNmosSenderConfig NvNmosSenderConfig;
typedef struct _NvNmosNetworkServicesConfig NvNmosNetworkServicesConfig;
 
typedef struct _NvNmosNodeConfig
{
    const char *host_name;
    const char **host_addresses;
    unsigned int num_host_addresses;
    unsigned int http_port;
 
    const char* label;
    const char* description;
 
    NvNmosAssetConfig* asset_tags;
 
    const char *seed;
 
    NvNmosReceiverConfig *receivers;
    unsigned int num_receivers;
    NvNmosSenderConfig *senders;
    unsigned int num_senders;
 
    nmos_connection_activation_callback connection_activated;
 
    nmos_channelmapping_activation_callback channelmapping_activated;
 
    const NvNmosAnnotation *node_annotation;
    const NvNmosAnnotation *device_annotation;
 
    nmos_annotation_update_callback annotation_updated;
 
    nmos_logging_callback log_callback;
    int log_level;
    const char **log_categories;
    unsigned int num_log_categories;
 
    NvNmosNetworkServicesConfig* network_services;
} NvNmosNodeConfig;
 
typedef struct _NvNmosAssetConfig
{
    const char* manufacturer;
    const char* product;
    const char* instance_id;
    const char** functions;
    unsigned int num_functions;
} NvNmosAssetConfig;
 
typedef struct _NvNmosReceiverConfig
{
    NvNmosTransport transport;
    const char *transport_file;
    const NvNmosAnnotation *receiver_annotation;
} NvNmosReceiverConfig;
 
typedef struct _NvNmosSenderConfig
{
    NvNmosTransport transport;
    const char *transport_file;
    const NvNmosAnnotation *source_annotation;
    const NvNmosAnnotation *flow_annotation;
    const NvNmosAnnotation *sender_annotation;
} NvNmosSenderConfig;
 
typedef struct _NvNmosNetworkServicesConfig
{
    const char* domain;
 
    const char* registration_address;
    unsigned int registration_port;
    const char* registration_version;
 
    const char* system_address;
    unsigned int system_port;
    const char* system_version;
} NvNmosNetworkServicesConfig;
 
typedef struct _NvNmosNodeServer
{
    void *user_data;
    void *impl;
} NvNmosNodeServer;
 
NVNMOS_API
bool create_nmos_node_server(
    const NvNmosNodeConfig *config,
    NvNmosNodeServer *server);
 
NVNMOS_API
bool destroy_nmos_node_server(
    NvNmosNodeServer *server);
 
NVNMOS_API
bool add_nmos_receiver_to_node_server(
    NvNmosNodeServer *server,
    const NvNmosReceiverConfig* config);
 
NVNMOS_API
bool remove_nmos_receiver_from_node_server(
    NvNmosNodeServer *server,
    const char* receiver_name);
 
NVNMOS_API
bool add_nmos_sender_to_node_server(
    NvNmosNodeServer *server,
    const NvNmosSenderConfig* config);
 
NVNMOS_API
bool remove_nmos_sender_from_node_server(
    NvNmosNodeServer *server,
    const char* sender_name);
 
NVNMOS_API
bool nmos_connection_activate(
    NvNmosNodeServer *server,
    NvNmosSide side,
    const char *name,
    const char *transport_file);
 
NVNMOS_API
bool nmos_annotation_update(
    NvNmosNodeServer *server,
    NvNmosResourceType type,
    const char *name,
    const NvNmosAnnotation *annotation);
 
typedef enum _NvNmosChannelMappingParentType
{
    NVNMOS_CHANNELMAPPING_PARENT_TYPE_RECEIVER = 0,
    NVNMOS_CHANNELMAPPING_PARENT_TYPE_SOURCE = 1
} NvNmosChannelMappingParentType;
 
typedef struct _NvNmosChannelMappingInput
{
    const char *id;
    const char *name;
    const char *description;
    const char **channel_labels;
    size_t num_channel_labels;
    const char *parent_name;
    NvNmosChannelMappingParentType parent_type;
    bool reordering;
    unsigned int block_size;
} NvNmosChannelMappingInput;
 
typedef struct _NvNmosChannelMappingOutput
{
    const char *id;
    const char *name;
    const char *description;
    const char **channel_labels;
    size_t num_channel_labels;
    const char *sender_name;
    const char **routable_inputs;
    size_t num_routable_inputs;
} NvNmosChannelMappingOutput;
 
typedef struct _NvNmosChannelMappingActiveMapEntry
{
    const char *input_id;
    unsigned int input_channel;
} NvNmosChannelMappingActiveMapEntry;
 
typedef struct _NvNmosChannelMappingConfig
{
    const NvNmosChannelMappingInput *inputs;
    size_t num_inputs;
    const NvNmosChannelMappingOutput *outputs;
    size_t num_outputs;
} NvNmosChannelMappingConfig;
 
NVNMOS_API
bool add_nmos_channelmapping_to_node_server(
    NvNmosNodeServer *server,
    const char *name,
    const NvNmosChannelMappingConfig *mapping);
 
NVNMOS_API
bool remove_nmos_channelmapping_from_node_server(
    NvNmosNodeServer *server,
    const char *name);
 
NVNMOS_API
bool nmos_channelmapping_activate(
    NvNmosNodeServer *server,
    const char *name,
    const char *output_id,
    const NvNmosChannelMappingActiveMapEntry *active_map,
    size_t num_active_map);
 
NVNMOS_API
bool nmos_make_node_id(
    const char *seed,
    char *out,
    size_t out_len);
 
NVNMOS_API
bool nmos_make_device_id(
    const char *seed,
    char *out,
    size_t out_len);
 
NVNMOS_API
bool nmos_make_sender_id(
    const char *seed,
    const char *sender_name,
    char *out,
    size_t out_len);
 
NVNMOS_API
bool nmos_make_receiver_id(
    const char *seed,
    const char *receiver_name,
    char *out,
    size_t out_len);
 
NVNMOS_API
bool nmos_make_source_id(
    const char *seed,
    const char *sender_name,
    char *out,
    size_t out_len);
 
NVNMOS_API
bool nmos_make_flow_id(
    const char *seed,
    const char *sender_name,
    char *out,
    size_t out_len);
 
NVNMOS_API
bool nmos_get_node_id(
    const NvNmosNodeServer *server,
    char *out,
    size_t out_len);
 
NVNMOS_API
bool nmos_get_device_id(
    const NvNmosNodeServer *server,
    char *out,
    size_t out_len);
 
NVNMOS_API
bool nmos_get_sender_id(
    const NvNmosNodeServer *server,
    const char *sender_name,
    char *out,
    size_t out_len);
 
NVNMOS_API
bool nmos_get_receiver_id(
    const NvNmosNodeServer *server,
    const char *receiver_name,
    char *out,
    size_t out_len);
 
NVNMOS_API
bool nmos_get_source_id(
    const NvNmosNodeServer *server,
    const char *sender_name,
    char *out,
    size_t out_len);
 
NVNMOS_API
bool nmos_get_flow_id(
    const NvNmosNodeServer *server,
    const char *sender_name,
    char *out,
    size_t out_len);
 
NVNMOS_API
bool nmos_make_id(
    const char *seed,
    NvNmosResourceType type,
    const char *name,
    char *out,
    size_t out_len);
 
NVNMOS_API
bool nmos_get_id(
    const NvNmosNodeServer *server,
    NvNmosResourceType type,
    const char *name,
    char *out,
    size_t out_len);
 
#ifdef __cplusplus
}
#endif
 
#endif