ntv2democommon.h

Go to the documentation of this file.

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

#include "ntv2rp188.h"
#include "ntv2publicinterface.h"
#include "ntv2card.h"
#include "ntv2utils.h"  //  for NTV2ACFrameRange
#include "ajaanc/includes/ancillarydata.h"
#include "ajabase/common/options_popt.h"
#include "ajabase/common/videotypes.h"
#include "ajabase/common/circularbuffer.h"
#include "ajabase/system/debug.h"
#include "ajabase/system/info.h"
#include "ajabase/system/systemtime.h"  //  for AJATime
#include "ajabase/common/common.h"  //  for aja::strip & etc.
#include <algorithm>
#include <string>

//  Convenience macros for EZ logging:
#define CAPFAIL(_expr_)     AJA_sERROR  (AJA_DebugUnit_DemoCapture, AJAFUNC << ": " << _expr_)
#define CAPWARN(_expr_)     AJA_sWARNING(AJA_DebugUnit_DemoCapture, AJAFUNC << ": " << _expr_)
#define CAPDBG(_expr_)      AJA_sDEBUG  (AJA_DebugUnit_DemoCapture, AJAFUNC << ": " << _expr_)
#define CAPNOTE(_expr_)     AJA_sNOTICE (AJA_DebugUnit_DemoCapture, AJAFUNC << ": " << _expr_)
#define CAPINFO(_expr_)     AJA_sINFO   (AJA_DebugUnit_DemoCapture, AJAFUNC << ": " << _expr_)

#define PLFAIL(_xpr_)       AJA_sERROR  (AJA_DebugUnit_DemoPlayout, AJAFUNC << ": " << _xpr_)
#define PLWARN(_xpr_)       AJA_sWARNING(AJA_DebugUnit_DemoPlayout, AJAFUNC << ": " << _xpr_)
#define PLNOTE(_xpr_)       AJA_sNOTICE (AJA_DebugUnit_DemoPlayout, AJAFUNC << ": " << _xpr_)
#define PLINFO(_xpr_)       AJA_sINFO   (AJA_DebugUnit_DemoPlayout, AJAFUNC << ": " << _xpr_)
#define PLDBG(_xpr_)        AJA_sDEBUG  (AJA_DebugUnit_DemoPlayout, AJAFUNC << ": " << _xpr_)

#define BURNFAIL(_expr_)    AJA_sERROR  (AJA_DebugUnit_Application, AJAFUNC << ": " << _expr_)
#define BURNWARN(_expr_)    AJA_sWARNING(AJA_DebugUnit_Application, AJAFUNC << ": " << _expr_)
#define BURNDBG(_expr_)     AJA_sDEBUG  (AJA_DebugUnit_Application, AJAFUNC << ": " << _expr_)
#define BURNNOTE(_expr_)    AJA_sNOTICE (AJA_DebugUnit_Application, AJAFUNC << ": " << _expr_)
#define BURNINFO(_expr_)    AJA_sINFO   (AJA_DebugUnit_Application, AJAFUNC << ": " << _expr_)

#define NTV2_AUDIOSIZE_MAX  (401 * 1024)
#define NTV2_ANCSIZE_MAX    (0x2000)        //  8K


typedef struct
{
    uint32_t *      fVideoBuffer;           
    uint32_t *      fVideoBuffer2;          
    uint32_t        fVideoBufferSize;       
    uint32_t *      fAudioBuffer;           
    uint32_t        fAudioBufferSize;       
    uint32_t *      fAncBuffer;             
    uint32_t        fAncBufferSize;         
    uint32_t *      fAncF2Buffer;           
    uint32_t        fAncF2BufferSize;       
    uint32_t        fAudioRecordSize;       
    uint32_t        fAncRecordSize;         
    RP188_STRUCT    fRP188Data;             
    RP188_STRUCT    fRP188Data2;            
    uint8_t *       fVideoBufferUnaligned;  
    uint32_t        fFrameFlags;            
} AVDataBuffer;


