enums_anc.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <promeki/namespace.h>
#include <promeki/enum.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class AncCategory : public TypedEnum<AncCategory> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("AncCategory", "Ancillary Data Category", 0,
                                           {"Unknown", 0, "Unknown"}, {"Captions", 1, "Closed Captions"},
                                           {"Timecode", 2, "Timecode (ATC LTC / VITC)"},
                                           {"Splice", 3, "Splice Markers (SCTE-104 / 35)"},
                                           {"Aspect", 4, "Aspect / AFD"}, {"Hdr", 5, "HDR Metadata"},
                                           {"AudioMetadata", 6, "Audio Metadata"},
                                           {"Display", 7, "Display Hints"},
                                           {"Geolocation", 8, "Geolocation (MISB KLV)"},
                                           {"PayloadId", 9, "Payload Identifier (SMPTE ST 352)"},
                                           {"UserDefined", 10, "User Defined"}, {"Subtitles", 11, "Subtitles (RDD 8 / OP-47)"},
                                           {"Klv", 12, "KLV Metadata (SMPTE ST 336)"}, {"Sei", 13, "SEI User Data"},
                                           {"Vbi", 14, "VBI / Line-21 (ST 2031)"},
                                           {"Control", 15, "Control / Management"}); // default: Unknown
 
                using TypedEnum<AncCategory>::TypedEnum;
 
                static const AncCategory Unknown;
                static const AncCategory Captions;
                static const AncCategory Timecode;
                static const AncCategory Splice;
                static const AncCategory Aspect;
                static const AncCategory Hdr;
                static const AncCategory AudioMetadata;
                static const AncCategory Display;
                static const AncCategory Geolocation;
                static const AncCategory PayloadId;
                static const AncCategory UserDefined;
                static const AncCategory Subtitles;
                static const AncCategory Klv;
                static const AncCategory Sei;
                static const AncCategory Vbi;
                static const AncCategory Control;
};
 
inline const AncCategory AncCategory::Unknown{0};
inline const AncCategory AncCategory::Captions{1};
inline const AncCategory AncCategory::Timecode{2};
inline const AncCategory AncCategory::Splice{3};
inline const AncCategory AncCategory::Aspect{4};
inline const AncCategory AncCategory::Hdr{5};
inline const AncCategory AncCategory::AudioMetadata{6};
inline const AncCategory AncCategory::Display{7};
inline const AncCategory AncCategory::Geolocation{8};
inline const AncCategory AncCategory::PayloadId{9};
inline const AncCategory AncCategory::UserDefined{10};
inline const AncCategory AncCategory::Subtitles{11};
inline const AncCategory AncCategory::Klv{12};
inline const AncCategory AncCategory::Sei{13};
inline const AncCategory AncCategory::Vbi{14};
inline const AncCategory AncCategory::Control{15};
 
class AncTransport : public TypedEnum<AncTransport> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("AncTransport", "Ancillary Data Transport", 0,
                                           {"Invalid", 0, "Invalid"}, {"St291", 1, "SMPTE ST 291 Packet"},
                                           {"NdiXml", 2, "NDI Metadata (XML)"},
                                           {"RtmpAmf", 3, "RTMP AMF0 Script Tag"},
                                           {"HdmiInfoFrame", 4, "HDMI InfoFrame"},
                                           {"MpegTsPrivate", 5, "MPEG-TS Private Section"},
                                           {"HlsSei", 6, "HLS SEI User Data"}); // default: Invalid
 
                using TypedEnum<AncTransport>::TypedEnum;
 
                static const AncTransport Invalid;
                static const AncTransport St291;
                static const AncTransport NdiXml;
                static const AncTransport RtmpAmf;
                static const AncTransport HdmiInfoFrame;
                static const AncTransport MpegTsPrivate;
                static const AncTransport HlsSei;
};
 
inline const AncTransport AncTransport::Invalid{0};
inline const AncTransport AncTransport::St291{1};
inline const AncTransport AncTransport::NdiXml{2};
inline const AncTransport AncTransport::RtmpAmf{3};
inline const AncTransport AncTransport::HdmiInfoFrame{4};
inline const AncTransport AncTransport::MpegTsPrivate{5};
inline const AncTransport AncTransport::HlsSei{6};
 
