movie_definition.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_MOVIE_DEFINITION_H
#define GNASH_MOVIE_DEFINITION_H

#ifdef HAVE_CONFIG_H
#include "gnashconfig.h" // for USE_SWFTREE
#endif

#include <string>
#include <memory> // for unique_ptr
#include <vector> // for PlayList typedef
#include <boost/intrusive_ptr.hpp>
#include <cstdint>

#include "DefinitionTag.h"
#include "log.h"

// Forward declarations
namespace gnash {
        class CachedBitmap;
        class Movie;
        class MovieClip;
        namespace SWF {
        class ControlTag;
    }
    class Font;
    class sound_sample;
    namespace image {
        class JpegInput;
    }
}

namespace gnash
{

//
class movie_definition : public SWF::DefinitionTag
{
public:
        typedef std::vector<boost::intrusive_ptr<SWF::ControlTag> > PlayList;

        virtual int     get_version() const = 0;

    //
        virtual size_t get_width_pixels() const = 0;
    
    //
        virtual size_t get_height_pixels() const = 0;

        virtual size_t get_frame_count() const = 0;
        virtual float get_frame_rate() const = 0;

        virtual const SWFRect& get_frame_size() const = 0;

        virtual size_t get_bytes_loaded() const = 0;

        //
        virtual size_t get_bytes_total() const = 0;

        //
        virtual Movie* createMovie(Global_as& /*gl*/, DisplayObject* /*parent*/=nullptr)
        {
                return nullptr;
        }

    virtual void incrementLoadedFrames() {}

        //
        virtual const PlayList* getPlaylist(size_t /*frame_number*/) const
        {
                return nullptr;
        }


        typedef std::pair<int, std::string> ImportSpec;
        typedef std::vector< ImportSpec > Imports;

        //
        virtual void importResources(
            boost::intrusive_ptr<movie_definition> /*source*/, 
            const Imports& /*imports*/)
        {
                IF_VERBOSE_MALFORMED_SWF(
            log_swferror(_("IMPORT tag appears outside SWF definition"));
                );
        }


        //
        virtual DefinitionTag* getDefinitionTag(std::uint16_t /*id*/) const
        {
                return nullptr;
        }

        //
        virtual bool get_labeled_frame(const std::string& /*label*/,
            size_t& /*frame_number*/) const
        {
                return false;
        }

        virtual size_t  get_loading_frame() const = 0;

        //
    //
        virtual void addDisplayObject(std::uint16_t /*id*/, DefinitionTag* /*c*/)
        {
        }

        //
        virtual void add_font(int /*id*/, boost::intrusive_ptr<Font> /*ch*/)
        {
        }

        //
        virtual Font* get_font(int /*id*/) const
        {
                return nullptr;
        }

        virtual Font* get_font(const std::string& /*name*/,
            bool /*bold*/, bool /*italic*/) const
        {
                return nullptr;
        }

        //
        virtual void addControlTag(boost::intrusive_ptr<SWF::ControlTag> /*c*/)
        {
        }

        //
        virtual void add_frame_name(const std::string& /*name*/)
        {
        }

        virtual void set_jpeg_loader(std::unique_ptr<image::JpegInput> /*j_in*/)
        {
        }

        virtual image::JpegInput* get_jpeg_loader() const
        {
                return nullptr;
        }

        //
        virtual CachedBitmap* getBitmap(int /*DisplayObject_id*/) const
        {
                return nullptr;
        }

        //
        virtual void addBitmap(int /*id*/, boost::intrusive_ptr<CachedBitmap> /*im*/)
        {
        }

        //
        virtual sound_sample* get_sound_sample(int /*DisplayObject_id*/) const
        {
                return nullptr;
        }

        //
        virtual void add_sound_sample(int /*DisplayObject_id*/, sound_sample* /*sam*/)
        {
        }

        //
        virtual void set_loading_sound_stream_id(int /*id*/)
        {
        }

        //
        virtual int get_loading_sound_stream_id() const
        {
                return -1;
        }

    //
    virtual void registerExport(const std::string&, std::uint16_t) {}
    
    //
    virtual std::uint16_t exportID(const std::string& /*symbol*/) const {
        return 0;
    }

    //
    virtual void setAS3() {
    }

    //
    virtual bool isAS3() const {
        return false;
    }

        virtual const std::string& get_url() const = 0;

        // Start the loader thread. By default no loader thread is engaged
        // so this function is a no-op.
        virtual bool completeLoad() {
                return true;
        }

        //
        virtual bool ensure_frame_loaded(size_t /*framenum*/) const {
                return true;
        }

#ifdef USE_SWFTREE

        // These methods attach the contents of the METADATA tag
        // to a movie_definition. They are not used by the player
        // at all, but are stored for display in Movie Properties.
        // To save memory and parsing time, this won't happen
        // when the swf tree view is disabled.
        virtual void storeDescriptiveMetadata(const std::string& /*data*/)
        {
        }

        virtual const std::string& getDescriptiveMetadata() const
        {
            static const std::string s;
            return s;
        }

#endif
protected:

    movie_definition(std::uint16_t id = 0)
        :
        DefinitionTag(id)
    {}

    virtual ~movie_definition() {}
};

} // namespace gnash

#endif // GNASH_MOVIE_DEFINITION_H