essence.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2003, Matt Beard
 *
 *  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__ESSENCE_H
#define MXFLIB__ESSENCE_H


#include <map>
#include <list>


// Forward refs
namespace mxflib
{
    class GCWriter;
    typedef SmartPtr<GCWriter> GCWriterPtr;

    class GCReader;
    typedef SmartPtr<GCReader> GCReaderPtr;

    // Type used to identify stream
    typedef int GCStreamID;
}


/* Global definitions */
namespace mxflib
{

    extern bool AllowFastClipWrap;

    inline void SetFastClipWrap(bool Flag) { AllowFastClipWrap = Flag; }

    inline bool GetFastClipWrap(void) { return AllowFastClipWrap; }
}


namespace mxflib
{

    class EssenceSource : public RefCount<EssenceSource>
    {
    protected:

        GCStreamID StreamID;
        
        IndexManagerPtr IndexMan;

        int IndexStreamID;

        DataChunkPtr SpecifiedKey;

        bool NonGC;

    public:
        // Base constructor
        EssenceSource() : StreamID(-1) {};

        virtual ~EssenceSource() { };


        virtual size_t GetEssenceDataSize(void) = 0;


        virtual DataChunkPtr GetEssenceData(size_t Size = 0, size_t MaxSize = 0) = 0;


        virtual bool EndOfItem(void) = 0;


        virtual bool EndOfData(void) = 0;

        virtual UInt8 GetGCEssenceType(void) = 0;

        virtual UInt8 GetGCElementType(void) = 0;

        void SetStreamID(GCStreamID NewID) { StreamID = NewID; }

        GCStreamID GetStreamID(void) { return StreamID; }

        virtual bool IsEditPoint(void) { return true; }


        virtual Rational GetEditRate(void) = 0;


        virtual Position GetCurrentPosition(void) = 0;

        virtual int GetBERSize(void) { return 0; }


        virtual bool SetOption(std::string Option, Int64 Param = 0) { return false; } ;


        virtual UInt32 GetBytesPerEditUnit(UInt32 KAGSize = 1) { return 0; }


        virtual bool CanIndex() { return false; }


        virtual void SetIndexManager(IndexManagerPtr &Manager, int StreamID)
        {
            IndexMan = Manager;
            IndexStreamID = StreamID;
        }

        virtual IndexManagerPtr &GetIndexManager(void) { return IndexMan; }

        virtual int GetIndexStreamID(void) { return IndexStreamID; }

        virtual void SetKey(DataChunkPtr &Key, bool NonGC = false)
        {
            ASSERT(Key->Size == 16);

            SpecifiedKey = Key;
            this->NonGC = NonGC;
        }


        virtual DataChunkPtr &GetKey(void) { return SpecifiedKey; }

        /*  \note Defined EssenceSource sub-classes may always use a non-GC-type key, in which case
         *        they will always return true from this function
         */
        virtual bool GetNonGC(void) { return NonGC; }

        /* Essence type identification */
        /* These functions can be overwridden, or use the base versions to parse GetGCEssenceType() */

        virtual bool IsPictureEssence(void)
        {
            UInt8 Type = GetGCEssenceType();
            if((Type == 0x05) || (Type == 0x15)) return true;
            return false;
        }

        virtual bool IsSoundEssence(void)
        {
            UInt8 Type = GetGCEssenceType();
            if((Type == 0x06) || (Type == 0x16)) return true;
            return false;
        }

        virtual bool IsDataEssence(void)
        {
            UInt8 Type = GetGCEssenceType();
            if((Type == 0x07) || (Type == 0x17)) return true;
            return false;
        }

        virtual bool IsCompoundEssence(void)
        {
            return (GetGCEssenceType() == 0x18);
        }


        virtual Int32 RelativeWriteOrder(void) { return 0; }


        virtual int RelativeWriteOrderType(void) { return 0; }


        virtual Length GetPrechargeSize(void) { return 0; }


        virtual Position GetRangeStart(void) { return 0; }


        virtual Position GetRangeEnd(void) { return 0; }


        virtual Length GetRangeDuration(void) { return 0; }
    };

    // Smart pointer to an EssenceSource object
    typedef SmartPtr<EssenceSource> EssenceSourcePtr;

    // Parent pointer to an EssenceSource object
    typedef ParentPtr<EssenceSource> EssenceSourceParent;

    // List of smart pointer to EssenceSource objects
    typedef std::list<EssenceSourcePtr> EssenceSourceList;
}



namespace mxflib
{

    class EssenceSink : public RefCount<EssenceSink>
    {
    protected:

    public:
        // Base constructor
        EssenceSink() {};

        virtual ~EssenceSink() {};


        virtual bool PutEssenceData(UInt8 *const Buffer, size_t BufferSize, bool EndOfItem = true) = 0;

        bool PutEssenceData(DataChunkPtr &Buffer, bool EndOfItem = true) { return PutEssenceData(Buffer->Data, Buffer->Size, EndOfItem); }

        bool PutEssenceData(DataChunk &Buffer, bool EndOfItem = true) { return PutEssenceData(Buffer.Data, Buffer.Size, EndOfItem); }


        virtual bool EndOfData(void) = 0;
    };

    // Smart pointer to an EssenceSink object
    typedef SmartPtr<EssenceSink> EssenceSinkPtr;

    // Parent pointer to an EssenceSink object
    typedef ParentPtr<EssenceSink> EssenceSinkParent;

    // List of smart pointer to EssenceSink objects
    typedef std::list<EssenceSinkPtr> EssenceSinkList;
}



namespace mxflib
{
    const UInt8 GCMulti_Data[16] = { 0x06, 0x0E, 0x2B, 0x34, 0x04, 0x01, 0x01, 0x03, 0x0d, 0x01, 0x03, 0x01, 0x02, 0x7F, 0x01, 0x00 };
}


namespace mxflib
{
    struct GCStreamData
    {
        DataChunkPtr SpecifiedKey;          
        bool NonGC;                         
        UInt8 Type;                         
        UInt8 SchemeOrCount;                
        UInt8 Element;                      
        UInt8 SubOrNumber;                  
        UInt8 RegDes;                       
        UInt8 RegVer;                       
        int LenSize;                        
        IndexManagerPtr IndexMan;           
        int IndexSubStream;                 
        bool IndexFiller;                   
        bool IndexClip;                     
        bool CountFixed;                    

        UInt32 WriteOrder;                  

    };

    class GCWriter : public RefCount<GCWriter>
    {
    protected:
        MXFFilePtr LinkedFile;              
        UInt32 TheBodySID;                  

        int StreamTableSize;                
        int StreamCount;                    

        int StreamBase;                     

        GCStreamData *StreamTable;          

        UInt32 KAGSize;                     
        bool ForceFillerBER4;               

        Int32 NextWriteOrder;               

        Position IndexEditUnit;             

        UInt64 StreamOffset;                

        std::map<UInt32, GCStreamID> WriteOrderMap;

    public:
        GCWriter(MXFFilePtr File, UInt32 BodySID = 0, int Base = 0);

        ~GCWriter();

        void SetKAG(UInt32 KAG, bool ForceBER4 = false) { KAGSize = KAG; ForceFillerBER4 = ForceBER4; };

        UInt32 GetKAG(void) { return KAGSize; }

