Common.hpp

#pragma once
 
#include "audinate/dal/Types.hpp"
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
//Windows: Add inline specifier to the member functions to make it accessible outside the dal library
//Refer https://stackoverflow.com/questions/24511376/how-to-dllexport-a-class-derived-from-stdruntime-error
#ifdef _WIN32
    #define INLINE_STD_EXCEPTION inline
#else
    #define INLINE_STD_EXCEPTION
#endif
 
namespace Audinate { namespace DAL {
 
enum class ChannelDirection
{
    Tx,
    Rx
};
 
 
class Ipv4Address
{
public:
    Ipv4Address() : _() {}
    ~Ipv4Address() {}
 
    union
    {
        uint32_t addr32;
        uint8_t addr8[4];
    } _;
 
    bool operator==(const Ipv4Address & other) const { return _.addr32 == other._.addr32; }
    bool operator!=(const Ipv4Address & other) const { return !operator==(other); }
 
    std::string toString() const
    {
        return std::to_string(_.addr8[0]) + "." + std::to_string(_.addr8[1]) + "." + std::to_string(_.addr8[2]) + "." + std::to_string(_.addr8[3]);
    }
};
 
#ifdef _WIN32
class DalException : public std::exception
#else
class __attribute__((visibility("default"))) DalException : public std::exception
#endif
{
public:
    static DalException create(Error err, const std::string & description);
    static DalException create(const std::string & name, const std::string & description);
    ~DalException() {}
 
    INLINE_STD_EXCEPTION  Error getError() { return mError; }
    INLINE_STD_EXCEPTION  std::string getErrorName() const { return mErrorName; }
    INLINE_STD_EXCEPTION  std::string getErrorDescription() const { return mErrorDescription; }
 
private:
    Error mError;
    std::string mErrorName;
    std::string mErrorDescription;
 
    DalException(Error error, const std::string & errorName, const std::string & errorDescription);
};
 
class SocketDescriptor
{
public:
    enum class Type
    {
        None,
        Port,
        Path
    };
    SocketDescriptor() : mType(Type::None), mPortNum(), mSocketPath() {}
    SocketDescriptor(uint16_t portNum) : mType(Type::Port), mPortNum(portNum), mSocketPath() {}
    SocketDescriptor(std::string socketPath) : mType(Type::Path), mPortNum(), mSocketPath(socketPath) {}
 
    Type getType() const { return mType; }
    uint16_t getPortNumber() const { return mPortNum; }
    std::string getSocketPath() const { return mSocketPath; }
 
private:
    Type mType;
    uint16_t mPortNum;
    std::string mSocketPath;
};

std::string toString(SocketDescriptor socketDescriptor);
 

enum class Protocol
{
    // The protocol used for managing audio routing configuration from external controllers. Externally visible. Application specifies the port number for the local server.
    Arcp, 
 
    // The protocol used for managing audio routing configuration from embedded controllers. Not externally visible. Application specifies the port number for the local server.
    ArcpLocal,
 
    // A protocol used within Dante networks for creating and maintaining audio connections. Externally visible. Application specifies the port number for the local server.
    Dbcp,
 
    // The protocol used within Dante networks for creating and maintaining conmon channels connections. Externally visible. Application specifies the port number for the local server.
    Cmcp,
 
    // The protocol for sending conmon messages on the various channels. Externally visible. Application specifies a base port number for the local instance's channel ports. DAL instances uses a range of up to 10 port numbers starting from the base number.
    ConmonChannels,
 
    // The protocol for conmon clients (Including Embedded DAPI instances) to communicate with their local server. Not externally visible. Application specifies the port number for the local server.
    ConmonClient,
 
    // The protocol for dante components (including Embedded DAPI instances) to communicate with the device's domain proxy. Not externally visible. Application can specify the port number for the local server.
    DomainClientProxy,
 
    // Protocol for audio transport. Externally visible. Application specifies the port number for the local instance's server ports. DAL instances uses a range of up to 256 port numbers starting from the base number. This range may eventually be programatically configurable / queryable.
    AudioBase,
 
    // Protocol for websocket API server. Externally visible. Setting this to zero will result in the websocket API server using an ephemeral port. Setting this
    // to a non-zero value will result in the websocket API server using the given fixed port. In both cases the Instance::getProtocolSocketDescriptor API can be
    // used to retrieve the runtime value that the server ends up using.
    WebSocket
 
#ifdef _WIN32
    // The protocol used by mdns-enabled applications to communicate with the mdns server
    , MdnsClient
#endif
};

std::string toString(Protocol protocol);

enum class Component
{
    None, 
 
    // Multicast-based DNS discovery engine. Not required if a globally installed Dante Discovery instance is assumed
    Mdns,
 
    // The Dante Control & Monitoring Engine. 
    ConmonServer,
 
    // The Dante Audio Routing Configuration Engine.
    Apec,
 
    // A Precision Time Protocol instance. Only used when DAL uses PTP as its time source.
    Ptp
};
 
std::string toString(Component component);
 
enum class ComponentStatus
{
    // The instance is stopped and the component is stopped.
    Stopped,
 
    // The instance is running, the component is not required
    Unused,
 
    // The instance is running. The component is required but is not currently running
    Pending,
 
    // The instance is running and the component is running
    Running
};

std::string toString(ComponentStatus status);
 
 
enum class TimeSource
{
    // DAL will track time from the network via Ptp. Incoming audio streams are not required in order to track time.
    Ptp, 
 
    // DAL will track time from incoming Audio Packets. The DAL instance will not run a ptp child process.
    RxAudio 
};
 
enum class LogLevel
{
    None, 
    Error, 
    Warning, 
    Notice, 
    Info, 
    Debug
};
 
}; };