class AJAExport NTV2FrameData
{
    public:
        NTV2Buffer      fVideoBuffer;       
        NTV2Buffer      fVideoBuffer2;      
        NTV2Buffer      fAudioBuffer;       
        NTV2Buffer      fAncBuffer;         
        NTV2Buffer      fAncBuffer2;        
        NTV2TimeCodes   fTimecodes;         
        ULWord          fNumAudioBytes;     
        ULWord          fNumAncBytes;       
        ULWord          fNumAnc2Bytes;      
        uint32_t        fFrameFlags;        
    public:
        explicit inline NTV2FrameData()
            :   fVideoBuffer    (0),
                fVideoBuffer2   (0),
                fAudioBuffer    (0),
                fAncBuffer      (0),
                fAncBuffer2     (0),
                fTimecodes      (),
                fNumAudioBytes  (0),
                fNumAncBytes    (0),
                fNumAnc2Bytes   (0),
                fFrameFlags(0)  {}

        //  Inquiry Methods
        inline NTV2Buffer & VideoBuffer (void)                          {return fVideoBuffer;}
        inline ULWord       VideoBufferSize (void) const                {return fVideoBuffer.GetByteCount();}

        inline NTV2Buffer & AudioBuffer (void)                          {return fAudioBuffer;}
        inline ULWord       AudioBufferSize (void) const                {return fAudioBuffer.GetByteCount();}
        inline ULWord       NumCapturedAudioBytes (void) const          {return fNumAudioBytes;}

        inline NTV2Buffer & AncBuffer (void)                            {return fAncBuffer;}
        inline ULWord       AncBufferSize (void) const                  {return fAncBuffer.GetByteCount();}
        inline ULWord       NumCapturedAncBytes (void) const            {return fNumAncBytes;}

        inline NTV2Buffer & AncBuffer2 (void)                           {return fAncBuffer2;}
        inline ULWord       AncBuffer2Size (void) const                 {return fAncBuffer2.GetByteCount();}
        inline ULWord       NumCapturedAnc2Bytes (void) const           {return fNumAnc2Bytes;}

        inline NTV2Buffer & VideoBuffer2 (void)                         {return fVideoBuffer2;}
        inline ULWord       VideoBufferSize2 (void) const               {return fVideoBuffer2.GetByteCount();}

        inline bool         IsNULL (void) const                         {return fVideoBuffer.IsNULL() && fVideoBuffer2.IsNULL()
                                                                            && fAudioBuffer.IsNULL() && fAncBuffer.IsNULL()
                                                                            && fAncBuffer2.IsNULL();}
        inline bool HasTimecode (const NTV2TCIndex inTCNdx) const       {return fTimecodes.find(inTCNdx) != fTimecodes.end();}
        NTV2_RP188  Timecode (const NTV2TCIndex inTCNdx) const;
        inline bool HasValidTimecode (const NTV2TCIndex inTCNdx) const  {return Timecode(inTCNdx).IsValid();}

        //  Modifier Methods
        inline void     ZeroBuffers (void)      {   if (fVideoBuffer)
                                                        fVideoBuffer.Fill(ULWord(0));
                                                    if (fVideoBuffer2)
                                                        fVideoBuffer2.Fill(ULWord(0));
                                                    if (fAudioBuffer)
                                                        fAudioBuffer.Fill(ULWord(0));
                                                    if (fAncBuffer)
                                                        fAncBuffer.Fill(ULWord(0));
                                                    if (fAncBuffer2)
                                                        fAncBuffer2.Fill(ULWord(0));
                                                    fNumAudioBytes = fNumAncBytes = fNumAnc2Bytes = 0;
                                                }
        bool            LockAll                 (CNTV2Card & inDevice);
        bool            UnlockAll               (CNTV2Card & inDevice);

        bool            Reset (void)            {return fVideoBuffer.Allocate(0) && fVideoBuffer2.Allocate(0)
                                                        && fAudioBuffer.Allocate(0) && fAncBuffer.Allocate(0)
                                                        && fAncBuffer2.Allocate(0);}
};  //  NTV2FrameData

