ntv2device.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_NTV2
 
#include <promeki/atomic.h>
#include <promeki/clock.h>
#include <promeki/error.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/mutex.h>
#include <promeki/namespace.h>
#include <promeki/ntv2capabilities.h>
#include <promeki/sdisignalconfig.h>
#include <promeki/string.h>
#include <promeki/uniqueptr.h>
#include <promeki/videoreferenceconfig.h>
 
class CNTV2Card;
 
PROMEKI_NAMESPACE_BEGIN
 
class Ntv2DeviceRegistry;
class Ntv2MediaIO;
 
class Ntv2Device {
        public:
                CNTV2Card &card();
 
                Mutex &mutex() { return _mutex; }
 
                const Ntv2Capabilities &caps() const { return _caps; }
 
                const String &displayName() const { return _displayName; }
 
                const String &serial() const { return _serial; }
 
                const String &key() const { return _key; }
 
                int deviceIndex() const { return _deviceIndex; }
 
                // ---- Reservations ----
 
                Error reserveChannel(int channel, Ntv2MediaIO *owner);
 
                Error releaseChannel(int channel, Ntv2MediaIO *owner);
 
                Error reservePorts(const SdiSignalConfig::PortList &ports, Ntv2MediaIO *owner);
 
                void releasePortsOwnedBy(Ntv2MediaIO *owner);
 
                Error reserveAudioSystem(int sysIndex, Ntv2MediaIO *owner);
 
                Error releaseAudioSystem(int sysIndex, Ntv2MediaIO *owner);
 
                // ---- Reference clock ----
 
                Error setReference(const VideoReferenceConfig &ref, Ntv2MediaIO *requester);
 
                // ---- Sample clock ----
 
                Clock::Ptr sampleClock();
 
                // ---- Static helpers ----
 
                static int resolveDeviceIndex(const String &locator);
 
                // Destructor is public so the registry's UniquePtr can
                // delete the device; construction stays restricted via
                // the private default constructor + friend declaration.
                ~Ntv2Device();
 
        private:
                friend class Ntv2DeviceRegistry;
                friend struct Ntv2DeviceTestAccess;
 
                // Constructed only through the registry.
                Ntv2Device();
 
                Ntv2Device(const Ntv2Device &) = delete;
                Ntv2Device &operator=(const Ntv2Device &) = delete;
 
                Error initialize(int deviceIndex, const String &locator, bool retailServices,
                                 bool multiFormat);
                void  shutdown(bool retailServices);
 
                // Returns the first audio system (1-based) currently
                // reserved by any channel, or 0 when none.  No longer
                // load-bearing for the device clock (which reads the
                // shared FPGA counter); retained for code paths that
                // still want to know whether any audio is in flight.
                int firstReservedAudioSystem() const;
 
                UniquePtr<CNTV2Card> _card;
                Ntv2Capabilities     _caps;
                mutable Mutex        _mutex;
 
                String _key;
                String _displayName;
                String _serial;
                int    _deviceIndex = -1;
 
                // Reservation tables.  Channels and audio systems use
                // sparse Map<int, Ntv2MediaIO*> rather than arrays so
                // the unused range stays cheap.
                Map<int, Ntv2MediaIO *> _channelOwners;
                Map<int, Ntv2MediaIO *> _audioSystemOwners;
 
                // Ports: (kindValue * 100 + index) → owner.  Encoded as
                // int so the same Map shape works for SDI + HDMI without
                // a custom key type.
                Map<int, Ntv2MediaIO *> _portOwners;
 
                // Reference clock state — used for the warn-on-conflict
                // path.  Both fields default to "unset" so the very
                // first request applies without a spurious warning.
                bool         _refSet = false;
                int          _currentReferenceRaw = 0;  // AJA NTV2ReferenceSource as int
                Ntv2MediaIO *_refOwner = nullptr;
 
                // Lazily constructed shared clock — see sampleClock().
                Clock::Ptr _sampleClock;
};
 
class Ntv2DeviceRegistry {
        public:
                static Ntv2DeviceRegistry &instance();
 
                Error acquire(int deviceIndex, const String &locator, bool retailServices,
                              bool multiFormat, Ntv2Device **outDevice);
 
                void release(Ntv2Device *device);
 
                List<Ntv2Device *> liveDevices() const;
 
        private:
                Ntv2DeviceRegistry() = default;
                ~Ntv2DeviceRegistry();
 
                Ntv2DeviceRegistry(const Ntv2DeviceRegistry &) = delete;
                Ntv2DeviceRegistry &operator=(const Ntv2DeviceRegistry &) = delete;
 
                struct Entry {
                                UniquePtr<Ntv2Device> device;
                                int                   refCount = 0;
                                bool                  retailServices = false;
                };
 
                mutable Mutex     _mutex;
                Map<String, Entry> _entries;
};
 
struct Ntv2DeviceTestAccess {
                static UniquePtr<Ntv2Device> create(int deviceIndex, const String &displayName,
                                                    const Ntv2Capabilities &caps);
 
                static size_t channelOwnerCount(const Ntv2Device &dev);
 
                static const Ntv2MediaIO *channelOwner(const Ntv2Device &dev, int channel);
 
                static size_t portOwnerCount(const Ntv2Device &dev);
 
                static size_t audioSystemOwnerCount(const Ntv2Device &dev);
 
                static const Ntv2MediaIO *audioSystemOwner(const Ntv2Device &dev, int sysIndex);
 
                static bool referenceSet(const Ntv2Device &dev);
 
                static int currentReferenceRaw(const Ntv2Device &dev);
 
                static const Ntv2MediaIO *referenceOwner(const Ntv2Device &dev);
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_NTV2