ntv2config2022.h

Go to the documentation of this file.

/* SPDX-License-Identifier: MIT */
#ifndef NTV2_2022CONFIG_H
#define NTV2_2022CONFIG_H

#include "ntv2card.h"
#include "ntv2enums.h"
#include "ntv2registers2022.h"
#include "ntv2mbcontroller.h"
#include "ntv2tshelper.h"
#include <string.h>

class AJAExport tx_2022_channel
{
public:
    tx_2022_channel() { init(); }

    void init();

    bool operator != ( const tx_2022_channel &other );
    bool operator == ( const tx_2022_channel &other );

public:
    bool        sfp1Enable;
    bool        sfp2Enable;

    uint32_t    sfp1LocalPort;      
    std::string sfp1RemoteIP;       
    uint32_t    sfp1RemotePort;     

    uint32_t    sfp2LocalPort;      
    std::string sfp2RemoteIP;       
    uint32_t    sfp2RemotePort;     

    uint8_t     tos;            // type of service
    uint8_t     ttl;            // time to live
    uint32_t    ssrc;
};

class AJAExport rx_2022_channel
{
public:
    rx_2022_channel() { init(); }

    void init();

    bool operator != ( const rx_2022_channel &other );
    bool operator == ( const rx_2022_channel &other );

public:
    bool        sfp1Enable;
    bool        sfp2Enable;

    uint8_t     sfp1RxMatch;            
    std::string sfp1SourceIP;           
    std::string sfp1DestIP;             
    uint32_t    sfp1SourcePort;         
    uint32_t    sfp1DestPort;           
    uint16_t    sfp1Vlan;               

    uint8_t     sfp2RxMatch;            
    std::string sfp2SourceIP;           
    std::string sfp2DestIP;             
    uint32_t    sfp2SourcePort;         
    uint32_t    sfp2DestPort;           
    uint16_t    sfp2Vlan;               

    uint32_t    ssrc;                   
    uint32_t    playoutDelay;           
};

class AJAExport j2kEncoderConfig
{
public:
    j2kEncoderConfig() { init(); }

    void init();

    bool operator == ( const j2kEncoderConfig &other );
    bool operator != ( const j2kEncoderConfig &other );

    NTV2VideoFormat         videoFormat;        
    uint32_t                ullMode;            
    uint32_t                bitDepth;           
    J2KChromaSubSampling    chromaSubsamp;      
    uint32_t                mbps;               
    J2KStreamType           streamType;         
    uint32_t                audioChannels;      
    uint32_t                pmtPid;             
    uint32_t                videoPid;           
    uint32_t                pcrPid;             
    uint32_t                audio1Pid;          
};

class AJAExport j2kDecoderConfig
{
public:
    typedef enum
    {
        eProgSel_Off,
        eProgSel_AutoFirstProg,
        eProgSel_LowestProgNum,
        eProgSel_SpecificProgNum,
        eProgSel_SpecificProgPID,
        eProgSel_Default = eProgSel_AutoFirstProg
    } eProgSelMode_t;

    j2kDecoderConfig() {init();}
    void init();

    bool operator == ( const j2kDecoderConfig &other );
    bool operator != ( const j2kDecoderConfig &other );

    eProgSelMode_t  selectionMode;
    uint32_t        programNumber;
    uint32_t        programPID;
    uint32_t        audioNumber;
};

class AJAExport j2kDecoderStatus
{
public:
    j2kDecoderStatus() {init();}
    void init();

    uint32_t              numAvailablePrograms;
    uint32_t              numAvailableAudios;
    std::vector<uint32_t> availableProgramNumbers;
    std::vector<uint32_t> availableProgramPIDs;
    std::vector<uint32_t> availableAudioPIDs;
};

struct s2022RxChannelStatus
{
    uint32_t sfp1RxPackets;
    uint32_t sfp1ValidRxPackets;
    uint32_t sfp2RxPackets;
    uint32_t sfp2ValidRxPackets;
};

class AJAExport CNTV2Config2022 : public CNTV2MBController
{
public:
    CNTV2Config2022 (CNTV2Card & device);
    ~CNTV2Config2022();

