esp_mpeg2ves.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__ESP_MPEG2VES_H
#define MXFLIB__ESP_MPEG2VES_H


#include <math.h>   // For "floor"

#define MPEG2_VES_BUFFERSIZE  8192

namespace mxflib
{
    class MPEG2_VES_EssenceSubParser : public EssenceSubParserBase
    {
    protected:
        Rational NativeEditRate;                            
        Rational SelectedEditRate;                          
        unsigned int EditRatio;                             

        Position PictureNumber;                             
        Position AnchorFrame;                               

        size_t CachedDataSize;                              
        UInt64 CachedCount;                                 

        Position CurrentPos;                                

        int GOPOffset;                                      

        bool ClosedGOP;                                     

        // File buffering
        UInt8 Buffer[MPEG2_VES_BUFFERSIZE];                 
        int BuffCount;                                      
        UInt8 *BuffPtr;                                     

        bool EditPoint;                                     

        bool SelectiveIndex;                                

        bool EndOfStream;                                   

        MDObjectParent CurrentDescriptor;                   

    public:
        class ESP_EssenceSource : public EssenceSubParserBase::ESP_EssenceSource
        {
        protected:
            size_t BytesRemaining;                          

        public:
            ESP_EssenceSource(EssenceSubParserPtr TheCaller, FileHandle InFile, UInt32 UseStream, UInt64 Count = 1)
                : EssenceSubParserBase::ESP_EssenceSource(TheCaller, InFile, UseStream, Count) 
            {
                BytesRemaining = 0;
            };


            virtual size_t GetEssenceDataSize(void) 
            {
                MPEG2_VES_EssenceSubParser *pCaller = SmartPtr_Cast(Caller, MPEG2_VES_EssenceSubParser);
                
                if(pCaller->SelectedWrapping->ThisWrapType == WrappingOption::Clip) return pCaller->ReadInternal(File, Stream, 0);
                
                return pCaller->ReadInternal(File, Stream, RequestedCount);
            };


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


            virtual bool EndOfItem(void) 
            { 
                // Items end when there is no data remaining from the last read
                return !BytesRemaining;
            }

            virtual int GetBERSize(void) 
            { 
                MPEG2_VES_EssenceSubParser *pCaller = SmartPtr_Cast(Caller, MPEG2_VES_EssenceSubParser);

                if(pCaller->SelectedWrapping->ThisWrapType == WrappingOption::Clip) return 8;
                return 4;
            }

            virtual bool IsEditPoint(void) 
            {
                MPEG2_VES_EssenceSubParser *pCaller = SmartPtr_Cast(Caller, MPEG2_VES_EssenceSubParser);
                return pCaller->EditPoint; 
            }
        };

        // Give our essence source class privilaged access
        friend class MPEG2_VES_EssenceSubParser::ESP_EssenceSource;

    public:
        // TODO: Check why properties are not initialised here!
        MPEG2_VES_EssenceSubParser()
        {
            CachedDataSize = static_cast<size_t>(-1);
            CachedCount = 0;

            EditPoint = false;
            EndOfStream = false;
        }

        virtual EssenceSubParserPtr NewParser(void) const { return new MPEG2_VES_EssenceSubParser; }

        virtual StringList HandledExtensions(void);

        virtual EssenceStreamDescriptorList IdentifyEssence(FileHandle InFile);

        virtual WrappingOptionList IdentifyWrappingOptions(FileHandle InFile, EssenceStreamDescriptor &Descriptor);

        virtual void Use(UInt32 Stream, WrappingOptionPtr &UseWrapping);

        virtual bool SetEditRate(Rational EditRate);

        virtual Rational GetEditRate(void) { return SelectedEditRate; }

        virtual Position GetCurrentPosition(void);


        // Index table functions
        

        virtual void SetIndexManager(IndexManagerPtr &TheManager, int StreamID = 0)
        {
            EssenceSubParserBase::SetIndexManager(TheManager, StreamID);
            TheManager->SetPosTableIndex(StreamID, -1);
        }

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

        virtual EssenceSourcePtr GetEssenceSource(FileHandle InFile, UInt32 Stream, UInt64 Count = 1)
        {
            return new ESP_EssenceSource(this, InFile, Stream, Count/*, Index*/);
        };

        virtual Length Write(FileHandle InFile, UInt32 Stream, MXFFilePtr OutFile, UInt64 Count = 1/*, IndexTablePtr Index = NULL*/);


        virtual bool SetOption(std::string Option, Int64 Param = 0);


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

    protected:
        MDObjectPtr BuildMPEG2VideoDescriptor(FileHandle InFile, UInt64 Start = 0);

        size_t ReadInternal(FileHandle InFile, UInt32 Stream, UInt64 Count);

        int BuffGetU8(FileHandle InFile);
    };

}


#endif // MXFLIB__ESP_MPEG2VES_H

---