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 <mutex>
#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 {

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, std::uint32_t from, std::uint32_t to) const {

        std::lock_guard<std::mutex> 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::unique_ptr<media::EncodedVideoFrame> frame);

private:

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

        void read(SWFStream& in);

        std::uint8_t m_reserved_flags;

        std::uint8_t m_deblocking_flags;

        bool m_smoothing_flags;

        //std::uint16_t m_start_frame;

        std::uint16_t m_num_frames;

        //
        media::videoCodecType m_codec_id;

        SWFRect m_bound;

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

        std::uint32_t _width;

        std::uint32_t _height;

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

};

} // namespace SWF
} // namespace gnash


#endif // GNASH_VIDEO_STREAM_DEF_H