DefineVideoStreamTag.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 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_SWF_DEFINEVIDEOSTREAMTAG_H
#define GNASH_SWF_DEFINEVIDEOSTREAMTAG_H

#include <boost/shared_array.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <memory> 
#include <vector> 

#include "DefinitionTag.h"
#include "SWF.h"
#include "SWFRect.h" // for composition
#include "MediaParser.h" // for videoFrameType and videoCodecType enums

// Forward declarations
namespace gnash {
    class movie_definition;
    class SWFStream;
    class RunResources;
}

namespace gnash {

class VideoData
{
public:
        VideoData(boost::shared_array<boost::uint8_t> data, boost::uint32_t size,
            media::videoFrameType ft)
                :
                videoData(data),
                dataSize(size),
                frameType(ft)
        {
        }

        ~VideoData()
        {
        }

        boost::shared_array<boost::uint8_t> videoData;
        boost::uint32_t dataSize;
        media::videoFrameType frameType;
};

namespace SWF {

class DefineVideoStreamTag : public DefinitionTag
{
        
        //
        typedef boost::ptr_vector<media::EncodedVideoFrame> EmbeddedFrames;

    //
    struct FrameFinder
    {
        typedef EmbeddedFrames::const_reference Frame;

        bool operator()(Frame frame, size_t i) const {
            return frame.frameNum() < i;
        }
        
        bool operator()(size_t i, Frame frame) const {
            return i < frame.frameNum();
        }
    };

public:

        ~DefineVideoStreamTag();

        DisplayObject* createDisplayObject(Global_as& gl, DisplayObject* parent)
        const;

        //
        static void loader(SWFStream& in, SWF::TagType tag, movie_definition& m,
            const RunResources& r);


        //
        void readDefineVideoFrame(SWFStream& in, SWF::TagType tag,
            movie_definition& m);

        const SWFRect& bounds() const {
                return m_bound;
        }

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

        //
    template<typename T>
    size_t visitSlice(const T& t, boost::uint32_t from, boost::uint32_t to) const {

        boost::mutex::scoped_lock lock(_video_mutex);

        // It's assumed that frame numbers are in order.
        EmbeddedFrames::const_iterator lower = std::lower_bound(
                _video_frames.begin(), _video_frames.end(), from, FrameFinder());

        EmbeddedFrames::const_iterator upper = std::upper_bound(
                lower, _video_frames.end(), to, FrameFinder());

        std::for_each(lower, upper, t);
        return (upper - lower);
    }
    
    void addVideoFrameTag(std::auto_ptr<media::EncodedVideoFrame> frame);

private:

        //
        DefineVideoStreamTag(SWFStream& in, boost::uint16_t id);

        void read(SWFStream& in);

        boost::uint8_t m_reserved_flags;

        boost::uint8_t m_deblocking_flags;

        bool m_smoothing_flags;

        //boost::uint16_t m_start_frame;

        boost::uint16_t m_num_frames;

        //
        media::videoCodecType m_codec_id;

        SWFRect m_bound;

    // Mutable for locking in const member functions.
        mutable boost::mutex _video_mutex;
        
        EmbeddedFrames _video_frames;

        boost::uint32_t _width;

        boost::uint32_t _height;

        //
        std::auto_ptr<media::VideoInfo> _videoInfo;

};

} // namespace SWF
} // namespace gnash


#endif // GNASH_VIDEO_STREAM_DEF_H