klvobject.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2003, Matt Beard
 *  Portions Copyright (c) 2003, Metaglue Corporation
 *
 *  This software is provided 'as-is', without any express or implied warranty.
 *  In no event will the authors be held liable for any damages arising from
 *  the use of this software.
 *
 *  Permission is granted to anyone to use this software for any purpose,
 *  including commercial applications, and to alter it and redistribute it
 *  freely, subject to the following restrictions:
 *
 *    1. The origin of this software must not be misrepresented; you must
 *       not claim that you wrote the original software. If you use this
 *       software in a product, an acknowledgment in the product
 *       documentation would be appreciated but is not required.
 *  
 *    2. Altered source versions must be plainly marked as such, and must
 *       not be misrepresented as being the original software.
 *  
 *    3. This notice may not be removed or altered from any source
 *       distribution.
 */
#ifndef MXFLIB__KLVOBJECT_H
#define MXFLIB__KLVOBJECT_H


// STL Includes
#include <string>
#include <list>
#include <map>


// Define some enums
namespace mxflib
{
    enum KeyFormat {
        KEY_NONE = 0,
        KEY_1_BYTE = 1,
        KEY_2_BYTE = 2,
        KEY_4_BYTE = 4,
        KEY_AUTO = 3
    };

    enum LenFormat
    {
        LEN_NONE = 0,
        LEN_1_BYTE = 1,
        LEN_2_BYTE = 2,
        LEN_4_BYTE = 4,
        LEN_BER = 3
    };
}


namespace mxflib
{
    // Forward declare so the class can include pointers to itself
    class KLVObject;

    typedef SmartPtr<KLVObject> KLVObjectPtr;

    typedef std::list<KLVObjectPtr> KLVObjectList;

    typedef std::map<std::string, KLVObjectPtr> KLVObjectMap;
}


namespace mxflib
{

    class KLVReadHandler_Base : public RefCount<KLVReadHandler_Base>
    {
    public:
        virtual ~KLVReadHandler_Base();


        virtual size_t ReadData(DataChunk &Buffer, KLVObjectPtr Object, Position Start = 0, size_t Size = static_cast<size_t>(-1)) = 0;

//      //! Read the key and length of the KLVObject
//      virtual Int32 ReadKL(KLVObjectPtr Object) { return -1;}
    };

    typedef SmartPtr<KLVReadHandler_Base> KLVReadHandlerPtr;


//  //! Base class for KLVObject write handlers
//  /*! \note Classes derived from this class <b>must not</b> include their own RefCount<> derivation
//   */
//  class KLVWriteHandler_Base : public RefCount<KLVWriteHandler_Base>
//  {
//  public:
//      //! Base destructor
//      virtual ~KLVReadHandler_Base();
//
//      //! Write data from the KLVObject to the destination
//      /*! \param Object KLVObject that is the data source
//       *  \param Buffer Location of the data to write
//       *  \param Start Offset from the start of the KLV value of the first byte to be written
//       *  \param Size Number of bytes to be written
//       *  \return The count of bytes written
//       */
//      virtual size_t WriteData(KLVObjectPtr Object, const UInt8 *Buffer, Position Start = 0, size_t Size = static_cast<size_t>(-1)) = 0;
//  };
//
//  //! Smart pointer for the base KLVObject read handler
//  typedef SmartPtr<KLVWriteHandler_Base> KLVWriteHandlerPtr;



    class KLVObject : public RefCount<KLVObject>
    {
    protected:
        class KLVInfo
        {
        private:
            KLVInfo(KLVInfo &);             

        public:
            MXFFilePtr File;                
            Position Offset;                
            Length OuterLength;             
            Int32 KLSize;                   
            bool Valid;                     

            KLVInfo()
            {
                Valid = false;
                Offset = -1;
                OuterLength = 0;
                KLSize = -1;
            }
            
            KLVInfo &operator=(const KLVInfo &RHS)
            {
                Valid = RHS.Valid;
                File = RHS.File;
                Offset = RHS.Offset;
                OuterLength = RHS.OuterLength;
                KLSize = RHS.KLSize;

                return *this;
            }
        };

        KLVInfo Source;                     
        KLVInfo Dest;                       

        ULPtr TheUL;                        
        Length ValueLength;                 

        DataChunk Data;                     
        Position DataBase;                  

        KLVReadHandlerPtr ReadHandler;      
//      KLVWriteHandlerPtr WriteHandler;    //!< A read-handler to supply data in response to read requests. If NULL data will be read from SourceFile (if available)

        //## DRAGONS: Ensure any new properties are copied by the KLVObject --> KLVEObject copy constructor ##

        //@@@ Is this another MSVC bug?  KLVEObject can't access protected KLVObject properties from KLVEObject constructor!!
        friend class KLVEObject;

