MediaParser.h

Go to the documentation of this file.

// MediaParser.h: Base class for media parsers
// 
//   Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc.
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef GNASH_MEDIAPARSER_H
#define GNASH_MEDIAPARSER_H

#include <boost/scoped_array.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/barrier.hpp>
#include <memory>
#include <deque>
#include <map>
#include <vector>
#include <iosfwd> // for output operator forward declarations
#include <boost/optional.hpp>

#include "IOChannel.h" // for inlines
#include "dsodefs.h" // DSOEXPORT

// Undefine this to load/parse media files in main thread
#define LOAD_MEDIA_IN_A_SEPARATE_THREAD 1

namespace gnash {
    class SimpleBuffer;
    namespace media {
        struct Id3Info;
    }
}

namespace gnash {
namespace media {


enum videoFrameType
{
        KEY_FRAME = 1,

        INTER_FRAME = 2,

        DIS_INTER_FRAME = 3
};

enum codecType
{
        CODEC_TYPE_FLASH,

        CODEC_TYPE_CUSTOM
};

enum videoCodecType
{
        VIDEO_CODEC_H263 = 2,

        VIDEO_CODEC_SCREENVIDEO = 3,

        VIDEO_CODEC_VP6 = 4,

        VIDEO_CODEC_VP6A = 5,

        VIDEO_CODEC_SCREENVIDEO2 = 6,

        VIDEO_CODEC_H264 = 7

        // NOTE: if you add more elements here remember to
        //       also add them to the output operator!
};

DSOEXPORT std::ostream& operator<< (std::ostream& os, const videoCodecType& t);

//
enum audioCodecType
{
        //
        AUDIO_CODEC_RAW = 0,    

    //
        AUDIO_CODEC_ADPCM = 1,

        //
        AUDIO_CODEC_MP3 = 2,

        AUDIO_CODEC_UNCOMPRESSED = 3,

    //
        AUDIO_CODEC_NELLYMOSER_8HZ_MONO = 5,

    //
        AUDIO_CODEC_NELLYMOSER = 6,

        AUDIO_CODEC_AAC = 10,

        AUDIO_CODEC_SPEEX = 11

        // NOTE: if you add more elements here remember to
        //       also add them to the output operator!
};

DSOEXPORT std::ostream& operator<< (std::ostream& os, const audioCodecType& t);

//
class AudioInfo
{

public:

    //
        AudioInfo(int codeci, boost::uint16_t sampleRatei,
            boost::uint16_t sampleSizei, bool stereoi,
            boost::uint64_t durationi, codecType typei)
                :
        codec(codeci),
                sampleRate(sampleRatei),
                sampleSize(sampleSizei),
                stereo(stereoi),
                duration(durationi),
                type(typei)
                {
                }

        //
        int codec;

        boost::uint16_t sampleRate;

        boost::uint16_t sampleSize;

        bool stereo;

        boost::uint64_t duration;

        codecType type;

    //
        class ExtraInfo {
        public:
                virtual ~ExtraInfo() {}
        };

    //
        std::auto_ptr<ExtraInfo> extra;
};

//
class VideoInfo
{
public:

    //
        VideoInfo(int codeci, boost::uint16_t widthi, boost::uint16_t heighti,
            boost::uint16_t frameRatei, boost::uint64_t durationi,
            codecType typei)
                :
        codec(codeci),
                width(widthi),
                height(heighti),
                frameRate(frameRatei),
                duration(durationi),
                type(typei)
        {
        }

        int codec;
        boost::uint16_t width;
        boost::uint16_t height;
        boost::uint16_t frameRate;
        boost::uint64_t duration;
        codecType type;

    //
        class ExtraInfo {
        public:
                virtual ~ExtraInfo() {}
        };

    //
        std::auto_ptr<ExtraInfo> extra;
};

DSOEXPORT std::ostream& operator << (std::ostream& os, const VideoInfo& vi);


class EncodedExtraData {

public:
        virtual ~EncodedExtraData() {}

};

class EncodedVideoFrame
{
public:

        //
        EncodedVideoFrame(boost::uint8_t* data, boost::uint32_t size,
                        unsigned int frameNum,
                        boost::uint64_t timestamp=0)
                :
                _size(size),
                _data(data),
                _frameNum(frameNum),
                _timestamp(timestamp)
        {}

        const boost::uint8_t* data() const { return _data.get(); }

        boost::uint32_t dataSize() const { return _size; }

        boost::uint64_t timestamp() const { return _timestamp; }

        unsigned frameNum() const { return _frameNum; }

        // FIXME: should have better encapsulation for this sort of stuff.
        std::auto_ptr<EncodedExtraData> extradata;
private:

        boost::uint32_t _size;
        boost::scoped_array<boost::uint8_t> _data;
        unsigned int _frameNum;
        boost::uint64_t _timestamp;
};

class EncodedAudioFrame
{
public:
        boost::uint32_t dataSize;
        boost::scoped_array<boost::uint8_t> data;
        boost::uint64_t timestamp;