        GCStreamID AddSystemElement(unsigned int RegistryDesignator, unsigned int SchemeID, unsigned int ElementID, unsigned int SubID = 0) { return AddSystemElement(false, RegistryDesignator, SchemeID, ElementID, SubID); }

        GCStreamID AddCPSystemElement(unsigned int RegistryDesignator, unsigned int SchemeID, unsigned int ElementID, unsigned int SubID = 0)   { return AddSystemElement(true, RegistryDesignator, SchemeID, ElementID, SubID); }

        GCStreamID AddSystemElement(bool CPCompatible, unsigned int RegistryDesignator, unsigned int SchemeID, unsigned int ElementID, unsigned int SubID = 0);
        
        GCStreamID AddPictureElement(unsigned int ElementType) { return AddPictureElement(false, ElementType); }

        GCStreamID AddCPPictureElement(unsigned int ElementType) { return AddPictureElement(true, ElementType); }

        GCStreamID AddPictureElement(bool CPCompatible, unsigned int ElementType) { return AddEssenceElement( CPCompatible ? 0x05 : 0x15, ElementType); }

        GCStreamID AddSoundElement(unsigned int ElementType) { return AddPictureElement(false, ElementType); }

        GCStreamID AddCPSoundElement(unsigned int ElementType) { return AddPictureElement(true, ElementType); }

        GCStreamID AddSoundElement(bool CPCompatible, unsigned int ElementType) { return AddEssenceElement( CPCompatible ? 0x06 : 0x16, ElementType); }

        GCStreamID AddDataElement(unsigned int ElementType) { return AddDataElement(false, ElementType); }

        GCStreamID AddCPDataElement(unsigned int ElementType) { return AddDataElement(true, ElementType); }

        GCStreamID AddDataElement(bool CPCompatible, unsigned int ElementType) { return AddEssenceElement( CPCompatible ? 0x07 : 0x17, ElementType); }

        GCStreamID AddCompoundElement(unsigned int ElementType) { return AddEssenceElement( 0x18, ElementType); }

        GCStreamID AddEssenceElement(unsigned int EssenceType, unsigned int ElementType, int LenSize = 0);

        GCStreamID AddEssenceElement(DataChunkPtr &Key, int LenSize = 0, bool NonGC = false);

        GCStreamID AddEssenceElement(int KeySize, UInt8 *KeyData, int LenSize = 0, bool NonGC = false)
        {
            DataChunkPtr Key = new DataChunk(KeySize, KeyData);
            return AddEssenceElement(Key, LenSize, NonGC);
        }

        void AddStreamIndex(GCStreamID ID, IndexManagerPtr &IndexMan, int IndexSubStream, bool IndexFiller = false, bool IndexClip = false);

        UInt32 GetTrackNumber(GCStreamID ID);

        void AssignEssenceUL(GCStreamID ID, ULPtr EssenceUL);

        void StartNewCP(void);

        UInt64 CalcWriteSize(void);

        void Flush(void);

        Int64 GetStreamOffset(void) { return StreamOffset; }

        void SetIndexEditUnit(Position EditUnit) { IndexEditUnit = EditUnit; }

        Position GetIndexEditUnit(void) { return IndexEditUnit; }

        void AddSystemData(GCStreamID ID, UInt64 Size, const UInt8 *Data);

        void AddSystemData(GCStreamID ID, DataChunkPtr Chunk) { AddSystemData(ID, Chunk->Size, Chunk->Data); }

        void AddSystemData(GCStreamID ID, UInt64 Size, const UInt8 *Data, UUIDPtr ContextID, Length PlaintextOffset = 0);
        
        void AddSystemData(GCStreamID ID, DataChunkPtr Chunk, UUIDPtr ContextID, Length PlaintextOffset = 0) { AddSystemData(ID, Chunk->Size, Chunk->Data, ContextID, PlaintextOffset); }

        void AddEssenceData(GCStreamID ID, UInt64 Size, const UInt8 *Data);

        void AddEssenceData(GCStreamID ID, DataChunkPtr Chunk) { AddEssenceData(ID, Chunk->Size, Chunk->Data); }

        void AddEssenceData(GCStreamID ID, EssenceSourcePtr Source, bool FastClipWrap = false);

/*      //! Add encrypted essence data to the current CP
        void AddEssenceData(GCStreamID ID, UInt64 Size, const UInt8 *Data, UUIDPtr ContextID, Length PlaintextOffset = 0);
        
        void AddEssenceData(GCStreamID ID, DataChunkPtr Chunk, UUIDPtr ContextID, Length PlaintextOffset = 0)  { AddEssenceData(ID, Chunk->Size, Chunk->Data, ContextID, PlaintextOffset); }

        void AddEssenceData(GCStreamID ID, EssenceSource* Source, UUIDPtr ContextID, Length PlaintextOffset = 0, bool FastClipWrap = false);
*/
        void AddEssenceData(GCStreamID ID, KLVObjectPtr Source, bool FastClipWrap = false);


        Length CalcRawSize(KLVObjectPtr Object);

        void WriteRaw(KLVObjectPtr Object);


        struct WriteBlock
        {
            UInt64 Size;                
            UInt8 *Buffer;              
            EssenceSourcePtr Source;    
            KLVObjectPtr KLVSource;     
            int LenSize;                
            IndexManagerPtr IndexMan;   
            int IndexSubStream;         
            bool IndexFiller;           
            bool IndexClip;             
            bool WriteEncrypted;        
            bool FastClipWrap;          
        };

        typedef std::map<UInt32,WriteBlock> WriteQueueMap;

        WriteQueueMap WriteQueue;


        void SetWriteOrder(GCStreamID ID, Int32 WriteOrder = -1, int Type =-1);

        void SetRelativeWriteOrder(GCStreamID ID, int Type, Int32 Position);

        Int32 GetWriteOrder(GCStreamID ID);

        int GetStreamCount(void) { return StreamCount; };
    };
}


namespace mxflib
{
    class EssenceSubParser;
    typedef SmartPtr<EssenceSubParser> EssenceSubParserPtr;
    typedef ParentPtr<EssenceSubParser> EssenceSubParserParent;

    class WrappingOption : public RefCount<WrappingOption>
    {
    public:

        enum WrapType { None, Frame, Clip, Line, Other } ;

        EssenceSubParserParent Handler;         
        std::string Name;                       
        std::string Description;                
        ULPtr   WrappingID;                     

        ULPtr   WrappingUL;                     
        ULList  RequiredPartners;               
        UInt8   GCEssenceType;                  
        UInt8   GCElementType;                  
        WrapType ThisWrapType;                  
        bool    CanSlave;                       
        bool    CanIndex;                       
        bool    CBRIndex;                       
        UInt8   BERSize;                        
        UInt32 BytesPerEditUnit;                
    };

    typedef SmartPtr<WrappingOption> WrappingOptionPtr;
    typedef std::list<WrappingOptionPtr> WrappingOptionList;

    class EssenceStreamDescriptor;

    typedef SmartPtr<EssenceStreamDescriptor> EssenceStreamDescriptorPtr;

    typedef std::list<EssenceStreamDescriptorPtr> EssenceStreamDescriptorList;

