rip.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__RIP_H
#define MXFLIB__RIP_H

#include <mxflib/partition.h>


#include <list>

namespace mxflib
{
    class PartitionInfo : public RefCount<PartitionInfo>
    {
    public:
        PartitionPtr ThePartition;  

        Position ByteOffset;        

        UInt32 BodySID;             

    protected:
        UInt32 IndexSID;            

        bool KnownSIDs;             

        Position StreamOffset;      

        Length StreamByteCount;     

        Position EstStreamOffset;   

        Length EstStreamByteCount;  

        Position EssenceStart;      

    public:
        PartitionInfo(PartitionPtr Part = NULL, Position Offset = -1, UInt32 SID = 0);

        bool operator< (PartitionInfo &Other) { return (ByteOffset < Other.ByteOffset); }

        PartitionPtr &GetPartition(void) { return ThePartition; }

        void SetPartition(PartitionPtr Val) { ThePartition = Val; }

        UInt32 GetBodySID(void) const { return BodySID; }

        void SetBodySID(UInt32 Val) { BodySID = Val; }
        
        UInt32 GetIndexSID(void) const { return IndexSID; }

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

        bool SIDsKnown(void) const { return KnownSIDs; }

        void SetKnownSIDs(bool Val) { KnownSIDs = Val; }

        void SetSIDs(UInt32 NewBodySID, UInt32 NewIndexSID)
        {
            BodySID = NewBodySID;
            IndexSID = NewIndexSID;
            KnownSIDs = true;
        }

        Position GetByteOffset(void) const { return ByteOffset; }

        void SetByteOffset(Position Val)  { ByteOffset = Val; }

        Position GetStreamOffset(void) const { return StreamOffset; }

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

        Position GetEstimatedStreamOffset(void) const { return EstStreamOffset; }

        void SetEstimatedStreamOffset(Position Val)  { EstStreamOffset = Val; }

        Position GetEssenceStart(void) const { return EssenceStart; }

        void SetEssenceStart(Position Val)  { EssenceStart = Val; }
    };

    typedef SmartPtr<PartitionInfo> PartitionInfoPtr;

    typedef std::map<Position, PartitionInfoPtr> PartitionInfoMap;
}


namespace mxflib
{

    class RIP : public PartitionInfoMap
    {
    public:
        // DRAGONS: This should probably mutate into a "MatchedPysical" property
        bool isGenerated;               

    public:
        RIP();
        ~RIP();


        PartitionInfoPtr AddPartition(PartitionPtr Part, Position Offset = -1, UInt32 SID = 0);


        PartitionInfoPtr FindPreviousPartition(Position Pos);


        PartitionInfoPtr FindNextPartition(Position Pos);


        PartitionInfoPtr FindPartition(UInt32 SID, Position StreamOffset);
    };
}

#endif // MXFLIB__RIP_H

---