Merge to XFA: Separate agg-authored code from fx-authored code.

Original Review URL: https://codereview.chromium.org/1152743007.
BUG=pdfium:166
R=brucedawson@chromium.org, thestig@chromium.org
TBR=brucedawson@chromium.org, thestig@chromium.org

Review URL: https://codereview.chromium.org/1186423003.

1 files changed, 472 insertions, 0 deletions

diff --git a/third_party/agg23/agg_rasterizer_scanline_aa.h b/third_party/agg23/agg_rasterizer_scanline_aa.h
new file mode 100644
index 0000000000..da1900d0dd
--- /dev/null
+++ b/third_party/agg23/agg_rasterizer_scanline_aa.h
@@ -0,0 +1,472 @@
+
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.3
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+//
+// The author gratefully acknowleges the support of David Turner,
+// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType
+// libray - in producing this work. See http://www.freetype.org for details.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates has been sponsored by
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_RASTERIZER_SCANLINE_AA_INCLUDED
+#define AGG_RASTERIZER_SCANLINE_AA_INCLUDED
+#include "../../core/include/fxge/fx_ge.h"
+#include "agg_basics.h"
+#include "agg_math.h"
+#include "agg_array.h"
+#include "agg_clip_liang_barsky.h"
+#include "agg_render_scanlines.h"
+namespace agg
+{
+enum poly_base_scale_e {
+    poly_base_shift = 8,
+    poly_base_size  = 1 << poly_base_shift,
+    poly_base_mask  = poly_base_size - 1
+};
+inline int poly_coord(FX_FLOAT c)
+{
+    return int(c * poly_base_size);
+}
+struct cell_aa  {
+    int x;
+    int y;
+    int cover;
+    int area;
+    void set(int x, int y, int c, int a);
+    void set_coord(int x, int y);
+    void set_cover(int c, int a);
+    void add_cover(int c, int a);
+};
+class outline_aa 
+{
+    enum cell_block_scale_e {
+        cell_block_shift = 12,
+        cell_block_size  = 1 << cell_block_shift,
+        cell_block_mask  = cell_block_size - 1,
+        cell_block_pool  = 256,
+        cell_block_limit = 1024
+    };
+    struct sorted_y  {
+        unsigned start;
+        unsigned num;
+    };
+public:
+    ~outline_aa();
+    outline_aa();
+    void reset();
+    void move_to(int x, int y);
+    void line_to(int x, int y);
+    int min_x() const
+    {
+        return m_min_x;
+    }
+    int min_y() const
+    {
+        return m_min_y;
+    }
+    int max_x() const
+    {
+        return m_max_x;
+    }
+    int max_y() const
+    {
+        return m_max_y;
+    }
+    void sort_cells();
+    unsigned total_cells() const
+    {
+        return m_num_cells;
+    }
+    unsigned scanline_num_cells(unsigned y) const
+    {
+        return m_sorted_y[y - m_min_y].num;
+    }
+    const cell_aa* const* scanline_cells(unsigned y) const
+    {
+        return m_sorted_cells.data() + m_sorted_y[y - m_min_y].start;
+    }
+    bool sorted() const
+    {
+        return m_sorted;
+    }
+private:
+    outline_aa(const outline_aa&);
+    const outline_aa& operator = (const outline_aa&);
+    void set_cur_cell(int x, int y);
+    void add_cur_cell();
+    void render_hline(int ey, int x1, int y1, int x2, int y2);
+    void render_line(int x1, int y1, int x2, int y2);
+    void allocate_block();
+private:
+    unsigned  m_num_blocks;
+    unsigned  m_max_blocks;
+    unsigned  m_cur_block;
+    unsigned  m_num_cells;
+    cell_aa** m_cells;
+    cell_aa*  m_cur_cell_ptr;
+    pod_array<cell_aa*> m_sorted_cells;
+    pod_array<sorted_y> m_sorted_y;
+    cell_aa   m_cur_cell;
+    int       m_cur_x;
+    int       m_cur_y;
+    int       m_min_x;
+    int       m_min_y;
+    int       m_max_x;
+    int       m_max_y;
+    bool      m_sorted;
+};
+class scanline_hit_test 
+{
+public:
+    scanline_hit_test(int x) : m_x(x), m_hit(false) {}
+    void reset_spans() {}
+    void finalize(int) {}
+    void add_cell(int x, int)
+    {
+        if(m_x == x) {
+            m_hit = true;
+        }
+    }
+    void add_span(int x, int len, int)
+    {
+        if(m_x >= x && m_x < x + len) {
+            m_hit = true;
+        }
+    }
+    unsigned num_spans() const
+    {
+        return 1;
+    }
+    bool hit() const
+    {
+        return m_hit;
+    }
+private:
+    int  m_x;
+    bool m_hit;
+};
+enum filling_rule_e {
+    fill_non_zero,
+    fill_even_odd
+};
+class rasterizer_scanline_aa 
+{
+    enum status {
+        status_initial,
+        status_line_to,
+        status_closed
+    };
+public:
+    enum aa_scale_e {
+        aa_num   = 1 << 8,
+        aa_mask  = aa_num - 1,
+        aa_2num  = aa_num * 2,
+        aa_2mask = aa_2num - 1
+    };
+    rasterizer_scanline_aa() :
+        m_filling_rule(fill_non_zero),
+        m_clipped_start_x(0),
+        m_clipped_start_y(0),
+        m_status(status_initial),
+        m_clipping(false)
+    {
+    }
+    ~rasterizer_scanline_aa() {}
+    void filling_rule(filling_rule_e filling_rule)
+    {
+        m_filling_rule = filling_rule;
+    }
+    int min_x() const
+    {
+        return m_outline.min_x();
+    }
+    int min_y() const
+    {
+        return m_outline.min_y();
+    }
+    int max_x() const
+    {
+        return m_outline.max_x();
+    }
+    int max_y() const
+    {
+        return m_outline.max_y();
+    }
+    void reset()
+    {
+        m_outline.reset();
+        m_status = status_initial;
+    }
+    void clip_box(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2)
+    {
+        m_clip_box = rect(poly_coord(x1), poly_coord(y1),
+                          poly_coord(x2), poly_coord(y2));
+        m_clip_box.normalize();
+        m_clipping = true;
+    }
+    void add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd)
+    {
+        if(is_close(cmd)) {
+            close_polygon();
+        } else {
+            if(is_move_to(cmd)) {
+                move_to(poly_coord(x), poly_coord(y));
+            } else {
+                if(is_vertex(cmd)) {
+                    line_to(poly_coord(x), poly_coord(y));
+                }
+            }
+        }
+    }
+    void move_to(int x, int y)
+    {
+        if(m_clipping) {
+            if(m_outline.sorted()) {
+                reset();
+            }
+            if(m_status == status_line_to) {
+                close_polygon();
+            }
+            m_prev_x = m_start_x = x;
+            m_prev_y = m_start_y = y;
+            m_status = status_initial;
+            m_prev_flags = clipping_flags(x, y, m_clip_box);
+            if(m_prev_flags == 0) {
+                move_to_no_clip(x, y);
+            }
+        } else {
+            move_to_no_clip(x, y);
+        }
+    }
+    void line_to(int x, int y)
+    {
+        if(m_clipping) {
+            clip_segment(x, y);
+        } else {
+            line_to_no_clip(x, y);
+        }
+    }
+    void close_polygon()
+    {
+        if (m_status != status_line_to) {
+            return;
+        }
+        if(m_clipping) {
+            clip_segment(m_start_x, m_start_y);
+        }
+        close_polygon_no_clip();
+    }
+    AGG_INLINE unsigned calculate_alpha(int area, bool no_smooth) const
+    {
+        int cover = area >> (poly_base_shift * 2 + 1 - 8);
+        if(cover < 0) {
+            cover = -cover;
+        }
+        if(m_filling_rule == fill_even_odd) {
+            cover &= aa_2mask;
+            if(cover > aa_num) {
+                cover = aa_2num - cover;
+            }
+        }
+        if (no_smooth) {
+            cover = cover > aa_mask / 2 ? aa_mask : 0;
+        }
+        if(cover > aa_mask) {
+            cover = aa_mask;
+        }
+        return cover;
+    }
+    AGG_INLINE void sort()
+    {
+        m_outline.sort_cells();
+    }
+    AGG_INLINE bool rewind_scanlines()
+    {
+        close_polygon();
+        m_outline.sort_cells();
+        if(m_outline.total_cells() == 0) {
+            return false;
+        }
+        m_cur_y = m_outline.min_y();
+        return true;
+    }
+    AGG_INLINE bool navigate_scanline(int y)
+    {
+        close_polygon();
+        m_outline.sort_cells();
+        if(m_outline.total_cells() == 0 ||
+                y < m_outline.min_y() ||
+                y > m_outline.max_y()) {
+            return false;
+        }
+        m_cur_y = y;
+        return true;
+    }
+    template<class Scanline> bool sweep_scanline(Scanline& sl, bool no_smooth)
+    {
+        for(;;) {
+            if(m_cur_y > m_outline.max_y()) {
+                return false;
+            }
+            sl.reset_spans();
+            unsigned num_cells = m_outline.scanline_num_cells(m_cur_y);
+            const cell_aa* const* cells = m_outline.scanline_cells(m_cur_y);
+            int cover = 0;
+            while(num_cells) {
+                const cell_aa* cur_cell = *cells;
+                int x    = cur_cell->x;
+                int area = cur_cell->area;
+                unsigned alpha;
+                cover += cur_cell->cover;
+                while(--num_cells) {
+                    cur_cell = *++cells;
+                    if(cur_cell->x != x) {
+                        break;
+                    }
+                    area  += cur_cell->area;
+                    cover += cur_cell->cover;
+                }
+                if(area) {
+                    alpha = calculate_alpha((cover << (poly_base_shift + 1)) - area, no_smooth);
+                    if(alpha) {
+                        sl.add_cell(x, alpha);
+                    }
+                    x++;
+                }
+                if(num_cells && cur_cell->x > x) {
+                    alpha = calculate_alpha(cover << (poly_base_shift + 1), no_smooth);
+                    if(alpha) {
+                        sl.add_span(x, cur_cell->x - x, alpha);
+                    }
+                }
+            }
+            if(sl.num_spans()) {
+                break;
+            }
+            ++m_cur_y;
+        }
+        sl.finalize(m_cur_y);
+        ++m_cur_y;
+        return true;
+    }
+    template<class VertexSource>
+    void add_path(VertexSource& vs, unsigned path_id = 0)
+    {
+        FX_FLOAT x;
+        FX_FLOAT y;
+        unsigned cmd;
+        vs.rewind(path_id);
+        while(!is_stop(cmd = vs.vertex(&x, &y))) {
+            add_vertex(x, y, cmd);
+        }
+    }
+    template<class VertexSource>
+    void add_path_transformed(VertexSource& vs, const CFX_AffineMatrix* pMatrix, unsigned path_id = 0)
+    {
+        FX_FLOAT x;
+        FX_FLOAT y;
+        unsigned cmd;
+        vs.rewind(path_id);
+        while(!is_stop(cmd = vs.vertex(&x, &y))) {
+            if (pMatrix) {
+                pMatrix->Transform(x, y);
+            }
+            add_vertex(x, y, cmd);
+        }
+    }
+private:
+    rasterizer_scanline_aa(const rasterizer_scanline_aa&);
+    const rasterizer_scanline_aa&
+    operator = (const rasterizer_scanline_aa&);
+    void move_to_no_clip(int x, int y)
+    {
+        if(m_status == status_line_to) {
+            close_polygon_no_clip();
+        }
+        m_outline.move_to(x * 1, y);
+        m_clipped_start_x = x;
+        m_clipped_start_y = y;
+        m_status = status_line_to;
+    }
+    void line_to_no_clip(int x, int y)
+    {
+        if(m_status != status_initial) {
+            m_outline.line_to(x * 1, y);
+            m_status = status_line_to;
+        }
+    }
+    void close_polygon_no_clip()
+    {
+        if(m_status == status_line_to) {
+            m_outline.line_to(m_clipped_start_x * 1, m_clipped_start_y);
+            m_status = status_closed;
+        }
+    }
+    void clip_segment(int x, int y)
+    {
+        unsigned flags = clipping_flags(x, y, m_clip_box);
+        if(m_prev_flags == flags) {
+            if(flags == 0) {
+                if(m_status == status_initial) {
+                    move_to_no_clip(x, y);
+                } else {
+                    line_to_no_clip(x, y);
+                }
+            }
+        } else {
+            int cx[4];
+            int cy[4];
+            unsigned n = clip_liang_barsky(m_prev_x, m_prev_y,
+                                           x, y,
+                                           m_clip_box,
+                                           cx, cy);
+            const int* px = cx;
+            const int* py = cy;
+            while(n--) {
+                if(m_status == status_initial) {
+                    move_to_no_clip(*px++, *py++);
+                } else {
+                    line_to_no_clip(*px++, *py++);
+                }
+            }
+        }
+        m_prev_flags = flags;
+        m_prev_x = x;
+        m_prev_y = y;
+    }
+private:
+    outline_aa     m_outline;
+    filling_rule_e m_filling_rule;
+    int            m_clipped_start_x;
+    int            m_clipped_start_y;
+    int            m_start_x;
+    int            m_start_y;
+    int            m_prev_x;
+    int            m_prev_y;
+    unsigned       m_prev_flags;
+    unsigned       m_status;
+    rect           m_clip_box;
+    bool           m_clipping;
+    int            m_cur_y;
+};
+}
+#endif