index.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__INDEX_H
#define MXFLIB__INDEX_H


namespace mxflib
{
    class IndexPos : public RefCount<IndexPos>
    {
    public:
        UInt64 ThisPos;         

        Position Location;      
        Rational PosOffset;     
        bool Exact;             

        bool OtherPos;          

        bool Offset;            
        Int8 KeyFrameOffset;    
        Int64 KeyLocation;      
        UInt8 Flags;            
    };

    typedef SmartPtr<IndexPos> IndexPosPtr;


    struct DeltaEntry
    {
        Int8    PosTableIndex;
        UInt8   Slice;
        UInt8   ElementDelta[4];        
    };

    typedef std::map<Position, IndexSegmentPtr> IndexSegmentMap;

    class IndexEntry : public RefCount<IndexEntry>
    {
    public:
        int TemporalOffset;
        int AnchorOffset;
        UInt8 Flags;
        UInt64 StreamOffset;
    };

    typedef SmartPtr<IndexEntry> IndexEntryPtr;

//typedef std::map<Int64, IndexEntryPtr> IndexEntryMap;
//typedef SmartPtr<IndexEntryMap> IndexEntryMapPtr;


    class ReorderIndex : public RefCount<ReorderIndex>
    {
    protected:
        DataChunk IndexEntries;             
        int CompleteEntryCount;             
        int EntryCount;                     

        Position FirstPosition;             
        UInt32 IndexEntrySize;              

    public:
        ReorderIndex(int UseIndexEntrySize)
        {
            // Set a high granularity to reduce overhead of frequent reallocation
            IndexEntries.SetGranularity(1024 * 16);

            CompleteEntryCount = 0;
            EntryCount = 0;

            ASSERT(UseIndexEntrySize);
            IndexEntrySize = UseIndexEntrySize;
        }

        bool SetEntry(Position Pos, UInt8 Flags, Int8 AnchorOffset, UInt8 *Tables = NULL);

        bool SetStreamOffset(Position Pos, Position StreamOffset);

        bool SetTemporalOffset(Position Pos, Int8 TemporalOffset);

        Int32 GetEntryCount(void) { return CompleteEntryCount; };

        Int32 CommitEntries(IndexTablePtr Index, Int32 Count = -1);
    };

    typedef SmartPtr<ReorderIndex> ReorderIndexPtr;
    typedef std::map<UInt32, ReorderIndexPtr> ReorderMap;


    class IndexTable : public RefCount<IndexTable>
    {
    public:
        UInt32 IndexSID;
        UInt32 BodySID;
        Rational EditRate;

        UInt32 EditUnitByteCount;

        int BaseDeltaCount;

        DeltaEntry *BaseDeltaArray;

        IndexSegmentMap SegmentMap;

        int NSL;            
        int NPE;            
        int IndexEntrySize; 

//      //! Map of index entries that may be out of order
//      /*! The entries will be built into segments by function xxx() */
//      IndexEntryMap IndexOrderEntryMap;
//      IndexEntryMap EssenceOrderEntryMap;

        ReorderIndexPtr     Reorder;            

    public:

        static const Position IndexLowest;

    public:
        IndexTable() : IndexSID(0), BodySID(0), EditUnitByteCount(0) , BaseDeltaCount(0) 
        { 
            EditRate.Numerator=0; 
            EditUnitByteCount=0; 
            NSL=0; 
            NPE=0; 
            IndexEntrySize=11; 
        };

        ~IndexTable() 
        { 
            if(BaseDeltaCount) delete[] BaseDeltaArray; 
        };

        void DefineDeltaArray(int DeltaCount, DeltaEntry *DeltaArray)
        {
            if(BaseDeltaCount) delete[] BaseDeltaArray;

            BaseDeltaCount = DeltaCount;
            if(!DeltaCount) return;
            
            // Build the new array
            BaseDeltaArray = new DeltaEntry[DeltaCount];
            memcpy(BaseDeltaArray, DeltaArray, DeltaCount * sizeof(DeltaEntry));

            // Slice numbers start at zero, PosTable numbers start at 1
            NSL = 0;
            NPE = 0;
            int i;
            for(i=0; i<DeltaCount; i++)
            {
                if(BaseDeltaArray[i].PosTableIndex > NPE) NPE = BaseDeltaArray[i].PosTableIndex;
                if(BaseDeltaArray[i].Slice > NSL) NSL = BaseDeltaArray[i].Slice;
            }
        
            // Calculate the size of each IndexEntry
            IndexEntrySize = (11 + 4*NSL + 8*NPE);
        }


