esp_wavepcm.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_WAVEPCM_H
#define MXFLIB__ESP_WAVEPCM_H

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


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

        Position DataStart;                                 
        Length DataSize;                                    
        Position CurrentPosition;                           
        Position BytePosition;                              

        size_t CachedDataSize;                              
        UInt64 CachedCount;                                 

        int SampleSize;                                     
        UInt32 ConstSamples;                                
        int SampleSequenceSize;                             
        UInt32 *SampleSequence;                             
        int SequencePos;                                    

        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/*, IndexTablePtr UseIndex = NULL*/)
                : EssenceSubParserBase::ESP_EssenceSource(TheCaller, InFile, UseStream, Count/*, UseIndex*/) 
            {
                BytesRemaining = 0;
            };


            virtual size_t GetEssenceDataSize(void) 
            {
                WAVE_PCM_EssenceSubParser *pCaller = SmartPtr_Cast(Caller, WAVE_PCM_EssenceSubParser);
                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) 
            { 
                WAVE_PCM_EssenceSubParser *pCaller = SmartPtr_Cast(Caller, WAVE_PCM_EssenceSubParser);

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

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

    public:
        WAVE_PCM_EssenceSubParser()
        {
            SampleRate = 1;
            ConstSamples = 0;
            SampleSequenceSize = 0;
            SampleSequence = NULL;
            SequencePos = 0;
            DataStart = 0;
            DataSize = 0;
            CurrentPosition = 0;
            BytePosition = 0;

            // Use a sensible default if no edit rate is set - not ideal, but better than one sample!
            // It will 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);
            CachedCount = 0;
        }

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

        virtual StringList HandledExtensions(void)
        {
            StringList ExtensionList;

            ExtensionList.push_back("WAV");

            return ExtensionList;
        }

        virtual EssenceStreamDescriptorList IdentifyEssence(FileHandle InFile);

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


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

            BytePosition = 0;
        }



        virtual bool SetEditRate(Rational EditRate)
        {
            // See if we can figure out a sequence for this rate
            bool Ret = CalcWrappingSequence(EditRate);

            // If we can then set the rate
            if(Ret)
            {
                SequencePos = 0;
                UseEditRate = EditRate;
            }

            return Ret;
        }

        virtual Rational GetEditRate(void) { return UseEditRate; }


        virtual Rational GetPreferredEditRate(void);

        virtual UInt32 GetBytesPerEditUnit(UInt32 KAGSize = 1)
        {
            // If we haven't determined the sample sequence we do it now
            if((ConstSamples == 0) && (SampleSequenceSize == 0)) CalcWrappingSequence(UseEditRate);

            UInt32 Ret = SampleSize*ConstSamples;

            if(Ret && (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
                    // DRAGONS: For very small KAGSizes we may need to add several KAGs
                    while((Remainder > 0) && (Remainder < 17))
                    {
                        Ret += KAGSize;
                        Remainder += KAGSize;
                    }
                }
            }

            return Ret;
        }


        virtual Position GetCurrentPosition(void) { return CurrentPosition; }

        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 std::string GetParserName(void) const { return "wavepcm"; }


    protected:
        bool CalcWrappingSequence(Rational EditRate);

        Position CalcCurrentPosition(void);

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

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

#endif // MXFLIB__ESP_WAVEPCM_H

---