typedef std::vector<NTV2FrameData>          NTV2FrameDataArray;             
typedef NTV2FrameDataArray::iterator        NTV2FrameDataArrayIter;         
typedef NTV2FrameDataArray::const_iterator  NTV2FrameDataArrayConstIter;    
typedef AJACircularBuffer<NTV2FrameData*>   FrameDataRingBuffer;            



static const size_t CIRCULAR_BUFFER_SIZE    (10);   
static const ULWord kDemoAppSignature       NTV2_FOURCC('D','E','M','O');


template <typename T> class Bouncer
{
    public:
        inline Bouncer (const T inUpperLimit, const T inLowerLimit = T(0), const T inStartValue = T(0), const bool inStartAscend = true)
            :   mMin        (inLowerLimit),
                mMax        (inUpperLimit),
                mValue      (inStartValue),
                mIncrement  (T(1)),
                mAscend     (inStartAscend)
        {
            if (mMin > mMax)
                std::swap (mMin, mMax);
            else if (mMin == mMax)
                mMax = mMin + mIncrement;
            if (mValue < mMin)
            {
                mValue = mMin;
                mAscend = true;
            }
            if (mValue > mMax)
            {
                mValue = mMax;
                mAscend = false;
            }
        }

        inline T    Next (void)
        {
            if (mAscend)
            {
                if (mValue < mMax)
                    mValue += mIncrement;
                else
                    mAscend = false;
            }
            else
            {
                if (mValue > mMin)
                    mValue -= mIncrement;
                else
                    mAscend = true;
            }
            return mValue;
        }

        inline void SetIncrement (const T inValue)  {mIncrement = inValue;}
        inline T    Value (void) const  {return mValue;}

    private:
        T       mMin, mMax, mValue, mIncrement;
        bool    mAscend;

};  //  Bouncer


typedef enum _NTV2VideoFormatKind
{
    VIDEO_FORMATS_NONE          = 0,
    VIDEO_FORMATS_SDHD          = 1,
    VIDEO_FORMATS_4KUHD         = 2,
    VIDEO_FORMATS_8KUHD2        = 4,
    VIDEO_FORMATS_ALL_UHD4K8K   = (VIDEO_FORMATS_4KUHD | VIDEO_FORMATS_8KUHD2),
    VIDEO_FORMATS_ALL           = (VIDEO_FORMATS_SDHD | VIDEO_FORMATS_4KUHD | VIDEO_FORMATS_8KUHD2)
#if !defined(NTV2_DEPRECATE_17_5)
    //  Deprecated old ones:
    ,VIDEO_FORMATS_NON_4KUHD    = VIDEO_FORMATS_SDHD
    ,VIDEO_FORMATS_UHD2         = VIDEO_FORMATS_8KUHD2
    ,BOTH_VIDEO_FORMATS         = VIDEO_FORMATS_ALL
    ,NON_UHD_VIDEO_FORMATS      = VIDEO_FORMATS_SDHD
    ,UHD_VIDEO_FORMATS          = VIDEO_FORMATS_4KUHD
#endif  //  !defined(NTV2_DEPRECATE_17_5)
} NTV2VideoFormatKind;

typedef ULWord NTV2VideoFormatKinds;


typedef enum _NTV2PixelFormatKind
{
    PIXEL_FORMATS_NONE      = 0,
    PIXEL_FORMATS_RGB       = 1,
    PIXEL_FORMATS_PLANAR    = 2,
    PIXEL_FORMATS_RAW       = 4,
    PIXEL_FORMATS_PACKED    = 8,
    PIXEL_FORMATS_ALPHA     = 16,
    PIXEL_FORMATS_NO_RAW    = (PIXEL_FORMATS_RGB | PIXEL_FORMATS_PLANAR | PIXEL_FORMATS_PACKED | PIXEL_FORMATS_ALPHA),
    PIXEL_FORMATS_ALL       = (PIXEL_FORMATS_RGB | PIXEL_FORMATS_PLANAR | PIXEL_FORMATS_RAW | PIXEL_FORMATS_PACKED | PIXEL_FORMATS_ALPHA)
} NTV2PixelFormatKind;

