SWFMovieDefinition.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

// The SWFMovieDefinition is the 'root' definition of a SWF movie, including
// movies loaded into another SWF file. Each self-contained SWF file has exactly
// one SWFMovieDefinition.

#ifndef GNASH_SWF_MOVIE_DEFINITION_H
#define GNASH_SWF_MOVIE_DEFINITION_H

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

#include "movie_definition.h" // for inheritance
#include "DefinitionTag.h" // for boost::intrusive_ptr visibility of dtor
#include "StringPredicates.h" 
#include "SWFRect.h"
#include "GnashNumeric.h"
#include "GnashAlgorithm.h"

#include <boost/intrusive_ptr.hpp>
#include <vector>
#include <map>
#include <set> 
#include <string>
#include <memory> 
#include <boost/thread/thread.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/barrier.hpp>
#include <boost/scoped_ptr.hpp>

// Forward declarations
namespace gnash {
    namespace image {
        class JpegInput;
    }
    class IOChannel;
    class SWFMovieDefinition;
    class SWFStream;
    class movie_root;
    class MovieClip;
    class SWFMovie;
    class RunResources;
    class Font;
}

namespace gnash {

class SWFMovieLoader
{
public:

    SWFMovieLoader(SWFMovieDefinition& md);

    ~SWFMovieLoader();

    //
    bool start();

    bool started() const;

    bool isSelfThread() const;

private:

    SWFMovieDefinition& _movie_def;

    mutable boost::mutex _mutex;
    std::auto_ptr<boost::thread> _thread;

    // Barrier to ensure that _thread
    // is initialized before the loader thread
    // continues execution
    boost::barrier _barrier;

    static void execute(SWFMovieLoader& ml, SWFMovieDefinition* md);

};

//
class CharacterDictionary
{
public:

    //
    typedef std::map<int, boost::intrusive_ptr<SWF::DefinitionTag> >
        CharacterContainer;

    typedef CharacterContainer::iterator CharacterIterator;

    typedef CharacterContainer::const_iterator CharacterConstIterator;

    //
    boost::intrusive_ptr<SWF::DefinitionTag> getDisplayObject(int id) const;

    //
    void addDisplayObject(int id, boost::intrusive_ptr<SWF::DefinitionTag> c);
      
    CharacterIterator begin() { return _map.begin(); }

    CharacterConstIterator begin() const { return _map.begin(); }

    CharacterIterator end() { return _map.end(); }

    CharacterConstIterator end() const { return _map.end(); }

    friend std::ostream& operator<<(std::ostream& o,
            const CharacterDictionary& cd);

private:

    CharacterContainer _map;

};


//
class SWFMovieDefinition : public movie_definition
{
public:

    //
    SWFMovieDefinition(const RunResources& runResources);

    ~SWFMovieDefinition();

    size_t get_frame_count() const {
        return m_frame_count;
    }
    
    float get_frame_rate() const {
        return m_frame_rate;
    }
    
    const SWFRect& get_frame_size() const {
        return m_frame_size;
    }

    size_t get_width_pixels() const {
        return std::ceil(twipsToPixels(m_frame_size.width()));
    }

    size_t get_height_pixels() const {
        return std::ceil(twipsToPixels(m_frame_size.height()));
    }

    void setAS3() {
        _as3 = true;
    }
    
    bool isAS3() const {
        return _as3;
    }

    //
    virtual int get_version() const { return m_version; }

    //
    virtual size_t get_loading_frame() const;

    //
    size_t get_bytes_loaded() const {
        boost::mutex::scoped_lock lock(_bytes_loaded_mutex);
        return _bytes_loaded;
    }

    size_t get_bytes_total() const {
        return m_file_length;
    }

    virtual void importResources(boost::intrusive_ptr<movie_definition> source,
            const Imports& imports);

    virtual void addDisplayObject(boost::uint16_t id, SWF::DefinitionTag* c);

    SWF::DefinitionTag* getDefinitionTag(boost::uint16_t id) const;

    // See dox in movie_definition
    //
    // locks _namedFramesMutex
    bool get_labeled_frame(const std::string& label, size_t& frame_number)
        const;

    void add_font(int font_id, boost::intrusive_ptr<Font> f);

    Font* get_font(int font_id) const;

    Font* get_font(const std::string& name, bool bold, bool italic) const;

    // See dox in movie_definition.h
    CachedBitmap* getBitmap(int DisplayObject_id) const;

    // See dox in movie_definition.h
    void addBitmap(int DisplayObject_id, boost::intrusive_ptr<CachedBitmap> im);

    // See dox in movie_definition.h
    sound_sample* get_sound_sample(int DisplayObject_id) const;

    // See dox in movie_definition.h
    virtual void add_sound_sample(int DisplayObject_id, sound_sample* sam);

