Merge branch 'feature/upstream' into develop

1 files changed, 663 insertions, 0 deletions

diff --git a/src/page-texture.vala b/src/page-texture.vala
new file mode 100644
index 0000000..1e55433
--- /dev/null
+++ b/src/page-texture.vala
@@ -0,0 +1,663 @@
+/*
+ * Copyright (C) 2009-2015 Canonical Ltd.
+ * Author: Robert Ancell <robert.ancell@canonical.com>,
+ *         Bartłomiej Maryńczak <marynczakbartlomiej@gmail.com>
+ *
+ * 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. See http://www.gnu.org/copyleft/gpl.html the full text of the
+ * license.
+ */
+
+private class PageToPixbuf : Object
+{
+    /* Image to render at current resolution */
+    public Gdk.Pixbuf? pixbuf { get { return pixbuf_; } }
+    private Gdk.Pixbuf? pixbuf_ = null;
+
+    /* Direction of currently scanned image */
+    private ScanDirection scan_direction;
+
+    /* Next scan line to render */
+    private int scan_line;
+
+    /* Dimensions of image to generate */
+    public int width;
+    public int height;
+
+    private static uchar get_sample (uchar[] pixels, int offset, int x, int depth, int sample)
+    {
+        // FIXME
+        return 0xFF;
+    }
+
+    private static void get_pixel (Page page, int x, int y, uchar[] pixel)
+    {
+        switch (page.scan_direction)
+        {
+        case ScanDirection.TOP_TO_BOTTOM:
+            break;
+        case ScanDirection.BOTTOM_TO_TOP:
+            x = page.scan_width - x - 1;
+            y = page.scan_height - y - 1;
+            break;
+        case ScanDirection.LEFT_TO_RIGHT:
+            var t = x;
+            x = page.scan_width - y - 1;
+            y = t;
+            break;
+        case ScanDirection.RIGHT_TO_LEFT:
+            var t = x;
+            x = y;
+            y = page.scan_height - t - 1;
+            break;
+        }
+
+        var depth = page.depth;
+        var n_channels = page.n_channels;
+        unowned uchar[] pixels = page.get_pixels ();
+        var offset = page.rowstride * y;
+
+        /* Optimise for 8 bit images */
+        if (depth == 8 && n_channels == 3)
+        {
+            var o = offset + x * n_channels;
+            pixel[0] = pixels[o];
+            pixel[1] = pixels[o+1];
+            pixel[2] = pixels[o+2];
+            return;
+        }
+        else if (depth == 8 && n_channels == 1)
+        {
+            pixel[0] = pixel[1] = pixel[2] = pixels[offset + x];
+            return;
+        }
+
+        /* Optimise for bitmaps */
+        else if (depth == 1 && n_channels == 1)
+        {
+            var o = offset + (x / 8);
+            pixel[0] = pixel[1] = pixel[2] = (pixels[o] & (0x80 >> (x % 8))) != 0 ? 0x00 : 0xFF;
+            return;
+        }
+
+        /* Optimise for 2 bit images */
+        else if (depth == 2 && n_channels == 1)
+        {
+            int block_shift[4] = { 6, 4, 2, 0 };
+
+            var o = offset + (x / 4);
+            var sample = (pixels[o] >> block_shift[x % 4]) & 0x3;
+            sample = sample * 255 / 3;
+
+            pixel[0] = pixel[1] = pixel[2] = (uchar) sample;
+            return;
+        }
+
+        /* Use slow method */
+        pixel[0] = get_sample (pixels, offset, x, depth, x * n_channels);
+        pixel[1] = get_sample (pixels, offset, x, depth, x * n_channels + 1);
+        pixel[2] = get_sample (pixels, offset, x, depth, x * n_channels + 2);
+    }
+
+    private static void set_pixel (Page page, double l, double r, double t, double b, uchar[] output, int offset)
+    {
+        /* Decimation:
+         *
+         * Target pixel is defined by (t,l)-(b,r)
+         * It touches 16 pixels in original image
+         * It completely covers 4 pixels in original image (T,L)-(B,R)
+         * Add covered pixels and add weighted partially covered pixels.
+         * Divide by total area.
+         *
+         *      l  L           R   r
+         *   +-----+-----+-----+-----+
+         *   |     |     |     |     |
+         * t |  +--+-----+-----+---+ |
+         * T +--+--+-----+-----+---+-+
+         *   |  |  |     |     |   | |
+         *   |  |  |     |     |   | |
+         *   +--+--+-----+-----+---+-+
+         *   |  |  |     |     |   | |
+         *   |  |  |     |     |   | |
+         * B +--+--+-----+-----+---+-+
+         *   |  |  |     |     |   | |
+         * b |  +--+-----+-----+---+ |
+         *   +-----+-----+-----+-----+
+         *
+         *
+         * Interpolation:
+         *
+         *             l    r
+         *   +-----+-----+-----+-----+
+         *   |     |     |     |     |
+         *   |     |     |     |     |
+         *   +-----+-----+-----+-----+
+         * t |     |   +-+--+  |     |
+         *   |     |   | |  |  |     |
+         *   +-----+---+-+--+--+-----+
+         * b |     |   +-+--+  |     |
+         *   |     |     |     |     |
+         *   +-----+-----+-----+-----+
+         *   |     |     |     |     |
+         *   |     |     |     |     |
+         *   +-----+-----+-----+-----+
+         *
+         * Same again, just no completely covered pixels.
+         */
+
+        var L = (int) l;
+        if (L != l)
+            L++;
+        var R = (int) r;
+        var T = (int) t;
+        if (T != t)
+            T++;
+        var B = (int) b;
+
+        var red = 0.0;
+        var green = 0.0;
+        var blue = 0.0;
+
+        /* Target can fit inside one source pixel
+         * +-----+
+         * |     |
+         * | +--+|      +-----+-----+      +-----+      +-----+      +-----+
+         * +-+--++  or  |   +-++    |  or  | +-+ |  or  | +--+|  or  |  +--+
+         * | +--+|      |   +-++    |      | +-+ |      | |  ||      |  |  |
+         * |     |      +-----+-----+      +-----+      +-+--++      +--+--+
+         * +-----+
+         */
+        if ((r - l <= 1.0 && (int)r == (int)l) || (b - t <= 1.0 && (int)b == (int)t))
+        {
+            /* Inside */
+            if ((int)l == (int)r || (int)t == (int)b)
+            {
+                uchar p[3];
+                get_pixel (page, (int)l, (int)t, p);
+                output[offset] = p[0];
+                output[offset+1] = p[1];
+                output[offset+2] = p[2];
+                return;
+            }
+
+            /* Stradling horizontal edge */
+            if (L > R)
+            {
+                uchar p[3];
+                get_pixel (page, R, T-1, p);
+                red   += p[0] * (r-l)*(T-t);
+                green += p[1] * (r-l)*(T-t);
+                blue  += p[2] * (r-l)*(T-t);
+                for (var y = T; y < B; y++)
+                {
+                    get_pixel (page, R, y, p);
+                    red   += p[0] * (r-l);
+                    green += p[1] * (r-l);
+                    blue  += p[2] * (r-l);
+                }
+                get_pixel (page, R, B, p);
+                red   += p[0] * (r-l)*(b-B);
+                green += p[1] * (r-l)*(b-B);
+                blue  += p[2] * (r-l)*(b-B);
+            }
+            /* Stradling vertical edge */
+            else
+            {
+                uchar p[3];
+                get_pixel (page, L - 1, B, p);
+                red   += p[0] * (b-t)*(L-l);
+                green += p[1] * (b-t)*(L-l);
+                blue  += p[2] * (b-t)*(L-l);
+                for (var x = L; x < R; x++) {
+                    get_pixel (page, x, B, p);
+                    red   += p[0] * (b-t);
+                    green += p[1] * (b-t);
+                    blue  += p[2] * (b-t);
+                }
+                get_pixel (page, R, B, p);
+                red   += p[0] * (b-t)*(r-R);
+                green += p[1] * (b-t)*(r-R);
+                blue  += p[2] * (b-t)*(r-R);
+            }
+
+            var scale = 1.0 / ((r - l) * (b - t));
+            output[offset] = (uchar)(red * scale + 0.5);
+            output[offset+1] = (uchar)(green * scale + 0.5);
+            output[offset+2] = (uchar)(blue * scale + 0.5);
+            return;
+        }
+
+        /* Add the middle pixels */
+        for (var x = L; x < R; x++)
+        {
+            for (var y = T; y < B; y++)
+            {
+                uchar p[3];
+                get_pixel (page, x, y, p);
+                red   += p[0];
+                green += p[1];
+                blue  += p[2];
+            }
+        }
+
+        /* Add the weighted top and bottom pixels */
+        for (var x = L; x < R; x++)
+        {
+            if (t != T)
+            {
+                uchar p[3];
+                get_pixel (page, x, T - 1, p);
+                red   += p[0] * (T - t);
+                green += p[1] * (T - t);
+                blue  += p[2] * (T - t);
+            }
+
+            if (b != B)
+            {
+                uchar p[3];
+                get_pixel (page, x, B, p);
+                red   += p[0] * (b - B);
+                green += p[1] * (b - B);
+                blue  += p[2] * (b - B);
+            }
+        }
+
+        /* Add the left and right pixels */
+        for (var y = T; y < B; y++)
+        {
+            if (l != L)
+            {
+                uchar p[3];
+                get_pixel (page, L - 1, y, p);
+                red   += p[0] * (L - l);
+                green += p[1] * (L - l);
+                blue  += p[2] * (L - l);
+            }
+
+            if (r != R)
+            {
+                uchar p[3];
+                get_pixel (page, R, y, p);
+                red   += p[0] * (r - R);
+                green += p[1] * (r - R);
+                blue  += p[2] * (r - R);
+            }
+        }
+
+        /* Add the corner pixels */
+        if (l != L && t != T)
+        {
+            uchar p[3];
+            get_pixel (page, L - 1, T - 1, p);
+            red   += p[0] * (L - l)*(T - t);
+            green += p[1] * (L - l)*(T - t);
+            blue  += p[2] * (L - l)*(T - t);
+        }
+        if (r != R && t != T)
+        {
+            uchar p[3];
+            get_pixel (page, R, T - 1, p);
+            red   += p[0] * (r - R)*(T - t);
+            green += p[1] * (r - R)*(T - t);
+            blue  += p[2] * (r - R)*(T - t);
+        }
+        if (r != R && b != B)
+        {
+            uchar p[3];
+            get_pixel (page, R, B, p);
+            red   += p[0] * (r - R)*(b - B);
+            green += p[1] * (r - R)*(b - B);
+            blue  += p[2] * (r - R)*(b - B);
+        }
+        if (l != L && b != B)
+        {
+            uchar p[3];
+            get_pixel (page, L - 1, B, p);
+            red   += p[0] * (L - l)*(b - B);
+            green += p[1] * (L - l)*(b - B);
+            blue  += p[2] * (L - l)*(b - B);
+        }
+
+        /* Scale pixel values and clamp in range [0, 255] */
+        var scale = 1.0 / ((r - l) * (b - t));
+        output[offset] = (uchar)(red * scale + 0.5);
+        output[offset+1] = (uchar)(green * scale + 0.5);
+        output[offset+2] = (uchar)(blue * scale + 0.5);
+    }
+
+    public static void update_preview (Page page, ref Gdk.Pixbuf? output_image, int output_width, int output_height,
+                                 ScanDirection scan_direction, int old_scan_line, int scan_line)
+    {
+        var input_width = page.width;
+        var input_height = page.height;
+
+        /* Create new image if one does not exist or has changed size */
+        int L, R, T, B;
+        if (output_image == null ||
+            output_image.width != output_width ||
+            output_image.height != output_height)
+        {
+            output_image = new Gdk.Pixbuf (Gdk.Colorspace.RGB,
+                                           false,
+                                           8,
+                                           output_width,
+                                           output_height);
+
+            /* Update entire image */
+            L = 0;
+            R = output_width - 1;
+            T = 0;
+            B = output_height - 1;
+        }
+        /* Otherwise only update changed area */
+        else
+        {
+            switch (scan_direction)
+            {
+            case ScanDirection.TOP_TO_BOTTOM:
+                L = 0;
+                R = output_width - 1;
+                T = (int)((double)old_scan_line * output_height / input_height);
+                B = (int)((double)scan_line * output_height / input_height + 0.5);
+                break;
+            case ScanDirection.LEFT_TO_RIGHT:
+                L = (int)((double)old_scan_line * output_width / input_width);
+                R = (int)((double)scan_line * output_width / input_width + 0.5);
+                T = 0;
+                B = output_height - 1;
+                break;
+            case ScanDirection.BOTTOM_TO_TOP:
+                L = 0;
+                R = output_width - 1;
+                T = (int)((double)(input_height - scan_line) * output_height / input_height);
+                B = (int)((double)(input_height - old_scan_line) * output_height / input_height + 0.5);
+                break;
+            case ScanDirection.RIGHT_TO_LEFT:
+                L = (int)((double)(input_width - scan_line) * output_width / input_width);
+                R = (int)((double)(input_width - old_scan_line) * output_width / input_width + 0.5);
+                T = 0;
+                B = output_height - 1;
+                break;
+            default:
+                L = R = B = T = 0;
+                break;
+            }
+        }
+
+        /* FIXME: There's an off by one error in there somewhere... */
+        if (R >= output_width)
+            R = output_width - 1;
+        if (B >= output_height)
+            B = output_height - 1;
+
+        return_if_fail (L >= 0);
+        return_if_fail (R < output_width);
+        return_if_fail (T >= 0);
+        return_if_fail (B < output_height);
+        return_if_fail (output_image != null);
+
+        unowned uchar[] output = output_image.get_pixels ();
+        var output_rowstride = output_image.rowstride;
+        var output_n_channels = output_image.n_channels;
+
+        if (!page.has_data)
+        {
+            for (var x = L; x <= R; x++)
+                for (var y = T; y <= B; y++)
+                {
+                    var o = output_rowstride * y + x * output_n_channels;
+                    output[o] = output[o+1] = output[o+2] = 0xFF;
+                }
+            return;
+        }
+
+        /* Update changed area */
+        for (var x = L; x <= R; x++)
+        {
+            var l = (double)x * input_width / output_width;
+            var r = (double)(x + 1) * input_width / output_width;
+
+            for (var y = T; y <= B; y++)
+            {
+                var t = (double)y * input_height / output_height;
+                var b = (double)(y + 1) * input_height / output_height;
+
+                set_pixel (page,
+                           l, r, t, b,
+                           output, output_rowstride * y + x * output_n_channels);
+            }
+        }
+    }
+
+    public void update (Page page)
+    {
+        var old_scan_line = scan_line;
+        scan_line = page.scan_line;
+
+        /* Delete old image if scan direction changed */
+        var left_steps = scan_direction - page.scan_direction;
+        if (left_steps != 0 && pixbuf_ != null)
+            pixbuf_ = null;
+        scan_direction = page.scan_direction;
+
+        update_preview (page,
+                        ref pixbuf_,
+                        width,
+                        height,
+                        page.scan_direction,
+                        old_scan_line,
+                        scan_line);
+    }
+}
+
+/**
+ * Just update texture contents
+ */
+private class TextureUpdateTask
+{
+    public Page page;
+}
+
+/**
+ * Resize the texture
+ */
+private class TextureResizeTask: TextureUpdateTask
+{
+    public int width { get; private set; }
+    public int height { get; private set; }
+    
+	public TextureResizeTask (int width, int height)
+    {
+        this.width = width;
+        this.height = height;
+	}
+}
+
+public class PageViewTexture : Object
+{
+    public Gdk.Pixbuf? pixbuf { get; private set; }
+    public signal void new_buffer ();
+
+    private int requested_width;
+    private int requested_height;
+    private TextureUpdateTask queued = null;
+
+    private bool in_proggres;
+
+    private ThreadPool<TextureUpdateTask> resize_pool;
+    
+    private Page page;
+    
+	public PageViewTexture (Page page)
+    {
+        this.page = page;
+
+        try {
+            resize_pool = new ThreadPool<TextureUpdateTask>.with_owned_data (thread_func, 1, false);
+        }
+        catch (ThreadError error)
+        {
+            // Pool is non-exclusive so this should never happen
+        }
+	}
+    
+    /**
+     * Notify that data needs updating (eg. pixels changed during scanning process)
+     */
+    public void request_update ()
+    {
+        queued = new TextureUpdateTask ();
+    }
+
+    /**
+     * Set size of the page, ignored if size did not change.
+     */
+    public void request_resize (int width, int height)
+    {
+        if (requested_width == width && requested_height == height)
+        {
+            return;
+        }
+
+        requested_width = width;
+        requested_height = height;
+        
+        queued = new TextureResizeTask (requested_width, requested_height);
+    }
+    
+    public void queue_update () throws ThreadError
+    {
+        if (in_proggres || queued == null)
+        {
+            return;
+        }
+
+        in_proggres = true;
+
+        // We copy the page as it will be sent to resize thread
+        queued.page = page.copy ();
+        resize_pool.add (queued);
+
+        queued = null;
+    }
+
+    private PageToPixbuf page_view = new PageToPixbuf ();
+    private void thread_func(owned TextureUpdateTask task)
+    {
+        if (task is TextureResizeTask)
+        {
+            page_view.width = task.width;
+            page_view.height = task.height;
+        }
+
+        page_view.update (task.page);
+        
+        Gdk.Pixbuf? new_pixbuf = null;
+        if (page_view.pixbuf != null)
+        {
+            // We are sending this buffer back to main thread, therefore copy
+            new_pixbuf = page_view.pixbuf.copy ();
+        }
+
+
+        Idle.add(() => {
+            new_pixbuf_cb (new_pixbuf);
+            return false;
+        });
+    }
+
+    private void new_pixbuf_cb (Gdk.Pixbuf? pixbuf)
+    {
+        in_proggres = false;
+        this.pixbuf = pixbuf;
+        new_buffer ();
+    }
+}
+
+public class PagePaintable: Gdk.Paintable, Object
+{
+    private Page page;
+    private PageViewTexture page_texture;
+    private Gdk.Texture? texture;
+    
+    public PagePaintable (Page page)
+    {
+        this.page = page;
+        page.pixels_changed.connect (pixels_changed);
+        page.size_changed.connect (pixels_changed);
+        page.scan_direction_changed.connect (pixels_changed);
+
+        page_texture = new PageViewTexture (page);
+        page_texture.new_buffer.connect (texture_updated);
+
+        pixels_changed ();
+    }
+    
+    ~PagePaintable ()
+    {
+        page.pixels_changed.disconnect (pixels_changed);
+        page.size_changed.disconnect (pixels_changed);
+        page.scan_direction_changed.disconnect (pixels_changed);
+        page_texture.new_buffer.disconnect (texture_updated);
+    }
+    
+    private void pixels_changed ()
+    {
+        page_texture.request_update ();
+        try {
+            page_texture.queue_update ();
+        }
+        catch (Error e)
+        {
+            warning ("Failed to queue_update of the texture: %s", e.message);
+            invalidate_contents ();
+        }
+    }
+
+    private void texture_updated ()
+    {
+        if (page_texture.pixbuf != null)
+            texture = Gdk.Texture.for_pixbuf(page_texture.pixbuf);
+        else
+            texture = null;
+
+        invalidate_contents ();
+    }
+
+	public override double get_intrinsic_aspect_ratio ()
+    {
+        return (double) page.width / (double) page.height;
+    }
+
+    public void snapshot (Gdk.Snapshot gdk_snapshot, double width, double height) {
+        var snapshot = (Gtk.Snapshot) gdk_snapshot;
+
+        var rect = Graphene.Rect();
+        rect.size.width = (float) width;
+        rect.size.height = (float) height;
+
+        page_texture.request_resize ((int) width, (int) height);
+
+        try {
+            page_texture.queue_update ();
+        }
+        catch (Error e)
+        {
+            warning ("Failed to queue_update of the texture: %s", e.message);
+            // Ask for another redraw
+            invalidate_contents ();
+        }
+
+        if (texture != null)
+        {
+            snapshot.append_texture(texture, rect);
+        }
+        else
+        {
+            snapshot.append_color ({1.0f, 1.0f, 1.0f, 1.0f}, rect);
+        }
+    }
+
+}
\ No newline at end of file