typedef ULWord NTV2PixelFormatKinds;


typedef enum _NTV2TCIndexKinds
{
    TC_INDEXES_NONE         = 0,
    TC_INDEXES_SDI          = 1,
    TC_INDEXES_ANALOG       = 2,
    TC_INDEXES_ATCLTC       = 4,
    TC_INDEXES_VITC1        = 8,
    TC_INDEXES_VITC2        = 16,
    TC_INDEXES_NO_ANALOG    = (TC_INDEXES_SDI | TC_INDEXES_ATCLTC | TC_INDEXES_VITC1 | TC_INDEXES_VITC2),
    TC_INDEXES_ALL          = (TC_INDEXES_NO_ANALOG | TC_INDEXES_ANALOG )
} NTV2TCIndexKinds;


class AJAExport CaptureConfig
{
    public:
        std::string         fDeviceSpec;        
        std::string         fAncDataFilePath;   
        NTV2Channel         fInputChannel;      
        NTV2InputSource     fInputSource;       
        NTV2ACFrameRange    fFrames;            
        NTV2PixelFormat     fPixelFormat;       
        UWord               fNumAudioLinks;     
        bool                fDoABConversion;    
        bool                fDoMultiFormat;     
        bool                fWithAnc;           
        bool                fWithAudio;         
        bool                fDoTSIRouting;      

        inline explicit CaptureConfig (const std::string & inDeviceSpec = "0")
            :   fDeviceSpec         (inDeviceSpec),
                fAncDataFilePath    (),
                fInputChannel       (NTV2_CHANNEL_INVALID),
                fInputSource        (NTV2_INPUTSOURCE_INVALID),
                fFrames             (7),
                fPixelFormat        (NTV2_FBF_8BIT_YCBCR),
                fNumAudioLinks      (1),
                fDoABConversion     (false),
                fDoMultiFormat      (false),
                fWithAnc            (false),
                fWithAudio          (true),
                fDoTSIRouting       (true)
        {
        }

        AJALabelValuePairs  Get (const bool inCompact = false) const;

};  //  CaptureConfig

AJAExport std::ostream &    operator << (std::ostream & ioStrm, const CaptureConfig & inObj);


typedef struct PlayerConfig
{
    public:
        std::string         fDeviceSpec;        
        std::string         fAncDataFilePath;   
        NTV2Channel         fOutputChannel;     
        NTV2OutputDest      fOutputDest;        
        NTV2ACFrameRange    fFrames;            
        NTV2PixelFormat     fPixelFormat;       
        NTV2VideoFormat     fVideoFormat;       
        NTV2VANCMode        fVancMode;          
        UWord               fNumAudioLinks;     
        bool                fDoMultiFormat;     
        bool                fSuppressAudio;     
        bool                fSuppressVideo;     
        bool                fTransmitLTC;       
        bool                fDoABConversion;    
        bool                fDoHDMIOutput;      
        bool                fDoTsiRouting;      
        bool                fDoRGBOnWire;       
        bool                fDoLinkGrouping;    

        inline explicit PlayerConfig (const std::string & inDeviceSpecifier = "0")
            :   fDeviceSpec         (inDeviceSpecifier),
                fAncDataFilePath    (),
                fOutputChannel      (NTV2_CHANNEL1),
                fOutputDest         (NTV2_OUTPUTDESTINATION_SDI2),
                fFrames             (7),
                fPixelFormat        (NTV2_FBF_8BIT_YCBCR),
                fVideoFormat        (NTV2_FORMAT_1080i_5994),
                fVancMode           (NTV2_VANCMODE_OFF),
                fNumAudioLinks      (1),
                fDoMultiFormat      (false),
                fSuppressAudio      (false),
                fSuppressVideo      (false),
                fTransmitLTC        (false),
                fDoABConversion     (false),
                fDoHDMIOutput       (false),
                fDoTsiRouting       (false),
                fDoRGBOnWire        (false),
                fDoLinkGrouping     (false)
        {
        }

        inline bool WithAudio(void) const   {return !fSuppressAudio  &&  fNumAudioLinks > 0;}   
        inline bool WithVideo(void) const   {return !fSuppressVideo;}   

        AJALabelValuePairs Get (const bool inCompact = false) const;

}   PlayerConfig;