    class EssenceStreamDescriptor : public RefCount<EssenceStreamDescriptor>
    {
    public:
        UInt32 ID;                              
        std::string Description;                
        UUID SourceFormat;                      
        MDObjectPtr Descriptor;                 
        EssenceStreamDescriptorList SubStreams; 
    };


    class EssenceSubParserFactory : public RefCount<EssenceSubParserFactory>
    {
    public:
        virtual EssenceSubParserPtr NewParser(void) const = 0;
    };

    typedef SmartPtr<EssenceSubParserFactory> EssenceSubParserFactoryPtr;



    class EssenceSubParser : public RefCount<EssenceSubParser>
    {
    protected:
        WrappingOptionPtr SelectedWrapping;

        IndexManagerPtr Manager;

        int ManagedStreamID;

    public:


        class ESP_EssenceSource : public EssenceSource
        {
        protected:
            EssenceSubParserPtr Caller;
            FileHandle File;
            UInt32 Stream;
            UInt64 RequestedCount;
            IndexTablePtr Index;
            DataChunkPtr RemainingData;
            bool AtEndOfData;
            bool Started;

        public:
            ESP_EssenceSource(EssenceSubParserPtr TheCaller, FileHandle InFile, UInt32 UseStream, UInt64 Count = 1)
            {
                Caller = TheCaller;
                File = InFile;
                Stream = UseStream;
                RequestedCount = Count;
                AtEndOfData = false;
                Started = false;
            };


            virtual DataChunkPtr GetEssenceData(size_t Size = 0, size_t MaxSize = 0) { return BaseGetEssenceData(Size, MaxSize); };


            DataChunkPtr BaseGetEssenceData(size_t Size = 0, size_t MaxSize = 0)
            {
                // Allow us to differentiate the first call
                if(!Started) Started = true;

                DataChunkPtr Data;

                if(RemainingData)
                {
                    Data = RemainingData;
                    RemainingData = NULL;
                }
                else
                {
                    Data = Caller->Read(File, Stream, 1);
                }
                if(Data)
                {
                    if(Data->Size == 0) Data = NULL;
                    else
                    {
                        if((MaxSize) && (Data->Size > MaxSize))
                        {
                            RemainingData = new DataChunk(Data->Size - MaxSize, &Data->Data[MaxSize]);
                            Data->Resize((UInt32)MaxSize);
                        }
                    }
                }

                // Record when we hit the end of all data
                if(!Data) AtEndOfData = true;

                return Data;
            }


            virtual bool EndOfItem(void) 
            { 
                // If we are clip wrapping then we only end when no more data
                if(Caller->GetWrapType() == WrappingOption::Clip) return AtEndOfData;

                // Otherwise items end when there is no data remaining from the last read
                return !RemainingData;
            }


            virtual bool EndOfData(void) { return AtEndOfData; }

            virtual UInt8 GetGCEssenceType(void) { return Caller->GetGCEssenceType(); }

            virtual UInt8 GetGCElementType(void) { return Caller->GetGCElementType(); }

            virtual bool IsEditPoint(void) { return true; }


            virtual Rational GetEditRate(void) { return Caller->GetEditRate(); }


            virtual Position GetCurrentPosition(void) { return Caller->GetCurrentPosition(); }


            virtual bool SetOption(std::string Option, Int64 Param = 0) { return Caller->SetOption(Option, Param); } ;


            virtual UInt32 GetBytesPerEditUnit(UInt32 KAGSize = 1) { return Caller->GetBytesPerEditUnit(KAGSize); }


            virtual bool CanIndex() { return Caller->SelectedWrapping->CanIndex; }

            virtual void SetIndexManager(IndexManagerPtr &Manager, int StreamID)
            {
                // Set the manager in our containing parser
                Caller->SetIndexManager(Manager, StreamID);
            }
        };

        // Allow embedded essence source to access our protected properties
        friend class ESP_EssenceSource;


    protected:

    public:
        virtual ~EssenceSubParser() {};

        virtual StringList HandledExtensions(void) { StringList Ret; return Ret; };


        virtual EssenceStreamDescriptorList IdentifyEssence(FileHandle InFile)
        {
            EssenceStreamDescriptorList Ret;
            return Ret;
        }


        virtual WrappingOptionList IdentifyWrappingOptions(FileHandle InFile, EssenceStreamDescriptor &Descriptor)
        {
            WrappingOptionList Ret;
            return Ret;
        }

        virtual void Use(UInt32 Stream, WrappingOptionPtr &UseWrapping)
        {
            // DRAGONS: Any derived version of Use() must also set SelectedWrapping
            SelectedWrapping = UseWrapping;
        }

        virtual bool CanReValidate(void) { return false; }


        virtual bool ReValidate(FileHandle Infile, UInt32 Stream, MDObjectPtr &Descriptor, WrappingOptionPtr &UseWrapping)
        {
            return false;
        }

        WrappingOption::WrapType GetWrapType(void)
        {
            if(!SelectedWrapping) return WrappingOption::None;

            return SelectedWrapping->ThisWrapType;
        }


        virtual bool SetEditRate(Rational EditRate)
        {
            // Default action is to not allow the edit rate to be changed
            return (EditRate == GetEditRate());
        }

        virtual Rational GetEditRate(void) = 0;


        virtual Rational GetPreferredEditRate(void)
        {
            // By default we don't know the preferred rate
            return Rational(0,0);
        }


        virtual UInt32 GetBytesPerEditUnit(UInt32 KAGSize = 1) { return KAGSize * 0; }


        virtual Position GetCurrentPosition(void) = 0;

        virtual void SetIndexManager(IndexManagerPtr &TheManager, int StreamID = 0)
        {
            Manager = TheManager;
            ManagedStreamID = StreamID;
        }

        virtual IndexManagerPtr &GetIndexManager(void) { return Manager; };

        virtual int GetIndexStreamID(void) { return ManagedStreamID; };

        virtual void SetStreamOffset(Position EditUnit, UInt64 Offset)
        {
            if(Manager) Manager->SetOffset(ManagedStreamID, EditUnit, Offset);
        }

        virtual bool OfferStreamOffset(Position EditUnit, UInt64 Offset)
        {
            if(!Manager) return false;
            return Manager->OfferOffset(ManagedStreamID, EditUnit, Offset);
        }

        virtual void IndexNext(void)
        {
            if(Manager) Manager->AcceptNext();
        }

        virtual int IndexLogNext(void)
        {
            if(Manager) return Manager->AcceptLogNext();
            return -1;
        }

        virtual int LogNext(void)
        {
            if(Manager) return Manager->LogNext();
            return -1;
        }

        virtual Position ReadLog(int LogID)
        {
            if(Manager) return Manager->ReadLog(LogID);
            return IndexTable::IndexLowest;
        }


        virtual Position AcceptProvisional(void)
        {
            if(Manager) return Manager->AcceptProvisional();
            return IndexTable::IndexLowest;
        }

        Position GetLastNewEditUnit(void) 
        { 
            if(Manager) return Manager->GetLastNewEditUnit();
            return IndexTable::IndexLowest;
        }

        virtual UInt8 GetGCEssenceType(void) { return SelectedWrapping->GCEssenceType; }

        virtual UInt8 GetGCElementType(void) { return SelectedWrapping->GCElementType; }



        virtual DataChunkPtr Read(FileHandle InFile, UInt32 Stream, UInt64 Count = 1) = 0;

        virtual EssenceSourcePtr GetEssenceSource(FileHandle InFile, UInt32 Stream, UInt64 Count = 1) = 0;


        virtual Length Write(FileHandle InFile, UInt32 Stream, MXFFilePtr OutFile, UInt64 Count = 1) = 0;


        virtual bool SetOption(std::string Option, Int64 Param = 0) { return false; } ;


        virtual std::string GetParserName(void) const { return ""; }



        virtual EssenceSubParserPtr NewParser(void) const = 0;
    };

    typedef EssenceSubParser EssenceSubParserBase;




    class EssenceSubParserSelfFactory : public EssenceSubParserFactory
    {
    protected:
        EssenceSubParserPtr Parser;

    public:
        EssenceSubParserSelfFactory(EssenceSubParserPtr Parser) : Parser(Parser) {};

        virtual EssenceSubParserPtr NewParser(void) const { return Parser->NewParser(); }
    };

}


namespace mxflib
{
    typedef std::pair<EssenceSubParserPtr, EssenceStreamDescriptorList> ParserDescriptorPair;
    typedef std::list<EssenceSubParserPtr> EssenceParserList;


    class ParserDescriptorList : public RefCount<ParserDescriptorList>, public std::list<ParserDescriptorPair> {};
    typedef SmartPtr<ParserDescriptorList> ParserDescriptorListPtr;


    class EssenceParser
    {
    public:
        typedef std::list<EssenceSubParserFactoryPtr> EssenceSubParserFactoryList;

    protected:

        static EssenceSubParserFactoryList EPList;
        
        static bool Inited;

    private:
        EssenceParser();

    public:

        static void AddNewSubParserType(EssenceSubParserFactoryPtr Factory)
        {
            EPList.push_back(Factory);
        }


        static void AddNewSubParserType(EssenceSubParserPtr SubParser)
        {
            EssenceSubParserFactoryPtr Factory = new EssenceSubParserSelfFactory(SubParser);

            EPList.push_back(Factory);
        }

        static ParserDescriptorListPtr IdentifyEssence(FileHandle InFile);

        class WrappingConfig;
        
        typedef SmartPtr<WrappingConfig> WrappingConfigPtr;

        typedef std::list<WrappingConfigPtr> WrappingConfigList;


        class WrappingConfig : public RefCount<WrappingConfig>
        {
        public:
            EssenceSubParserPtr Parser;                 
            WrappingOptionPtr WrapOpt;                  
            MDObjectPtr EssenceDescriptor;              
            UInt32 Stream;                              
            Rational EditRate;                          
            WrappingConfigList SubStreams;              
        };

        static WrappingConfigList ListWrappingOptions(bool AllowMultiples, FileHandle InFile, ParserDescriptorListPtr PDList, Rational ForceEditRate, WrappingOption::WrapType ForceWrap = WrappingOption::None);

        static WrappingConfigList ListWrappingOptions(FileHandle InFile, ParserDescriptorListPtr PDList, Rational ForceEditRate, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            return ListWrappingOptions(false, InFile, PDList, ForceEditRate, ForceWrap);
        }

        static WrappingConfigList ListWrappingOptions(bool AllowMultiples, FileHandle InFile, Rational ForceEditRate, WrappingOption::WrapType ForceWrap = WrappingOption::None);

        static WrappingConfigList ListWrappingOptions(FileHandle InFile, Rational ForceEditRate, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            return ListWrappingOptions(false, InFile, ForceEditRate, ForceWrap);
        }

        static WrappingConfigList ListWrappingOptions(bool AllowMultiples, FileHandle InFile, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            Rational ForceEditRate(0,0);
            return ListWrappingOptions(AllowMultiples, InFile, ForceEditRate, ForceWrap);
        }

        static WrappingConfigList ListWrappingOptions(FileHandle InFile, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            Rational ForceEditRate(0,0);
            return ListWrappingOptions(false, InFile, ForceEditRate, ForceWrap);
        }

        static WrappingConfigPtr SelectWrappingOption(FileHandle InFile, ParserDescriptorListPtr PDList, Rational ForceEditRate, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            return SelectWrappingOption(false, InFile, PDList, ForceEditRate, ForceWrap);
        }

        static WrappingConfigPtr SelectWrappingOption(FileHandle InFile, ParserDescriptorListPtr PDList, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            Rational ForceEditRate(0,0);
            return SelectWrappingOption(false, InFile, PDList, ForceEditRate, ForceWrap);
        }

        static WrappingConfigPtr SelectWrappingOption(bool AllowMultiples, FileHandle InFile, ParserDescriptorListPtr PDList, Rational ForceEditRate, WrappingOption::WrapType ForceWrap = WrappingOption::None);

        static WrappingConfigPtr SelectWrappingOption(bool AllowMultiples, FileHandle InFile, ParserDescriptorListPtr PDList, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            Rational ForceEditRate(0,0);
            return SelectWrappingOption(AllowMultiples, InFile, PDList, ForceEditRate, ForceWrap);
        }

        static WrappingConfigPtr SelectWrappingOption(FileHandle InFile, Rational ForceEditRate, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            return SelectWrappingOption(false, InFile, ForceEditRate, ForceWrap);
        }

        static WrappingConfigPtr SelectWrappingOption(FileHandle InFile, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            Rational ForceEditRate(0,0);
            return SelectWrappingOption(false, InFile, ForceEditRate, ForceWrap);
        }

        static WrappingConfigPtr SelectWrappingOption(bool AllowMultiples, FileHandle InFile, Rational ForceEditRate, WrappingOption::WrapType ForceWrap = WrappingOption::None);

        static WrappingConfigPtr SelectWrappingOption(bool AllowMultiples, FileHandle InFile, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            Rational ForceEditRate(0,0);
            return SelectWrappingOption(AllowMultiples, InFile, ForceEditRate, ForceWrap);
        }

        static void SelectWrappingOption(EssenceParser::WrappingConfigPtr Config);

        static WrappingConfigPtr SelectWrappingOption(FileHandle InFile)
        {
            Rational ForceEditRate(0,0);
            return SelectWrappingOption(InFile, ForceEditRate);
        }

        static WrappingConfigPtr SelectWrappingOption(FileHandle InFile, std::string WrappingName, Rational ForceEditRate);

        static WrappingConfigPtr SelectWrappingOption(FileHandle InFile, std::string WrappingName)
        {
            Rational ForceEditRate(0,0);
            return SelectWrappingOption(InFile, WrappingName, ForceEditRate);
        }

        static WrappingConfigPtr SelectWrappingOption(FileHandle InFile, std::list<std::string> WrappingNameList, Rational ForceEditRate);

        static WrappingConfigPtr SelectWrappingOption(FileHandle InFile, std::list<std::string> WrappingNameList)
        {
            Rational ForceEditRate(0,0);
            return SelectWrappingOption(InFile, WrappingNameList, ForceEditRate);
        }

        static WrappingConfigPtr SelectWrappingOption(FileHandle InFile, ULPtr &WrappingID, Rational ForceEditRate);

        static WrappingConfigPtr SelectWrappingOption(FileHandle InFile, ULPtr &WrappingID)
        {
            Rational ForceEditRate(0,0);
            return SelectWrappingOption(InFile, WrappingID, ForceEditRate);
        }