    bool        SetNetworkConfiguration(const eSFP sfp, const IPVNetConfig & netConfig);
    bool        GetNetworkConfiguration(const eSFP sfp, IPVNetConfig & netConfig);
    bool        SetNetworkConfiguration(const eSFP sfp, const std::string localIPAddress, const std::string subnetMask, const std::string gateway);
    bool        GetNetworkConfiguration(const eSFP sfp, std::string & localIPAddress, std::string & subnetMask, std::string & gateway);
    bool        DisableNetworkInterface(const eSFP sfp);

    bool        SetRxChannelConfiguration(const NTV2Channel channel, const rx_2022_channel & rxConfig);
    bool        GetRxChannelConfiguration(const NTV2Channel channel, rx_2022_channel & rxConfig);

    bool        SetRxChannelEnable(const NTV2Channel channel, bool enable);
    bool        GetRxChannelEnable(const NTV2Channel channel, bool & enabled);

    bool        SetTxChannelConfiguration(const NTV2Channel channel, const tx_2022_channel & txConfig);
    bool        GetTxChannelConfiguration(const NTV2Channel channel, tx_2022_channel & txConfig);

    bool        SetTxChannelEnable(const NTV2Channel channel, bool enable);
    bool        GetTxChannelEnable(const NTV2Channel channel, bool & enabled);

    bool        SetJ2KEncoderConfiguration(const NTV2Channel channel, const j2kEncoderConfig & j2kConfig);
    bool        GetJ2KEncoderConfiguration(const NTV2Channel channel, j2kEncoderConfig &j2kConfig);

    bool        SetJ2KDecoderConfiguration(const j2kDecoderConfig & j2kConfig);
    bool        GetJ2KDecoderConfiguration(j2kDecoderConfig &j2kConfig);
    bool        GetJ2KDecoderStatus(j2kDecoderStatus & j2kStatus);

    bool        Set2022_7_Mode(bool enable, uint32_t rx_networkPathDifferential);
    bool        Get2022_7_Mode(bool & enable, uint32_t & rx_networkPathDifferential);

    bool        SetIGMPDisable(eSFP sfp, bool disable);
    bool        GetIGMPDisable(eSFP sfp, bool & disabled);

    bool        SetIGMPVersion(eIGMPVersion_t version);
    bool        GetIGMPVersion(eIGMPVersion_t & version);

    void        SetBiDirectionalChannels(bool bidirectional) { _biDirectionalChannels = bidirectional;}
    bool        GetBiDirectionalChannels() {return _biDirectionalChannels;}

    bool        GetMACAddress(eSFP sfp, NTV2Stream stream, std::string remoteIP, uint32_t & hi, uint32_t & lo);

    bool        GetSFPMSAData(eSFP sfp, SFPMSAData & data);
    bool        GetLinkStatus(eSFP sfp, SFPStatus & sfpStatus);
    bool        Get2022ChannelRxStatus(NTV2Channel channel, s2022RxChannelStatus & status);

    bool        SetIPServicesControl(const bool enable, const bool forceReconfig);
    bool        GetIPServicesControl(bool & enable, bool & forceReconfig);


    // If method returns false call this to get details
    std::string getLastError();
    NTV2IpError getLastErrorCode();

private:
    void        ChannelSemaphoreSet(uint32_t controlReg, uint32_t baseaddr);
    void        ChannelSemaphoreClear(uint32_t controlReg, uint32_t baseaddr);

    bool        SelectRxChannel(NTV2Channel channel, eSFP sfp, uint32_t & baseAddr);
    bool        SelectTxChannel(NTV2Channel channel, eSFP sfp, uint32_t & baseAddr);

    NTV2Stream VideoChannelToStream(const NTV2Channel channel);
    NTV2Channel VideoStreamToChannel(const NTV2Stream stream);

    class CNTV2ConfigTs2022 * _tstreamConfig;

    eSFP        GetTxLink(NTV2Channel chan);

    uint32_t    _numRx0Chans;
    uint32_t    _numRx1Chans;
    uint32_t    _numTx0Chans;
    uint32_t    _numTx1Chans;
    uint32_t    _numRxChans;
    uint32_t    _numTxChans;
    bool        _is2022_6;
    bool        _is2022_2;
    bool        _is2022_7;
    bool        _biDirectionalChannels;             // logically bi-directional channels
    bool        _is_txTop34;
    bool        _isIoIp;
};  //  CNTV2Config2022

#endif // NTV2_2022CONFIG_H