AJAExport std::ostream &    operator << (std::ostream & ioStrm, const PlayerConfig & inObj);

typedef struct BurnConfig
{
    public:
        std::string         fDeviceSpec;        
        std::string         fDeviceSpec2;       
        NTV2Channel         fInputChannel;      
        NTV2Channel         fOutputChannel;     
        NTV2InputSource     fInputSource;       
        NTV2OutputDest      fOutputDest;        
        NTV2ACFrameRange    fInputFrames;       
        NTV2ACFrameRange    fOutputFrames;      
        NTV2PixelFormat     fPixelFormat;       
        NTV2TCIndex         fTimecodeSource;    
        bool                fDoMultiFormat;     
        bool                fSuppressAudio;     
        bool                fSuppressVideo;     
        bool                fIsFieldMode;       
        bool                fWithAnc;           
        bool                fWithTallFrames;    
        bool                fWithHanc;          
        bool                fVerbose;           

        inline explicit BurnConfig (const std::string & inDeviceSpecifier   = "0")
            :   fDeviceSpec         (inDeviceSpecifier),
                fDeviceSpec2        (),
                fInputChannel       (NTV2_CHANNEL1),
                fOutputChannel      (NTV2_CHANNEL3),
                fInputSource        (NTV2_INPUTSOURCE_SDI1),
                fOutputDest         (NTV2_OUTPUTDESTINATION_INVALID),
                fInputFrames        (7),
                fOutputFrames       (7),
                fPixelFormat        (NTV2_FBF_8BIT_YCBCR),
                fTimecodeSource     (NTV2_TCINDEX_SDI1),
                fDoMultiFormat      (false),
                fSuppressAudio      (false),
                fSuppressVideo      (false),
                fIsFieldMode        (false),
                fWithAnc            (false),
                fWithTallFrames     (false),
                fWithHanc           (false),
                fVerbose            (false)
        {
        }

        inline bool WithAudio(void) const       {return !fSuppressAudio;}   
        inline bool WithVideo(void) const       {return !fSuppressVideo;}   
        inline bool WithAnc(void) const         {return fWithAnc;}          
        inline bool WithTallVANC(void) const    {return fWithTallFrames;}   
        inline bool WithHanc(void) const        {return fWithHanc;}         
        inline bool WithTimecode(void) const    {return NTV2_IS_VALID_TIMECODE_INDEX(fTimecodeSource);} 
        inline bool FieldMode(void) const       {return fIsFieldMode;}      
        inline bool OutputSpecified(void) const {return NTV2_IS_VALID_OUTPUT_DEST(fOutputDest);}    
        inline bool IsVerbose(void) const       {return fVerbose;}          
        inline std::string  ISrcStr(void) const {return ::NTV2InputSourceToString(fInputSource, true);}
        inline NTV2Channel  ISrcCh(void) const  {return ::NTV2InputSourceToChannel(fInputSource);}
        inline bool ISrcIsSDI(void) const       {return NTV2_INPUT_SOURCE_IS_SDI(fInputSource);}
        inline std::string  ODstStr(void) const {return ::NTV2OutputDestinationToString(fOutputDest, true);}
        inline NTV2Channel  ODstCh(void) const  {return ::NTV2OutputDestinationToChannel(fOutputDest);}
        inline std::string  IChStr(void) const  {std::ostringstream oss; oss << "Ch" << int(fInputChannel); return oss.str();}
        inline std::string  OChStr(void) const  {std::ostringstream oss; oss << "Ch" << int(fOutputChannel); return oss.str();}
        inline bool ODstIsSDI(void) const       {return NTV2_OUTPUT_DEST_IS_SDI(fOutputDest);}

        AJALabelValuePairs Get (const bool inCompact = false) const;

}   BurnConfig;

inline std::ostream &   operator << (std::ostream & strm, const BurnConfig & inObj) {return strm << AJASystemInfo::ToString(inObj.Get());}



class AJAExport CNTV2DemoCommon
{
    public:

        static bool                         IsValidDevice (const std::string & inDeviceSpec);


        static NTV2VideoFormatSet           GetSupportedVideoFormats (const NTV2VideoFormatKinds inKinds = VIDEO_FORMATS_SDHD);

        static std::string                  GetVideoFormatStrings (const NTV2VideoFormatKinds inKinds = VIDEO_FORMATS_SDHD,
                                                                    const std::string inDevSpec = std::string());

        static NTV2VideoFormat              GetVideoFormatFromString (const std::string & inStr,
                                                                        const NTV2VideoFormatKinds inKinds  = VIDEO_FORMATS_SDHD,
                                                                        const std::string & inDevSpec       = std::string());

        static bool                         Get4KInputFormat (NTV2VideoFormat & inOutVideoFormat);
        
        static bool                         Get8KInputFormat (NTV2VideoFormat & inOutVideoFormat);


        static NTV2PixelFormats             GetSupportedPixelFormats (const NTV2PixelFormatKinds inKinds = PIXEL_FORMATS_ALL);

        static std::string                  GetPixelFormatStrings (const NTV2PixelFormatKinds inKinds = PIXEL_FORMATS_ALL,
                                                                    const std::string inDevSpec = std::string());

        static NTV2PixelFormat              GetPixelFormatFromString (const std::string & inStr,
                                                                        const NTV2PixelFormatKinds inKinds = PIXEL_FORMATS_ALL,
                                                                        const std::string inDevSpec = std::string());

        static AJA_PixelFormat              GetAJAPixelFormat (const NTV2PixelFormat inFormat);


        static const NTV2InputSourceSet     GetSupportedInputSources (const NTV2IOKinds inKinds = NTV2_IOKINDS_ALL);

        static std::string                  GetInputSourceStrings (const NTV2IOKinds inKinds = NTV2_IOKINDS_ALL,
                                                                    const std::string inDevSpec = std::string ());

        static NTV2InputSource              GetInputSourceFromString (const std::string & inStr,
                                                                        const NTV2IOKinds inKinds = NTV2_IOKINDS_ALL,
                                                                        const std::string inDevSpec = std::string());


        static const NTV2OutputDestinations GetSupportedOutputDestinations (const NTV2IOKinds inKinds);

        static std::string                  GetOutputDestinationStrings (const NTV2IOKinds inKinds, const std::string inDevSpec = std::string ());

        static NTV2OutputDestination        GetOutputDestinationFromString (const std::string & inStr,
                                                                            const NTV2IOKinds inKinds = NTV2_IOKINDS_ALL,
                                                                            const std::string inDevSpec = std::string());


        static const NTV2TCIndexes          GetSupportedTCIndexes (const NTV2TCIndexKinds inKinds);

        static std::string                  GetTCIndexStrings (const NTV2TCIndexKinds inKinds = TC_INDEXES_ALL,
                                                                const std::string inDeviceSpecifier = std::string(),
                                                                const bool inIsInputOnly = true);

        static NTV2TCIndex                  GetTCIndexFromString (const std::string & inStr,
                                                                const NTV2TCIndexKinds inKinds = TC_INDEXES_ALL,
                                                                const std::string inDevSpec = std::string());


        static std::string                  GetAudioSystemStrings (const std::string inDeviceSpecifier = std::string ());

        static NTV2AudioSystem              GetAudioSystemFromString (const std::string & inStr);


        static std::string                  GetTestPatternStrings (void);

        static std::string                  GetTestPatternNameFromString (const std::string & inStr);


        static std::string                  GetVANCModeStrings (void);

        static NTV2VANCMode                 GetVANCModeFromString (const std::string & inStr);


        static bool                         GetInputRouting (NTV2XptConnections & outConnections,
                                                            const CaptureConfig & inConfig,
                                                            const bool isInputRGB = false);

        static bool                         GetInputRouting4K ( NTV2XptConnections & outConnections,
                                                                const CaptureConfig & inConfig,
                                                                const NTV2DeviceID inDevID = DEVICE_ID_INVALID,
                                                                const bool isInputRGB = false);

        static bool                         GetInputRouting8K ( NTV2XptConnections & outConnections,
                                                                const CaptureConfig & inConfig,
                                                                const NTV2VideoFormat inVidFormat,
                                                                const NTV2DeviceID inDevID = DEVICE_ID_INVALID,
                                                                const bool isInputRGB = false);


        static std::string                  ToLower (const std::string & inStr);

        static std::string                  StripFormatString (const std::string & inStr);

        static char                         ReadCharacterPress (void);

        static void                         WaitForEnterKeyPress (void);

        static TimecodeFormat               NTV2FrameRate2TimecodeFormat(const NTV2FrameRate inFrameRate);

        static AJA_FrameRate                GetAJAFrameRate (const NTV2FrameRate inFrameRate);

        static const char *                 GetGlobalMutexName (void);

        static NTV2ChannelList              GetTSIMuxesForFrameStore (CNTV2Card & inDevice, const NTV2Channel in1stFrameStore, const UWord inCount);

        static bool                         ConfigureAudioSystems (CNTV2Card & inDevice, const CaptureConfig & inConfig, const NTV2AudioSystemSet inAudioSystems);

        static size_t                       SetDefaultPageSize (void);

    typedef NTV2ACFrameRange    ACFrameRange;   

    typedef struct poptOption   PoptOpts;
    class AJAExport Popt
    {
        public:
            Popt (const int inArgc, const char ** pArgs, const PoptOpts * pInOptionsTable);
            virtual                                 ~Popt();
            virtual inline int                      parseResult(void) const     {return mResult;}
            virtual inline bool                     isGood (void) const         {return parseResult() == -1;}
            virtual inline                          operator bool() const       {return isGood();}
            virtual inline const std::string &      errorStr (void) const       {return mError;}
            virtual inline const NTV2StringList &   otherArgs (void) const      {return mOtherArgs;}
        private:
            poptContext     mContext;
            int             mResult;
            std::string     mError;
            NTV2StringList  mOtherArgs;
    };

    static bool BFT(void);

};  //  CNTV2DemoCommon


//  These AJA_NTV2_AUDIO_RECORD* macros can, if enabled, record audio samples into a file in the current directory.
//  Optionally used in the CNTV2Capture demo.
#if defined(AJA_RAW_AUDIO_RECORD)
    #include "ntv2debug.h"                  //  For NTV2DeviceString
    #include <fstream>                      //  For ofstream
    //  To open the raw audio file in Audacity -- see http://audacity.sourceforge.net/ ...
    //      1)  Choose File => Import => Raw Data...
    //      2)  Select "Signed 32 bit PCM", Little/No/Default Endian, "16 Channels" (or 8 if applicable), "48000" sample rate.
    //      3)  Click "Import"
    #define     AJA_NTV2_AUDIO_RECORD_BEGIN     ostringstream   _filename;                                                      \
                                                _filename   << ::NTV2DeviceString(mDeviceID) << "-" << mDevice.GetIndexNumber() \
                                                            << "." << ::NTV2ChannelToString(mConfig.fInputChannel,true)                 \
                                                            << "." << ::NTV2InputSourceToString(mConfig.fInputSource, true)             \
                                                            << "." << ::NTV2VideoFormatToString(mVideoFormat)                   \
                                                            << "." << ::NTV2AudioSystemToString(mAudioSystem, true)             \
                                                            << "." << AJAProcess::GetPid()                                      \
                                                            << ".raw";                                                          \
                                                ofstream _ostrm(_filename.str(), ios::binary);

    #define     AJA_NTV2_AUDIO_RECORD_DO        if (NTV2_IS_VALID_AUDIO_SYSTEM(mAudioSystem))                                   \
                                                    if (pFrameData->fAudioBuffer)                                               \
                                                        _ostrm.write(pFrameData->AudioBuffer(),                                 \
                                                                    streamsize(pFrameData->NumCapturedAudioBytes()));

    #define     AJA_NTV2_AUDIO_RECORD_END       
