Renderer.h

Go to the documentation of this file.

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


    


#include <vector>
#include <boost/noncopyable.hpp>

#include "dsodefs.h" // for DSOEXPORT

#include "FileTypes.h"
#include "gnash.h" // Quality
#include "Range2d.h"
#include "Point2d.h"
#include "RGBA.h"
#include "log.h"
#include "snappingrange.h"
#include "SWFRect.h"

// Forward declarations.
namespace gnash {
    class CachedBitmap;
    class rgba;
    class Transform;
    class SWFMatrix;
    class FillStyle;
    class LineStyle;
    class Shape;
    class MorphShape;

    // XXX: GnashImageProxy (delayed image rendering)
    class GnashVaapiImageProxy;

    namespace SWF {
        class ShapeRecord;
    }
    namespace image {
        class GnashImage;
    }
}

namespace gnash {

//
class DSOEXPORT Renderer : boost::noncopyable
{
public:

    Renderer()
        :
        _quality(QUALITY_HIGH)
    {}

    virtual ~Renderer() {}

    virtual std::string description() const = 0;


    virtual void set_scale(float /*xscale*/, float /*yscale*/) {} 

    virtual void set_translation(float /*xoff*/, float /*yoff*/) {}

    void setQuality(Quality q) { _quality = q; }
        
    
    virtual CachedBitmap* createCachedBitmap(
            std::auto_ptr<image::GnashImage> im) = 0;



    //
    virtual void drawVideoFrame(image::GnashImage* frame,
            const Transform& xform, const SWFRect* bounds, bool smooth) = 0;

    //
    virtual void drawLine(const std::vector<point>& coords,
            const rgba& color, const SWFMatrix& mat) = 0;
        
    //
    virtual void draw_poly(const point* corners, size_t corner_count, 
        const rgba& fill, const rgba& outline, const SWFMatrix& mat,
        bool masked) = 0;
        
    virtual void drawShape(const SWF::ShapeRecord& shape,
            const Transform& xform) = 0;
        
    //
    virtual void drawGlyph(const SWF::ShapeRecord& rec, const rgba& color,
           const SWFMatrix& mat) = 0;

    //
    //
    virtual void renderToImage(boost::shared_ptr<IOChannel> /*io*/,
        FileType /*type*/) const {

        log_debug(_("Rendering to image not implemented for this "
            "renderer"));
    }
        

    
    //
    virtual void set_invalidated_regions(const InvalidatedRanges& /*ranges*/)
    {        
    }


    typedef boost::shared_ptr<GnashVaapiImageProxy> RenderImage;
    typedef std::vector<RenderImage> RenderImages;

    // Get first render image
    virtual RenderImages::iterator getFirstRenderImage()
            { return _render_images.begin(); }
    virtual RenderImages::const_iterator getFirstRenderImage() const
            { return _render_images.begin(); }

    // Get last render image
    virtual RenderImages::iterator getLastRenderImage()
            { return _render_images.end(); }
    virtual RenderImages::const_iterator getLastRenderImage() const
            { return _render_images.end(); }
    
        
    virtual void begin_submit_mask() = 0;
    virtual void end_submit_mask() = 0;
    virtual void disable_mask() = 0;
    
    
    virtual geometry::Range2d<int> world_to_pixel(const SWFRect& worldbounds) = 0;
    
    virtual point pixel_to_world(int x, int y) = 0;
    
    virtual geometry::Range2d<int> pixel_to_world(
                    const geometry::Range2d<int>& pixelbounds)
    {
        point topleft = pixel_to_world(
                        pixelbounds.getMinX(), pixelbounds.getMinY());
        point bottomright = pixel_to_world(
                        pixelbounds.getMaxX(), pixelbounds.getMaxY());
        
        return geometry::Range2d<int> (topleft.x, topleft.y, 
            bottomright.x, bottomright.y);
    }
    
    virtual geometry::Range2d<int> world_to_pixel(
                    const geometry::Range2d<int>& worldbounds)
    {
        if ((worldbounds.isNull() || worldbounds.isWorld())) return worldbounds;

        // We always get compiler warnings on casting floats to int
        // here, so we cast it ourselves to get rid of the warning
        // message. Note that in both cases this rounds the float to
        // an integer by dropping the decimal part.
        return world_to_pixel(SWFRect(static_cast<int>(worldbounds.getMinX()),
                                   static_cast<int>(worldbounds.getMinY()),
                                   static_cast<int>(worldbounds.getMaxX()),
                                   static_cast<int>(worldbounds.getMaxY())));
    }
        
    //
    virtual bool bounds_in_clipping_area(const SWFRect& bounds) {
        return bounds_in_clipping_area(bounds.getRange());
    }
    
    virtual bool bounds_in_clipping_area(const InvalidatedRanges& ranges)
    {
        for (unsigned int rno=0; rno<ranges.size(); rno++) 
        {
            if (bounds_in_clipping_area(ranges.getRange(rno)))
                return true;
        }
                
        return false;
    }
    
    virtual bool bounds_in_clipping_area(
            const geometry::Range2d<int>& /*bounds*/)
    {
        return true;
    }

#ifdef USE_TESTSUITE



    virtual bool getPixel(rgba& /*color_return*/, int /*x*/, int /*y*/) const {

        log_debug("getPixel() not implemented for this renderer");
        abort();        
        return false; // avoid compiler warning        
    }
    
    
    virtual bool getAveragePixel(rgba& color_return, int x, int y, 
        unsigned int radius) const
    {
    
        assert(radius>0); 
    
        // optimization:
        if (radius==1) return getPixel(color_return, x, y);
    
        unsigned int r=0, g=0, b=0, a=0;
        
        x -= radius/2;
        y -= radius/2;
        
        int xe = x+radius;
        int ye = y+radius;

        rgba pixel;
        
        for (int yp=y; yp<ye; yp++)
        for (int xp=x; xp<xe; xp++)
        {
            if (!getPixel(pixel, xp, yp))
                return false;
                
            r += pixel.m_r;            
            g += pixel.m_g;            
            b += pixel.m_b;            
            a += pixel.m_a;            
        }
        
        int pcount = radius*radius; 
        color_return.m_r = r / pcount; 
        color_return.m_g = g / pcount; 
        color_return.m_b = b / pcount; 
        color_return.m_a = a / pcount; 
        
        return true;
    }
    
    
    virtual bool initTestBuffer(unsigned /*width*/, unsigned /*height*/) {
        return false;
    }

    //
    virtual unsigned int getBitsPerPixel() const {
        return 0;
    }
    
#endif

    class External 
    {
    public:
        //
        External(Renderer& r, const rgba& c, int w = 0, int h = 0,
                float x0 = 0, float x1 = 0, float y0 = 0, float y1 = 0)
            :
            _r(r)
        {
            _r.begin_display(c, w, h, x0, x1, y0, y1);
        }

        ~External() {
            _r.end_display();
        }

    private:
        Renderer& _r;
    };
    
    class Internal 
    {
    public:

        Internal(Renderer& r, image::GnashImage& im)
            :
            _r(r),
            _ext(_r.startInternalRender(im))
        {
        }

        Renderer* renderer() const {
            return _ext;
        }

        ~Internal() {
            _r.endInternalRender();
        }

    private:
        Renderer& _r;
        Renderer* _ext;
    };

protected:

    Quality _quality;

    // Delayed imaged to render
    RenderImages _render_images;

private:

    //
    //
    virtual void begin_display(const rgba& background_color, 
                    int viewport_width, int viewport_height,
                    float x0, float x1, float y0, float y1) = 0;

    virtual void end_display() = 0;

    //
    //
    virtual Renderer* startInternalRender(image::GnashImage& buffer) = 0;

    //
    virtual void endInternalRender() = 0;

}; 

} // namespace gnash

#endif 


// Local Variables:
// mode: C++
// indent-tabs-mode: t
// End: