esp_jp2k.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2005, 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_JP2K_H
#define MXFLIB__ESP_JP2K_H

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


namespace mxflib
{
    class JP2K_EssenceSubParser : public EssenceSubParserBase
    {
    protected:
        UInt32 SampleRate;                                  
        Rational UseEditRate;                               

        Position PictureNumber;                             

        Position DataStart;                                 
        Length DataSize;                                    
        Position CurrentPos;                                

        size_t CachedDataSize;                              

        MDObjectParent CurrentDescriptor;                   

    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*/) 
            {
            };


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


            virtual DataChunkPtr GetEssenceData(size_t Size = 0, size_t MaxSize = 0)
            {
                return BaseGetEssenceData(Size, MaxSize);
            }

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

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

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

    public:
        JP2K_EssenceSubParser()
        {
            PictureNumber = 0;

            SampleRate = 1;
            DataStart = 0;
            DataSize = 0;
            CurrentPos = 0;

            // Use a sensible default if no edit rate is set - not ideal, but better than one sample!
            // It should always be possible to wrap at this rate, but the end of the data may not be a whole edit unit
            UseEditRate.Numerator = 1;
            UseEditRate.Denominator = 1;

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

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

        virtual StringList HandledExtensions(void)
        {
            StringList ExtensionList;

            // TODO: Add any supported extentions here
            //       This is used as a hint to the overall essence parser to decide which sub-parsers to try.
            //       Calls may still be made to this sub-parser for files of different extensions, but this is a starting point.

            ExtensionList.push_back("JP2");

            return ExtensionList;
        }

        virtual EssenceStreamDescriptorList IdentifyEssence(FileHandle InFile);

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


        virtual void Use(UInt32 Stream, WrappingOptionPtr UseWrapping)
        {
            SelectedWrapping = UseWrapping;

            CurrentPos = 0;
        }


        virtual bool SetEditRate(Rational EditRate)
        {
            UseEditRate = EditRate;

            // Pretend that the essence is sampled at whatever rate we are wrapping at
            MDObjectPtr Ptr;
            if(CurrentDescriptor) Ptr = CurrentDescriptor->AddChild(SampleRate_UL);
            if(Ptr)
            {
                Ptr->SetInt("Numerator", UseEditRate.Numerator);
                Ptr->SetInt("Denominator", UseEditRate.Denominator);
            }
            
            return true;
        }

        virtual Rational GetEditRate(void) { return UseEditRate; }


        virtual Rational GetPreferredEditRate(void) { return Rational(24, 1); };

        virtual Position GetCurrentPosition(void) { return PictureNumber; }

        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);
        };

        virtual Length Write(FileHandle InFile, UInt32 Stream, MXFFilePtr OutFile, UInt64 Count = 1);


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


    protected:
        typedef std::multimap<std::string, DataChunkPtr> HeaderType;

        HeaderType Header;

        bool CalcWrappingSequence(Rational EditRate);


        MDObjectPtr BuildDescriptorFromCodeStream(FileHandle InFile, Position Offset = 0 );


        MDObjectPtr BuildDescriptorFromJP2(FileHandle InFile);

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

        bool ParseJP2Header(FileHandle InFile);


        bool ParseJP2KCodestreamHeader(FileHandle InFile, Position Offset);


        UInt32 GreatestCommonDivisor(UInt32 Large, UInt32 Small)
        {
            // Zero is never the GCD
            if(Large == 0) return 1;

            UInt32 Temp;

            // The rest of the algorithm assumes Large >= Small
            if(Large < Small)
            {
                Temp = Large;
                Large = Small;
                Small = Temp;
            }

            while (Small > 0)
            {
                Temp = Large % Small;
                Large = Small;
                Small = Temp;
            }
            
            return Large;
        }

        void ReduceRational(UInt32 &Numerator, UInt32 &Denominator)
        {
            if(Denominator == 1) return;

            UInt32 GCD = GreatestCommonDivisor(Numerator, Denominator);
            
            Numerator /= GCD;
            Denominator /= GCD;
        }
    };
}

#endif // MXFLIB__ESP_JP2K_H

---