        // FIXME: should have better encapsulation for this sort of stuff.
        std::auto_ptr<EncodedExtraData> extradata;
};

//
class MediaParser
{
public:

    //
    typedef std::multimap<boost::uint64_t, boost::shared_ptr<SimpleBuffer> >
        MetaTags;
    
    typedef std::vector<MetaTags::mapped_type> OrderedMetaTags;
        MediaParser(std::auto_ptr<IOChannel> stream);

        // Classes with virtual methods (virtual classes)
        // must have a virtual destructor, or the destructors
        // of subclasses will never be invoked, tipically resulting
        // in memory leaks..
        //
        virtual ~MediaParser();

        //
        virtual bool seek(boost::uint32_t& time)=0;

        //
        DSOEXPORT boost::uint64_t getBufferLength() const;

        //
        DSOEXPORT bool isBufferEmpty() const;

        DSOEXPORT boost::uint64_t getBufferTime() const
        {
                boost::mutex::scoped_lock lock(_bufferTimeMutex);
                return _bufferTime;
        }

        //
        DSOEXPORT void setBufferTime(boost::uint64_t t)
        {
                boost::mutex::scoped_lock lock(_bufferTimeMutex);
                _bufferTime=t;
        }

        //
        DSOEXPORT bool nextFrameTimestamp(boost::uint64_t& ts) const;

        //
        DSOEXPORT bool nextVideoFrameTimestamp(boost::uint64_t& ts) const;

        //
        DSOEXPORT std::auto_ptr<EncodedVideoFrame> nextVideoFrame();

        //
        DSOEXPORT bool nextAudioFrameTimestamp(boost::uint64_t& ts) const;

        //
        DSOEXPORT std::auto_ptr<EncodedAudioFrame> nextAudioFrame();

        //
        VideoInfo* getVideoInfo() { return _videoInfo.get(); }

        //
        AudioInfo* getAudioInfo() { return _audioInfo.get(); }

        //
        bool parsingCompleted() const { return _parsingComplete; }

        //
        virtual bool indexingCompleted() const { return true; }

        virtual boost::uint64_t getBytesLoaded() const { return 0; }

        boost::uint64_t getBytesTotal() const
        {
                return _stream->size();
        }

        //
        virtual bool parseNextChunk()=0;

    //
    //
    virtual void fetchMetaTags(OrderedMetaTags& tags, boost::uint64_t ts);

    //
    virtual boost::optional<Id3Info> getId3Info() const;

protected:


        std::auto_ptr<VideoInfo> _videoInfo;

        std::auto_ptr<AudioInfo> _audioInfo;

        bool _parsingComplete;

        boost::uint64_t _bytesLoaded;


        void startParserThread();

        //
        void stopParserThread();

        void clearBuffers();

        //
        void pushEncodedAudioFrame(std::auto_ptr<EncodedAudioFrame> frame);

        //
        void pushEncodedVideoFrame(std::auto_ptr<EncodedVideoFrame> frame);

        std::auto_ptr<IOChannel> _stream;
        mutable boost::mutex _streamMutex;

        static void parserLoopStarter(MediaParser* mp)
        {
                mp->parserLoop();
        }

        void parserLoop();

        bool parserThreadKillRequested() const
        {
                boost::mutex::scoped_lock lock(_parserThreadKillRequestMutex);
                return _parserThreadKillRequested;
        }

        boost::uint64_t _bufferTime;
        mutable boost::mutex _bufferTimeMutex;

        std::auto_ptr<boost::thread> _parserThread;
        boost::barrier _parserThreadStartBarrier;
        mutable boost::mutex _parserThreadKillRequestMutex;
        bool _parserThreadKillRequested;
        boost::condition _parserThreadWakeup;

        void waitIfNeeded(boost::mutex::scoped_lock& qMutexLock);

        void wakeupParserThread();

        mutable boost::mutex _qMutex;

        mutable boost::mutex _bytesLoadedMutex;

        //
        bool bufferFull() const;

        bool _seekRequest;

private:

        typedef std::deque<EncodedVideoFrame*> VideoFrames;
        typedef std::deque<EncodedAudioFrame*> AudioFrames;

        //
        const EncodedVideoFrame* peekNextVideoFrame() const;

        //
        const EncodedAudioFrame* peekNextAudioFrame() const;


        //
        VideoFrames _videoFrames;

        //
        AudioFrames _audioFrames;

        void requestParserThreadKill()
        {
                boost::mutex::scoped_lock lock(_parserThreadKillRequestMutex);
                _parserThreadKillRequested=true;
                _parserThreadWakeup.notify_all();
        }

        boost::uint64_t audioBufferLength() const;

        boost::uint64_t videoBufferLength() const;

        boost::uint64_t getBufferLengthNoLock() const;
        
};


} // gnash.media namespace 
} // namespace gnash

#endif // __MEDIAPARSER_H__