        static WrappingConfigPtr SelectWrappingOption(FileHandle InFile, ULList &WrappingIDList, Rational ForceEditRate);

        static WrappingConfigPtr SelectWrappingOption(FileHandle InFile, ULList &WrappingIDList)
        {
            Rational ForceEditRate(0,0);
            return SelectWrappingOption(InFile, WrappingIDList, ForceEditRate);
        }

    protected:

        static void ExtractValidWrappingOptions(WrappingConfigList &Ret, FileHandle InFile, EssenceStreamDescriptorPtr &ESDescriptor, WrappingOptionList &WO, Rational &ForceEditRate, WrappingOption::WrapType ForceWrap);

    
    protected:
        static void Init(void);
    };


    /* Make top-level versions of EssenceParser::WrappingConfig typedefs */

    typedef EssenceParser::WrappingConfigPtr WrappingConfigPtr;

    typedef EssenceParser::WrappingConfigList WrappingConfigList;
}


namespace mxflib
{
    class NewFileHandler : public RefCount<NewFileHandler>
    {
    public:
        virtual ~NewFileHandler() {};


        virtual void NewFile(std::string &FileName) = 0;
    };

    typedef SmartPtr<NewFileHandler> NewFileHandlerPtr;

    // Forware declare the file parser
    class FileParser;

    typedef SmartPtr<FileParser> FileParserPtr;


    class ListOfFiles
    {
    protected:
        NewFileHandlerPtr Handler;              
        std::string BaseFileName;               
        std::list<std::string> FollowingNames;  
        bool FileList;                          
        int ListOrigin;                         
        int ListIncrement;                      
        int ListNumber;                         
        int ListEnd;                            
        int FileNumber;                         
        int FilesRemaining;                     
        bool AtEOF;                             
        std::string CurrentFileName;            

        Position RangeStart;                    
        Position RangeEnd;                      
        Length RangeDuration;                   

    public:
        ListOfFiles(std::string FileName = "") : RangeStart(-1), RangeEnd(-1), RangeDuration(-1)
        {
            AtEOF = false;

            // Set the filename pattern if required
            if(FileName.size())
            {
                ParseFileName(FileName); 
            }
            else
            {
                BaseFileName = "";
                FileList = false; 
            }
        }

        virtual ~ListOfFiles() {}

        void SetFileName(std::string &FileName) 
        { 
            FollowingNames.clear();
            ParseFileName(FileName); 
        }

        void AddFileName(std::string &FileName) 
        { 
            if(BaseFileName.empty())
            {
                ParseFileName(FileName); 
            }
            else
            {
                FollowingNames.push_back(FileName);
            }
        }

        void SetNewFileHandler(NewFileHandlerPtr &NewHandler) { Handler = NewHandler; }

        void SetNewFileHandler(NewFileHandler *NewHandler) { Handler = NewHandler; }

        Position GetRangeStart(void) const { return RangeStart; }

        Position GetRangeEnd(void) const { return RangeEnd; }

        Position GetRangeDuration(void) const { return RangeDuration; }

        std::string FileName(void) { return CurrentFileName; }


        virtual bool OpenFile(void) = 0;


        virtual void CloseFile(void) = 0;


        virtual bool IsFileOpen(void) = 0;

        bool IsFileList(void) { return FileList; }


        bool GetNextFile(void);

    protected:
        void ParseFileName(std::string FileName);

    };


    class FileParser : public ListOfFiles, public RefCount<FileParser>
    {
    protected:
        bool CurrentFileOpen;                   
        FileHandle CurrentFile;                 
        EssenceSubParserPtr SubParser;          
        UInt32 CurrentStream;                   
        MDObjectPtr CurrentDescriptor;          
        WrappingOptionPtr CurrentWrapping;      
        EssenceSourceParent SeqSource;          

        DataChunkPtr PendingData;               

        struct SubStreamInfo
        {
            UInt32 StreamID;                    
            EssenceSourcePtr Source;            
        };

        typedef std::list<SubStreamInfo> SubStreamList;

        SubStreamList SubStreams;               


    public:
        FileParser(std::string FileName = "") : ListOfFiles(FileName)
        {
            // Let our sequential source know who we are
            SeqSource = new SequentialEssenceSource(this);

            CurrentFileOpen = false;
        }

        ParserDescriptorListPtr IdentifyEssence(void);

        EssenceParser::WrappingConfigList ListWrappingOptions(bool AllowMultiples, ParserDescriptorListPtr PDList, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            Rational Zero(0,0);
            return ListWrappingOptions(AllowMultiples, PDList, Zero, ForceWrap);
        }

        EssenceParser::WrappingConfigList ListWrappingOptions(ParserDescriptorListPtr PDList, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            Rational Zero(0,0);
            return ListWrappingOptions(false, PDList, Zero, ForceWrap);
        }

        EssenceParser::WrappingConfigList ListWrappingOptions(bool AllowMultiples, ParserDescriptorListPtr PDList, Rational ForceEditRate, WrappingOption::WrapType ForceWrap = WrappingOption::None);

        EssenceParser::WrappingConfigList ListWrappingOptions(ParserDescriptorListPtr PDList, Rational ForceEditRate, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            return ListWrappingOptions(false, PDList, ForceEditRate, ForceWrap);
        }

        EssenceParser::WrappingConfigPtr SelectWrappingOption(ParserDescriptorListPtr PDList, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            Rational Zero(0,0);
            return SelectWrappingOption(false, PDList, Zero, ForceWrap);
        }

        EssenceParser::WrappingConfigPtr SelectWrappingOption(ParserDescriptorListPtr PDList, Rational ForceEditRate, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            return SelectWrappingOption(false, PDList, ForceEditRate, ForceWrap);
        }

        EssenceParser::WrappingConfigPtr SelectWrappingOption(bool AllowMultiples, ParserDescriptorListPtr PDList, WrappingOption::WrapType ForceWrap = WrappingOption::None)
        {
            Rational Zero(0,0);
            return SelectWrappingOption(AllowMultiples, PDList, Zero, ForceWrap);
        }

        EssenceParser::WrappingConfigPtr SelectWrappingOption(bool AllowMultiples, ParserDescriptorListPtr PDList, Rational ForceEditRate, WrappingOption::WrapType ForceWrap = WrappingOption::None);

        void SelectWrappingOption(EssenceParser::WrappingConfigPtr Config);


        void Use(UInt32 Stream, WrappingOptionPtr &UseWrapping);

        EssenceSourcePtr GetEssenceSource(UInt32 Stream);

        EssenceSourcePtr GetSubSource(UInt32 Stream);


        bool OpenFile(void)
        {
            CurrentFile = FileOpenRead(CurrentFileName.c_str());
            CurrentFileOpen = FileValid(CurrentFile);
            return CurrentFileOpen;
        }


        void CloseFile(void)
        {
            if(CurrentFileOpen) FileClose(CurrentFile);
            CurrentFileOpen = false;
        }


        bool IsFileOpen(void) { return CurrentFileOpen; }

    protected:

        bool GetFirstSource(void);


        bool GetNextSource(void);

