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 <boost/intrusive_ptr.hpp>

#include <atomic>
#include <vector>
#include <map>
#include <set> 
#include <string>
#include <memory> 
#include <mutex>
#include <thread>
#include <condition_variable>

#include "movie_definition.h" // for inheritance
#include "StringPredicates.h" 
#include "SWFRect.h"
#include "GnashNumeric.h"
#include "dsodefs.h" // for DSOTEXPORT

// 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 SWF {
        class DefinitionTag;
    }
}

namespace gnash {

class SWFMovieLoader
{
public:

    SWFMovieLoader(SWFMovieDefinition& md);

    ~SWFMovieLoader();

    //
    bool start();

    bool started() const;

    bool isSelfThread() const;

private:

    SWFMovieDefinition& _movie_def;

    mutable std::mutex _mutex;
    std::thread _thread;
};

//
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;

    //
    DSOTEXPORT 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 DSOTEXPORT SWFMovieDefinition : public movie_definition
{
public:

    //
    SWFMovieDefinition(const RunResources& runResources);

    DSOTEXPORT ~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.load();
    }

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

    //
    virtual size_t get_loading_frame() const;

    size_t get_bytes_loaded() const {
        return _bytes_loaded.load();
    }

    size_t get_bytes_total() const {
        return m_file_length;
    }

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

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

    DSOTEXPORT SWF::DefinitionTag* getDefinitionTag(std::uint16_t id) const;

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

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

    DSOTEXPORT 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
    DSOTEXPORT 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);
        size_t frames_loaded = get_loading_frame();
        m_playlist[frames_loaded].push_back(tag);
    }

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

    DSOTEXPORT void set_jpeg_loader(std::unique_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
        assert(frame_number <= _frames_loaded.load());
#endif

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

    //
    bool readHeader(std::unique_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 = nullptr);

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

    virtual const std::string& get_url() const { return _url; }
    
    //
    //
    std::uint16_t exportID(const std::string& symbol) const;
    
    //
    //
    void registerExport(const std::string& symbol, std::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 std::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 std::mutex _namedFramesMutex;

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

    Exports _exportTable;

    // Mutex protecting access to the export map.
    mutable std::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;

    std::atomic<size_t>    _frames_loaded;

    mutable std::condition_variable _frame_reached_condition;

    mutable std::atomic<size_t> _waiting_for_frame;

    std::atomic<unsigned long> _bytes_loaded;

    int m_loading_sound_stream;

    std::uint32_t m_file_length;

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

    std::string _url;

    std::unique_ptr<SWFStream> _str;

    std::unique_ptr<IOChannel> _in;

    // This is set by readHeader, and used in the parsing thread, which starts
    // after readHeader() runs.
    size_t _swf_end_pos;

    SWFMovieLoader _loader;

    DSOTEXPORT virtual void incrementLoadedFrames();

    void setBytesLoaded(unsigned long bytes)
    {
        _bytes_loaded=bytes;
    }

    mutable std::mutex _loadingCanceledMutex;
    bool _loadingCanceled;

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

private:

    //
    const RunResources& _runResources;

    std::atomic<bool> _as3;

};

} // namespace gnash

#endif