Player.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010,
//   2011 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_PLAYER_H
#define GNASH_PLAYER_H

#ifdef HAVE_CONFIG_H
#include "gnashconfig.h"
#endif

#include "HostInterface.h"              // for HostInterface, FsCallback, etc
#include "StringPredicates.h"           // for StringNoCaseLessThan
#include "movie_definition.h"
#include "NetworkAdapter.h"             // for setCookiesIn

#include <boost/intrusive_ptr.hpp>
#include <string>
#include <map>
#include <memory>

// Forward declarations
namespace gnash {
    class MovieClip;
    class RunResources;
    class Gui;
    namespace media {
        class MediaHandler;
    }
    namespace sound {
        class sound_handler;
    }
}

namespace gnash {

class Player
{
public:
    
    Player();
    
    ~Player();
    
    //
    void run(int argc, char* argv[],
            const std::string& infile, const std::string& url = "");
    
    float setScale(float s);
    
    // milliseconds per frame
    void setDelay(unsigned int d) { _delay=d; }
    
#ifdef GNASH_FPS_DEBUG
    //
    void setFpsPrintTime(float time)
    {
        assert(time >= 0.0);
        _fpsDebugTime = time;
    }
#endif // def GNASH_FPS_DEBUG
    
    void setWidth(size_t w) { _width = w; }
    size_t getWidth() const { return _width; }
    
    void setHeight(size_t h) { _height = h; }
    size_t getHeight() const { return _height; }
    
    void setXPosition(int xPos) { _xPosition = xPos; }
    size_t getXPosition() const { return _xPosition; }
    
    void setYPosition(int yPos) { _yPosition = yPos; }
    size_t getYPosition() const { return _yPosition; }
    
    void setWindowId(unsigned long x) { _windowID = x; }
    
    void setDoLoop(bool b) { _doLoop = b; }
    
    void setDoRender(bool b) { _doRender = b; }
    
    void setDoSound(bool b) { _doSound = b; }
    
    void setMaxAdvances(unsigned long ul) { if (ul > 0) _maxAdvances = ul; }
    
    //
    void setBaseUrl(const std::string& baseurl) {
        _baseurl = baseurl;
    }
    
    float setExitTimeout(float n) {
        float oldtimeout = _exitTimeout;
        _exitTimeout = n;
        return oldtimeout;
    }
    
    void setParam(const std::string& name, const std::string& value) {
        _params[name] = value;
    }
    
    void setHostFD(int fd) {
        _hostfd = fd;
    }
    
    int getHostFD() const {
        return _hostfd;
    }

    void setMedia(const std::string& media) {
        _media = media;
    }

    void setControlFD(int fd) {
        _controlfd = fd;
    }
    
    int getControlFD() const {
        return _controlfd;
    }

    void setCookiesIn(const std::string& filename) {
        NetworkAdapter::setCookiesIn(filename);
    }

    void setStartFullscreen(bool x) {
        _startFullscreen = x;
    }
    
    void hideMenu(bool x) {
        _hideMenu = x;
    }
    
    void setAudioDumpfile(const std::string& filespec) {
        _audioDump = filespec;
    }
    
    void setRenderer(const std::string& x) { _renderer = x; }
    
    void setHWAccel(const std::string& x) { _hwaccel = x; }

    //
    //
    void setScreenShots(const std::string& screenshots) {
        _screenshots = screenshots;
    }

    //
    void setScreenShotFile(const std::string& file) {
        _screenshotFile = file;
    }

    //
    void setScreenShotQuality(int quality) {
        _screenshotQuality = quality;
    }

private:

    std::string _hwaccel;
    
    std::string _renderer;

    class CallbacksHandler : public HostInterface, public FsCallback
    {
    public:
        CallbacksHandler(Gui& gui, const Player& player)
            :
            _gui(gui),
            _player(player)
        {
        }
        
        boost::any call(const HostInterface::Message& e);

        void exit();
        
        // For handling notification callbacks from ActionScript.
        // The callback is always sent to a hosting application
        // (i.e. if a file descriptor is supplied). It is never
        // acted on by Gnash when running as a plugin.
        void notify(const std::string& event, const std::string& arg);
        
    private:
        
        Gui& _gui;
        
        const Player& _player;
    };
    
    std::shared_ptr<CallbacksHandler> _callbacksHandler;
    
    void init();
    
    static unsigned int silentStream(void* udata, std::int16_t* stream,
                     unsigned int len, bool& atEOF);
    
    void init_sound();
    
    void init_logfile();
    
    void init_gui();
    
    //
    std::unique_ptr<Gui> getGui();
    
    void setFlashVars(const std::string& varstr);

    typedef std::map<std::string, std::string, StringNoCaseLessThan> Params;
    
    // Movie parameters (for -P)
    Params      _params;
    
    // the scale at which to play 
    float       _scale;
    unsigned int _delay;
    size_t      _width;
    size_t      _height;
    int         _xPosition;
    int         _yPosition;
    unsigned long _windowID;
    bool        _doLoop;
    bool        _doRender;
    bool        _doSound;
    float       _exitTimeout;
    std::string _baseurl;
    
    //
    //
    //
    std::shared_ptr<sound::sound_handler> _soundHandler;
    
    std::shared_ptr<media::MediaHandler> _mediaHandler;
    
    //
    std::shared_ptr<RunResources> _runResources;
    
    std::shared_ptr<Gui> _gui;
    
    std::string         _url;
    
    std::string         _infile;
    
    boost::intrusive_ptr<movie_definition> _movieDef;
    
    unsigned long       _maxAdvances;
    
    // 
    boost::intrusive_ptr<movie_definition> load_movie();
    
#ifdef GNASH_FPS_DEBUG
    float       _fpsDebugTime;
#endif
    
    // Filedescriptor to use for host application requests, -1 if none
    int         _hostfd;
    
    int         _controlfd;

    // Whether to start Gnash in fullscreen mode.
    // (Or what did you think it meant?)
    bool        _startFullscreen;
    bool        _hideMenu;
    
    std::string _audioDump;
    
    //
    std::string _screenshots;
    
    //
    std::string _screenshotFile;
    
    //
    int _screenshotQuality;

    //
    std::string _media;

};
 
} // end of gnash namespace

// end of _PLAYER_H_
#endif

// local Variables:
// mode: C++
// indent-tabs-mode: nil
// End: