enums_mediaio.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 MediaIOOpenMode : public TypedEnum<MediaIOOpenMode> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("MediaIOOpenMode", "Open Mode", 0,
                                           {"Read", 0, "Read"}, {"Write", 1, "Write"}); // default: Read
 
                using TypedEnum<MediaIOOpenMode>::TypedEnum;
 
                static const MediaIOOpenMode Read;
                static const MediaIOOpenMode Write;
};
 
inline const MediaIOOpenMode MediaIOOpenMode::Read{0};
inline const MediaIOOpenMode MediaIOOpenMode::Write{1};
 
class MediaIODirection : public TypedEnum<MediaIODirection> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("MediaIODirection", "MediaIO Direction", 0,
                                           {"Source", 0, "Source"}, {"Sink", 1, "Sink"},
                                           {"Transform", 2, "Transform"}); // default: Source
 
                using TypedEnum<MediaIODirection>::TypedEnum;
 
                static const MediaIODirection Source;
                static const MediaIODirection Sink;
                static const MediaIODirection Transform;
};
 
inline const MediaIODirection MediaIODirection::Source{0};
inline const MediaIODirection MediaIODirection::Sink{1};
inline const MediaIODirection MediaIODirection::Transform{2};
 
class MediaPayloadKind : public TypedEnum<MediaPayloadKind> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("MediaPayloadKind", "Payload Kind", 0,
                                           {"Video", 0, "Video"}, {"Audio", 1, "Audio"},
                                           {"Metadata", 2, "Timed Metadata"}, {"Subtitle", 3, "Subtitle / Caption"},
                                           {"AncillaryData", 4, "Ancillary Data"},
                                           {"Custom", 5, "Custom"}); // default: Video
 
                using TypedEnum<MediaPayloadKind>::TypedEnum;
 
                static const MediaPayloadKind Video;
                static const MediaPayloadKind Audio;
                static const MediaPayloadKind Metadata;
                static const MediaPayloadKind Subtitle;
                static const MediaPayloadKind AncillaryData;
                static const MediaPayloadKind Custom;
};
 
inline const MediaPayloadKind MediaPayloadKind::Video{0};
inline const MediaPayloadKind MediaPayloadKind::Audio{1};
inline const MediaPayloadKind MediaPayloadKind::Metadata{2};
inline const MediaPayloadKind MediaPayloadKind::Subtitle{3};
inline const MediaPayloadKind MediaPayloadKind::AncillaryData{4};
inline const MediaPayloadKind MediaPayloadKind::Custom{5};
 
class FrameType : public TypedEnum<FrameType> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("FrameType", "Frame Type", 0,
                                           {"Unknown", 0, "Unknown"}, {"I", 1, "Intra (I)"},
                                           {"P", 2, "Predicted (P)"}, {"B", 3, "Bidirectional (B)"},
                                           {"IDR", 4, "Instantaneous Decoder Refresh (IDR)"},
                                           {"BRef", 5, "Referenced B-Frame"}); // default: Unknown
 
                using TypedEnum<FrameType>::TypedEnum;
 
                static const FrameType Unknown;
                static const FrameType I;
                static const FrameType P;
                static const FrameType B;
                static const FrameType IDR;
                static const FrameType BRef;
};
 
inline const FrameType FrameType::Unknown{0};
inline const FrameType FrameType::I{1};
inline const FrameType FrameType::P{2};
inline const FrameType FrameType::B{3};
inline const FrameType FrameType::IDR{4};
inline const FrameType FrameType::BRef{5};
 
class QuickTimeLayout : public TypedEnum<QuickTimeLayout> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("QuickTimeLayout", "QuickTime Layout", 1,
                                           {"Classic", 0, "Classic (Single moov)"},
                                           {"Fragmented", 1, "Fragmented (moof / mdat)"}); // default: Fragmented
 
                using TypedEnum<QuickTimeLayout>::TypedEnum;
 
                static const QuickTimeLayout Classic;
                static const QuickTimeLayout Fragmented;
};
 
