esp_dvdif.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_DVDIF_H
#define MXFLIB__ESP_DVDIF_H


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

#define DV_DIF_BUFFERSIZE  (256 * 1024)

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

        Position PictureNumber;                             
        Position CurrentPos;                                

        Position DIFStart;                                  
        Position DIFEnd;                                    

        int SeqCount;                                       

        bool isS314M;                                       

        UInt32 AVIFrameCount;                               
        int StreamNumber;                                   

        UInt32 AVIStreamID;                                 
        UInt32 AVIListRemaining;                            
        UInt32 AVIChunkRemaining;                           

        size_t CachedDataSize;                              
        UInt64 CachedCount;                                 

        // File buffering
        UInt8 *Buffer;                                      

        int BuffCount;                                      
        UInt8 *BuffPtr;                                     

        MDObjectParent CurrentDescriptor;                   

        // Options
        // None (yet)

    public:
        class ESP_EssenceSource : public EssenceSubParserBase::ESP_EssenceSource
        {
        public:
            ESP_EssenceSource(EssenceSubParserPtr TheCaller, FileHandle InFile, UInt32 UseStream, UInt64 Count = 1/*, IndexTablePtr UseIndex = NULL*/)
                : EssenceSubParserBase::ESP_EssenceSource(TheCaller, InFile, UseStream, Count/*, UseIndex*/) 
            {
                DV_DIF_EssenceSubParser *pCaller = SmartPtr_Cast(Caller, DV_DIF_EssenceSubParser);

                if(pCaller->SelectedWrapping->ThisWrapType == WrappingOption::Clip) RequestedCount = 0;
            };


            virtual size_t GetEssenceDataSize(void) 
            {
                DV_DIF_EssenceSubParser *pCaller = SmartPtr_Cast(Caller, DV_DIF_EssenceSubParser);
                return pCaller->ReadInternal(File, Stream, RequestedCount/*, Index*/);
            };


            virtual DataChunkPtr GetEssenceData(size_t Size = 0, size_t MaxSize = 0)
            {
/*              // Allow us to differentiate the first call
                if(!Started)
                {
                    // Move to the selected position
                    DV_DIF_EssenceSubParser *pCaller = SmartPtr_Cast(Caller, DV_DIF_EssenceSubParser);

                    Started = true;
                }
*/

                return BaseGetEssenceData(Size, MaxSize);
            }

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

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

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

    public:
        DV_DIF_EssenceSubParser()
        {
            DIFStart = 0;
            DIFEnd = 0;
            SeqCount = 10;
            AVIFrameCount = 0;
            StreamNumber = 0;
            Buffer = NULL;

            CachedDataSize = static_cast<size_t>(-1);
            CachedCount = 0;
        }

        ~DV_DIF_EssenceSubParser()
        {
            // Free our buffer if we have allocated one
            if(Buffer) delete[] Buffer;
        }

        virtual EssenceSubParserPtr NewParser(void) const;

        virtual StringList HandledExtensions(void)
        {
            StringList ExtensionList;

            ExtensionList.push_back("AVI");
            ExtensionList.push_back("DV");
            ExtensionList.push_back("DIF");

            return ExtensionList;
        }

        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 UInt32 GetBytesPerEditUnit(UInt32 KAGSize = 1)
        {
            // FIXME: Assumes 25Mbps
            UInt32 Ret = (150 * 80 * SeqCount);

            if(SelectedWrapping->ThisWrapType == WrappingOption::Frame) 
            {
                // FIXME: This assumes that 4-byte BER coding will be used - this needs to be adjusted or forced to be true!!
                Ret += 16 + 4;

                // Adjust for whole KAGs if required
                if(KAGSize > 1)
                {
                    // Work out how much short of the next KAG boundary we would be
                    UInt32 Remainder = Ret % KAGSize;
                    if(Remainder) Remainder = KAGSize - Remainder;

                    // Round up to the start of the next KAG
                    Ret += Remainder;

                    // If there is not enough space to fit a filler in the remaining space an extra KAG will be required
                    if((Remainder > 0) && (Remainder < 17)) Ret++;
                }
            }

            return Ret;
        }

        virtual Position GetCurrentPosition(void);

        virtual DataChunkPtr Read(FileHandle InFile, UInt32 Stream, UInt64 Count = 1/*, IndexTablePtr Index = NULL*/);

        virtual EssenceSourcePtr GetEssenceSource(FileHandle InFile, UInt32 Stream, UInt64 Count = 1/*, IndexTablePtr Index = NULL*/)
        {
            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 "dvdif"; }

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

        MDObjectPtr BuildSoundEssenceDescriptor(FileHandle InFile, UInt64 Start = 0);

        MDObjectPtr BuildCDCIEssenceDescriptorFromAVI(FileHandle InFile, UInt64 Start);

        MDObjectPtr BuildSoundEssenceDescriptorFromAVI(FileHandle InFile, UInt64 Start);

        size_t ReadInternal(FileHandle InFile, UInt32 Stream, UInt64 Count/*, IndexTablePtr Index = NULL*/);


        DataChunkPtr AVIRead(FileHandle InFile, size_t Bytes);
    };


    class DV_DIF_EssenceSubParserFactory : public EssenceSubParserFactory
    {
    public:
        virtual EssenceSubParserPtr NewParser(void) const { return new DV_DIF_EssenceSubParser; }
    };

}

#endif // MXFLIB__ESP_DVDIF_H

---