    // See dox in movie_definition.h
    virtual void set_loading_sound_stream_id(int id) {
        m_loading_sound_stream = id;
    }

    // See dox in movie_definition.h
    int get_loading_sound_stream_id() const {
        return m_loading_sound_stream;
    }

    // See dox in movie_definition.h
    void addControlTag(boost::intrusive_ptr<SWF::ControlTag> tag) {
        assert(tag);
        boost::mutex::scoped_lock lock(_frames_loaded_mutex);
        m_playlist[_frames_loaded].push_back(tag);
    }

    // See dox in movie_definition.h
    //
    // locks _namedFramesMutex and _frames_loaded_mutex
    //
    void add_frame_name(const std::string& name);

    void set_jpeg_loader(std::auto_ptr<image::JpegInput> j_in);

    // See dox in movie_definition.h
    image::JpegInput* get_jpeg_loader() const {
        return m_jpeg_in.get();
    }

    virtual const PlayList* getPlaylist(size_t frame_number) const {

#ifndef NDEBUG
        boost::mutex::scoped_lock lock(_frames_loaded_mutex);
        assert(frame_number <= _frames_loaded);
#endif

        PlayListMap::const_iterator it = m_playlist.find(frame_number);
        if ( it == m_playlist.end() ) return NULL;
        else return &(it->second);
    }

    //
    bool readHeader(std::auto_ptr<IOChannel> in, const std::string& url);

    //
    bool completeLoad();

    bool ensure_frame_loaded(size_t framenum) const;

    //
    void read_all_swf();

    //
    Movie* createMovie(Global_as& gl, DisplayObject* parent = 0);

    virtual DisplayObject* createDisplayObject(Global_as&, DisplayObject*)
        const {
        return 0;
    }

    virtual const std::string& get_url() const { return _url; }
    
    //
    //
    boost::uint16_t exportID(const std::string& symbol) const;
    
    //
    //
    void registerExport(const std::string& symbol, boost::uint16_t id);

    
#ifdef USE_SWFTREE

    // These methods attach the contents of the METADATA tag
    // to a movie_definition.
    virtual void storeDescriptiveMetadata(const std::string& data) {
        _metadata = data;
    }

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

#endif

private:

#ifdef USE_SWFTREE
    // For storing descriptive metadata (information only)
    std::string _metadata;
#endif

    CharacterDictionary    _dictionary;

    mutable boost::mutex _dictionaryMutex;

    typedef std::map<int, boost::intrusive_ptr<Font> > FontMap;
    FontMap m_fonts;

    typedef std::map<int, boost::intrusive_ptr<CachedBitmap> > Bitmaps;
    Bitmaps _bitmaps;

    typedef std::map<int, boost::intrusive_ptr<sound_sample> > SoundSampleMap;
    SoundSampleMap m_sound_samples;

    typedef std::map<size_t, PlayList> PlayListMap;

    PlayListMap m_playlist;

    typedef std::map<std::string, size_t, StringNoCaseLessThan> NamedFrameMap;
    NamedFrameMap _namedFrames;

    // Mutex protecting access to _namedFrames
    mutable boost::mutex _namedFramesMutex;

    typedef std::map<std::string, boost::uint16_t,
            StringNoCaseLessThan> Exports;

    Exports _exportTable;

    // Mutex protecting access to the export map.
    mutable boost::mutex _exportedResourcesMutex;

    typedef std::vector<boost::intrusive_ptr<movie_definition> > ImportVect;
    ImportVect m_import_source_movies;

    SWFRect    m_frame_size;
    float    m_frame_rate;
    size_t    m_frame_count;
    int    m_version;

    size_t    _frames_loaded;

    //
    mutable boost::mutex _frames_loaded_mutex;

    mutable boost::condition _frame_reached_condition;

    //
    mutable size_t _waiting_for_frame;

    unsigned long _bytes_loaded;

    //
    mutable boost::mutex _bytes_loaded_mutex;

    int m_loading_sound_stream;

    boost::uint32_t m_file_length;

    std::auto_ptr<image::JpegInput> m_jpeg_in;

    std::string _url;

    boost::scoped_ptr<SWFStream> _str;

    std::auto_ptr<IOChannel> _in;

    size_t _swf_end_pos;

    SWFMovieLoader _loader;

    virtual void incrementLoadedFrames();

    //
    void setBytesLoaded(unsigned long bytes)
    {
        boost::mutex::scoped_lock lock(_bytes_loaded_mutex);
        _bytes_loaded=bytes;
    }

    bool _loadingCanceled;

    std::set< boost::intrusive_ptr<movie_definition> > _importSources;

private:

    //
    const RunResources& _runResources;

    bool _as3;

};

} // namespace gnash

#endif