        class SequentialEssenceSource : public EssenceSource
        {
        protected:
            EssenceSourcePtr CurrentSource;             
            FileParserPtr Outer;                        
            Length PreviousLength;                      
            
            typedef std::pair<std::string, Int64> OptionPair;
            
            std::list<OptionPair> OptionList;

            SequentialEssenceSource();

        public:
            SequentialEssenceSource(FileParser *Outer) : Outer(Outer), PreviousLength(0) {}

            void SetSource(EssenceSourcePtr NewSource) 
            { 
                CurrentSource = NewSource;

                // Set all options
                std::list<OptionPair>::iterator it = OptionList.begin();
                while(it != OptionList.end())
                {
                    NewSource->SetOption((*it).first, (*it).second);
                    it++;
                }

                // Set the index manager
                if(IndexMan) NewSource->SetIndexManager(IndexMan, IndexStreamID);
            }

            virtual size_t GetEssenceDataSize(void) 
            { 
                if(!ValidSource()) return 0;

                // If we have emptied all files then exit now
                if(Outer->AtEOF) return 0;

                size_t Ret = CurrentSource->GetEssenceDataSize();

                // If no more data move to the next source file
                if(!Ret)
                {
                    // Work out how much was read from this file
                    Length CurrentSize = (Length)CurrentSource->GetCurrentPosition();

                    if(Outer->GetNextSource())
                    {
                        // Add this length to the previous lengths
                        PreviousLength += CurrentSize;

                        return GetEssenceDataSize();
                    }
                }

                // Return the source size
                return Ret;
            }

            virtual DataChunkPtr GetEssenceData(size_t Size = 0, size_t MaxSize = 0);

            virtual bool EndOfItem(void) { if(ValidSource()) return CurrentSource->EndOfItem(); else return true; }

            virtual bool EndOfData(void) { if(ValidSource()) return CurrentSource->EndOfItem(); else return true; }

            virtual UInt8 GetGCEssenceType(void) { if(ValidSource()) return CurrentSource->GetGCEssenceType(); else return 0; }

            virtual UInt8 GetGCElementType(void) { if(ValidSource()) return CurrentSource->GetGCElementType(); else return 0; }

            virtual bool IsEditPoint(void) { if(ValidSource()) return CurrentSource->IsEditPoint(); else return true; }

            virtual Rational GetEditRate(void) { if(ValidSource()) return CurrentSource->GetEditRate(); else return Rational(0,0); }

            virtual Position GetCurrentPosition(void)
            { 
                if(!ValidSource()) return 0;

                return CurrentSource->GetCurrentPosition() + (Position)PreviousLength;
            }

            virtual int GetBERSize(void) 
            { 
                if(!ValidSource()) return 0;

                return CurrentSource->GetBERSize();
            }

            virtual bool SetOption(std::string Option, Int64 Param = 0) 
            { 
                if(!ValidSource()) return false;

                // Record this option to allow us to reconfigure sources if we switch source
                OptionList.push_back(OptionPair(Option, Param));

                return CurrentSource->SetOption(Option, Param);
            }

            virtual UInt32 GetBytesPerEditUnit(UInt32 KAGSize = 1) { if(ValidSource()) return CurrentSource->GetBytesPerEditUnit(KAGSize); else return 0; }

            virtual bool CanIndex() { if(ValidSource()) return CurrentSource->CanIndex(); else return false; }

            virtual void SetIndexManager(IndexManagerPtr &Manager, int StreamID) 
            { 
                IndexMan = Manager;
                IndexStreamID = StreamID;

                if(ValidSource()) CurrentSource->SetIndexManager(Manager, StreamID); 
            }

            virtual IndexManagerPtr &GetIndexManager(void) { return IndexMan; }

            virtual int GetIndexStreamID(void) { return IndexStreamID; }


            virtual Length GetPrechargeSize(void) 
            { 
                if(!ValidSource()) return 0;

                return CurrentSource->GetPrechargeSize();
            }

            virtual Position GetRangeStart(void) { return Outer->GetRangeStart(); }

            virtual Position GetRangeEnd(void) { return Outer->GetRangeEnd(); }

            virtual Length GetRangeDuration(void) { return Outer->GetRangeDuration(); }


        protected:

            bool ValidSource(void)
            {
                if(CurrentSource) return true;

                // If this is the first time through when we will have a file open but no source set to get current not text source
                if(Outer->CurrentFileOpen) return Outer->GetFirstSource(); 
                
                return Outer->GetNextSource();
            }

            // Allow the parser to access our internals
            friend class FileParser;
        };
        
        // Allow our protected member to access our internals
        friend class SequentialEssenceSource;
    };
}



// GCReader and associated structures
namespace mxflib
{

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


        virtual bool HandleData(GCReaderPtr Caller, KLVObjectPtr Object) = 0;
    };

    // Smart pointer for the base GCReader read handler
    typedef SmartPtr<GCReadHandler_Base> GCReadHandlerPtr;

    class GCReader : public RefCount<GCReader>
    {
    protected:
        MXFFilePtr File;                                
        Position FileOffset;                            
        Position StreamOffset;                          

        bool StopNow;                                   
        bool StopCalled;                                
        bool PushBackRequested;                         

        GCReadHandlerPtr DefaultHandler;                
        GCReadHandlerPtr FillerHandler;                 
        GCReadHandlerPtr EncryptionHandler;             

        std::map<UInt32, GCReadHandlerPtr> Handlers;    

    public:

        GCReader( MXFFilePtr File, GCReadHandlerPtr DefaultHandler = NULL, GCReadHandlerPtr FillerHandler = NULL );


        void SetDefaultHandler(GCReadHandlerPtr DefaultHandler = NULL)
        {
            this->DefaultHandler = DefaultHandler;
        }


        void SetFillerHandler(GCReadHandlerPtr FillerHandler = NULL)
        {
            this->FillerHandler = FillerHandler;
        }


        void SetEncryptionHandler(GCReadHandlerPtr EncryptionHandler = NULL)
        {
            this->EncryptionHandler = EncryptionHandler;
        }

        void SetDataHandler(UInt32 TrackNumber, GCReadHandlerPtr DataHandler = NULL)
        {
            if(DataHandler)
            {
                Handlers[TrackNumber] = DataHandler;
            }
            else
            {
                Handlers.erase(TrackNumber);
            }
        }


        bool ReadFromFile(Position FilePos, Position StreamPos, bool SingleKLV = false)
        {
            FileOffset = FilePos;                   // Record the file location
            StreamOffset = StreamPos;               // Record the stream location

            return ReadFromFile(SingleKLV);         // Then do a "continue" read
        }


        bool ReadFromFile(bool SingleKLV = false);


        void SetStreamOffset(Position NewOffset) 
        { 
            StreamOffset = NewOffset; 
        };


        Position GetFileOffset(void) { return FileOffset; }


        /*** Functions for use by read handlers ***/


        bool HandleData(KLVObjectPtr Object);


        void StopReading(bool PushBackKLV = false);

        Position GetStreamOffset(void) { return StreamOffset; };
    };
}


// BodyReader and associated structures
namespace mxflib
{
    class BodyReader : public RefCount<BodyReader>
    {
    protected:
        MXFFilePtr File;                        
        Position CurrentPos;                    

        bool NewPos;                            
        bool SeekInited;                        
        bool AtPartition;                       
        bool AtEOF;                             

