Grcov report - cairo-mask-compositor.c

1

/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */

2

/* cairo - a vector graphics library with display and print output

3

4

 * Copyright © 2002 University of Southern California

5

 * Copyright © 2005 Red Hat, Inc.

6

 * Copyright © 2011 Intel Corporation

7

8

 * This library is free software; you can redistribute it and/or

9

 * modify it either under the terms of the GNU Lesser General Public

10

 * License version 2.1 as published by the Free Software Foundation

11

 * (the "LGPL") or, at your option, under the terms of the Mozilla

12

 * Public License Version 1.1 (the "MPL"). If you do not alter this

13

 * notice, a recipient may use your version of this file under either

14

 * the MPL or the LGPL.

15

16

 * You should have received a copy of the LGPL along with this library

17

 * in the file COPYING-LGPL-2.1; if not, write to the Free Software

18

 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA

19

 * You should have received a copy of the MPL along with this library

20

 * in the file COPYING-MPL-1.1

21

22

 * The contents of this file are subject to the Mozilla Public License

23

 * Version 1.1 (the "License"); you may not use this file except in

24

 * compliance with the License. You may obtain a copy of the License at

25

 * http://www.mozilla.org/MPL/

26

27

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY

28

 * OF ANY KIND, either express or implied. See the LGPL or the MPL for

29

 * the specific language governing rights and limitations.

30

31

 * The Original Code is the cairo graphics library.

32

33

 * The Initial Developer of the Original Code is University of Southern

34

 * California.

35

36

 * Contributor(s):

37

 *	Carl D. Worth <cworth@cworth.org>

38

 *      Joonas Pihlaja <jpihlaja@cc.helsinki.fi>

39

 *	Chris Wilson <chris@chris-wilson.co.uk>

40

*/

41

42

/* This compositor renders the shape to a mask using an image surface

43

 * then calls composite.

44

*/

45

46

#include "cairoint.h"

47

48

#include "cairo-clip-inline.h"

49

#include "cairo-compositor-private.h"

50

#include "cairo-image-surface-private.h"

51

#include "cairo-pattern-inline.h"

52

#include "cairo-region-private.h"

53

#include "cairo-surface-observer-private.h"

54

#include "cairo-surface-offset-private.h"

55

#include "cairo-surface-snapshot-private.h"

56

#include "cairo-surface-subsurface-private.h"

57

58

typedef cairo_int_status_t

59

(*draw_func_t) (const cairo_mask_compositor_t *compositor,

60

		cairo_surface_t			*dst,

61

		void				*closure,

62

		cairo_operator_t		 op,

63

		const cairo_pattern_t		*src,

64

		const cairo_rectangle_int_t	*src_sample,

65

		int				 dst_x,

66

		int				 dst_y,

67

		const cairo_rectangle_int_t	*extents,

68

		cairo_clip_t			*clip);

69

70

static void do_unaligned_row(void (*blt)(void *closure,

71

					 int16_t x, int16_t y,

72

					 int16_t w, int16_t h,

73

					 uint16_t coverage),

74

			     void *closure,

75

			     const cairo_box_t *b,

76

			     int tx, int y, int h,

77

			     uint16_t coverage)

78

79

    int x1 = _cairo_fixed_integer_part (b->p1.x) - tx;

80

    int x2 = _cairo_fixed_integer_part (b->p2.x) - tx;

81

    if (x2 > x1) {

82

	if (! _cairo_fixed_is_integer (b->p1.x)) {

83

	    blt(closure, x1, y, 1, h,

84

		coverage * (256 - _cairo_fixed_fractional_part (b->p1.x)));

85

	    x1++;

86

87

88

	if (x2 > x1)

89

	    blt(closure, x1, y, x2-x1, h, (coverage << 8) - (coverage >> 8));

90

91

	if (! _cairo_fixed_is_integer (b->p2.x))

92

	    blt(closure, x2, y, 1, h,

93

		coverage * _cairo_fixed_fractional_part (b->p2.x));

94

    } else

95

	blt(closure, x1, y, 1, h,

96

	    coverage * (b->p2.x - b->p1.x));

97

98

99

static void do_unaligned_box(void (*blt)(void *closure,

100

					 int16_t x, int16_t y,

101

					 int16_t w, int16_t h,

102

					 uint16_t coverage),

103

			     void *closure,

104

			     const cairo_box_t *b, int tx, int ty)

105

106

    int y1 = _cairo_fixed_integer_part (b->p1.y) - ty;

107

    int y2 = _cairo_fixed_integer_part (b->p2.y) - ty;

108

    if (y2 > y1) {

109

	if (! _cairo_fixed_is_integer (b->p1.y)) {

110

	    do_unaligned_row(blt, closure, b, tx, y1, 1,

111

			     256 - _cairo_fixed_fractional_part (b->p1.y));

112

	    y1++;

113

114

115

	if (y2 > y1)

116

	    do_unaligned_row(blt, closure, b, tx, y1, y2-y1, 256);

117

118

	if (! _cairo_fixed_is_integer (b->p2.y))

119

	    do_unaligned_row(blt, closure, b, tx, y2, 1,

120

			     _cairo_fixed_fractional_part (b->p2.y));

121

    } else

122

	do_unaligned_row(blt, closure, b, tx, y1, 1,

123

			 b->p2.y - b->p1.y);

124

125

126

struct blt_in {

127

    const cairo_mask_compositor_t *compositor;

128

    cairo_surface_t *dst;

129

};

130

131

static void blt_in(void *closure,

132

		   int16_t x, int16_t y,

133

		   int16_t w, int16_t h,

134

		   uint16_t coverage)

135

136

    struct blt_in *info = closure;

137

    cairo_color_t color;

138

    cairo_rectangle_int_t rect;

139

140

    if (coverage == 0xffff)

141

	return;

142

143

    rect.x = x;

144

    rect.y = y;

145

    rect.width  = w;

146

    rect.height = h;

147

148

    _cairo_color_init_rgba (&color, 0, 0, 0, coverage / (double) 0xffff);

149

    info->compositor->fill_rectangles (info->dst, CAIRO_OPERATOR_IN,

150

				       &color, &rect, 1);

151

152

153

static cairo_surface_t *

154

create_composite_mask (const cairo_mask_compositor_t *compositor,

155

		       cairo_surface_t		*dst,

156

		       void			*draw_closure,

157

		       draw_func_t		 draw_func,

158

		       draw_func_t		 mask_func,

159

		       const cairo_composite_rectangles_t *extents)

160

161

    cairo_surface_t *surface;

162

    cairo_int_status_t status;

163

    struct blt_in info;

164

    int i;

165

166

    surface = _cairo_surface_create_scratch (dst, CAIRO_CONTENT_ALPHA,

167

					     extents->bounded.width,

168

					     extents->bounded.height,

169

					     NULL);

170

    if (unlikely (surface->status))

171

	return surface;

172

173

    status = compositor->acquire (surface);

174

    if (unlikely (status)) {

175

	cairo_surface_destroy (surface);

176

	return _cairo_int_surface_create_in_error (status);

177

178

179

    if (!surface->is_clear) {

180

	cairo_rectangle_int_t rect;

181

182

	rect.x = rect.y = 0;

183

	rect.width = extents->bounded.width;

184

	rect.height = extents->bounded.height;

185

186

	status = compositor->fill_rectangles (surface, CAIRO_OPERATOR_CLEAR,

187

					      CAIRO_COLOR_TRANSPARENT,

188

					      &rect, 1);

189

	if (unlikely (status))

190

	    goto error;

191

192

193

    if (mask_func) {

194

	status = mask_func (compositor, surface, draw_closure,

195

			    CAIRO_OPERATOR_SOURCE, NULL, NULL,

196

			    extents->bounded.x, extents->bounded.y,

197

			    &extents->bounded, extents->clip);

198

	if (likely (status != CAIRO_INT_STATUS_UNSUPPORTED))

199

	    goto out;

200

201

202

    /* Is it worth setting the clip region here? */

203

    status = draw_func (compositor, surface, draw_closure,

204

			CAIRO_OPERATOR_ADD, NULL, NULL,

205

			extents->bounded.x, extents->bounded.y,

206

			&extents->bounded, NULL);

207

    if (unlikely (status))

208

	goto error;

209

210

    info.compositor = compositor;

211

    info.dst = surface;

212

    for (i = 0; i < extents->clip->num_boxes; i++) {

213

	cairo_box_t *b = &extents->clip->boxes[i];

214

215

	if (! _cairo_fixed_is_integer (b->p1.x) ||

216

	    ! _cairo_fixed_is_integer (b->p1.y) ||

217

	    ! _cairo_fixed_is_integer (b->p2.x) ||

218

	    ! _cairo_fixed_is_integer (b->p2.y))

219

220

	    do_unaligned_box(blt_in, &info, b,

221

			     extents->bounded.x,

222

			     extents->bounded.y);

223

224

225

226

    if (extents->clip->path != NULL) {

227

	status = _cairo_clip_combine_with_surface (extents->clip, surface,

228

						   extents->bounded.x,

229

						   extents->bounded.y);

230

	if (unlikely (status))

231

	    goto error;

232

233

234

out:

235

    compositor->release (surface);

236

    surface->is_clear = FALSE;

237

    return surface;

238

239

error:

240

    compositor->release (surface);

241

    if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) {

242

	cairo_surface_destroy (surface);

243

	surface = _cairo_int_surface_create_in_error (status);

244

245

    return surface;

246

247

248

/* Handles compositing with a clip surface when the operator allows

249

 * us to combine the clip with the mask

250

*/

251

static cairo_status_t

252

clip_and_composite_with_mask (const cairo_mask_compositor_t *compositor,

253

			      void			*draw_closure,

254

			      draw_func_t		 draw_func,

255

			      draw_func_t		 mask_func,

256

			      cairo_operator_t		 op,

257

			      cairo_pattern_t		*pattern,

258

			      const cairo_composite_rectangles_t*extents)

259

260

    cairo_surface_t *dst = extents->surface;

261

    cairo_surface_t *mask, *src;

262

    int src_x, src_y;

263

264

    mask = create_composite_mask (compositor, dst, draw_closure,

265

				  draw_func, mask_func,

266

				  extents);

267

    if (unlikely (mask->status))

268

	return mask->status;

269

270

    if (pattern != NULL || dst->content != CAIRO_CONTENT_ALPHA) {

271

	src = compositor->pattern_to_surface (dst,

272

					      &extents->source_pattern.base,

273

					      FALSE,

274

					      &extents->bounded,

275

					      &extents->source_sample_area,

276

					      &src_x, &src_y);

277

	if (unlikely (src->status)) {

278

	    cairo_surface_destroy (mask);

279

	    return src->status;

280

281

282

	compositor->composite (dst, op, src, mask,

283

			       extents->bounded.x + src_x,

284

			       extents->bounded.y + src_y,

285

			       0, 0,

286

			       extents->bounded.x,      extents->bounded.y,

287

			       extents->bounded.width,  extents->bounded.height);

288

289

	cairo_surface_destroy (src);

290

    } else {

291

	compositor->composite (dst, op, mask, NULL,

292

			       0, 0,

293

			       0, 0,

294

			       extents->bounded.x,      extents->bounded.y,

295

			       extents->bounded.width,  extents->bounded.height);

296

297

    cairo_surface_destroy (mask);

298

299

    return CAIRO_STATUS_SUCCESS;

300

301

302

static cairo_surface_t *

303

get_clip_source (const cairo_mask_compositor_t *compositor,

304

		 cairo_clip_t *clip,

305

		 cairo_surface_t *dst,

306

		 const cairo_rectangle_int_t *bounds,

307

		 int *out_x, int *out_y)

308

309

    cairo_surface_pattern_t pattern;

310

    cairo_rectangle_int_t r;

311

    cairo_surface_t *surface;

312

313

    surface = _cairo_clip_get_image (clip, dst, bounds);

314

    if (unlikely (surface->status))

315

	return surface;

316

317

    _cairo_pattern_init_for_surface (&pattern, surface);

318

    pattern.base.filter = CAIRO_FILTER_NEAREST;

319

    cairo_surface_destroy (surface);

320

321

    r.x = r.y = 0;

322

    r.width  = bounds->width;

323

    r.height = bounds->height;

324

325

    surface = compositor->pattern_to_surface (dst, &pattern.base, TRUE,

326

					      &r, &r, out_x, out_y);

327

    _cairo_pattern_fini (&pattern.base);

328

329

    *out_x += -bounds->x;

330

    *out_y += -bounds->y;

331

    return surface;

332

333

334

/* Handles compositing with a clip surface when we have to do the operation

335

 * in two pieces and combine them together.

336

*/

337

static cairo_status_t

338

clip_and_composite_combine (const cairo_mask_compositor_t *compositor,

339

			    void			*draw_closure,

340

			    draw_func_t		 draw_func,

341

			    cairo_operator_t		 op,

342

			    const cairo_pattern_t	*pattern,

343

			    const cairo_composite_rectangles_t*extents)

344

345

    cairo_surface_t *dst = extents->surface;

346

    cairo_surface_t *tmp, *clip;

347

    cairo_status_t status;

348

    int clip_x, clip_y;

349

350

    tmp = _cairo_surface_create_scratch (dst, dst->content,

351

					 extents->bounded.width,

352

					 extents->bounded.height,

353

					 NULL);

354

    if (unlikely (tmp->status))

355

	return tmp->status;

356

357

    compositor->composite (tmp, CAIRO_OPERATOR_SOURCE, dst, NULL,

358

			   extents->bounded.x,      extents->bounded.y,

359

			   0, 0,

360

			   0, 0,

361

			   extents->bounded.width,  extents->bounded.height);

362

363

    status = draw_func (compositor, tmp, draw_closure, op,

364

			pattern, &extents->source_sample_area,

365

			extents->bounded.x, extents->bounded.y,

366

			&extents->bounded, NULL);

367

    if (unlikely (status))

368

	goto cleanup;

369

370

    clip = get_clip_source (compositor,

371

			    extents->clip, dst, &extents->bounded,

372

			    &clip_x, &clip_y);

373

    if (unlikely ((status = clip->status)))

374

	goto cleanup;

375

376

    if (dst->is_clear) {

377

	compositor->composite (dst, CAIRO_OPERATOR_SOURCE, tmp, clip,

378

			       0, 0,

379

			       clip_x, clip_y,

380

			       extents->bounded.x,      extents->bounded.y,

381

			       extents->bounded.width,  extents->bounded.height);

382

    } else {

383

	/* Punch the clip out of the destination */

384

	compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, clip, NULL,

385

			       clip_x, clip_y,

386

			       0, 0,

387

			       extents->bounded.x,     extents->bounded.y,

388

			       extents->bounded.width, extents->bounded.height);

389

390

	/* Now add the two results together */

391

	compositor->composite (dst, CAIRO_OPERATOR_ADD, tmp, clip,

392

			       0, 0,

393

			       clip_x, clip_y,

394

			       extents->bounded.x,     extents->bounded.y,

395

			       extents->bounded.width, extents->bounded.height);

396

397

    cairo_surface_destroy (clip);

398

399

cleanup:

400

    cairo_surface_destroy (tmp);

401

    return status;

402

403

404

/* Handles compositing for %CAIRO_OPERATOR_SOURCE, which is special; it's

405

 * defined as (src IN mask IN clip) ADD (dst OUT (mask IN clip))

406

*/

407

static cairo_status_t

408

clip_and_composite_source (const cairo_mask_compositor_t	*compositor,

409

			   void				*draw_closure,

410

			   draw_func_t			 draw_func,

411

			   draw_func_t			 mask_func,

412

			   cairo_pattern_t		*pattern,

413

			   const cairo_composite_rectangles_t	*extents)

414

415

    cairo_surface_t *dst = extents->surface;

416

    cairo_surface_t *mask, *src;

417

    int src_x, src_y;

418

419

    /* Create a surface that is mask IN clip */

420

    mask = create_composite_mask (compositor, dst, draw_closure,

421

				  draw_func, mask_func,

422

				  extents);

423

    if (unlikely (mask->status))

424

	return mask->status;

425

426

    src = compositor->pattern_to_surface (dst,

427

					  pattern,

428

					  FALSE,

429

					  &extents->bounded,

430

					  &extents->source_sample_area,

431

					  &src_x, &src_y);

432

    if (unlikely (src->status)) {

433

	cairo_surface_destroy (mask);

434

	return src->status;

435

436

437

    if (dst->is_clear) {

438

	compositor->composite (dst, CAIRO_OPERATOR_SOURCE, src, mask,

439

			       extents->bounded.x + src_x, extents->bounded.y + src_y,

440

			       0, 0,

441

			       extents->bounded.x,      extents->bounded.y,

442

			       extents->bounded.width,  extents->bounded.height);

443

    } else {

444

	/* Compute dest' = dest OUT (mask IN clip) */

445

	compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL,

446

			       0, 0, 0, 0,

447

			       extents->bounded.x,     extents->bounded.y,

448

			       extents->bounded.width, extents->bounded.height);

449

450

	/* Now compute (src IN (mask IN clip)) ADD dest' */

451

	compositor->composite (dst, CAIRO_OPERATOR_ADD, src, mask,

452

			       extents->bounded.x + src_x, extents->bounded.y + src_y,

453

			       0, 0,

454

			       extents->bounded.x,     extents->bounded.y,

455

			       extents->bounded.width, extents->bounded.height);

456

457

458

    cairo_surface_destroy (src);

459

    cairo_surface_destroy (mask);

460

461

    return CAIRO_STATUS_SUCCESS;

462

463

464

static cairo_bool_t

465

can_reduce_alpha_op (cairo_operator_t op)

466

467

    int iop = op;

468

    switch (iop) {

469

    case CAIRO_OPERATOR_OVER:

470

    case CAIRO_OPERATOR_SOURCE:

471

    case CAIRO_OPERATOR_ADD:

472

	return TRUE;

473

    default:

474

	return FALSE;

475

476

477

478

static cairo_bool_t

479

reduce_alpha_op (cairo_surface_t *dst,

480

		 cairo_operator_t op,

481

		 const cairo_pattern_t *pattern)

482

483

    return dst->is_clear &&

484

	   dst->content == CAIRO_CONTENT_ALPHA &&

485

	   _cairo_pattern_is_opaque_solid (pattern) &&

486

	   can_reduce_alpha_op (op);

487

488

489

static cairo_status_t

490

fixup_unbounded (const cairo_mask_compositor_t *compositor,

491

		 cairo_surface_t *dst,

492

		 const cairo_composite_rectangles_t *extents)

493

494

    cairo_rectangle_int_t rects[4];

495

    int n;

496

497

    if (extents->bounded.width  == extents->unbounded.width &&

498

	extents->bounded.height == extents->unbounded.height)

499

500

	return CAIRO_STATUS_SUCCESS;

501

502

503

    n = 0;

504

    if (extents->bounded.width == 0 || extents->bounded.height == 0) {

505

	rects[n].x = extents->unbounded.x;

506

	rects[n].width = extents->unbounded.width;

507

	rects[n].y = extents->unbounded.y;

508

	rects[n].height = extents->unbounded.height;

509

	n++;

510

    } else {

511

	/* top */

512

	if (extents->bounded.y != extents->unbounded.y) {

513

	    rects[n].x = extents->unbounded.x;

514

	    rects[n].width = extents->unbounded.width;

515

	    rects[n].y = extents->unbounded.y;

516

	    rects[n].height = extents->bounded.y - extents->unbounded.y;

517

	    n++;

518

519

	/* left */

520

	if (extents->bounded.x != extents->unbounded.x) {

521

	    rects[n].x = extents->unbounded.x;

522

	    rects[n].width = extents->bounded.x - extents->unbounded.x;

523

	    rects[n].y = extents->bounded.y;

524

	    rects[n].height = extents->bounded.height;

525

	    n++;

526

527

	/* right */

528

	if (extents->bounded.x + extents->bounded.width != extents->unbounded.x + extents->unbounded.width) {

529

	    rects[n].x = extents->bounded.x + extents->bounded.width;

530

	    rects[n].width = extents->unbounded.x + extents->unbounded.width - rects[n].x;

531

	    rects[n].y = extents->bounded.y;

532

	    rects[n].height = extents->bounded.height;

533

	    n++;

534

535

	/* bottom */

536

	if (extents->bounded.y + extents->bounded.height != extents->unbounded.y + extents->unbounded.height) {

537

	    rects[n].x = extents->unbounded.x;

538

	    rects[n].width = extents->unbounded.width;

539

	    rects[n].y = extents->bounded.y + extents->bounded.height;

540

	    rects[n].height = extents->unbounded.y + extents->unbounded.height - rects[n].y;

541

	    n++;

542

543

544

545

    return compositor->fill_rectangles (dst, CAIRO_OPERATOR_CLEAR,

546

					CAIRO_COLOR_TRANSPARENT,

547

					rects, n);

548

549

550

static cairo_status_t

551

fixup_unbounded_with_mask (const cairo_mask_compositor_t *compositor,

552

			   cairo_surface_t *dst,

553

			   const cairo_composite_rectangles_t *extents)

554

555

    cairo_surface_t *mask;

556

    int mask_x, mask_y;

557

558

    mask = get_clip_source (compositor,

559

			    extents->clip, dst, &extents->unbounded,

560

			    &mask_x, &mask_y);

561

    if (unlikely (mask->status))

562

	return mask->status;

563

564

    /* top */

565

    if (extents->bounded.y != extents->unbounded.y) {

566

	int x = extents->unbounded.x;

567

	int y = extents->unbounded.y;

568

	int width = extents->unbounded.width;

569

	int height = extents->bounded.y - y;

570

571

	compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL,

572

			       x + mask_x, y + mask_y,

573

			       0, 0,

574

			       x, y,

575

			       width, height);

576

577

578

    /* left */

579

    if (extents->bounded.x != extents->unbounded.x) {

580

	int x = extents->unbounded.x;

581

	int y = extents->bounded.y;

582

	int width = extents->bounded.x - x;

583

	int height = extents->bounded.height;

584

585

	compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL,

586

			       x + mask_x, y + mask_y,

587

			       0, 0,

588

			       x, y,

589

			       width, height);

590

591

592

    /* right */

593

    if (extents->bounded.x + extents->bounded.width != extents->unbounded.x + extents->unbounded.width) {

594

	int x = extents->bounded.x + extents->bounded.width;

595

	int y = extents->bounded.y;

596

	int width = extents->unbounded.x + extents->unbounded.width - x;

597

	int height = extents->bounded.height;

598

599

	compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL,

600

			       x + mask_x, y + mask_y,

601

			       0, 0,

602

			       x, y,

603

			       width, height);

604

605

606

    /* bottom */

607

    if (extents->bounded.y + extents->bounded.height != extents->unbounded.y + extents->unbounded.height) {

608

	int x = extents->unbounded.x;

609

	int y = extents->bounded.y + extents->bounded.height;

610

	int width = extents->unbounded.width;

611

	int height = extents->unbounded.y + extents->unbounded.height - y;

612

613

	compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL,

614

			       x + mask_x, y + mask_y,

615

			       0, 0,

616

			       x, y,

617

			       width, height);

618

619

620

    cairo_surface_destroy (mask);

621

622

    return CAIRO_STATUS_SUCCESS;

623

624

625

static cairo_status_t

626

fixup_unbounded_boxes (const cairo_mask_compositor_t *compositor,

627

		       const cairo_composite_rectangles_t *extents,

628

		       cairo_boxes_t *boxes)

629

630

    cairo_surface_t *dst = extents->surface;

631

    cairo_boxes_t clear;

632

    cairo_region_t *clip_region;

633

    cairo_box_t box;

634

    cairo_status_t status;

635

    struct _cairo_boxes_chunk *chunk;

636

    int i;

637

638

    assert (boxes->is_pixel_aligned);

639

640

    clip_region = NULL;

641

    if (_cairo_clip_is_region (extents->clip) &&

642

	(clip_region = _cairo_clip_get_region (extents->clip)) &&

643

	cairo_region_contains_rectangle (clip_region,

644

					 &extents->bounded) == CAIRO_REGION_OVERLAP_IN)

645

	clip_region = NULL;

646

647

648

    if (boxes->num_boxes <= 1 && clip_region == NULL)

649

	return fixup_unbounded (compositor, dst, extents);

650

651

    _cairo_boxes_init (&clear);

652

653

    box.p1.x = _cairo_fixed_from_int (extents->unbounded.x + extents->unbounded.width);

654

    box.p1.y = _cairo_fixed_from_int (extents->unbounded.y);

655

    box.p2.x = _cairo_fixed_from_int (extents->unbounded.x);

656

    box.p2.y = _cairo_fixed_from_int (extents->unbounded.y + extents->unbounded.height);

657

658

    if (clip_region == NULL) {

659

	cairo_boxes_t tmp;

660

661

	_cairo_boxes_init (&tmp);

662

663

	status = _cairo_boxes_add (&tmp, CAIRO_ANTIALIAS_DEFAULT, &box);

664

	assert (status == CAIRO_STATUS_SUCCESS);

665

666

	tmp.chunks.next = &boxes->chunks;

667

	tmp.num_boxes += boxes->num_boxes;

668

669

	status = _cairo_bentley_ottmann_tessellate_boxes (&tmp,

670

							  CAIRO_FILL_RULE_WINDING,

671

							  &clear);

672

673

	tmp.chunks.next = NULL;

674

    } else {

675

	pixman_box32_t *pbox;

676

677

	pbox = pixman_region32_rectangles (&clip_region->rgn, &i);

678

	_cairo_boxes_limit (&clear, (cairo_box_t *) pbox, i);

679

680

	status = _cairo_boxes_add (&clear, CAIRO_ANTIALIAS_DEFAULT, &box);

681

	assert (status == CAIRO_STATUS_SUCCESS);

682

683

	for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) {

684

	    for (i = 0; i < chunk->count; i++) {

685

		status = _cairo_boxes_add (&clear,

686

					   CAIRO_ANTIALIAS_DEFAULT,

687

					   &chunk->base[i]);

688

		if (unlikely (status)) {

689

		    _cairo_boxes_fini (&clear);

690

		    return status;

691

692

693

694

695

	status = _cairo_bentley_ottmann_tessellate_boxes (&clear,

696

							  CAIRO_FILL_RULE_WINDING,

697

							  &clear);

698

699

700

    if (likely (status == CAIRO_STATUS_SUCCESS)) {

701

	status = compositor->fill_boxes (dst,

702

					 CAIRO_OPERATOR_CLEAR,

703

					 CAIRO_COLOR_TRANSPARENT,

704

					 &clear);

705

706

707

    _cairo_boxes_fini (&clear);

708

709

    return status;

710

711

712

enum {

713

    NEED_CLIP_REGION = 0x1,

714

    NEED_CLIP_SURFACE = 0x2,

715

    FORCE_CLIP_REGION = 0x4,

716

};

717

718

static cairo_bool_t

719

need_bounded_clip (cairo_composite_rectangles_t *extents)

720

721

    unsigned int flags = NEED_CLIP_REGION;

722

    if (! _cairo_clip_is_region (extents->clip))

723

	flags |= NEED_CLIP_SURFACE;

724

    return flags;

725

726

727

static cairo_bool_t

728

need_unbounded_clip (cairo_composite_rectangles_t *extents)

729

730

    unsigned int flags = 0;

731

    if (! extents->is_bounded) {

732

	flags |= NEED_CLIP_REGION;

733

	if (! _cairo_clip_is_region (extents->clip))

734

	    flags |= NEED_CLIP_SURFACE;

735

736

    if (extents->clip->path != NULL)

737

	flags |= NEED_CLIP_SURFACE;

738

    return flags;

739

740

741

static cairo_status_t

742

clip_and_composite (const cairo_mask_compositor_t *compositor,

743

		    draw_func_t			 draw_func,

744

		    draw_func_t			 mask_func,

745

		    void			*draw_closure,

746

		    cairo_composite_rectangles_t*extents,

747

		    unsigned int need_clip)

748

749

    cairo_surface_t *dst = extents->surface;

750

    cairo_operator_t op = extents->op;

751

    cairo_pattern_t *src = &extents->source_pattern.base;

752

    cairo_region_t *clip_region = NULL;

753

    cairo_status_t status;

754

755

    compositor->acquire (dst);

756

757

    if (need_clip & NEED_CLIP_REGION) {

758

	clip_region = _cairo_clip_get_region (extents->clip);

759

	if ((need_clip & FORCE_CLIP_REGION) == 0 &&

760

	    _cairo_composite_rectangles_can_reduce_clip (extents,

761

							 extents->clip))

762

	    clip_region = NULL;

763

	if (clip_region != NULL) {

764

	    status = compositor->set_clip_region (dst, clip_region);

765

	    if (unlikely (status)) {

766

		compositor->release (dst);

767

		return status;

768

769

770

771

772

    if (reduce_alpha_op (dst, op, &extents->source_pattern.base)) {

773

	op = CAIRO_OPERATOR_ADD;

774

	src = NULL;

775

776

777

    if (op == CAIRO_OPERATOR_SOURCE) {

778

	status = clip_and_composite_source (compositor,

779

					    draw_closure, draw_func, mask_func,

780

					    src, extents);

781

    } else {

782

	if (op == CAIRO_OPERATOR_CLEAR) {

783

	    op = CAIRO_OPERATOR_DEST_OUT;

784

	    src = NULL;

785

786

787

	if (need_clip & NEED_CLIP_SURFACE) {

788

	    if (extents->is_bounded) {

789

		status = clip_and_composite_with_mask (compositor,

790

						       draw_closure,

791

						       draw_func,

792

						       mask_func,

793

						       op, src, extents);

794

	    } else {

795

		status = clip_and_composite_combine (compositor,

796

						     draw_closure,

797

						     draw_func,

798

						     op, src, extents);

799

800

	} else {

801

	    status = draw_func (compositor,

802

				dst, draw_closure,

803

				op, src, &extents->source_sample_area,

804

				0, 0,

805

				&extents->bounded,

806

				extents->clip);

807

808

809

810

    if (status == CAIRO_STATUS_SUCCESS && ! extents->is_bounded) {

811

	if (need_clip & NEED_CLIP_SURFACE)

812

	    status = fixup_unbounded_with_mask (compositor, dst, extents);

813

	else

814

	    status = fixup_unbounded (compositor, dst, extents);

815

816

817

    if (clip_region)

818

	compositor->set_clip_region (dst, NULL);

819

820

    compositor->release (dst);

821

822

    return status;

823

824

825

static cairo_int_status_t

826

trim_extents_to_boxes (cairo_composite_rectangles_t *extents,

827

		       cairo_boxes_t *boxes)

828

829

    cairo_box_t box;

830

831

    _cairo_boxes_extents (boxes, &box);

832

    return _cairo_composite_rectangles_intersect_mask_extents (extents, &box);

833

834

835

static cairo_status_t

836

upload_boxes (const cairo_mask_compositor_t *compositor,

837

	      cairo_composite_rectangles_t *extents,

838

	      cairo_boxes_t *boxes)

839

840

    cairo_surface_t *dst = extents->surface;

841

    const cairo_pattern_t *source = &extents->source_pattern.base;

842

    cairo_surface_t *src;

843

    cairo_rectangle_int_t limit;

844

    cairo_int_status_t status;

845

    int tx, ty;

846

847

    src = _cairo_pattern_get_source ((cairo_surface_pattern_t *)source, &limit);

848

    if (!(src->type == CAIRO_SURFACE_TYPE_IMAGE || src->type == dst->type))

849

	return CAIRO_INT_STATUS_UNSUPPORTED;

850

851

    if (! _cairo_matrix_is_integer_translation (&source->matrix, &tx, &ty))

852

	return CAIRO_INT_STATUS_UNSUPPORTED;

853

854

    /* Check that the data is entirely within the image */

855

    if (extents->bounded.x + tx < limit.x || extents->bounded.y + ty < limit.y)

856

	return CAIRO_INT_STATUS_UNSUPPORTED;

857

858

    if (extents->bounded.x + extents->bounded.width  + tx > limit.x + limit.width ||

859

	extents->bounded.y + extents->bounded.height + ty > limit.y + limit.height)

860

	return CAIRO_INT_STATUS_UNSUPPORTED;

861

862

    tx += limit.x;

863

    ty += limit.y;

864

865

    if (src->type == CAIRO_SURFACE_TYPE_IMAGE)

866

	status = compositor->draw_image_boxes (dst,

867

					       (cairo_image_surface_t *)src,

868

					       boxes, tx, ty);

869

    else

870

	status = compositor->copy_boxes (dst, src, boxes, &extents->bounded,

871

					 tx, ty);

872

873

    return status;

874

875

876

static cairo_status_t

877

composite_boxes (const cairo_mask_compositor_t *compositor,

878

		 const cairo_composite_rectangles_t *extents,

879

		 cairo_boxes_t *boxes)

880

881

    cairo_surface_t *dst = extents->surface;

882

    cairo_operator_t op = extents->op;

883

    const cairo_pattern_t *source = &extents->source_pattern.base;

884

    cairo_bool_t need_clip_mask = extents->clip->path != NULL;

885

    cairo_status_t status;

886

887

    if (need_clip_mask &&

888

	(! extents->is_bounded || op == CAIRO_OPERATOR_SOURCE))

889

890

	return CAIRO_INT_STATUS_UNSUPPORTED;

891

892

893

    status = compositor->acquire (dst);

894

    if (unlikely (status))

895

	return status;

896

897

    if (! need_clip_mask && source->type == CAIRO_PATTERN_TYPE_SOLID) {

898

	const cairo_color_t *color;

899

900

	color = &((cairo_solid_pattern_t *) source)->color;

901

	status = compositor->fill_boxes (dst, op, color, boxes);

902

    } else {

903

	cairo_surface_t *src, *mask = NULL;

904

	int src_x, src_y;

905

	int mask_x = 0, mask_y = 0;

906

907

	if (need_clip_mask) {

908

	    mask = get_clip_source (compositor,

909

				    extents->clip, dst, &extents->bounded,

910

				    &mask_x, &mask_y);

911

	    if (unlikely (mask->status))

912

		return mask->status;

913

914

	    if (op == CAIRO_OPERATOR_CLEAR) {

915

		source = NULL;

916

		op = CAIRO_OPERATOR_DEST_OUT;

917

918

919

920

	if (source || mask == NULL) {

921

	    src = compositor->pattern_to_surface (dst, source, FALSE,

922

						  &extents->bounded,

923

						  &extents->source_sample_area,

924

						  &src_x, &src_y);

925

	} else {

926

	    src = mask;

927

	    src_x = mask_x;

928

	    src_y = mask_y;

929

	    mask = NULL;

930

931

932

	status = compositor->composite_boxes (dst, op, src, mask,

933

					      src_x, src_y,

934

					      mask_x, mask_y,

935

					      0, 0,

936

					      boxes, &extents->bounded);

937

938

	cairo_surface_destroy (src);

939

	cairo_surface_destroy (mask);

940

941

942

    if (status == CAIRO_STATUS_SUCCESS && ! extents->is_bounded)

943

	status = fixup_unbounded_boxes (compositor, extents, boxes);

944

945

    compositor->release (dst);

946

947

    return status;

948

949

950

static cairo_status_t

951

clip_and_composite_boxes (const cairo_mask_compositor_t *compositor,

952

			  cairo_composite_rectangles_t *extents,

953

			  cairo_boxes_t *boxes)

954

955

    cairo_surface_t *dst = extents->surface;

956

    cairo_int_status_t status;

957

958

    if (boxes->num_boxes == 0) {

959

	if (extents->is_bounded)

960

	    return CAIRO_STATUS_SUCCESS;

961

962

	return fixup_unbounded_boxes (compositor, extents, boxes);

963

964

965

    if (! boxes->is_pixel_aligned)

966

	return CAIRO_INT_STATUS_UNSUPPORTED;

967

968

    status = trim_extents_to_boxes (extents, boxes);

969

    if (unlikely (status))

970

	return status;

971

972

    if (extents->source_pattern.base.type == CAIRO_PATTERN_TYPE_SURFACE &&

973

	extents->clip->path == NULL &&

974

	(extents->op == CAIRO_OPERATOR_SOURCE ||

975

	 (dst->is_clear && (extents->op == CAIRO_OPERATOR_OVER ||

976

			    extents->op == CAIRO_OPERATOR_ADD))))

977

978

	status = upload_boxes (compositor, extents, boxes);

979

	if (status != CAIRO_INT_STATUS_UNSUPPORTED)

980

	    return status;

981

982

983

    return composite_boxes (compositor, extents, boxes);

984

985

986

/* high-level compositor interface */

987

988

static cairo_int_status_t

989

_cairo_mask_compositor_paint (const cairo_compositor_t *_compositor,

990

			      cairo_composite_rectangles_t *extents)

991

992

    cairo_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor;

993

    cairo_boxes_t boxes;

994

    cairo_int_status_t status;

995

996

    status = compositor->check_composite (extents);

997

    if (unlikely (status))

998

	return status;

999

1000

    _cairo_clip_steal_boxes (extents->clip, &boxes);

1001

    status = clip_and_composite_boxes (compositor, extents, &boxes);

1002

    _cairo_clip_unsteal_boxes (extents->clip, &boxes);

1003

1004

    return status;

1005

1006

1007

struct composite_opacity_info {

1008

    const cairo_mask_compositor_t *compositor;

1009

    uint8_t op;

1010

    cairo_surface_t *dst;

1011

    cairo_surface_t *src;

1012

    int src_x, src_y;

1013

    double opacity;

1014

};

1015

1016

static void composite_opacity(void *closure,

1017

			      int16_t x, int16_t y,

1018

			      int16_t w, int16_t h,

1019

			      uint16_t coverage)

1020

1021

    struct composite_opacity_info *info = closure;

1022

    const cairo_mask_compositor_t *compositor = info->compositor;

1023

    cairo_surface_t *mask;

1024

    int mask_x, mask_y;

1025

    cairo_color_t color;

1026

    cairo_solid_pattern_t solid;

1027

1028

    _cairo_color_init_rgba (&color, 0, 0, 0, info->opacity * coverage);

1029

    _cairo_pattern_init_solid (&solid, &color);

1030

    mask = compositor->pattern_to_surface (info->dst, &solid.base, TRUE,

1031

					   &_cairo_unbounded_rectangle,

1032

					   &_cairo_unbounded_rectangle,

1033

					   &mask_x, &mask_y);

1034

    if (likely (mask->status == CAIRO_STATUS_SUCCESS)) {

1035

	if (info->src) {

1036

	    compositor->composite (info->dst, info->op, info->src, mask,

1037

				   x + info->src_x,  y + info->src_y,

1038

				   mask_x,           mask_y,

1039

				   x,                y,

1040

				   w,                h);

1041

	} else {

1042

	    compositor->composite (info->dst, info->op, mask, NULL,

1043

				   mask_x,            mask_y,

1044

				   0,                 0,

1045

				   x,                 y,

1046

				   w,                 h);

1047

1048

1049

1050

    cairo_surface_destroy (mask);

1051

1052

1053

static cairo_int_status_t

1054

composite_opacity_boxes (const cairo_mask_compositor_t *compositor,

1055

			 cairo_surface_t		*dst,

1056

			 void				*closure,

1057

			 cairo_operator_t		 op,

1058

			 const cairo_pattern_t		*src_pattern,

1059

			 const cairo_rectangle_int_t	*src_sample,

1060

			 int				 dst_x,

1061

			 int				 dst_y,

1062

			 const cairo_rectangle_int_t	*extents,

1063

			 cairo_clip_t			*clip)

1064

1065

    const cairo_solid_pattern_t *mask_pattern = closure;

1066

    struct composite_opacity_info info;

1067

    int i;

1068

1069

    assert (clip);

1070

1071

    info.compositor = compositor;

1072

    info.op = op;

1073

    info.dst = dst;

1074

1075

    if (src_pattern != NULL) {

1076

	info.src = compositor->pattern_to_surface (dst, src_pattern, FALSE,

1077

						   extents, src_sample,

1078

						   &info.src_x, &info.src_y);

1079

	if (unlikely (info.src->status))

1080

	    return info.src->status;

1081

    } else

1082

	info.src = NULL;

1083

1084

    info.opacity = mask_pattern->color.alpha / (double) 0xffff;

1085

1086

    /* XXX for lots of boxes create a clip region for the fully opaque areas */

1087

    for (i = 0; i < clip->num_boxes; i++)

1088

	do_unaligned_box(composite_opacity, &info,

1089

			 &clip->boxes[i], dst_x, dst_y);

1090

    cairo_surface_destroy (info.src);

1091

1092

    return CAIRO_STATUS_SUCCESS;

1093

1094

1095

struct composite_box_info {

1096

    const cairo_mask_compositor_t *compositor;

1097

    cairo_surface_t *dst;

1098

    cairo_surface_t *src;

1099

    int src_x, src_y;

1100

    uint8_t op;

1101

};

1102

1103

static void composite_box(void *closure,

1104

			  int16_t x, int16_t y,

1105

			  int16_t w, int16_t h,

1106

			  uint16_t coverage)

1107

1108

    struct composite_box_info *info = closure;

1109

    const cairo_mask_compositor_t *compositor = info->compositor;

1110

1111

    if (! CAIRO_ALPHA_SHORT_IS_OPAQUE (coverage)) {

1112

	cairo_surface_t *mask;

1113

	cairo_color_t color;

1114

	cairo_solid_pattern_t solid;

1115

	int mask_x, mask_y;

1116

1117

	_cairo_color_init_rgba (&color, 0, 0, 0, coverage / (double)0xffff);

1118

	_cairo_pattern_init_solid (&solid, &color);

1119

1120

	mask = compositor->pattern_to_surface (info->dst, &solid.base, FALSE,

1121

					       &_cairo_unbounded_rectangle,

1122

					       &_cairo_unbounded_rectangle,

1123

					       &mask_x, &mask_y);

1124

1125

	if (likely (mask->status == CAIRO_STATUS_SUCCESS)) {

1126

	    compositor->composite (info->dst, info->op, info->src, mask,

1127

				   x + info->src_x,  y + info->src_y,

1128

				   mask_x,           mask_y,

1129

				   x,                y,

1130

				   w,                h);

1131

1132

1133

	cairo_surface_destroy (mask);

1134

    } else {

1135

	compositor->composite (info->dst, info->op, info->src, NULL,

1136

			       x + info->src_x,  y + info->src_y,

1137

			       0,                0,

1138

			       x,                y,

1139

			       w,                h);

1140

1141

1142

1143

static cairo_int_status_t

1144

composite_mask_clip_boxes (const cairo_mask_compositor_t *compositor,

1145

			   cairo_surface_t		*dst,

1146

			   void				*closure,

1147

			   cairo_operator_t		 op,

1148

			   const cairo_pattern_t	*src_pattern,

1149

			   const cairo_rectangle_int_t	*src_sample,

1150

			   int				 dst_x,

1151

			   int				 dst_y,

1152

			   const cairo_rectangle_int_t	*extents,

1153

			   cairo_clip_t			*clip)

1154

1155

    cairo_composite_rectangles_t *composite = closure;

1156

    struct composite_box_info info;

1157

    int i;

1158

1159

    assert (src_pattern == NULL);

1160

    assert (op == CAIRO_OPERATOR_SOURCE);

1161

1162

    info.compositor = compositor;

1163

    info.op = CAIRO_OPERATOR_SOURCE;

1164

    info.dst = dst;

1165

    info.src = compositor->pattern_to_surface (dst,

1166

					       &composite->mask_pattern.base,

1167

					       FALSE, extents,

1168

					       &composite->mask_sample_area,

1169

					       &info.src_x, &info.src_y);

1170

    if (unlikely (info.src->status))

1171

	return info.src->status;

1172

1173

    info.src_x += dst_x;

1174

    info.src_y += dst_y;

1175

1176

    for (i = 0; i < clip->num_boxes; i++)

1177

	do_unaligned_box(composite_box, &info, &clip->boxes[i], dst_x, dst_y);

1178

1179

    cairo_surface_destroy (info.src);

1180

1181

    return CAIRO_STATUS_SUCCESS;

1182

1183

1184

static cairo_int_status_t

1185

composite_mask (const cairo_mask_compositor_t *compositor,

1186

		cairo_surface_t			*dst,

1187

		void				*closure,

1188

		cairo_operator_t		 op,

1189

		const cairo_pattern_t		*src_pattern,

1190

		const cairo_rectangle_int_t	*src_sample,

1191

		int				 dst_x,

1192

		int				 dst_y,

1193

		const cairo_rectangle_int_t	*extents,

1194

		cairo_clip_t			*clip)

1195

1196

    cairo_composite_rectangles_t *composite = closure;

1197

    cairo_surface_t *src, *mask;

1198

    int src_x, src_y;

1199

    int mask_x, mask_y;

1200

1201

    if (src_pattern != NULL) {

1202

	src = compositor->pattern_to_surface (dst, src_pattern, FALSE,

1203

					      extents, src_sample,

1204

					      &src_x, &src_y);

1205

	if (unlikely (src->status))

1206

	    return src->status;

1207

1208

	mask = compositor->pattern_to_surface (dst, &composite->mask_pattern.base, TRUE,

1209

					       extents, &composite->mask_sample_area,

1210

					       &mask_x, &mask_y);

1211

	if (unlikely (mask->status)) {

1212

	    cairo_surface_destroy (src);

1213

	    return mask->status;

1214

1215

1216

	compositor->composite (dst, op, src, mask,

1217

			       extents->x + src_x,  extents->y + src_y,

1218

			       extents->x + mask_x, extents->y + mask_y,

1219

			       extents->x - dst_x,  extents->y - dst_y,

1220

			       extents->width,      extents->height);

1221

1222

	cairo_surface_destroy (mask);

1223

	cairo_surface_destroy (src);

1224

    } else {

1225

	src = compositor->pattern_to_surface (dst, &composite->mask_pattern.base, FALSE,

1226

					      extents, &composite->mask_sample_area,

1227

					      &src_x, &src_y);

1228

	if (unlikely (src->status))

1229

	    return src->status;

1230

1231

	compositor->composite (dst, op, src, NULL,

1232

			       extents->x + src_x,  extents->y + src_y,

1233

			       0, 0,

1234

			       extents->x - dst_x,  extents->y - dst_y,

1235

			       extents->width,      extents->height);

1236

1237

	cairo_surface_destroy (src);

1238

1239

1240

    return CAIRO_STATUS_SUCCESS;

1241

1242

1243

static cairo_int_status_t

1244

_cairo_mask_compositor_mask (const cairo_compositor_t *_compositor,

1245

			     cairo_composite_rectangles_t *extents)

1246

1247

    const cairo_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor;

1248

    cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED;

1249

1250

    status = compositor->check_composite (extents);

1251

    if (unlikely (status))

1252

	return status;

1253

1254

    if (extents->mask_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID &&

1255

	extents->clip->path == NULL &&

1256

	_cairo_clip_is_region (extents->clip)) {

1257

	status = clip_and_composite (compositor,

1258

				     composite_opacity_boxes,

1259

				     composite_opacity_boxes,

1260

				     &extents->mask_pattern.solid,

1261

				     extents, need_unbounded_clip (extents));

1262

    } else {

1263

	status = clip_and_composite (compositor,

1264

				     composite_mask,

1265

				     extents->clip->path == NULL ? composite_mask_clip_boxes : NULL,

1266

				     extents,

1267

				     extents, need_bounded_clip (extents));

1268

1269

1270

    return status;

1271

1272

1273

static cairo_int_status_t

1274

_cairo_mask_compositor_stroke (const cairo_compositor_t *_compositor,

1275

			       cairo_composite_rectangles_t *extents,

1276

			       const cairo_path_fixed_t	*path,

1277

			       const cairo_stroke_style_t	*style,

1278

			       const cairo_matrix_t	*ctm,

1279

			       const cairo_matrix_t	*ctm_inverse,

1280

			       double		 tolerance,

1281

			       cairo_antialias_t	 antialias)

1282

1283

    const cairo_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor;

1284

    cairo_surface_t *mask;

1285

    cairo_surface_pattern_t pattern;

1286

    cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED;

1287

1288

    status = compositor->check_composite (extents);

1289

    if (unlikely (status))

1290

	return status;

1291

1292

    if (_cairo_path_fixed_stroke_is_rectilinear (path)) {

1293

	cairo_boxes_t boxes;

1294

1295

	_cairo_boxes_init_with_clip (&boxes, extents->clip);

1296

	status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path,

1297

								style,

1298

								ctm,

1299

								antialias,

1300

								&boxes);

1301

	if (likely (status == CAIRO_INT_STATUS_SUCCESS))

1302

	    status = clip_and_composite_boxes (compositor, extents, &boxes);

1303

	_cairo_boxes_fini (&boxes);

1304

1305

1306

1307

    if (status == CAIRO_INT_STATUS_UNSUPPORTED) {

1308

	mask = cairo_surface_create_similar_image (extents->surface,

1309

						   CAIRO_FORMAT_A8,

1310

						   extents->bounded.width,

1311

						   extents->bounded.height);

1312

	if (unlikely (mask->status))

1313

	    return mask->status;

1314

1315

	status = _cairo_surface_offset_stroke (mask,

1316

					       extents->bounded.x,

1317

					       extents->bounded.y,

1318

					       CAIRO_OPERATOR_ADD,

1319

					       &_cairo_pattern_white.base,

1320

					       path, style, ctm, ctm_inverse,

1321

					       tolerance, antialias,

1322

					       extents->clip);

1323

	if (unlikely (status)) {

1324

	    cairo_surface_destroy (mask);

1325

	    return status;

1326

1327

1328

	_cairo_pattern_init_for_surface (&pattern, mask);

1329

	cairo_surface_destroy (mask);

1330

1331

	cairo_matrix_init_translate (&pattern.base.matrix,

1332

				     -extents->bounded.x,

1333

				     -extents->bounded.y);

1334

	pattern.base.filter = CAIRO_FILTER_NEAREST;

1335

	pattern.base.extend = CAIRO_EXTEND_NONE;

1336

	status = _cairo_surface_mask (extents->surface,

1337

				      extents->op,

1338

				      &extents->source_pattern.base,

1339

				      &pattern.base,

1340

				      extents->clip);

1341

	_cairo_pattern_fini (&pattern.base);

1342

1343

1344

    return status;

1345

1346

1347

static cairo_int_status_t

1348

_cairo_mask_compositor_fill (const cairo_compositor_t *_compositor,

1349

			     cairo_composite_rectangles_t *extents,

1350

			     const cairo_path_fixed_t	*path,

1351

			     cairo_fill_rule_t	 fill_rule,

1352

			     double			 tolerance,

1353

			     cairo_antialias_t	 antialias)

1354

1355

    const cairo_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor;

1356

    cairo_surface_t *mask;

1357

    cairo_surface_pattern_t pattern;

1358

    cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED;

1359

1360

    status = compositor->check_composite (extents);

1361

    if (unlikely (status))

1362

	return status;

1363

1364

    if (_cairo_path_fixed_fill_is_rectilinear (path)) {

1365

	cairo_boxes_t boxes;

1366

1367

	_cairo_boxes_init_with_clip (&boxes, extents->clip);

1368

	status = _cairo_path_fixed_fill_rectilinear_to_boxes (path,

1369

							      fill_rule,

1370

							      antialias,

1371

							      &boxes);

1372

	if (likely (status == CAIRO_INT_STATUS_SUCCESS))

1373

	    status = clip_and_composite_boxes (compositor, extents, &boxes);

1374

	_cairo_boxes_fini (&boxes);

1375

1376

1377

    if (status == CAIRO_INT_STATUS_UNSUPPORTED) {

1378

	mask = cairo_surface_create_similar_image (extents->surface,

1379

						   CAIRO_FORMAT_A8,

1380

						   extents->bounded.width,

1381

						   extents->bounded.height);

1382

	if (unlikely (mask->status))

1383

	    return mask->status;

1384

1385

	status = _cairo_surface_offset_fill (mask,

1386

					     extents->bounded.x,

1387

					     extents->bounded.y,

1388

					     CAIRO_OPERATOR_ADD,

1389

					     &_cairo_pattern_white.base,

1390

					     path, fill_rule, tolerance, antialias,

1391

					     extents->clip);

1392

	if (unlikely (status)) {

1393

	    cairo_surface_destroy (mask);

1394

	    return status;

1395

1396

1397

	_cairo_pattern_init_for_surface (&pattern, mask);

1398

	cairo_surface_destroy (mask);

1399

1400

	cairo_matrix_init_translate (&pattern.base.matrix,

1401

				     -extents->bounded.x,

1402

				     -extents->bounded.y);

1403

	pattern.base.filter = CAIRO_FILTER_NEAREST;

1404

	pattern.base.extend = CAIRO_EXTEND_NONE;

1405

	status = _cairo_surface_mask (extents->surface,

1406

				      extents->op,

1407

				      &extents->source_pattern.base,

1408

				      &pattern.base,

1409

				      extents->clip);

1410

	_cairo_pattern_fini (&pattern.base);

1411

1412

1413

    return status;

1414

1415

1416

static cairo_int_status_t

1417

_cairo_mask_compositor_glyphs (const cairo_compositor_t *_compositor,

1418

			       cairo_composite_rectangles_t *extents,

1419

			       cairo_scaled_font_t	*scaled_font,

1420

			       cairo_glyph_t		*glyphs,

1421

			       int			 num_glyphs,

1422

			       cairo_bool_t		 overlap)

1423

1424

    const cairo_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor;

1425

    cairo_surface_t *mask;

1426

    cairo_surface_pattern_t pattern;

1427

    cairo_int_status_t status;

1428

1429

    status = compositor->check_composite (extents);

1430

    if (unlikely (status))

1431

	return CAIRO_INT_STATUS_UNSUPPORTED;

1432

1433

    mask = cairo_surface_create_similar_image (extents->surface,

1434

					       CAIRO_FORMAT_A8,

1435

					       extents->bounded.width,

1436

					       extents->bounded.height);

1437

    if (unlikely (mask->status))

1438

	return mask->status;

1439

1440

    status = _cairo_surface_offset_glyphs (mask,

1441

					   extents->bounded.x,

1442

					   extents->bounded.y,

1443

					   CAIRO_OPERATOR_ADD,

1444

					   &_cairo_pattern_white.base,

1445

					   scaled_font, glyphs, num_glyphs,

1446

					   extents->clip);

1447

    if (unlikely (status)) {

1448

	cairo_surface_destroy (mask);

1449

	return status;

1450

1451

1452

    _cairo_pattern_init_for_surface (&pattern, mask);

1453

    cairo_surface_destroy (mask);

1454

1455

    cairo_matrix_init_translate (&pattern.base.matrix,

1456

				 -extents->bounded.x,

1457

				 -extents->bounded.y);

1458

    pattern.base.filter = CAIRO_FILTER_NEAREST;

1459

    pattern.base.extend = CAIRO_EXTEND_NONE;

1460

    status = _cairo_surface_mask (extents->surface,

1461

				  extents->op,

1462

				  &extents->source_pattern.base,

1463

				  &pattern.base,

1464

				  extents->clip);

1465

    _cairo_pattern_fini (&pattern.base);

1466

1467

    return status;

1468

1469

1470

void

1471

4

_cairo_mask_compositor_init (cairo_mask_compositor_t *compositor,

1472

			     const cairo_compositor_t *delegate)

1473

1474

4

    compositor->base.delegate = delegate;

1475

1476

4

    compositor->base.paint = _cairo_mask_compositor_paint;

1477

4

    compositor->base.mask  = _cairo_mask_compositor_mask;

1478

4

    compositor->base.fill  = _cairo_mask_compositor_fill;

1479

4

    compositor->base.stroke = _cairo_mask_compositor_stroke;

1480

4

    compositor->base.glyphs = _cairo_mask_compositor_glyphs;

1481

4