← Back to branch summary

~ubuntu-branches/ubuntu/raring/cairo/raring

« back to all changes in this revision

Viewing changes to src/cairo-gl-spans-compositor.c

  • Committer: Package Import Robot
  • Author(s): Chris Coulson
  • Date: 2013-01-23 21:19:34 UTC
  • mfrom: (1.3.11) (28.1.7 experimental)
  • Revision ID: package-import@ubuntu.com-20130123211934-q9qb538ujcmkliic
Tags: 1.12.10-1ubuntu1
https://launchpad.net/bugs/725434
* Merge from Debian, remaining changes:
* debian/patches/server_side_gradients.patch:
  - Don't use server side gradients, most drivers don't handle those and
    are really slow
* debian/control: Add missing libxext-dev dependency to libcairo2-dev.
  Spotted by autopkgtest.
* debian/patches/git_evince_rendering_fix.patch:
  Backport GIT commit to fix a rendering bug in evince
* debian/control, debian/libcairo2.symbols, debian/rules:
  - Disable GL backend due to LP: #725434

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cairo-gl-spans-compositor.c
57
57
    cairo_gl_composite_t setup;
58
58
    double opacity;
59
59
 
 
60
    cairo_gl_emit_span_t emit;
 
61
 
60
62
    int xmin, xmax;
61
63
    int ymin, ymax;
62
64
 
70
72
                                unsigned num_spans)
71
73
{
72
74
    cairo_gl_span_renderer_t *r = abstract_renderer;
 
75
    cairo_gl_emit_span_t emit = r->emit;
73
76
 
74
77
    if (num_spans == 0)
75
78
        return CAIRO_STATUS_SUCCESS;
76
79
 
77
80
    do {
78
81
        if (spans[0].coverage) {
79
 
            _cairo_gl_composite_emit_rect (r->ctx,
80
 
                                           spans[0].x, y,
81
 
                                           spans[1].x, y + height,
82
 
                                           spans[0].coverage);
 
82
            emit (r->ctx,
 
83
                  spans[0].x, y,
 
84
                  spans[1].x, y + height,
 
85
                  spans[0].coverage);
83
86
        }
84
87
 
85
88
        spans++;
95
98
                         unsigned num_spans)
96
99
{
97
100
    cairo_gl_span_renderer_t *r = abstract_renderer;
 
101
    cairo_gl_emit_span_t emit = r->emit;
98
102
 
99
103
    if (num_spans == 0)
100
104
        return CAIRO_STATUS_SUCCESS;
101
105
 
102
106
    do {
103
107
        if (spans[0].coverage) {
104
 
            _cairo_gl_composite_emit_rect (r->ctx,
105
 
                                           spans[0].x, y,
106
 
                                           spans[1].x, y + height,
107
 
                                           r->opacity * spans[0].coverage);
 
108
            emit (r->ctx,
 
109
                  spans[0].x, y,
 
110
                  spans[1].x, y + height,
 
111
                  r->opacity * spans[0].coverage);
108
112
        }
109
113
 
110
114
        spans++;
120
124
                           unsigned num_spans)
121
125
{
122
126
    cairo_gl_span_renderer_t *r = abstract_renderer;
 
127
    cairo_gl_emit_span_t emit = r->emit;
123
128
 
124
129
    if (y > r->ymin) {
125
 
        _cairo_gl_composite_emit_rect (r->ctx,
126
 
                                       r->xmin, r->ymin,
127
 
                                       r->xmax, y,
128
 
                                       0);
 
130
        emit (r->ctx,
 
131
              r->xmin, r->ymin,
 
132
              r->xmax, y,
 
133
              0);
129
134
    }
130
135
 
131
136
    if (num_spans == 0) {
132
 
        _cairo_gl_composite_emit_rect (r->ctx,
133
 
                                       r->xmin, y,
134
 
                                       r->xmax, y + height,
135
 
                                       0);
 
137
        emit (r->ctx,
 
138
              r->xmin, y,
 
139
              r->xmax, y + height,
 
140
              0);
136
141
    } else {
137
142
        if (spans[0].x != r->xmin) {
138
 
            _cairo_gl_composite_emit_rect (r->ctx,
139
 
                                           r->xmin, y,
140
 
                                           spans[0].x,     y + height,
141
 
                                           0);
 
143
            emit (r->ctx,
 
144
                  r->xmin, y,
 
145
                  spans[0].x,     y + height,
 
146
                  0);
142
147
        }
143
148
 
144
149
        do {
145
 
            _cairo_gl_composite_emit_rect (r->ctx,
146
 
                                           spans[0].x, y,
147
 
                                           spans[1].x, y + height,
148
 
                                           r->opacity * spans[0].coverage);
 
150
            emit (r->ctx,
 
151
                  spans[0].x, y,
 
152
                  spans[1].x, y + height,
 
153
                  r->opacity * spans[0].coverage);
149
154
            spans++;
150
155
        } while (--num_spans > 1);
151
156
 
152
157
        if (spans[0].x != r->xmax) {
153
 
            _cairo_gl_composite_emit_rect (r->ctx,
154
 
                                           spans[0].x,     y,
155
 
                                           r->xmax, y + height,
156
 
                                           0);
 
158
            emit (r->ctx,
 
159
                  spans[0].x,     y,
 
160
                  r->xmax, y + height,
 
161
                  0);
157
162
        }
158
163
    }
159
164
 
169
174
                           unsigned num_spans)
170
175
{
171
176
    cairo_gl_span_renderer_t *r = abstract_renderer;
 
177
    cairo_gl_emit_span_t emit = r->emit;
172
178
 
173
179
    if (y > r->ymin) {
174
 
        _cairo_gl_composite_emit_rect (r->ctx,
175
 
                                       r->xmin, r->ymin,
176
 
                                       r->xmax, y,
177
 
                                       0);
 
180
        emit (r->ctx,
 
181
              r->xmin, r->ymin,
 
182
              r->xmax, y,
 
183
              0);
178
184
    }
179
185
 
180
186
    if (num_spans == 0) {
181
 
        _cairo_gl_composite_emit_rect (r->ctx,
182
 
                                       r->xmin, y,
183
 
                                       r->xmax, y + height,
184
 
                                       0);
 
187
        emit (r->ctx,
 
188
              r->xmin, y,
 
189
              r->xmax, y + height,
 
190
              0);
185
191
    } else {
186
192
        if (spans[0].x != r->xmin) {
187
 
            _cairo_gl_composite_emit_rect (r->ctx,
188
 
                                           r->xmin, y,
189
 
                                           spans[0].x,     y + height,
190
 
                                           0);
 
193
            emit (r->ctx,
 
194
                  r->xmin, y,
 
195
                  spans[0].x,     y + height,
 
196
                  0);
191
197
        }
192
198
 
193
199
        do {
194
 
            _cairo_gl_composite_emit_rect (r->ctx,
195
 
                                           spans[0].x, y,
196
 
                                           spans[1].x, y + height,
197
 
                                           r->opacity * spans[0].coverage);
 
200
            emit (r->ctx,
 
201
                  spans[0].x, y,
 
202
                  spans[1].x, y + height,
 
203
                  r->opacity * spans[0].coverage);
198
204
            spans++;
199
205
        } while (--num_spans > 1);
200
206
 
201
207
        if (spans[0].x != r->xmax) {
202
 
            _cairo_gl_composite_emit_rect (r->ctx,
203
 
                                           spans[0].x,     y,
204
 
                                           r->xmax, y + height,
205
 
                                           0);
 
208
            emit (r->ctx,
 
209
                  spans[0].x,     y,
 
210
                  r->xmax, y + height,
 
211
                  0);
206
212
        }
207
213
    }
208
214
 
214
220
_cairo_gl_finish_unbounded_spans (void *abstract_renderer)
215
221
{
216
222
    cairo_gl_span_renderer_t *r = abstract_renderer;
 
223
    cairo_gl_emit_span_t emit = r->emit;
217
224
 
218
225
    if (r->ymax > r->ymin) {
219
 
        _cairo_gl_composite_emit_rect (r->ctx,
220
 
                                       r->xmin, r->ymin,
221
 
                                       r->xmax, r->ymax,
222
 
                                       0);
 
226
        emit (r->ctx,
 
227
              r->xmin, r->ymin,
 
228
              r->xmax, r->ymax,
 
229
              0);
223
230
    }
224
231
 
225
232
    return _cairo_gl_context_release (r->ctx, CAIRO_STATUS_SUCCESS);
238
245
                    const cairo_boxes_t *boxes)
239
246
{
240
247
    const struct _cairo_boxes_chunk *chunk;
 
248
    cairo_gl_emit_rect_t emit = _cairo_gl_context_choose_emit_rect (ctx);
241
249
    int i;
242
250
 
243
251
    TRACE ((stderr, "%s: num_boxes=%d\n", __FUNCTION__, boxes->num_boxes));
247
255
            int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y);
248
256
            int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x);
249
257
            int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y);
250
 
            _cairo_gl_composite_emit_rect (ctx, x1, y1, x2, y2, 255);
 
258
            emit (ctx, x1, y1, x2, y2);
251
259
        }
252
260
    }
253
261
}
468
476
    if (unlikely (status))
469
477
        goto FAIL;
470
478
 
 
479
    r->emit = _cairo_gl_context_choose_emit_span (r->ctx);
471
480
    if (composite->is_bounded) {
472
481
        if (r->opacity == 1.)
473
482
            r->base.render_rows = _cairo_gl_bounded_opaque_spans;