MediaParser.h

Go to the documentation of this file.

// MediaParser.h: Base class for media parsers
// 
//   Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016
//   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 <atomic>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <memory>
#include <deque>
#include <map>
#include <vector>
#include <iostream> // for output operator
#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
{
        NO_VIDEO_CODEC = 0,

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

inline std::ostream&
operator<< (std::ostream& os, const audioCodecType& t)
{
    switch (t)
    {
        case AUDIO_CODEC_RAW:
            os << "Raw";
            break;
        case AUDIO_CODEC_ADPCM:
            os << "ADPCM";
            break;
        case AUDIO_CODEC_MP3:
            os << "MP3";
            break;
        case AUDIO_CODEC_UNCOMPRESSED:
            os << "Uncompressed";
            break;
        case AUDIO_CODEC_NELLYMOSER_8HZ_MONO:
            os << "Nellymoser 8Hz mono";
            break;
        case AUDIO_CODEC_NELLYMOSER:
            os << "Nellymoser";
            break;
        case AUDIO_CODEC_AAC:
            os << "Advanced Audio Coding";
            break;
        case AUDIO_CODEC_SPEEX:
            os << "Speex";
            break;
        default:
            os << "unknown/invalid codec " << static_cast<int>(t);
            break;
    }
    return os;
}

//
class AudioInfo
{

public:

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

        //
        int codec;

        std::uint16_t sampleRate;

        std::uint16_t sampleSize;

        bool stereo;

        std::uint64_t duration;

        codecType type;

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

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

//
class VideoInfo
{
public:

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

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

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

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

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


class EncodedExtraData {

public:
        virtual ~EncodedExtraData() {}

};

class EncodedVideoFrame
{
public:

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

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

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

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

        unsigned frameNum() const { return _frameNum; }

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

        std::uint32_t _size;
        std::unique_ptr<std::uint8_t[]> _data;
        unsigned int _frameNum;
        std::uint64_t _timestamp;
};

class EncodedAudioFrame
{
public:
        std::uint32_t dataSize;
        std::unique_ptr<std::uint8_t[]> data;
        std::uint64_t timestamp;

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

//
class DSOEXPORT MediaParser
{
public:

    //
    typedef std::multimap<std::uint64_t, std::shared_ptr<SimpleBuffer> >
        MetaTags;
    
    typedef std::vector<MetaTags::mapped_type> OrderedMetaTags;

        MediaParser(std::unique_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(std::uint32_t& time)=0;

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

        //
        DSOEXPORT bool isBufferEmpty() const;

        DSOEXPORT std::uint_fast64_t getBufferTime() const
        {
                return _bufferTime.load();
        }

        //
        DSOEXPORT void setBufferTime(std::uint_fast64_t t)
        {
                _bufferTime=t;
        }

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

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

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

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

        //
        DSOEXPORT std::unique_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 std::uint64_t getBytesLoaded() const { return 0; }

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

        //
        virtual bool parseNextChunk()=0;

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

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

protected:


        std::unique_ptr<VideoInfo> _videoInfo;

        std::unique_ptr<AudioInfo> _audioInfo;

        bool _parsingComplete;

        std::atomic<std::uint_fast64_t> _bytesLoaded;


        void startParserThread();

        //
        void stopParserThread();

        void clearBuffers();

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

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

        std::unique_ptr<IOChannel> _stream;
        mutable std::mutex _streamMutex;

        void parserLoop();

        bool parserThreadKillRequested() const
        {
                return _parserThreadKillRequested.load();
        }

        std::atomic<std::uint_fast64_t> _bufferTime;

        std::thread _parserThread;
        std::atomic<bool> _parserThreadKillRequested;
        std::condition_variable _parserThreadWakeup;

        void waitIfNeeded(std::unique_lock<std::mutex>& qMutexLock);

        void wakeupParserThread();

        mutable std::mutex _qMutex;

        //
        bool bufferFull() const;

        bool _seekRequest;

private:

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

        //
        const EncodedVideoFrame* peekNextVideoFrame() const;

        //
        const EncodedAudioFrame* peekNextAudioFrame() const;


        //
        VideoFrames _videoFrames;

        //
        AudioFrames _audioFrames;

        void requestParserThreadKill()
        {
                _parserThreadKillRequested=true;
                _parserThreadWakeup.notify_all();
        }

        std::uint64_t audioBufferLength() const;

        std::uint64_t videoBufferLength() const;

        std::uint64_t getBufferLengthNoLock() const;
        
};


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

#endif // __MEDIAPARSER_H__