        void DefineDeltaArray(int DeltaCount, UInt32 *ElementSizes)
        {
            if(BaseDeltaCount) delete[] BaseDeltaArray;

            BaseDeltaCount = DeltaCount;
            if(!DeltaCount) return;

            // Build the new array
            BaseDeltaArray = new DeltaEntry[DeltaCount];

            // Slice numbers start at zero, PosTable numbers start at 1
            NSL = 0;
            NPE = 0;
            UInt32 Delta = 0;           
            int i;
            for(i=0; i<DeltaCount; i++)
            {
                // Start of a new slice?
                PutU32(Delta, BaseDeltaArray[i].ElementDelta);
                Delta += ElementSizes[i];
                BaseDeltaArray[i].PosTableIndex = 0;
                BaseDeltaArray[i].Slice = NSL;

                // End of a slice?
                if((i != (DeltaCount-1)) && (ElementSizes[i] == 0))
                {
                    Delta = 0;
                    NSL++;
                }
            }

            // Calculate the size of each IndexEntry
            IndexEntrySize = (11 + 4*NSL + 8*NPE);
        }

        IndexSegmentPtr AddSegment(MDObjectPtr Segment);

        IndexSegmentPtr AddSegment(Int64 StartPosition);

        IndexSegmentPtr GetSegment(Position EditUnit);

        bool AddIndexEntry(Position EditUnit, Int8 TemporalOffset, Int8 KeyFrameOffset, UInt8 Flags, UInt64 StreamOffset, 
                           int SliceCount = 0, UInt32 *SliceOffsets = NULL, 
                           int PosCount = 0, Rational *PosTable = NULL);

//#####
//##### DRAGONS: Should Lookup also check the pending items?
//#####
        IndexPosPtr Lookup(Position EditUnit, int SubItem = 0, bool Reorder = true);

        void Update(Position EditUnit, UInt64 StreamOffset);

        void Correct(Position EditUnit, Int8 TemporalOffset, Int8 KeyFrameOffset, UInt8 Flags);

        void Purge(UInt64 FirstPosition, UInt64 LastPosition);

        size_t WriteIndex(DataChunk &Buffer);

        ReorderIndexPtr GetReorder(void)
        {
            return Reorder;
        }

        ReorderIndexPtr EnableReorder(void)
        {
            if(!Reorder) Reorder = new ReorderIndex(IndexEntrySize);

            return Reorder;
        }
    };
}


namespace mxflib
{
    class IndexSegment : public RefCount<IndexSegment>
    {
    private:
        static PrimerPtr IndexPrimer;

    public:
        IndexTableParent Parent;
    
        Int64 StartPosition;

        int DeltaCount;

        DeltaEntry *DeltaArray;

        int EntryCount;


        DataChunk IndexEntryArray;

    private:
        IndexSegment() : EntryCount(0) { };

    public:
        ~IndexSegment() { if(DeltaCount) delete[] DeltaArray; };


        static IndexSegmentPtr AddIndexSegmentToIndexTable(IndexTablePtr ParentTable, Int64 IndexStartPosition);

        bool AddIndexEntry(Int8 TemporalOffset, Int8 KeyFrameOffset, UInt8 Flags, UInt64 StreamOffset, 
                           int SliceCount = 0, UInt32 *SliceOffsets = NULL, 
                           int PosCount = 0, Rational *PosTable = NULL);

        bool AddIndexEntries(int Count, int Size, UInt8 *Entries);

        void Update(Position EditUnit, UInt64 StreamOffset);
    };
}


namespace mxflib
{
    class IndexManager : public RefCount<IndexManager>
    {
    protected:
        bool UsesReordering;                
        bool FormatFixed;                   

        bool DataIsCBR;                     
        int StreamCount;                    
        int StreamListSize;                 
        int *PosTableList;                  
        UInt32 *ElementSizeList;            

        struct IndexData
        {
            int         Status;             

            int         Flags;              
            int         KeyOffset;          
            int         TemporalOffset;     
            int         TemporalDiff;       

            UInt64      StreamOffset[1];    

        };

        int ManagedDataEntrySize;           

        std::map<Position, IndexData*> ManagedData;

        /* DRAGONS: Provisional entries are not currently implemented */
        IndexData *ProvisionalEntry;        
        Position ProvisionalEditUnit;       

        std::map<Position, int> UnsatisfiedTemporalOffsets;

        std::map<Position, int> UnsatisfiedTemporalDiffs;

        UInt32 BodySID;                     
        UInt32 IndexSID;                    
        Rational EditRate;                  

        std::map<int, Position> EntryLog;   
        int NextLogID;                      
        bool LogWrapped;                    
        int LogNextEntry;                   

        bool AcceptNextEntry;               

        Position LastNewEditUnit;           

        bool ValueRelativeIndexing;         

        Position SubRangeOffset;            

    public:
        IndexManager(int PosTableIndex, UInt32 ElementSize);

        ~IndexManager()
        {
            delete[] PosTableList;
            delete[] ElementSizeList;
            
            std::map<Position, IndexData*>::iterator it = ManagedData.begin();
            while ( ! ManagedData.empty() )
            {
                delete[] (UInt8*)(*it).second;
                ManagedData.erase(it);
                it = ManagedData.begin();
            }
            
            if(ProvisionalEntry) delete[] ProvisionalEntry;
        }

        void SetBodySID(UInt32 SID) { BodySID = SID; };

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

        void SetEditRate(Rational Rate) { EditRate = Rate; };

        void SetEditRate(Int32 Rate_n, Int32 Rate_d) { EditRate.Numerator = Rate_n;  EditRate.Denominator = Rate_d;};

        UInt32 GetBodySID(void) { return BodySID; };

        UInt32 GetIndexSID(void) { return IndexSID; };

        Rational GetEditRate(void) { return EditRate; };


        int AddSubStream(int PosTableIndex, UInt32 ElementSize);

        void SetPosTableIndex(int StreamID, int PosTableIndex)
        {
            if(StreamID < StreamCount) PosTableList[StreamID] = PosTableIndex;
        }

        void AddEditUnit(int SubStream, Position EditUnit, int KeyOffset = 0, int Flags = -1);

        void SetOffset(int SubStream, Position EditUnit, UInt64 Offset, int KeyOffset = 0, int Flags = -1);

        bool OfferEditUnit(int SubStream, Position EditUnit, int KeyOffset = 0, int Flags = -1);

        bool OfferOffset(int SubStream, Position EditUnit, UInt64 Offset, int KeyOffset = 0, int Flags = -1);

        void SetTemporalOffset(Position EditUnit, int Offset);

        bool OfferTemporalOffset(Position EditUnit, int Offset);

        void SetKeyOffset(Position EditUnit, int Offset);

        bool OfferKeyOffset(Position EditUnit, int Offset);


        Position AcceptProvisional(void)
        {
            if(!ProvisionalEntry) return IndexTable::IndexLowest;

            // Add the entry to the managed data
            ManagedData.insert(std::pair<Position, IndexData*>(ProvisionalEditUnit, ProvisionalEntry));
            LastNewEditUnit = ProvisionalEditUnit;

            // The entry no longer exists as a provisional entry
            ProvisionalEntry = NULL;

            return ProvisionalEditUnit;
        }

        Position GetLastNewEditUnit(void) { return  LastNewEditUnit; }

        void AcceptNext(void)
        {
            AcceptNextEntry = true;
        }


        int LogNext(void);

        int AcceptLogNext(void) { AcceptNext();  return LogNext(); }

        Position ReadLog(int LogID)
        {
            std::map<int, Position>::iterator it;
            it = EntryLog.find(LogID);
            if(it == EntryLog.end()) return IndexTable::IndexLowest;
            return (*it).second;
        }

        void Flush(Position FirstEditUnit, Position LastEditUnit);

        UInt64 GetFirstAvailable(void);


        UInt64 GetLastAvailable(void);

        IndexTablePtr MakeIndex(void);


        int AddEntriesToIndex(IndexTablePtr Index, Position FirstEditUnit = IndexTable::IndexLowest, Position LastEditUnit = UINT64_C(0x7fffffffffffffff))
        {
            return AddEntriesToIndex(false, Index, FirstEditUnit, LastEditUnit);
        }

        int AddEntriesToIndex(bool UndoReorder, IndexTablePtr Index, Position FirstEditUnit = IndexTable::IndexLowest, Position LastEditUnit = UINT64_C(0x7fffffffffffffff));


        void ForceVBR(void) { DataIsCBR = false; };

        bool IsCBR(void) { return DataIsCBR; };


        void SetValueRelativeIndexing(bool Val) { ValueRelativeIndexing = Val; }


        bool GetValueRelativeIndexing(void) { return ValueRelativeIndexing; }

        void SetSubRangeOffset(Position Offset) { SubRangeOffset = Offset; }

    protected:
        IndexData *GetArrayEntry(Position EditUnit);

        void Log(Position EditUnit)
        {
            if(LogNextEntry >= 0)
            {
                EntryLog[LogNextEntry] = EditUnit;
                LogNextEntry = -1;
            }
        }
    };

    typedef SmartPtr<IndexManager> IndexManagerPtr;
}


#endif // MXFLIB__INDEX_H


// Temporary Notepad...
//
//
//Criteria for accepting edit units:
//
// Making full index:  Accept all
// Making index segment:   Accept if in range
// Making sparse index (per n edit units): Accept if divisible by n
// Making sparse index (per something else): Accpet first edit unit offered each section

---