class AncTransmissionModel : public TypedEnum<AncTransmissionModel> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("AncTransmissionModel", "ST 2110-40 Transmission Model", 0,
                                           {"Unsignalled", 0, "Unsignalled"},
                                           {"Lltm", 1, "Low-Latency Transmission Model (LLTM)"},
                                           {"Ctm", 2, "Compatible Transmission Model (CTM)"}); // default: Unsignalled
 
                using TypedEnum<AncTransmissionModel>::TypedEnum;
 
                static const AncTransmissionModel Unsignalled;
                static const AncTransmissionModel Lltm;
                static const AncTransmissionModel Ctm;
};
 
inline const AncTransmissionModel AncTransmissionModel::Unsignalled{0};
inline const AncTransmissionModel AncTransmissionModel::Lltm{1};
inline const AncTransmissionModel AncTransmissionModel::Ctm{2};
 
class AncFidelity : public TypedEnum<AncFidelity> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("AncFidelity", "Translator Output Fidelity", 0,
                                           {"Default", 0, "Default"}, {"Strict", 1, "Strict (Minimal Fields)"},
                                           {"Full", 2, "Full (All Optional Fields)"}); // default: Default
 
                using TypedEnum<AncFidelity>::TypedEnum;
 
                static const AncFidelity Default;
                static const AncFidelity Strict;
                static const AncFidelity Full;
};
 
inline const AncFidelity AncFidelity::Default{0};
inline const AncFidelity AncFidelity::Strict{1};
inline const AncFidelity AncFidelity::Full{2};
 
class AncDetailSeverity : public TypedEnum<AncDetailSeverity> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("AncDetailSeverity", "ANC Detail Severity", 0,
                                           {"Info", 0, "Info"}, {"Warning", 1, "Warning"},
                                           {"Error", 2, "Error"}); // default: Info
 
                using TypedEnum<AncDetailSeverity>::TypedEnum;
 
                static const AncDetailSeverity Info;
                static const AncDetailSeverity Warning;
                static const AncDetailSeverity Error;
};
 
inline const AncDetailSeverity AncDetailSeverity::Info{0};
inline const AncDetailSeverity AncDetailSeverity::Warning{1};
inline const AncDetailSeverity AncDetailSeverity::Error{2};
 
class AncChecksumPolicy : public TypedEnum<AncChecksumPolicy> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("AncChecksumPolicy", "Checksum Policy", 0,
                                           {"PreserveOrRecompute", 0, "Preserve or Recompute"},
                                           {"AlwaysRecompute", 1, "Always Recompute"},
                                           {"StrictValidate", 2, "Strict Validate"}); // default: PreserveOrRecompute
 
                using TypedEnum<AncChecksumPolicy>::TypedEnum;
 
                static const AncChecksumPolicy PreserveOrRecompute;
                static const AncChecksumPolicy AlwaysRecompute;
                static const AncChecksumPolicy StrictValidate;
};
 
inline const AncChecksumPolicy AncChecksumPolicy::PreserveOrRecompute{0};
inline const AncChecksumPolicy AncChecksumPolicy::AlwaysRecompute{1};
inline const AncChecksumPolicy AncChecksumPolicy::StrictValidate{2};
 
class AncOnUnsupported : public TypedEnum<AncOnUnsupported> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("AncOnUnsupported", "On Unsupported Input", 1,
                                           {"Skip", 0, "Skip"}, {"BestEffort", 1, "Best Effort"},
                                           {"Fail", 2, "Fail"}); // default: BestEffort
 
                using TypedEnum<AncOnUnsupported>::TypedEnum;
 
                static const AncOnUnsupported Skip;
                static const AncOnUnsupported BestEffort;
                static const AncOnUnsupported Fail;
};
 
inline const AncOnUnsupported AncOnUnsupported::Skip{0};
inline const AncOnUnsupported AncOnUnsupported::BestEffort{1};
inline const AncOnUnsupported AncOnUnsupported::Fail{2};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE