ancatc.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
#include <promeki/datatype.h>
#include <promeki/error.h>
#include <promeki/json.h>
#include <promeki/namespace.h>
#include <promeki/result.h>
#include <promeki/string.h>
#include <promeki/timecode.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
constexpr bool ancAtcIsPairHfrRate(uint32_t frameRateFps) {
        return frameRateFps == 48u || frameRateFps == 50u || frameRateFps == 60u;
}
 
constexpr bool ancAtcIsHfrtcRate(uint32_t frameRateFps) {
        return frameRateFps == 72u || frameRateFps == 96u || frameRateFps == 100u ||
               frameRateFps == 120u;
}
 
constexpr bool ancAtcIsHfrRate(uint32_t frameRateFps) {
        return ancAtcIsPairHfrRate(frameRateFps) || ancAtcIsHfrtcRate(frameRateFps);
}
 
class AncAtc {
        public:
                PROMEKI_DATATYPE(AncAtc, DataTypeAncAtc, 2)
 
                
                enum PayloadType : uint8_t {
                        Ltc       = 0x00, 
                        Vitc1     = 0x01, 
                        Vitc2     = 0x02, 
                        HfrtcBase = 0x80, 
                };
 
                struct VitcDbb2 {
                                uint8_t line       = 0; 
                                bool    duplicate  = false; 
                                bool    valid      = true;  
                                bool    processed  = true;  
                };
 
                struct HfrtcDbb2 {
                                uint8_t superFrameCount = 0; 
                                uint8_t n               = 0; 
                };
 
                AncAtc() = default;
 
                explicit AncAtc(const Timecode &tc) : _tc(tc) {}
 
                // -- Timecode --------------------------------------------
 
                const Timecode &timecode() const { return _tc; }
 
                void setTimecode(const Timecode &tc) { _tc = tc; }
 
                // -- Payload type (DBB1) ---------------------------------
 
                uint8_t payloadType() const { return _payloadType; }
 
                void setPayloadType(uint8_t v) { _payloadType = v; }
 
                bool isHfrtcPayload() const {
                        return _payloadType >= 0x80u && _payloadType <= 0x8Fu;
                }
 
                uint8_t hfrtcBitstream() const {
                        return isHfrtcPayload() ? static_cast<uint8_t>(_payloadType & 0x0Fu) : uint8_t{0};
                }
 
                // -- DBB2 ------------------------------------------------
 
                uint8_t dbb2() const { return _dbb2; }
 
                void setDbb2(uint8_t v) { _dbb2 = v; }
 
                static VitcDbb2 dbb2DecodeVitc(uint8_t b) {
                        VitcDbb2 r;
                        r.line      = static_cast<uint8_t>(b & 0x1Fu);
                        r.duplicate = (b & 0x20u) != 0u;
                        r.valid     = (b & 0x40u) == 0u;
                        r.processed = (b & 0x80u) == 0u;
                        return r;
                }
 
                static uint8_t dbb2EncodeVitc(uint8_t line, bool duplicate, bool valid, bool processed) {
                        uint8_t b = static_cast<uint8_t>(line & 0x1Fu);
                        if (duplicate) b = static_cast<uint8_t>(b | 0x20u);
                        if (!valid) b = static_cast<uint8_t>(b | 0x40u);
                        if (!processed) b = static_cast<uint8_t>(b | 0x80u);
                        return b;
                }
 
                static HfrtcDbb2 dbb2DecodeHfrtc(uint8_t b) {
                        HfrtcDbb2 r;
                        r.n               = static_cast<uint8_t>(b & 0x1Fu);
                        r.superFrameCount = static_cast<uint8_t>((b >> 5) & 0x03u);
                        return r;
                }
 
                static uint8_t dbb2EncodeHfrtc(uint8_t superFrameCount, uint8_t n) {
                        return static_cast<uint8_t>(((superFrameCount & 0x03u) << 5) | (n & 0x1Fu));
                }
 
                // -- Comparison ------------------------------------------
 
                bool operator==(const AncAtc &o) const {
                        return _tc == o._tc && _payloadType == o._payloadType && _dbb2 == o._dbb2;
                }
 
                bool operator!=(const AncAtc &o) const { return !(*this == o); }
 
                // -- Diagnostics -----------------------------------------
 
                String toString() const;
 
                JsonObject toJson() const;
 
                // -- DataStream ------------------------------------------
 
                Error writeToStream(DataStream &s) const;
 
                template <uint32_t V> static Result<AncAtc> readFromStream(DataStream &s);
 
                static int atcVitcFormatForFrame(uint32_t frameRateFps, uint64_t frameIndex);
 
        private:
                Timecode _tc;
                uint8_t  _payloadType = Ltc;
                uint8_t  _dbb2 = 0;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV