ntv2bitfile.h

Go to the documentation of this file.

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

#include <fstream>
#ifdef AJALinux
    #include <stdint.h>
    #include <stdlib.h>
#endif
#include "ajatypes.h"
#include "ajaexport.h"
#include "ntv2enums.h"
#include "ntv2publicinterface.h"
#include "ntv2utils.h"


class AJAExport NTV2BitfileHeaderParser
{
    public:
        explicit                    NTV2BitfileHeaderParser ()  {Clear();}
        bool                        ParseHeader         (const NTV2Buffer & inHdrBuffer,
                                                        std::ostream & outMsgs);
        void                        Clear               (void);

        inline ULWord               UserID              (void) const        {return mUserID;}
        inline const std::string &  Date                (void) const        {return mDate;}
        inline const std::string &  Time                (void) const        {return mTime;}
        inline const std::string &  PartName            (void) const        {return mPartName;}
        inline const std::string &  RawDesign           (void) const        {return mRawDesignName;}
        std::string                 DesignName          (void) const;

        inline ULWord               DesignID            (void) const        {return mDesignID;}
        inline ULWord               DesignVersion       (void) const        {return mDesignVersion;}
        inline ULWord               BitfileID           (void) const        {return mBitfileID;}
        inline ULWord               BitfileVersion      (void) const        {return mBitfileVersion;}
        inline ULWord               ProgramOffsetBytes  (void) const        {return mProgOffsetBytes;}
        inline ULWord               ProgramSizeBytes    (void) const        {return mProgSizeBytes;}
        inline bool                 IsValid             (void) const        {return mValid;}
        inline bool                 IsTandem            (void) const        {return RawDesign().find("TANDEM=TRUE")   != std::string::npos;}
        inline bool                 IsPartial           (void) const        {return RawDesign().find("PARTIAL=TRUE")  != std::string::npos;}
        inline bool                 IsClear             (void) const        {return RawDesign().find("CLEAR=TRUE")    != std::string::npos;}
        inline bool                 IsCompress          (void) const        {return RawDesign().find("COMPRESS=TRUE") != std::string::npos;}

    public: //  Class Methods
        static inline ULWord        GetDesignID         (const ULWord userID)       { return (userID & 0xff000000) >> 24; }
        static inline ULWord        GetDesignVersion    (const ULWord userID)       { return (userID & 0x00ff0000) >> 16; }
        static inline ULWord        GetBitfileID        (const ULWord userID)       { return (userID & 0x0000ff00) >> 8; }
        static inline ULWord        GetBitfileVersion   (const ULWord userID)       { return (userID & 0x000000ff) >> 0; }

    protected:
        bool                        SetRawDesign            (const std::string & inStr, std::ostream & oss);
        bool                        SetDate                 (const std::string & inStr, std::ostream & oss);
        bool                        SetTime                 (const std::string & inStr, std::ostream & oss);
        inline void                 SetPartName             (const std::string & inStr)     {mPartName = inStr;}
        bool                        SetProgramOffsetBytes   (const ULWord inValue, std::ostream & oss);
        bool                        SetProgramSizeBytes     (const ULWord inValue, std::ostream & oss);

    private:
        std::string     mDate;              //  Compile/build date
        std::string     mTime;              //  Compile/build time
        std::string     mPartName;          //  Part name
        std::string     mRawDesignName;     //  Untruncated, unmodified design string
        ULWord          mUserID;            //  User ID
        ULWord          mProgOffsetBytes;   //  Program offset, in bytes
        ULWord          mProgSizeBytes;     //  Program length, in bytes
        ULWord          mDesignID;          //  Design ID
        ULWord          mDesignVersion;     //  Design version
        ULWord          mBitfileID;         //  Bitfile ID
        ULWord          mBitfileVersion;    //  Bitfile version
        bool            mValid;             //  Is valid?
};  //  NTV2BitfileHeaderParser


class AJAExport CNTV2Bitfile
{
    public:
                                            CNTV2Bitfile ();

        virtual                             ~CNTV2Bitfile ();

        virtual bool                        Open (const std::string & inBitfilePath);

        virtual void                        Close (void);

        virtual std::string                 ParseHeaderFromBuffer (const uint8_t* inBitfileBuffer, const size_t inBufferSize);

        virtual std::string                 ParseHeaderFromBuffer (const NTV2Buffer & inBitfileBuffer);

        virtual inline const std::string &  GetDate (void) const            {return mHeaderParser.Date();}

        virtual inline const std::string &  GetTime (void) const            {return mHeaderParser.Time();}

        virtual inline std::string          GetDesignName (void) const      {return mHeaderParser.DesignName();}

        virtual inline const std::string &  GetPartName (void) const        {return mHeaderParser.PartName();}

        virtual inline const std::string &  GetLastError (void) const       { return mLastError; }

        virtual inline bool     IsTandem (void) const                       {return mHeaderParser.IsTandem();}

        virtual inline bool     IsPartial (void) const                      {return mHeaderParser.IsPartial();}

        virtual inline bool     IsClear (void) const                        {return mHeaderParser.IsClear();}

        virtual inline bool     IsCompress (void) const                     {return mHeaderParser.IsCompress();}

        virtual inline ULWord   GetDesignID (void) const                    {return mHeaderParser.DesignID();}

        virtual inline ULWord   GetDesignVersion (void) const               {return mHeaderParser.DesignVersion();}

        virtual inline ULWord   GetBitfileID (void) const                   {return mHeaderParser.BitfileID();}

        virtual inline ULWord   GetBitfileVersion (void) const              {return mHeaderParser.BitfileVersion();}

        virtual inline ULWord   GetUserID (void) const                      {return mHeaderParser.UserID();}

        virtual bool            CanFlashDevice (const NTV2DeviceID inDeviceID) const;

        virtual NTV2DeviceID    GetDeviceID (void) const;

        virtual inline size_t   GetProgramStreamLength (void) const     {return mReady ? size_t(mHeaderParser.ProgramSizeBytes()) : 0;}

        virtual inline size_t   GetFileStreamLength (void) const        {return mReady ? mFileSize : 0;}
        
        virtual size_t          GetProgramByteStream (NTV2Buffer & outBuffer);

        virtual size_t          GetFileByteStream (NTV2Buffer & outBuffer);

    public: //  Class Methods
        static NTV2DeviceID     ConvertToDeviceID   (const ULWord inDesignID, const ULWord inBitfileID);
        static ULWord           ConvertToDesignID   (const NTV2DeviceID inDeviceID);
        static ULWord           ConvertToBitfileID  (const NTV2DeviceID inDeviceID);
        static std::string      GetPrimaryHardwareDesignName (const NTV2DeviceID inDeviceID);
        static NTV2DeviceID     GetDeviceIDFromHardwareDesignName (const std::string & inDesignName);

    protected:  //  Protected Methods
        virtual void            SetLastError (const std::string & inStr, const bool inAppend = false);

    private:    //  Private Member Data
        std::ifstream           mFileStream;    //  Binary input filestream
        NTV2Buffer              mHeaderBuffer;  //  Header buffer in use
        NTV2BitfileHeaderParser mHeaderParser;  //  Header parser (and state info)
        std::string             mLastError;     //  Last error message
        size_t                  mFileSize;      //  Bitfile size, in bytes
        bool                    mReady;         //  Ready?
};  //  CNTV2Bitfile

#endif // NTV2BITFILE_H