        UInt32 CurrentBodySID;                  
        
        GCReadHandlerPtr GCRDefaultHandler;     
        GCReadHandlerPtr GCRFillerHandler;      
        GCReadHandlerPtr GCREncryptionHandler;  

        std::map<UInt32, GCReaderPtr> Readers;  

    public:
        BodyReader(MXFFilePtr File);


        Position Seek(Position Pos = 0);

        Position Tell(void) { return CurrentPos; };


        Position Seek(UInt32 BodySID, Position Pos);


        Position Tell(UInt32 BodySID);


        void SetDefaultHandler(GCReadHandlerPtr DefaultHandler = NULL) { GCRDefaultHandler = DefaultHandler; };


        void SetFillerHandler(GCReadHandlerPtr FillerHandler = NULL) { GCRFillerHandler = FillerHandler; };


        void SetEncryptionHandler(GCReadHandlerPtr EncryptionHandler = NULL) { GCREncryptionHandler = EncryptionHandler; };


        bool MakeGCReader(UInt32 BodySID, GCReadHandlerPtr DefaultHandler = NULL, GCReadHandlerPtr FillerHandler = NULL);

        GCReaderPtr GetGCReader(UInt32 BodySID)
        {
            // See if we have a GCReader for this BodySID
            std::map<UInt32, GCReaderPtr>::iterator it = Readers.find(BodySID);

            // If not found return NULL
            if(it == Readers.end()) return NULL;

            // Return the pointer
            return (*it).second;
        }


        bool ReadFromFile(bool SingleKLV = false);


        bool ReSync();

        bool IsAtPartition(void);

        bool Eof(void);


        /*** Functions for use by read handlers ***/

        UInt32 GetBodySID(void) { return CurrentBodySID; }


    protected:

        bool InitSeek(void);
    };

    typedef SmartPtr<BodyReader> BodyReaderPtr;
}


//*********************************************
//**                                         **
//**        General essence functions        **
//**                                         **
//*********************************************

namespace mxflib
{
    struct GCElementKind
    {
        bool    IsValid;                    
        UInt8   Item;                       
        UInt8   Count;                      
        UInt8   ElementType;                
        UInt8   Number;                     
    };


    void RegisterGCElementKey(DataChunkPtr &Key);

    GCElementKind GetGCElementKind(ULPtr TheUL);


    UInt32 GetGCTrackNumber(ULPtr TheUL);
}


/* BodyWriter and related classes */

namespace mxflib
{

    class BodyStream : public RefCount<BodyStream>, public EssenceSourceList
    {
    public:
        enum StateType
        {
            BodyStreamStart = 0,                                    
            BodyStreamHeadIndex,                                    
            BodyStreamPreBodyIndex,                                 
            BodyStreamBodyWithIndex,                                
            BodyStreamBodyNoIndex,                                  
            BodyStreamPostBodyIndex,                                
            BodyStreamFootIndex,                                    
            BodyStreamDone                                          
        };

        enum IndexType
        {
            StreamIndexNone = 0,                                    
            StreamIndexFullFooter = 1,                              
            StreamIndexSparseFooter = 2,                            
            StreamIndexSprinkled = 4,                               
            StreamIndexSprinkledIsolated = 8,                       
            StreamIndexCBRHeader = 16,                              
            StreamIndexCBRHeaderIsolated = 32,                      
            StreamIndexCBRFooter = 64,                              
            StreamIndexCBRBody = 128,                               
            StreamIndexCBRIsolated = 256,                           
            StreamIndexCBRPreIsolated = 512                         
        };

        enum WrapType
        {
            StreamWrapOther = 0,                                    
            StreamWrapFrame,                                        
            StreamWrapClip                                          
        };

    protected:
        EssenceSourcePtr Source;                                    
        EssenceSourceList SubStreams;                               
        EssenceSourceList::iterator SubStream_it;                   
        bool SubStreamRestart;                                      

        StateType State;                                            

        IndexType StreamIndex;                                      
        IndexType FooterIndexFlags;                                 

        UInt32 BodySID;                                             
        UInt32 IndexSID;                                            

        WrapType StreamWrap;                                        

        GCWriterPtr StreamWriter;                                   

        bool EssencePendingData;                                    

        bool EndOfStream;                                           

        IndexManagerPtr IndexMan;                                   
        
        Position NextSprinkled;                                     

        bool FreeSpaceIndex;                                        

        bool ValueRelativeIndexing;                                 

        Length PrechargeSize;                                       


        UInt32 KAG;

        bool ForceBER4;


        bool EditAlign;

        BodyStream();

        BodyStream(BodyStream &);

    /* Public properties */
    public:
        std::list<Position> SparseList;                             

    public:
        BodyStream(UInt32 SID, EssenceSourcePtr &EssSource, DataChunkPtr Key = NULL, bool NonGC = false)
        {
            BodySID = SID;
            IndexSID = 0;
            Source = EssSource;
            State = BodyStreamStart;
            StreamIndex = StreamIndexNone;
            FooterIndexFlags = StreamIndexNone;
            StreamWrap = StreamWrapOther;
            SubStreamRestart = true;
            NextSprinkled = 0;
            EssencePendingData = false;
            EndOfStream = false;
            FreeSpaceIndex = false;
            ValueRelativeIndexing = false;
            PrechargeSize = 0;

            KAG = 0;
            ForceBER4 = false;
            EditAlign = false;

            // Set the non-standard key if requested
            if(Key) EssSource->SetKey(Key, NonGC);

            // Set the master stream as one of the essence streams
            push_back(Source);
        }

        EssenceSourcePtr &GetSource(void) { return Source; }

        size_type SubStreamCount(void) { return size(); }

        void AddSubStream(EssenceSourcePtr &SubSource, DataChunkPtr Key = NULL, bool NonGC = false);

        UInt32 GetBodySID(void) { return BodySID; }

        void SetIndexSID(UInt32 SID) { IndexSID = SID; }

        UInt32 GetIndexSID(void) { return IndexSID; }

        void SetState(StateType NewState) { State = NewState; }

        StateType GetState(void) 
        {
            if(State == BodyStreamStart) GetNextState();
            return State;
        }


        StateType GetNextState(void);

        void AddIndexType(IndexType NewIndexType) { StreamIndex = (IndexType) (StreamIndex | NewIndexType); }


        void SetIndexType(IndexType NewIndexType) { StreamIndex = NewIndexType; }

        IndexType GetIndexType(void) { return StreamIndex; }


        void SetFooterIndex(IndexType NewIndexType) { FooterIndexFlags = NewIndexType; }

        IndexType GetFooterIndex(void) { return FooterIndexFlags; }

        void SetWrapType(WrapType NewWrapType) { StreamWrap = NewWrapType; }

        void SetWrapType(WrappingOption::WrapType NewWrapType) 
        { 
            if(NewWrapType == WrappingOption::Frame) StreamWrap = StreamWrapFrame; 
            else if(NewWrapType == WrappingOption::Clip) StreamWrap = StreamWrapClip; 
            else StreamWrap = StreamWrapOther;
        }

        WrapType GetWrapType(void) { return StreamWrap; }

        void SetWriter(GCWriterPtr &Writer);

        IndexManagerPtr &GetIndexManager(void) 
        { 
            if(!IndexMan) InitIndexManager();
            return IndexMan; 
        }

        GCWriterPtr &GetWriter(void) { return StreamWriter; }

        UInt32 GetTrackNumber(void) 
        { 
            if(!Source) return 0;
            return StreamWriter->GetTrackNumber(Source->GetStreamID());
        }

        Uint32 GetTrackNumber(GCStreamID ID)
        { 
            if(!Source) return 0;
            return StreamWriter->GetTrackNumber(ID);
        }

        void SetPendingData(bool Value = true) { EssencePendingData = Value; }

        bool HasPendingData(void) { return EssencePendingData; }
        
        void SetEndOfStream(bool Value = true) { EndOfStream = Value; }

        bool GetEndOfStream(void) { return EndOfStream; }
        
        void SetNextSprinkled(Position Sprinkled) { NextSprinkled = Sprinkled; }

        Position GetNextSprinkled(void) { return NextSprinkled; }

        // FIXME: This will break CBR indexing if changed during writing!
        void SetKAG(UInt32 NewKAG) { KAG = NewKAG; }

        UInt32 GetKAG(void) { return KAG; }

        void SetForceBER4(bool Force) { ForceBER4 = Force; }

        bool GetForceBER4(void) { return ForceBER4; }

        void SetEditAlign(bool Align) { EditAlign = Align; }

        bool GetEditAlign(void) { return EditAlign; }


        void SetFreeSpaceIndex(bool Flag) { FreeSpaceIndex = Flag; }

        bool GetFreeSpaceIndex(void) { return FreeSpaceIndex; }


        void SetValueRelativeIndexing(bool Val) 
        { 
            ValueRelativeIndexing = Val; 
            if(IndexMan) IndexMan->SetValueRelativeIndexing(Val);
        }


        bool GetValueRelativeIndexing(void) { return ValueRelativeIndexing; }

        Length GetPrechargeSize(void) const { return PrechargeSize; }

        void DecrementPrecharge(void) { if(PrechargeSize) PrechargeSize--; }

        void InitIndexManager(void);
    };

    typedef SmartPtr<BodyStream> BodyStreamPtr;

    typedef std::list<BodyStreamPtr> BodyStreamList;

    // Forward declare BodyWriterPtr to allow it to be used in BodyWriterHandler
    class BodyWriter;
    typedef SmartPtr<BodyWriter> BodyWriterPtr;

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


        virtual bool HandlePartition(BodyWriterPtr Caller, UInt32 BodySID, UInt32 IndexSID) = 0;
    };

    typedef SmartPtr<BodyWriterHandler> BodyWriterHandlerPtr;


    class BodyWriter : public RefCount<BodyWriter>
    {
    protected:
        // States for BodyWriter
        enum BodyState
        {
            BodyStateStart = 0,                                     
            BodyStateHeader,                                        
            BodyStateBody,                                          
            BodyStateFooter,                                        
            BodyStateDone                                           
        };

        BodyState State;


        class StreamInfo : public RefCount<StreamInfo>
        {
        public:
            bool Active;                                            
            BodyStreamPtr Stream;                                   
            Length StopAfter;                                       

        public:
            StreamInfo() { Active = false; }

            StreamInfo(const StreamInfo &rhs)
            {
                Active = rhs.Active;
                Stream = rhs.Stream;
                StopAfter = rhs.StopAfter;
            }
        };

        typedef SmartPtr<StreamInfo> StreamInfoPtr;


        typedef std::list<StreamInfoPtr> StreamInfoList;

        MXFFilePtr File;

        StreamInfoList StreamList;

        UInt32 KAG;

        bool ForceBER4;

        PartitionPtr BasePartition;

        BodyWriterHandlerPtr PartitionHandler;                  

        UInt32 MinPartitionSize;                                
        UInt32 MinPartitionFiller;                              

        bool IndexSharesWithMetadata;                           
        bool EssenceSharesWithMetadata;                         

        UInt32 CurrentBodySID;

        bool PartitionDone;

        StreamInfoList::iterator CurrentStream;


        /* Details about the pending partition, set but not yet written
         * This is because the value of BodySID depends on whether any
         * essence is going to be written in this partition which won't
         * be known for certain until we are about to write the essence
         */

        bool PartitionWritePending;

        bool PendingHeader;

        bool PendingFooter;

        bool PendingMetadata;

        DataChunkPtr PendingIndexData;


        UInt32 PartitionBodySID;

        BodyWriter();

        BodyWriter(BodyWriter &);

    public:
        BodyWriter(MXFFilePtr &DestFile)
        {
            State = BodyStateStart;
            CurrentBodySID = 0;
            PartitionDone = false;

            File = DestFile;

            // By default index tables may share with metadata, but not essence
            IndexSharesWithMetadata = true;
            EssenceSharesWithMetadata = false;

            KAG = 0;
            ForceBER4 = false;

            MinPartitionSize = 0;
            MinPartitionFiller = 0;

            PartitionWritePending = false;
            PendingHeader = 0;
            PendingFooter = 0;
            PendingMetadata = false;
            PartitionBodySID = 0;
        }


        void ClearStreams(void) { StreamList.clear(); CurrentBodySID = 0; }


        bool AddStream(BodyStreamPtr &Stream, Length StopAfter = 0);

        void SetKAG(UInt32 NewKAG) 
        { 
            // TODO: This is probably not the best way - but is the only way to currently ensure correct CBR indexing!
            if(StreamList.size()) warning("KAG size changed after adding streams - CBR indexing may be incorrect\n");
            KAG = NewKAG; 
        }

        UInt32 GetKAG(void) { return KAG; }

        void SetForceBER4(bool Force) { ForceBER4 = Force; }

        bool GetForceBER4(void) { return ForceBER4; }

        void SetMetadataSharing(bool IndexMayShare = true, bool EssenceMayShare = false)
        {
            IndexSharesWithMetadata = IndexMayShare;
            EssenceSharesWithMetadata = EssenceMayShare;
        }


        void SetPartition(PartitionPtr &ThePartition) { BasePartition = ThePartition; }

        PartitionPtr GetPartition(void) { return BasePartition; }


        void WriteHeader(bool IsClosed, bool IsComplete);


        void EndPartition(void);


        void WriteBody(Length Duration = 0, Length MaxPartitionSize = 0);


        Length WritePartition(Length Duration = 0, Length MaxPartitionSize = 0);


        bool BodyDone(void) { return (State == BodyStateFooter) || (State == BodyStateDone); }


        void WriteFooter(bool WriteMetadata = false, bool IsComplete = true);


        void SetPartitionHandler(BodyWriterHandlerPtr &NewBodyHandler) { PartitionHandler = NewBodyHandler; }


        void SetPartitionSize(UInt32 PartitionSize) { MinPartitionSize = PartitionSize; }


        void SetPartitionFiller(UInt32 PartitionFiller) { MinPartitionFiller = PartitionFiller; }

        void InitIndexManagers(void);

    protected:

        void SetNextStream(void);


        Length WriteEssence(StreamInfoPtr &Info, Length Duration = 0, Length MaxPartitionSize = 0);
    };

    typedef SmartPtr<BodyWriter> BodyWriterPtr;
}

#endif // MXFLIB__ESSENCE_H

---