#elif defined(AJA_WAV_AUDIO_RECORD)
    #include "ntv2debug.h"                  //  For NTV2DeviceString
    #include "ajabase/common/wavewriter.h"  //  For AJAWavWriter
    #define     AJA_NTV2_AUDIO_RECORD_BEGIN     ostringstream   _wavfilename;                                                       \
                                                _wavfilename    << ::NTV2DeviceString(mDeviceID) << "-" << mDevice.GetIndexNumber() \
                                                                << "." << ::NTV2ChannelToString(mConfig.fInputChannel,true)         \
                                                                << "." << ::NTV2InputSourceToString(mConfig.fInputSource, true)     \
                                                                << "." << ::NTV2VideoFormatToString(mVideoFormat)                   \
                                                                << "." << ::NTV2AudioSystemToString(mAudioSystem, true)             \
                                                                << "." << AJAProcess::GetPid()                                      \
                                                                << ".wav";                                                          \
                                                const int       _wavMaxNumAudChls(mDevice.features().GetMaxAudioChannels());        \
                                                AJAWavWriter    _wavWriter (_wavfilename.str(),                                     \
                                                                            AJAWavWriterAudioFormat(_wavMaxNumAudChls, 48000, 32)); \
                                                _wavWriter.open();

    #define     AJA_NTV2_AUDIO_RECORD_DO        if (NTV2_IS_VALID_AUDIO_SYSTEM(mAudioSystem))                                       \
                                                    if (pFrameData->fAudioBuffer)                                                   \
                                                        if (_wavWriter.IsOpen())                                                    \
                                                            _wavWriter.write(pFrameData->AudioBuffer(), pFrameData->NumCapturedAudioBytes());

    #define     AJA_NTV2_AUDIO_RECORD_END       if (_wavWriter.IsOpen())                                                            \
                                                    _wavWriter.close();
#else
    #define     AJA_NTV2_AUDIO_RECORD_BEGIN     
    #define     AJA_NTV2_AUDIO_RECORD_DO            
    #define     AJA_NTV2_AUDIO_RECORD_END       
#endif

//  Optionally used in the CNTV2Capture4K demo.
#if defined(AJA_RECORD_MLAUDIO)
    #include <fstream>
    #define AJA_NTV2_MLAUDIO_RECORD_BEGIN       ofstream ofs1, ofs2;                                                \
                                                if (mConfig.fNumAudioLinks > 1)                                     \
                                                {                                                                   \
                                                    ofs1.open("temp1.raw", ios::out | ios::trunc | ios::binary);    \
                                                    ofs2.open("temp2.raw", ios::out | ios::trunc | ios::binary);    \
                                                }

    #define AJA_NTV2_MLAUDIO_RECORD_DO          if (mConfig.fNumAudioLinks > 1)                                                             \
                                                {   const ULWord halfBytes (pFrameData->NumCapturedAudioBytes() / 2);                       \
                                                    ofs1.write(pFrameData->AudioBuffer(), halfBytes);                                       \
                                                    NTV2Buffer lastHalf (pFrameData->fAudioBuffer.GetHostAddress(halfBytes), halfBytes);    \
                                                    ofs2.write(lastHalf, lastHalf.GetByteCount());                                          \
                                                }

    #define AJA_NTV2_MLAUDIO_RECORD_END         if (mConfig.fNumAudioLinks > 1)             \
                                                {                                           \
                                                    ofs1.close();                           \
                                                    ofs2.close();                           \
                                                }
#else
    #define AJA_NTV2_MLAUDIO_RECORD_BEGIN       
    #define AJA_NTV2_MLAUDIO_RECORD_DO          
    #define AJA_NTV2_MLAUDIO_RECORD_END         
#endif

#endif  //  _NTV2DEMOCOMMON_H