    public:
        KLVObject(ULPtr ObjectUL = NULL);
        virtual void Init(void);
        virtual ~KLVObject() {};        


        virtual void SetSource(MXFFilePtr File, Position Location = -1)
        {
            Source.Valid = true;
            Source.File = File;
            if(Location < 0) Source.Offset = File->Tell();
            else Source.Offset = Location;

            // If we don't have a destination file assume it is the same as the source file
            if(!Dest.Valid)
            {
                Dest = Source;
            }
        }


        virtual void SetDestination(MXFFilePtr File, Position Location = -1)
        {
            Dest.Valid = true;
            Dest.File = File;

            if(Location < 0) Dest.Offset = File->Tell();
            else Dest.Offset = Location;
        }

        virtual ULPtr GetUL(void) { return TheUL; }

        virtual void SetUL(ULPtr NewUL) { TheUL = NewUL; }

        virtual Position GetLocation(void) { return Source.Offset; }

        virtual std::string GetSource(void);

        std::string GetSourceLocation(void) 
        {
            if(!Source.File) return std::string("KLVObject created in memory");
            return std::string("0x") + Int64toHexString(GetLocation(),8) + std::string(" in ") + GetSource();
        }

        virtual Int32 GetKLSize(void) { return Source.KLSize >= 0 ? Source.KLSize : Dest.KLSize; }


        virtual void SetKLSize(Int32 NewKLSize) { Dest.KLSize = NewKLSize; }

        virtual GCElementKind GetGCElementKind(void) { return mxflib::GetGCElementKind(TheUL); }

        virtual UInt32 GetGCTrackNumber(void) { return mxflib::GetGCTrackNumber(TheUL); };


        virtual Position GetDataBase(void) { return DataBase; };


        virtual void SetDataBase(Position NewBase) { DataBase = NewBase; };


        virtual Int32 ReadKL(void) { return Base_ReadKL(); }


        Int32 Base_ReadKL(void);


        virtual size_t ReadData(size_t Size = static_cast<size_t>(-1)) { return Base_ReadDataFrom(0, Size); }


        virtual size_t ReadDataFrom(Position Offset, size_t Size = static_cast<size_t>(-1)) { return Base_ReadDataFrom(Offset, Size); }


        inline size_t Base_ReadDataFrom(Position Offset, size_t Size = static_cast<size_t>(-1)) { return Base_ReadDataFrom(Data, Offset, Size); }


        size_t Base_ReadDataFrom(DataChunk &Buffer, Position Offset, size_t Size = static_cast<size_t>(-1));


        virtual Int32 WriteKL(Int32 LenSize = 0) { return Base_WriteKL(LenSize); }


        Int32 Base_WriteKL(Int32 LenSize = 0, Length NewLength = -1);



        virtual size_t WriteData(size_t Size = static_cast<size_t>(-1)) { return WriteDataFromTo(0, 0, Size); }


        virtual size_t WriteDataFrom(Position Start, size_t Size = static_cast<size_t>(-1)) { return WriteDataFromTo(0, Start, Size); }


        virtual size_t WriteDataTo(Position Offset, size_t Size = static_cast<size_t>(-1)) { return WriteDataFromTo(Offset, 0, Size); }


        virtual size_t WriteDataFromTo(Position Offset, Position Start, size_t Size = static_cast<size_t>(-1))
        {
            // Calculate default number of bytes to write
            Length BytesToWrite = Data.Size - Start;

            // Write the requested size (if valid)
            if((Size > 0) && (Size < BytesToWrite)) BytesToWrite = Size;

            // Sanity check the size of this chunk
            if((sizeof(size_t) < 8) && (BytesToWrite > 0xffffffff))
            {
                error("Tried to write > 4GBytes, but this platform can only handle <= 4GByte chunks\n");
                return 0;
            }

            return Base_WriteDataTo(&Data.Data[Start], Offset, static_cast<size_t>(BytesToWrite));
        }


        virtual size_t WriteDataTo(const UInt8 *Buffer, Position Offset, size_t Size) { return Base_WriteDataTo(Buffer, Offset, Size); }


        size_t Base_WriteDataTo(const UInt8 *Buffer, Position Offset, size_t Size);



        virtual void SetReadHandler(KLVReadHandlerPtr Handler) { ReadHandler = Handler; }

//      //! Set a handler to supply data when a write is performed
//      /*! \note If not set it will be written to destination file (if available) or cause an error message
//       */
//      virtual void SetWriteHandler(KLVWriteHandlerPtr Handler) { WriteHandler = Handler; }

        virtual Length GetLength(void) { return ValueLength; }

        virtual void SetLength(Length NewLength) { ValueLength = Dest.OuterLength = Source.OuterLength = NewLength; }

        virtual DataChunk& GetData(void) { return Data; }
    };
}

#endif // MXFLIB__KLVOBJECT_H

---