inline const QuickTimeLayout QuickTimeLayout::Classic{0};
inline const QuickTimeLayout QuickTimeLayout::Fragmented{1};
 
class QuickTimeCaptionReadPolicy : public TypedEnum<QuickTimeCaptionReadPolicy> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("QuickTimeCaptionReadPolicy", "QuickTime Caption Read Policy", 0,
                                           {"Auto", 0, "Auto (merge c608 only if ANC has no captions)"},
                                           {"VancOnly", 1, "VANC only (ignore the c608 track)"},
                                           {"CaptionTrackOnly", 2, "Caption track only (c608 is the caption source)"});
 
                using TypedEnum<QuickTimeCaptionReadPolicy>::TypedEnum;
 
                static const QuickTimeCaptionReadPolicy Auto;
                static const QuickTimeCaptionReadPolicy VancOnly;
                static const QuickTimeCaptionReadPolicy CaptionTrackOnly;
};
 
inline const QuickTimeCaptionReadPolicy QuickTimeCaptionReadPolicy::Auto{0};
inline const QuickTimeCaptionReadPolicy QuickTimeCaptionReadPolicy::VancOnly{1};
inline const QuickTimeCaptionReadPolicy QuickTimeCaptionReadPolicy::CaptionTrackOnly{2};
 
class MpegTsAacFraming : public TypedEnum<MpegTsAacFraming> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("MpegTsAacFraming", "MPEG-TS AAC Framing", 0,
                                           {"Adts", 0, "ADTS (stream_type 0x0F)"},
                                           {"Latm", 1, "LATM (stream_type 0x11)"}); // default: Adts
 
                using TypedEnum<MpegTsAacFraming>::TypedEnum;
 
                static const MpegTsAacFraming Adts;
                static const MpegTsAacFraming Latm;
};
 
inline const MpegTsAacFraming MpegTsAacFraming::Adts{0};
inline const MpegTsAacFraming MpegTsAacFraming::Latm{1};
 
class ImgSeqPathMode : public TypedEnum<ImgSeqPathMode> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("ImgSeqPathMode", "Image Sequence Path Mode", 0,
                                           {"Relative", 0, "Relative Path"},
                                           {"Absolute", 1, "Absolute Path"}); // default: Relative
 
                using TypedEnum<ImgSeqPathMode>::TypedEnum;
 
                static const ImgSeqPathMode Relative;
                static const ImgSeqPathMode Absolute;
};
 
inline const ImgSeqPathMode ImgSeqPathMode::Relative{0};
inline const ImgSeqPathMode ImgSeqPathMode::Absolute{1};
 
class SrtVideoPacing : public TypedEnum<SrtVideoPacing> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("SrtVideoPacing", "SRT Video Pacing", 0,
                                           {"Internal", 0, "Internal Wall Clock"},
                                           {"External", 1, "External Clock"},
                                           {"None", 2, "None (Unpaced)"}); // default: Internal
 
                using TypedEnum<SrtVideoPacing>::TypedEnum;
 
                static const SrtVideoPacing Internal;
                static const SrtVideoPacing External;
                static const SrtVideoPacing None;
};
 
inline const SrtVideoPacing SrtVideoPacing::Internal{0};
inline const SrtVideoPacing SrtVideoPacing::External{1};
inline const SrtVideoPacing SrtVideoPacing::None{2};
 
class SrtMode : public TypedEnum<SrtMode> {
        public:
                PROMEKI_REGISTER_ENUM_TYPE_DISPLAY("SrtMode", "SRT Mode", 0,
                                           {"Caller", 0, "Caller (dial out)"},
                                           {"Listener", 1, "Listener (accept one peer)"},
                                           {"Rendezvous", 2, "Rendezvous (peer-to-peer)"}); // default: Caller
 
                using TypedEnum<SrtMode>::TypedEnum;
 
                static const SrtMode Caller;
                static const SrtMode Listener;
                static const SrtMode Rendezvous;
};
 
inline const SrtMode SrtMode::Caller{0};
inline const SrtMode SrtMode::Listener{1};
inline const SrtMode SrtMode::Rendezvous{2};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE