vbi.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2006, 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__VBI_H
#define MXFLIB__VBI_H


// Forward refs
namespace mxflib
{
}


namespace mxflib
{
    enum VBIWrappingType
    {
        VBIFrame = 1,                   
        VBIField1 = 2,                  
        VBIField2 = 3,                  
        VBIProgressive = 4              
    };

    enum VBISampleCoding
    {
        Y1Bit = 1,                      
        C1Bit = 2,                      
        YC1Bit = 3,                     
        Y8Bit = 4,                      
        C8Bit = 5,                      
        YC8Bit = 6,                     
        Y10Bit = 7,                     
        C10Bit = 8,                     
        YC10Bit = 9                     
    };

    class VBILine : public RefCount<VBILine>
    {
    protected:
        DataChunk Data;                 
        int LineNumber;                 
        VBIWrappingType WrappingType;   
        VBISampleCoding SampleCoding;   
        UInt16 SampleCount;             

    public:
        VBILine(int LineNumber, VBIWrappingType Wrapping, VBISampleCoding Coding)
            : LineNumber(LineNumber), WrappingType(Wrapping), SampleCoding(Coding) {};

        VBILine(int Field, int LineNumber, VBIWrappingType Wrapping, VBISampleCoding Coding)
            : WrappingType(Wrapping), SampleCoding(Coding) 
        {
            if(Field == 2) this->LineNumber = 0x4000 + LineNumber;
            else this->LineNumber = LineNumber;
        };


        VBILine(int LineNumber, VBIWrappingType Wrapping, VBISampleCoding Coding, UInt16 SampleCount, DataChunkPtr &LineData)
            : LineNumber(LineNumber), WrappingType(Wrapping), SampleCoding(Coding), SampleCount(SampleCount)
        {
            // Take the buffer from LineData (and clear LineData)
            Data.TakeBuffer(LineData, true);
        }


        VBILine(int Field, int LineNumber, VBIWrappingType Wrapping, VBISampleCoding Coding, UInt16 SampleCount, DataChunkPtr &LineData)
            : LineNumber(LineNumber), WrappingType(Wrapping), SampleCoding(Coding), SampleCount(SampleCount)
        {
            if(Field == 2) this->LineNumber = 0x4000 + LineNumber;
            else this->LineNumber = LineNumber;

            // Take the buffer from LineData (and clear LineData)
            Data.TakeBuffer(LineData, true);
        }


        void SetData(UInt16 SampleCount, DataChunkPtr &LineData)
        {
            // Take the buffer from LineData (and clear LineData)
            Data.TakeBuffer(LineData, true);

            this->SampleCount = SampleCount;
        }

        size_t GetDataSize(void) { return static_cast<size_t>(Data.Size); }

        size_t GetFullDataSize(void) { return static_cast<size_t>(Data.Size) + 6; }


        void WriteData(UInt8 *Buffer);
    };


    // Smart pointer to an VBILine object
    typedef SmartPtr<VBILine> VBILinePtr;

    // Map of smart pointer to VBILine objects, indexed by line number
    typedef std::map<int, VBILinePtr> VBILineMap;


    class VBISource : public EssenceSource
    {
    protected:
        EssenceSourceParent MasterSource;   

        VBILineMap Lines;                   

        DataChunkList BufferedData;         

        size_t BufferOffset;                

        Position CurrentPosition;           

    public:
        // Base constructor
        VBISource(EssenceSource *Master) : MasterSource(Master), BufferOffset(0), CurrentPosition(0) {};

        virtual ~VBISource() {};

        // Add a line of data
        void AddLine(int LineNumber, VBIWrappingType Wrapping, VBISampleCoding Coding, UInt16 SampleCount, DataChunkPtr &LineData);

        // Add a line of data, for an interlaced frame
        void AddLine(int Field, int LineNumber, VBIWrappingType Wrapping, VBISampleCoding Coding, UInt16 SampleCount, DataChunkPtr &LineData)
        {
            if(Field == 2) LineNumber += 0x4000;
            AddLine(LineNumber, Wrapping, Coding, SampleCount, LineData);
        }


        virtual size_t GetEssenceDataSize(void);


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


        virtual bool EndOfItem(void) { return (BufferOffset == 0); }


        virtual bool EndOfData(void) 
        { 
            if(!MasterSource) return true;
            return MasterSource->EndOfData();
        }

        virtual UInt8 GetGCEssenceType(void) { return 0x17; }

        virtual UInt8 GetGCElementType(void) { return 0x01; }


        virtual Rational GetEditRate(void)
        { 
            if(!MasterSource) return Rational(1,1);
            return MasterSource->GetEditRate();
        }


        virtual Position GetCurrentPosition(void)
        {
            return CurrentPosition;
        }

        virtual int GetBERSize(void) { return 4; }

        virtual bool IsPictureEssence(void) { return false; }

        virtual bool IsSoundEssence(void) { return false; }

        virtual bool IsDataEssence(void) { return true; }

        virtual bool IsCompoundEssence(void) { return false; }


        virtual Int32 RelativeWriteOrder(void) 
        { 
            // We need to be BEFORE the CP picture data
            return -1; 
        }


        virtual int RelativeWriteOrderType(void) 
        { 
            // We need to be before the CP PICTURE DATA
            return 0x05; 
        }

    protected:
        DataChunkPtr BuildChunk(void);
    };
}

#endif // MXFLIB__VBI_H

---