Grcov report - cairo-xcb-surface-render.c

1

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

2

3

 * Copyright © 2009 Intel Corporation

4

5

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

6

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

7

 * License version 2.1 as published by the Free Software Foundation

8

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

9

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

10

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

11

 * the MPL or the LGPL.

12

13

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

14

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

15

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

16

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

17

 * in the file COPYING-MPL-1.1

18

19

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

20

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

21

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

22

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

23

24

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

25

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

26

 * the specific language governing rights and limitations.

27

28

 * Contributor(s):

29

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

30

*/

31

32

#include "cairoint.h"

33

34

#include "cairo-xcb-private.h"

35

36

#include "cairo-boxes-private.h"

37

#include "cairo-clip-inline.h"

38

#include "cairo-clip-private.h"

39

#include "cairo-composite-rectangles-private.h"

40

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

41

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

42

#include "cairo-list-inline.h"

43

#include "cairo-region-private.h"

44

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

45

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

46

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

47

#include "cairo-traps-private.h"

48

#include "cairo-recording-surface-inline.h"

49

#include "cairo-paginated-private.h"

50

#include "cairo-pattern-inline.h"

51

52

#define PIXMAN_MAX_INT ((pixman_fixed_1 >> 1) - pixman_fixed_e) /* need to ensure deltas also fit */

53

54

static cairo_status_t

55

_clip_and_composite_boxes (cairo_xcb_surface_t *dst,

56

			   cairo_operator_t op,

57

			   const cairo_pattern_t *src,

58

			   cairo_boxes_t *boxes,

59

			   cairo_composite_rectangles_t *extents);

60

61

static inline cairo_xcb_connection_t *

62

3

_picture_to_connection (cairo_xcb_picture_t *picture)

63

64

3

    return (cairo_xcb_connection_t *) picture->base.device;

65

66

67

static void

68

_cairo_xcb_surface_ensure_picture (cairo_xcb_surface_t *surface);

69

70

static uint32_t

71

hars_petruska_f54_1_random (void)

72

73

#define rol(x,k) ((x << k) | (x >> (32-k)))

74

    static uint32_t x;

75

    return x = (x ^ rol (x, 5) ^ rol (x, 24)) + 0x37798849;

76

#undef rol

77

78

79

static cairo_status_t

80

3

_cairo_xcb_picture_finish (void *abstract_surface)

81

82

3

    cairo_xcb_picture_t *surface = abstract_surface;

83

3

    cairo_xcb_connection_t *connection = _picture_to_connection (surface);

84

    cairo_status_t status;

85

86

3

    status = _cairo_xcb_connection_acquire (connection);

87

3

    cairo_list_del (&surface->link);

88

3

    if (unlikely (status))

89

	return status;

90

91

3

    _cairo_xcb_connection_render_free_picture (connection, surface->picture);

92

93

3

    _cairo_xcb_connection_release (connection);

94

95

3

    return CAIRO_STATUS_SUCCESS;

96

97

98

static const cairo_surface_backend_t _cairo_xcb_picture_backend = {

99

    CAIRO_SURFACE_TYPE_XCB,

100

    _cairo_xcb_picture_finish,

101

};

102

103

static const struct xcb_render_transform_t identity_transform = {

104

    1 << 16, 0, 0,

105

    0, 1 << 16, 0,

106

    0, 0, 1 << 16,

107

};

108

109

static cairo_xcb_picture_t *

110

3

_cairo_xcb_picture_create (cairo_xcb_screen_t *screen,

111

			   pixman_format_code_t pixman_format,

112

			   xcb_render_pictformat_t xrender_format,

113

			   int width, int height)

114

115

    cairo_xcb_picture_t *surface;

116

117

3

    surface = _cairo_calloc (sizeof (cairo_xcb_picture_t));

118

3

    if (unlikely (surface == NULL))

119

	return (cairo_xcb_picture_t *)

120

	    _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));

121

122

3

    _cairo_surface_init (&surface->base,

123

			 &_cairo_xcb_picture_backend,

124

3

			 &screen->connection->device,

125

			 _cairo_content_from_pixman_format (pixman_format),

126

			 FALSE); /* is_vector */

127

128

3

    cairo_list_add (&surface->link, &screen->pictures);

129

130

3

    surface->screen = screen;

131

3

    surface->picture = xcb_generate_id (screen->connection->xcb_connection);

132

3

    surface->pixman_format = pixman_format;

133

3

    surface->xrender_format = xrender_format;

134

135

3

    surface->x0 = surface->y0 = 0;

136

3

    surface->x = surface->y = 0;

137

3

    surface->width = width;

138

3

    surface->height = height;

139

140

3

    surface->transform = identity_transform;

141

3

    surface->extend = CAIRO_EXTEND_NONE;

142

3

    surface->filter = CAIRO_FILTER_NEAREST;

143

3

    surface->has_component_alpha = FALSE;

144

145

3

    return surface;

146

147

148

static inline cairo_bool_t

149

33

_operator_is_supported (uint32_t flags, cairo_operator_t op)

150

151

33

    if (op <= CAIRO_OPERATOR_SATURATE)

152

33

	return TRUE;

153

154

    /* Can we use PDF operators? */

155

#if CAIRO_XCB_RENDER_AT_LEAST(0, 11)

156

    if (op <= CAIRO_OPERATOR_HSL_LUMINOSITY)

157

	return flags & CAIRO_XCB_RENDER_HAS_PDF_OPERATORS;

158

#endif

159

160

    return FALSE;

161

162

163

static int

164

33

_render_operator (cairo_operator_t op)

165

166

#define C(x,y) case CAIRO_OPERATOR_##x: return XCB_RENDER_PICT_OP_##y

167

33

    switch (op) {

168

6

    C(CLEAR, CLEAR);

169

27

    C(SOURCE, SRC);

170

171

    C(OVER, OVER);

172

    C(IN, IN);

173

    C(OUT, OUT);

174

    C(ATOP, ATOP);

175

176

    C(DEST, DST);

177

    C(DEST_OVER, OVER_REVERSE);

178

    C(DEST_IN, IN_REVERSE);

179

    C(DEST_OUT, OUT_REVERSE);

180

    C(DEST_ATOP, ATOP_REVERSE);

181

182

    C(XOR, XOR);

183

    C(ADD, ADD);

184

    C(SATURATE, SATURATE);

185

186

    /* PDF operators were added in RENDER 0.11, check if the xcb headers have

187

     * the defines, else fall through to the default case. */

188

#if CAIRO_XCB_RENDER_AT_LEAST(0, 11)

189

#define BLEND(x,y) C(x,y)

190

#else

191

#define BLEND(x,y) case CAIRO_OPERATOR_##x:

192

#endif

193

    BLEND(MULTIPLY, MULTIPLY);

194

    BLEND(SCREEN, SCREEN);

195

    BLEND(OVERLAY, OVERLAY);

196

    BLEND(DARKEN, DARKEN);

197

    BLEND(LIGHTEN, LIGHTEN);

198

    BLEND(COLOR_DODGE, COLOR_DODGE);

199

    BLEND(COLOR_BURN, COLOR_BURN);

200

    BLEND(HARD_LIGHT, HARD_LIGHT);

201

    BLEND(SOFT_LIGHT, SOFT_LIGHT);

202

    BLEND(DIFFERENCE, DIFFERENCE);

203

    BLEND(EXCLUSION, EXCLUSION);

204

    BLEND(HSL_HUE, HSL_HUE);

205

    BLEND(HSL_SATURATION, HSL_SATURATION);

206

    BLEND(HSL_COLOR, HSL_COLOR);

207

    BLEND(HSL_LUMINOSITY, HSL_LUMINOSITY);

208

209

    default:

210

	ASSERT_NOT_REACHED;

211

	return XCB_RENDER_PICT_OP_OVER;

212

213

214

215

static cairo_status_t

216

_cairo_xcb_surface_set_clip_region (cairo_xcb_surface_t *surface,

217

				    cairo_region_t	*region)

218

219

    xcb_rectangle_t stack_rects[CAIRO_STACK_ARRAY_LENGTH (xcb_rectangle_t)];

220

    xcb_rectangle_t *rects = stack_rects;

221

    int i, num_rects;

222

223

    num_rects = cairo_region_num_rectangles (region);

224

225

    if (num_rects > ARRAY_LENGTH (stack_rects)) {

226

	rects = _cairo_malloc_ab (num_rects, sizeof (xcb_rectangle_t));

227

	if (unlikely (rects == NULL)) {

228

	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);

229

230

231

232

    for (i = 0; i < num_rects; i++) {

233

	cairo_rectangle_int_t rect;

234

235

	cairo_region_get_rectangle (region, i, &rect);

236

237

	rects[i].x = rect.x;

238

	rects[i].y = rect.y;

239

	rects[i].width  = rect.width;

240

	rects[i].height = rect.height;

241

242

243

    _cairo_xcb_connection_render_set_picture_clip_rectangles (surface->connection,

244

							      surface->picture,

245

							      0, 0,

246

							      num_rects, rects);

247

248

    if (rects != stack_rects)

249

	free (rects);

250

251

    return CAIRO_STATUS_SUCCESS;

252

253

254

static void

255

_cairo_xcb_surface_clear_clip_region (cairo_xcb_surface_t *surface)

256

257

    uint32_t values[] = { XCB_NONE };

258

    _cairo_xcb_connection_render_change_picture (surface->connection,

259

						 surface->picture,

260

						 XCB_RENDER_CP_CLIP_MASK,

261

						 values);

262

263

264

static void

265

_cairo_xcb_surface_set_precision (cairo_xcb_surface_t	*surface,

266

				  cairo_antialias_t	 antialias)

267

268

    cairo_xcb_connection_t *connection = surface->connection;

269

    uint32_t precision;

270

271

    if (connection->force_precision != -1)

272

	    precision = connection->force_precision;

273

    else switch (antialias) {

274

    default:

275

    case CAIRO_ANTIALIAS_DEFAULT:

276

    case CAIRO_ANTIALIAS_GRAY:

277

    case CAIRO_ANTIALIAS_NONE:

278

    case CAIRO_ANTIALIAS_FAST:

279

    case CAIRO_ANTIALIAS_GOOD:

280

	precision = XCB_RENDER_POLY_MODE_IMPRECISE;

281

	break;

282

    case CAIRO_ANTIALIAS_SUBPIXEL:

283

    case CAIRO_ANTIALIAS_BEST:

284

	precision = XCB_RENDER_POLY_MODE_PRECISE;

285

	break;

286

287

288

    if (surface->precision != precision) {

289

	_cairo_xcb_connection_render_change_picture (connection,

290

						     surface->picture,

291

						     XCB_RENDER_CP_POLY_MODE,

292

						     &precision);

293

	surface->precision = precision;

294

295

296

297

298

static void

299

33

_cairo_xcb_surface_ensure_picture (cairo_xcb_surface_t *surface)

300

301

33

    assert (surface->fallback == NULL);

302

33

    if (surface->picture == XCB_NONE) {

303

	uint32_t values[1];

304

6

	uint32_t flags = 0;

305

306

6

	if (surface->precision != XCB_RENDER_POLY_MODE_PRECISE) {

307

6

	    flags |= XCB_RENDER_CP_POLY_MODE;

308

6

	    values[0] = surface->precision;

309

310

311

6

	surface->picture = xcb_generate_id (surface->connection->xcb_connection);

312

6

	_cairo_xcb_connection_render_create_picture (surface->connection,

313

						     surface->picture,

314

						     surface->drawable,

315

						     surface->xrender_format,

316

						     flags, values);

317

318

33

319

320

static cairo_xcb_picture_t *

321

_picture_from_image (cairo_xcb_surface_t *target,

322

		     xcb_render_pictformat_t format,

323

		     cairo_image_surface_t *image,

324

		     cairo_xcb_shm_info_t *shm_info)

325

326

    xcb_pixmap_t pixmap;

327

    xcb_gcontext_t gc;

328

    cairo_xcb_picture_t *picture;

329

330

    pixmap = _cairo_xcb_connection_create_pixmap (target->connection,

331

						  image->depth,

332

						  target->drawable,

333

						  image->width, image->height);

334

335

    gc = _cairo_xcb_screen_get_gc (target->screen, pixmap, image->depth);

336

337

    if (shm_info != NULL) {

338

	_cairo_xcb_connection_shm_put_image (target->connection,

339

					     pixmap, gc,

340

					     image->width, image->height,

341

					     0, 0,

342

					     image->width, image->height,

343

					     0, 0,

344

					     image->depth,

345

					     shm_info->shm,

346

					     shm_info->offset);

347

    } else {

348

	int len;

349

350

	/* Do we need to trim the image? */

351

	len = CAIRO_STRIDE_FOR_WIDTH_BPP (image->width, PIXMAN_FORMAT_BPP (image->pixman_format));

352

	if (len == image->stride) {

353

	    _cairo_xcb_connection_put_image (target->connection,

354

					     pixmap, gc,

355

					     image->width, image->height,

356

					     0, 0,

357

					     image->depth,

358

					     image->stride,

359

					     image->data);

360

	} else {

361

	    _cairo_xcb_connection_put_subimage (target->connection,

362

						pixmap, gc,

363

						0, 0,

364

						image->width, image->height,

365

						PIXMAN_FORMAT_BPP (image->pixman_format) / 8,

366

						image->stride,

367

						0, 0,

368

						image->depth,

369

						image->data);

370

371

372

373

374

    _cairo_xcb_screen_put_gc (target->screen, image->depth, gc);

375

376

    picture = _cairo_xcb_picture_create (target->screen,

377

					 image->pixman_format, format,

378

					 image->width, image->height);

379

    if (likely (picture->base.status == CAIRO_STATUS_SUCCESS)) {

380

	_cairo_xcb_connection_render_create_picture (target->connection,

381

						     picture->picture, pixmap, format,

382

						     0, 0);

383

384

385

    xcb_free_pixmap (target->connection->xcb_connection, pixmap);

386

387

    return picture;

388

389

390

static cairo_bool_t

391

3

_pattern_is_supported (uint32_t flags,

392

		       const cairo_pattern_t *pattern)

393

394

395

3

    if (pattern->type == CAIRO_PATTERN_TYPE_SOLID)

396

	return TRUE;

397

398

3

    switch (pattern->extend) {

399

    default:

400

	ASSERT_NOT_REACHED;

401

    case CAIRO_EXTEND_NONE:

402

    case CAIRO_EXTEND_REPEAT:

403

3

	break;

404

    case CAIRO_EXTEND_PAD:

405

    case CAIRO_EXTEND_REFLECT:

406

	if ((flags & CAIRO_XCB_RENDER_HAS_EXTENDED_REPEAT) == 0)

407

	    return FALSE;

408

409

410

3

    if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE) {

411

3

	switch (pattern->filter) {

412

3

	case CAIRO_FILTER_FAST:

413

	case CAIRO_FILTER_NEAREST:

414

3

	    return (flags & CAIRO_XCB_RENDER_HAS_PICTURE_TRANSFORM) ||

415

		_cairo_matrix_is_integer_translation (&pattern->matrix, NULL, NULL);

416

	case CAIRO_FILTER_GOOD:

417

	    return flags & CAIRO_XCB_RENDER_HAS_FILTER_GOOD;

418

	case CAIRO_FILTER_BEST:

419

	    return flags & CAIRO_XCB_RENDER_HAS_FILTER_BEST;

420

	case CAIRO_FILTER_BILINEAR:

421

	case CAIRO_FILTER_GAUSSIAN:

422

	default:

423

	    return flags & CAIRO_XCB_RENDER_HAS_FILTERS;

424

425

    } else if (pattern->type == CAIRO_PATTERN_TYPE_MESH) {

426

	return FALSE;

427

    } else { /* gradient */

428

	if ((flags & CAIRO_XCB_RENDER_HAS_GRADIENTS) == 0)

429

	    return FALSE;

430

431

	/* The RENDER specification says that the inner circle has to be

432

	 * completely contained inside the outer one. */

433

	if (pattern->type == CAIRO_PATTERN_TYPE_RADIAL &&

434

	    ! _cairo_radial_pattern_focus_is_inside ((cairo_radial_pattern_t *) pattern))

435

436

	    return FALSE;

437

438

	return TRUE;

439

440

441

442

static void

443

3

_cairo_xcb_picture_set_matrix (cairo_xcb_picture_t *picture,

444

			       const cairo_matrix_t *matrix,

445

			       cairo_filter_t filter,

446

			       double xc, double yc)

447

448

    xcb_render_transform_t transform;

449

    pixman_transform_t *pixman_transform;

450

    cairo_int_status_t ignored;

451

452

    /* Casting between pixman_transform_t and xcb_render_transform_t is safe

453

     * because they happen to be the exact same type.

454

*/

455

3

    pixman_transform = (pixman_transform_t *) &transform;

456

457

3

    picture->x = picture->x0;

458

3

    picture->y = picture->y0;

459

3

    ignored = _cairo_matrix_to_pixman_matrix_offset (matrix, filter, xc, yc,

460

						     pixman_transform,

461

						     &picture->x, &picture->y);

462

    (void) ignored;

463

464

3

    if (memcmp (&picture->transform, &transform, sizeof (xcb_render_transform_t))) {

465

	_cairo_xcb_connection_render_set_picture_transform (_picture_to_connection (picture),

466

							    picture->picture,

467

							    &transform);

468

469

	picture->transform = transform;

470

471

3

472

473

static void

474

3

_cairo_xcb_picture_set_filter (cairo_xcb_picture_t *picture,

475

			       cairo_filter_t filter)

476

477

    const char *render_filter;

478

    int len;

479

480

3

    if (picture->filter == filter)

481

3

	return;

482

483

    switch (filter) {

484

    case CAIRO_FILTER_FAST:

485

	render_filter = "fast";

486

	len = strlen ("fast");

487

	break;

488

489

    case CAIRO_FILTER_GOOD:

490

	render_filter = "good";

491

	len = strlen ("good");

492

	break;

493

494

    case CAIRO_FILTER_BEST:

495

	render_filter = "best";

496

	len = strlen ("best");

497

	break;

498

499

    case CAIRO_FILTER_NEAREST:

500

	render_filter = "nearest";

501

	len = strlen ("nearest");

502

	break;

503

504

    case CAIRO_FILTER_BILINEAR:

505

	render_filter = "bilinear";

506

	len = strlen ("bilinear");

507

	break;

508

509

    default:

510

	ASSERT_NOT_REACHED;

511

    case CAIRO_FILTER_GAUSSIAN:

512

	render_filter = "best";

513

	len = strlen ("best");

514

	break;

515

516

517

    _cairo_xcb_connection_render_set_picture_filter (_picture_to_connection (picture),

518

						     picture->picture,

519

						     len, (char *) render_filter);

520

    picture->filter = filter;

521

522

523

static void

524

3

_cairo_xcb_picture_set_extend (cairo_xcb_picture_t *picture,

525

			       cairo_extend_t extend)

526

527

    uint32_t pa[1];

528

529

3

    if (picture->extend == extend)

530

3

	return;

531

532

    switch (extend) {

533

    default:

534

	ASSERT_NOT_REACHED;

535

    case CAIRO_EXTEND_NONE:

536

	pa[0] = XCB_RENDER_REPEAT_NONE;

537

	break;

538

539

    case CAIRO_EXTEND_REPEAT:

540

	pa[0] = XCB_RENDER_REPEAT_NORMAL;

541

	break;

542

543

    case CAIRO_EXTEND_REFLECT:

544

	pa[0] = XCB_RENDER_REPEAT_REFLECT;

545

	break;

546

547

    case CAIRO_EXTEND_PAD:

548

	pa[0] = XCB_RENDER_REPEAT_PAD;

549

	break;

550

551

552

    _cairo_xcb_connection_render_change_picture (_picture_to_connection (picture),

553

						 picture->picture,

554

						 XCB_RENDER_CP_REPEAT, pa);

555

    picture->extend = extend;

556

557

558

static void

559

3

_cairo_xcb_picture_set_component_alpha (cairo_xcb_picture_t *picture,

560

					cairo_bool_t ca)

561

562

    uint32_t pa[1];

563

564

3

    if (picture->has_component_alpha == ca)

565

3

	return;

566

567

    pa[0] = ca;

568

569

    _cairo_xcb_connection_render_change_picture (_picture_to_connection (picture),

570

						 picture->picture,

571

						 XCB_RENDER_CP_COMPONENT_ALPHA,

572

						 pa);

573

    picture->has_component_alpha = ca;

574

575

576

static cairo_xcb_picture_t *

577

_solid_picture (cairo_xcb_surface_t *target,

578

		const cairo_color_t *color)

579

580

    xcb_render_color_t xcb_color;

581

    xcb_render_pictformat_t xrender_format;

582

    cairo_xcb_picture_t *picture;

583

584

    xcb_color.red   = color->red_short;

585

    xcb_color.green = color->green_short;

586

    xcb_color.blue  = color->blue_short;

587

    xcb_color.alpha = color->alpha_short;

588

589

    xrender_format = target->screen->connection->standard_formats[CAIRO_FORMAT_ARGB32];

590

    picture = _cairo_xcb_picture_create (target->screen,

591

					 PIXMAN_a8r8g8b8,

592

					 xrender_format,

593

					 -1, -1);

594

    if (unlikely (picture->base.status))

595

	return picture;

596

597

    if (target->connection->flags & CAIRO_XCB_RENDER_HAS_GRADIENTS) {

598

	_cairo_xcb_connection_render_create_solid_fill (target->connection,

599

							picture->picture,

600

							xcb_color);

601

    } else {

602

	xcb_pixmap_t pixmap;

603

	uint32_t values[] = { XCB_RENDER_REPEAT_NORMAL };

604

605

	pixmap = _cairo_xcb_connection_create_pixmap (target->connection,

606

						      32, target->drawable, 1, 1);

607

	_cairo_xcb_connection_render_create_picture (target->connection,

608

						     picture->picture,

609

						     pixmap,

610

						     xrender_format,

611

						     XCB_RENDER_CP_REPEAT,

612

						     values);

613

	if (target->connection->flags & CAIRO_XCB_RENDER_HAS_FILL_RECTANGLES) {

614

	    xcb_rectangle_t rect;

615

616

	    rect.x = rect.y = 0;

617

	    rect.width = rect.height = 1;

618

619

	    _cairo_xcb_connection_render_fill_rectangles (_picture_to_connection (picture),

620

							  XCB_RENDER_PICT_OP_SRC,

621

							  picture->picture,

622

							  xcb_color, 1, &rect);

623

	} else {

624

	    xcb_gcontext_t gc;

625

	    uint32_t pixel;

626

627

	    gc = _cairo_xcb_screen_get_gc (target->screen, pixmap, 32);

628

629

	    /* XXX byte ordering? */

630

	    pixel = (((uint32_t)color->alpha_short >> 8) << 24) |

631

		    ((color->red_short   >> 8) << 16) |

632

		    ((color->green_short >> 8) << 8) |

633

		    ((color->blue_short  >> 8) << 0);

634

635

	    _cairo_xcb_connection_put_image (target->connection,

636

					     pixmap, gc,

637

					     1, 1, 0, 0,

638

					     32, 4, &pixel);

639

640

	    _cairo_xcb_screen_put_gc (target->screen, 32, gc);

641

642

643

	xcb_free_pixmap (target->connection->xcb_connection, pixmap);

644

645

646

    return picture;

647

648

649

static cairo_xcb_picture_t *

650

_cairo_xcb_transparent_picture (cairo_xcb_surface_t *target)

651

652

    cairo_xcb_picture_t *picture;

653

654

    picture = (cairo_xcb_picture_t *) target->screen->stock_colors[CAIRO_STOCK_TRANSPARENT];

655

    if (picture == NULL) {

656

	picture = _solid_picture (target, CAIRO_COLOR_TRANSPARENT);

657

	target->screen->stock_colors[CAIRO_STOCK_TRANSPARENT] = &picture->base;

658

659

660

    return (cairo_xcb_picture_t *) cairo_surface_reference (&picture->base);

661

662

663

static cairo_xcb_picture_t *

664

_cairo_xcb_black_picture (cairo_xcb_surface_t *target)

665

666

    cairo_xcb_picture_t *picture;

667

668

    picture = (cairo_xcb_picture_t *) target->screen->stock_colors[CAIRO_STOCK_BLACK];

669

    if (picture == NULL) {

670

	picture = _solid_picture (target, CAIRO_COLOR_BLACK);

671

	target->screen->stock_colors[CAIRO_STOCK_BLACK] = &picture->base;

672

673

674

    return (cairo_xcb_picture_t *) cairo_surface_reference (&picture->base);

675

676

677

static cairo_xcb_picture_t *

678

_cairo_xcb_white_picture (cairo_xcb_surface_t *target)

679

680

    cairo_xcb_picture_t *picture;

681

682

    picture = (cairo_xcb_picture_t *) target->screen->stock_colors[CAIRO_STOCK_WHITE];

683

    if (picture == NULL) {

684

	picture = _solid_picture (target, CAIRO_COLOR_WHITE);

685

	target->screen->stock_colors[CAIRO_STOCK_WHITE] = &picture->base;

686

687

688

    return (cairo_xcb_picture_t *) cairo_surface_reference (&picture->base);

689

690

691

static cairo_xcb_picture_t *

692

_cairo_xcb_solid_picture (cairo_xcb_surface_t *target,

693

			  const cairo_solid_pattern_t *pattern)

694

695

    cairo_xcb_picture_t *picture;

696

    cairo_xcb_screen_t *screen;

697

    int i, n_cached;

698

699

    if (pattern->color.alpha_short <= 0x00ff)

700

	return _cairo_xcb_transparent_picture (target);

701

702

    if (pattern->color.alpha_short >= 0xff00) {

703

	if (pattern->color.red_short <= 0x00ff &&

704

	    pattern->color.green_short <= 0x00ff &&

705

	    pattern->color.blue_short <= 0x00ff)

706

707

	    return _cairo_xcb_black_picture (target);

708

709

710

	if (pattern->color.red_short >= 0xff00 &&

711

	    pattern->color.green_short >= 0xff00 &&

712

	    pattern->color.blue_short >= 0xff00)

713

714

	    return _cairo_xcb_white_picture (target);

715

716

717

718

    screen = target->screen;

719

    n_cached = screen->solid_cache_size;

720

    for (i = 0; i < n_cached; i++) {

721

	if (_cairo_color_equal (&screen->solid_cache[i].color, &pattern->color)) {

722

	    return (cairo_xcb_picture_t *) cairo_surface_reference (screen->solid_cache[i].picture);

723

724

725

726

    picture = _solid_picture (target, &pattern->color);

727

    if (unlikely (picture->base.status))

728

	return picture;

729

730

    if (screen->solid_cache_size < ARRAY_LENGTH (screen->solid_cache)) {

731

	i = screen->solid_cache_size++;

732

    } else {

733

	i = hars_petruska_f54_1_random () % ARRAY_LENGTH (screen->solid_cache);

734

	cairo_surface_destroy (screen->solid_cache[i].picture);

735

736

    screen->solid_cache[i].picture = cairo_surface_reference (&picture->base);

737

    screen->solid_cache[i].color = pattern->color;

738

739

    return picture;

740

741

742

static cairo_xcb_picture_t *

743

_render_to_picture (cairo_xcb_surface_t *target,

744

		    const cairo_pattern_t *pattern,

745

		    const cairo_rectangle_int_t *extents)

746

747

    cairo_image_surface_t *image;

748

    cairo_xcb_shm_info_t *shm_info;

749

    cairo_pattern_union_t copy;

750

    cairo_status_t status;

751

    cairo_xcb_picture_t *picture;

752

    pixman_format_code_t pixman_format;

753

    xcb_render_pictformat_t xrender_format;

754

755

    /* XXX handle extend modes via tiling? */

756

    /* XXX alpha-only masks? */

757

758

    pixman_format = PIXMAN_a8r8g8b8;

759

    xrender_format = target->screen->connection->standard_formats[CAIRO_FORMAT_ARGB32];

760

761

    status = _cairo_xcb_shm_image_create (target->screen->connection,

762

					  pixman_format,

763

					  extents->width, extents->height,

764

					  &image, &shm_info);

765

    if (unlikely (status))

766

	return (cairo_xcb_picture_t *) _cairo_surface_create_in_error (status);

767

768

    _cairo_pattern_init_static_copy (&copy.base, pattern);

769

    cairo_matrix_translate (&copy.base.matrix, extents->x, extents->y);

770

    status = _cairo_surface_paint (&image->base,

771

				   CAIRO_OPERATOR_SOURCE,

772

				   &copy.base,

773

				   NULL);

774

    if (unlikely (status)) {

775

	cairo_surface_destroy (&image->base);

776

	return (cairo_xcb_picture_t *) _cairo_surface_create_in_error (status);

777

778

779

    picture = _picture_from_image (target, xrender_format, image, shm_info);

780

    cairo_surface_destroy (&image->base);

781

782

    if (unlikely (picture->base.status))

783

	return picture;

784

785

    _cairo_xcb_picture_set_component_alpha (picture, pattern->has_component_alpha);

786

    picture->x = -extents->x;

787

    picture->y = -extents->y;

788

789

    return picture;

790

791

792

static xcb_render_fixed_t *

793

_gradient_to_xcb (const cairo_gradient_pattern_t *gradient,

794

		  unsigned int *n_stops,

795

		  char *buf, unsigned int buflen)

796

797

    xcb_render_fixed_t *stops;

798

    xcb_render_color_t *colors;

799

    unsigned int i;

800

801

    assert (gradient->n_stops > 0);

802

    *n_stops = MAX (gradient->n_stops, 2);

803

804

    if (*n_stops * (sizeof (xcb_render_fixed_t) + sizeof (xcb_render_color_t)) < buflen)

805

806

	stops = (xcb_render_fixed_t *) buf;

807

808

    else

809

810

	stops =

811

	    _cairo_malloc_ab (*n_stops,

812

			      sizeof (xcb_render_fixed_t) + sizeof (xcb_render_color_t));

813

	if (unlikely (stops == NULL))

814

	    return NULL;

815

816

817

    colors = (xcb_render_color_t *) (stops + *n_stops);

818

    for (i = 0; i < gradient->n_stops; i++) {

819

	stops[i] =

820

	    _cairo_fixed_16_16_from_double (gradient->stops[i].offset);

821

822

	colors[i].red   = gradient->stops[i].color.red_short;

823

	colors[i].green = gradient->stops[i].color.green_short;

824

	colors[i].blue  = gradient->stops[i].color.blue_short;

825

	colors[i].alpha = gradient->stops[i].color.alpha_short;

826

827

828

    /* RENDER does not support gradients with less than 2 stops. If a

829

     * gradient has only a single stop, duplicate it to make RENDER

830

     * happy. */

831

    if (gradient->n_stops == 1) {

832

	stops[1] = _cairo_fixed_16_16_from_double (gradient->stops[0].offset);

833

834

	colors[1].red   = gradient->stops[0].color.red_short;

835

	colors[1].green = gradient->stops[0].color.green_short;

836

	colors[1].blue  = gradient->stops[0].color.blue_short;

837

	colors[1].alpha = gradient->stops[0].color.alpha_short;

838

839

840

    return stops;

841

842

843

static cairo_xcb_picture_t *

844

_cairo_xcb_linear_picture (cairo_xcb_surface_t *target,

845

			   const cairo_linear_pattern_t *pattern,

846

			   const cairo_rectangle_int_t *extents)

847

848

    char buf[CAIRO_STACK_BUFFER_SIZE];

849

    xcb_render_fixed_t *stops;

850

    xcb_render_color_t *colors;

851

    xcb_render_pointfix_t p1, p2;

852

    cairo_matrix_t matrix;

853

    cairo_circle_double_t extremes[2];

854

    cairo_xcb_picture_t *picture;

855

    cairo_status_t status;

856

    unsigned int n_stops;

857

858

    _cairo_gradient_pattern_fit_to_range (&pattern->base, PIXMAN_MAX_INT >> 1, &matrix, extremes);

859

860

    picture = (cairo_xcb_picture_t *)

861

	_cairo_xcb_screen_lookup_linear_picture (target->screen, pattern);

862

    if (picture != NULL)

863

	goto setup_picture;

864

865

    stops = _gradient_to_xcb (&pattern->base, &n_stops, buf, sizeof (buf));

866

    if (unlikely (stops == NULL))

867

	return (cairo_xcb_picture_t *) _cairo_surface_create_in_error (CAIRO_STATUS_NO_MEMORY);

868

869

    picture = _cairo_xcb_picture_create (target->screen,

870

					 target->screen->connection->standard_formats[CAIRO_FORMAT_ARGB32],

871

					 PIXMAN_a8r8g8b8,

872

					 -1, -1);

873

    if (unlikely (picture->base.status)) {

874

	if (stops != (xcb_render_fixed_t *) buf)

875

	    free (stops);

876

	return picture;

877

878

    picture->filter = CAIRO_FILTER_DEFAULT;

879

880

    colors = (xcb_render_color_t *) (stops + n_stops);

881

882

    p1.x = _cairo_fixed_16_16_from_double (extremes[0].center.x);

883

    p1.y = _cairo_fixed_16_16_from_double (extremes[0].center.y);

884

    p2.x = _cairo_fixed_16_16_from_double (extremes[1].center.x);

885

    p2.y = _cairo_fixed_16_16_from_double (extremes[1].center.y);

886

887

    _cairo_xcb_connection_render_create_linear_gradient (target->connection,

888

							 picture->picture,

889

							 p1, p2,

890

							 n_stops,

891

							 stops, colors);

892

893

    if (stops != (xcb_render_fixed_t *) buf)

894

	free (stops);

895

896

    status = _cairo_xcb_screen_store_linear_picture (target->screen,

897

						     pattern,

898

						     &picture->base);

899

    if (unlikely (status)) {

900

	cairo_surface_destroy (&picture->base);

901

	return (cairo_xcb_picture_t *) _cairo_surface_create_in_error (status);

902

903

904

setup_picture:

905

    _cairo_xcb_picture_set_matrix (picture, &matrix,

906

				   pattern->base.base.filter,

907

				   extents->x + extents->width/2.,

908

				   extents->y + extents->height/2.);

909

    _cairo_xcb_picture_set_filter (picture, pattern->base.base.filter);

910

    _cairo_xcb_picture_set_extend (picture, pattern->base.base.extend);

911

    _cairo_xcb_picture_set_component_alpha (picture,

912

					    pattern->base.base.has_component_alpha);

913

914

    return picture;

915

916

917

static cairo_xcb_picture_t *

918

_cairo_xcb_radial_picture (cairo_xcb_surface_t *target,

919

			   const cairo_radial_pattern_t *pattern,

920

			   const cairo_rectangle_int_t *extents)

921

922

    char buf[CAIRO_STACK_BUFFER_SIZE];

923

    xcb_render_fixed_t *stops;

924

    xcb_render_color_t *colors;

925

    xcb_render_pointfix_t p1, p2;

926

    xcb_render_fixed_t r1, r2;

927

    cairo_matrix_t matrix;

928

    cairo_circle_double_t extremes[2];

929

    cairo_xcb_picture_t *picture;

930

    cairo_status_t status;

931

    unsigned int n_stops;

932

933

    _cairo_gradient_pattern_fit_to_range (&pattern->base, PIXMAN_MAX_INT >> 1, &matrix, extremes);

934

935

    picture = (cairo_xcb_picture_t *)

936

	_cairo_xcb_screen_lookup_radial_picture (target->screen, pattern);

937

    if (picture != NULL)

938

	goto setup_picture;

939

940

    stops = _gradient_to_xcb (&pattern->base, &n_stops, buf, sizeof (buf));

941

    if (unlikely (stops == NULL))

942

	return (cairo_xcb_picture_t *) _cairo_surface_create_in_error (CAIRO_STATUS_NO_MEMORY);

943

944

    picture = _cairo_xcb_picture_create (target->screen,

945

					 target->screen->connection->standard_formats[CAIRO_FORMAT_ARGB32],

946

					 PIXMAN_a8r8g8b8,

947

					 -1, -1);

948

    if (unlikely (picture->base.status)) {

949

	if (stops != (xcb_render_fixed_t *) buf)

950

	    free (stops);

951

	return picture;

952

953

    picture->filter = CAIRO_FILTER_DEFAULT;

954

955

    colors = (xcb_render_color_t *) (stops + n_stops);

956

957

    p1.x = _cairo_fixed_16_16_from_double (extremes[0].center.x);

958

    p1.y = _cairo_fixed_16_16_from_double (extremes[0].center.y);

959

    p2.x = _cairo_fixed_16_16_from_double (extremes[1].center.x);

960

    p2.y = _cairo_fixed_16_16_from_double (extremes[1].center.y);

961

962

    r1 = _cairo_fixed_16_16_from_double (extremes[0].radius);

963

    r2 = _cairo_fixed_16_16_from_double (extremes[1].radius);

964

965

    _cairo_xcb_connection_render_create_radial_gradient (target->connection,

966

							 picture->picture,

967

							 p1, p2, r1, r2,

968

							 n_stops,

969

							 stops, colors);

970

971

    if (stops != (xcb_render_fixed_t *) buf)

972

	free (stops);

973

974

    status = _cairo_xcb_screen_store_radial_picture (target->screen,

975

						     pattern,

976

						     &picture->base);

977

    if (unlikely (status)) {

978

	cairo_surface_destroy (&picture->base);

979

	return (cairo_xcb_picture_t *) _cairo_surface_create_in_error (status);

980

981

982

setup_picture:

983

    _cairo_xcb_picture_set_matrix (picture, &matrix,

984

				   pattern->base.base.filter,

985

				   extents->x + extents->width/2.,

986

				   extents->y + extents->height/2.);

987

    _cairo_xcb_picture_set_filter (picture, pattern->base.base.filter);

988

    _cairo_xcb_picture_set_extend (picture, pattern->base.base.extend);

989

    _cairo_xcb_picture_set_component_alpha (picture,

990

					    pattern->base.base.has_component_alpha);

991

992

    return picture;

993

994

995

static cairo_xcb_picture_t *

996

3

_copy_to_picture (cairo_xcb_surface_t *source)

997

998

    cairo_xcb_picture_t *picture;

999

3

    uint32_t values[] = { 0, 1 };

1000

1001

3

    if (source->deferred_clear) {

1002

	cairo_status_t status = _cairo_xcb_surface_clear (source);

1003

	if (unlikely (status))

1004

	    return (cairo_xcb_picture_t *) _cairo_surface_create_in_error (status);

1005

1006

1007

3

    picture = _cairo_xcb_picture_create (source->screen,

1008

3

					 source->xrender_format,

1009

3

					 source->pixman_format,

1010

					 source->width,

1011

					 source->height);

1012

3

    if (unlikely (picture->base.status))

1013

	return picture;

1014

1015

3

    _cairo_xcb_connection_render_create_picture (source->connection,

1016

						 picture->picture,

1017

						 source->drawable,

1018

						 source->xrender_format,

1019

						 XCB_RENDER_CP_GRAPHICS_EXPOSURE |

1020

						 XCB_RENDER_CP_SUBWINDOW_MODE,

1021

						 values);

1022

1023

3

    return picture;

1024

1025

1026

static void

1027

3

_cairo_xcb_surface_setup_surface_picture(cairo_xcb_picture_t *picture,

1028

					 const cairo_surface_pattern_t *pattern,

1029

					 const cairo_rectangle_int_t *extents)

1030

1031

    cairo_filter_t filter;

1032

1033

3

    filter = pattern->base.filter;

1034

3

    if (filter != CAIRO_FILTER_NEAREST &&

1035

        _cairo_matrix_is_pixel_exact (&pattern->base.matrix))

1036

1037

	filter = CAIRO_FILTER_NEAREST;

1038

1039

3

    _cairo_xcb_picture_set_filter (picture, filter);

1040

1041

3

    _cairo_xcb_picture_set_matrix (picture,

1042

				   &pattern->base.matrix, filter,

1043

3

				   extents->x + extents->width/2.,

1044

3

				   extents->y + extents->height/2.);

1045

1046

1047

3

    _cairo_xcb_picture_set_extend (picture, pattern->base.extend);

1048

3

    _cairo_xcb_picture_set_component_alpha (picture, pattern->base.has_component_alpha);

1049

3

1050

1051

static cairo_xcb_picture_t *

1052

record_to_picture (cairo_surface_t *target,

1053

		   const cairo_surface_pattern_t *pattern,

1054

		   const cairo_rectangle_int_t *extents)

1055

1056

    cairo_surface_pattern_t tmp_pattern;

1057

    cairo_xcb_picture_t *picture;

1058

    cairo_status_t status;

1059

    cairo_matrix_t matrix;

1060

    cairo_surface_t *tmp;

1061

    cairo_surface_t *source;

1062

    cairo_rectangle_int_t limit;

1063

    cairo_extend_t extend;

1064

1065

    /* XXX: The following was once more or less copied from cairo-xlibs-ource.c,

1066

     * record_source() and recording_pattern_get_surface(), can we share a

1067

     * single version?

1068

*/

1069

1070

    /* First get the 'real' recording surface and figure out the size for tmp */

1071

    source = _cairo_pattern_get_source (pattern, &limit);

1072

    assert (_cairo_surface_is_recording (source));

1073

1074

    if (! _cairo_matrix_is_identity (&pattern->base.matrix)) {

1075

	double x1, y1, x2, y2;

1076

1077

	matrix = pattern->base.matrix;

1078

	status = cairo_matrix_invert (&matrix);

1079

	assert (status == CAIRO_STATUS_SUCCESS);

1080

1081

	x1 = limit.x;

1082

	y1 = limit.y;

1083

	x2 = limit.x + limit.width;

1084

	y2 = limit.y + limit.height;

1085

1086

	_cairo_matrix_transform_bounding_box (&matrix,

1087

					      &x1, &y1, &x2, &y2, NULL);

1088

1089

	limit.x = floor (x1);

1090

	limit.y = floor (y1);

1091

	limit.width  = ceil (x2) - limit.x;

1092

	limit.height = ceil (y2) - limit.y;

1093

1094

    extend = pattern->base.extend;

1095

    if (_cairo_rectangle_contains_rectangle (&limit, extents))

1096

	extend = CAIRO_EXTEND_NONE;

1097

    if (extend == CAIRO_EXTEND_NONE && ! _cairo_rectangle_intersect (&limit, extents))

1098

	return _cairo_xcb_transparent_picture ((cairo_xcb_surface_t *) target);

1099

1100

    /* Now draw the recording surface to an xcb surface */

1101

    tmp = _cairo_surface_create_scratch (target,

1102

                                         source->content,

1103

                                         limit.width,

1104

                                         limit.height,

1105

                                         CAIRO_COLOR_TRANSPARENT);

1106

    if (tmp->status != CAIRO_STATUS_SUCCESS) {

1107

	return (cairo_xcb_picture_t *) tmp;

1108

1109

1110

    cairo_matrix_init_translate (&matrix, limit.x, limit.y);

1111

    cairo_matrix_multiply (&matrix, &matrix, &pattern->base.matrix);

1112

1113

    status = _cairo_recording_surface_replay_with_clip (source,

1114

							&matrix, tmp,

1115

							NULL);

1116

    if (unlikely (status)) {

1117

	cairo_surface_destroy (tmp);

1118

	return (cairo_xcb_picture_t *) _cairo_surface_create_in_error (status);

1119

1120

1121

    /* Now that we have drawn this to an xcb surface, try again with that */

1122

    _cairo_pattern_init_static_copy (&tmp_pattern.base, &pattern->base);

1123

    tmp_pattern.surface = tmp;

1124

    cairo_matrix_init_translate (&tmp_pattern.base.matrix, -limit.x, -limit.y);

1125

1126

    picture = _copy_to_picture ((cairo_xcb_surface_t *) tmp);

1127

    if (picture->base.status == CAIRO_STATUS_SUCCESS)

1128

	_cairo_xcb_surface_setup_surface_picture (picture, &tmp_pattern, extents);

1129

    cairo_surface_destroy (tmp);

1130

    return picture;

1131

1132

1133

static cairo_xcb_picture_t *

1134

3

_cairo_xcb_surface_picture (cairo_xcb_surface_t *target,

1135

			    const cairo_surface_pattern_t *pattern,

1136

			    const cairo_rectangle_int_t *extents)

1137

1138

3

    cairo_surface_t *source = pattern->surface;

1139

    cairo_xcb_picture_t *picture;

1140

1141

    picture = (cairo_xcb_picture_t *)

1142

3

	_cairo_surface_has_snapshot (source, &_cairo_xcb_picture_backend);

1143

3

    if (picture != NULL) {

1144

	if (picture->screen == target->screen) {

1145

	    picture = (cairo_xcb_picture_t *) cairo_surface_reference (&picture->base);

1146

	    _cairo_xcb_surface_setup_surface_picture (picture, pattern, extents);

1147

	    return picture;

1148

1149

	picture = NULL;

1150

1151

1152

3

    if (source->type == CAIRO_SURFACE_TYPE_XCB)

1153

1154

3

	if (_cairo_surface_is_xcb(source)) {

1155

3

	    cairo_xcb_surface_t *xcb = (cairo_xcb_surface_t *) source;

1156

3

	    if (xcb->screen == target->screen && xcb->fallback == NULL) {

1157

3

		picture = _copy_to_picture ((cairo_xcb_surface_t *) source);

1158

3

		if (unlikely (picture->base.status))

1159

		    return picture;

1160

1161

	} else if (source->backend->type == CAIRO_SURFACE_TYPE_SUBSURFACE) {

1162

	    cairo_surface_subsurface_t *sub = (cairo_surface_subsurface_t *) source;

1163

	    cairo_xcb_surface_t *xcb = (cairo_xcb_surface_t *) sub->target;

1164

1165

	    /* XXX repeat interval with source clipping? */

1166

	    if (FALSE && xcb->screen == target->screen && xcb->fallback == NULL) {

1167

		xcb_rectangle_t rect;

1168

1169

		picture = _copy_to_picture (xcb);

1170

		if (unlikely (picture->base.status))

1171

		    return picture;

1172

1173

		rect.x = sub->extents.x;

1174

		rect.y = sub->extents.y;

1175

		rect.width  = sub->extents.width;

1176

		rect.height = sub->extents.height;

1177

1178

		_cairo_xcb_connection_render_set_picture_clip_rectangles (xcb->connection,

1179

									  picture->picture,

1180

									  0, 0,

1181

									  1, &rect);

1182

		picture->x0 = rect.x;

1183

		picture->y0 = rect.y;

1184

		picture->width  = rect.width;

1185

		picture->height = rect.height;

1186

1187

	} else if (_cairo_surface_is_snapshot (source)) {

1188

	    cairo_surface_snapshot_t *snap = (cairo_surface_snapshot_t *) source;

1189

	    cairo_xcb_surface_t *xcb = (cairo_xcb_surface_t *) snap->target;

1190

1191

	    if (xcb->screen == target->screen && xcb->fallback == NULL) {

1192

		picture = _copy_to_picture (xcb);

1193

		if (unlikely (picture->base.status))

1194

		    return picture;

1195

1196

1197

1198

#if CAIRO_HAS_XLIB_XCB_FUNCTIONS

1199

    else if (source->type == CAIRO_SURFACE_TYPE_XLIB)

1200

1201

	if (source->backend->type == CAIRO_SURFACE_TYPE_XLIB) {

1202

	    cairo_xcb_surface_t *xcb = ((cairo_xlib_xcb_surface_t *) source)->xcb;

1203

	    if (xcb->screen == target->screen && xcb->fallback == NULL) {

1204

		picture = _copy_to_picture (xcb);

1205

		if (unlikely (picture->base.status))

1206

		    return picture;

1207

1208

	} else if (source->backend->type == CAIRO_SURFACE_TYPE_SUBSURFACE) {

1209

	    cairo_surface_subsurface_t *sub = (cairo_surface_subsurface_t *) source;

1210

	    cairo_xcb_surface_t *xcb = ((cairo_xlib_xcb_surface_t *) sub->target)->xcb;

1211

1212

	    if (FALSE && xcb->screen == target->screen && xcb->fallback == NULL) {

1213

		xcb_rectangle_t rect;

1214

1215

		picture = _copy_to_picture (xcb);

1216

		if (unlikely (picture->base.status))

1217

		    return picture;

1218

1219

		rect.x = sub->extents.x;

1220

		rect.y = sub->extents.y;

1221

		rect.width  = sub->extents.width;

1222

		rect.height = sub->extents.height;

1223

1224

		_cairo_xcb_connection_render_set_picture_clip_rectangles (xcb->connection,

1225

									  picture->picture,

1226

									  0, 0,

1227

									  1, &rect);

1228

		picture->x0 = rect.x;

1229

		picture->y0 = rect.y;

1230

		picture->width  = rect.width;

1231

		picture->height = rect.height;

1232

1233

	} else if (_cairo_surface_is_snapshot (source)) {

1234

	    cairo_surface_snapshot_t *snap = (cairo_surface_snapshot_t *) source;

1235

	    cairo_xcb_surface_t *xcb = ((cairo_xlib_xcb_surface_t *) snap->target)->xcb;

1236

1237

	    if (xcb->screen == target->screen && xcb->fallback == NULL) {

1238

		picture = _copy_to_picture (xcb);

1239

		if (unlikely (picture->base.status))

1240

		    return picture;

1241

1242

1243

1244

#endif

1245

    else if (source->type == CAIRO_SURFACE_TYPE_RECORDING)

1246

1247

	/* We have to skip the call to attach_snapshot() because we possibly

1248

	 * only drew part of the recording surface.

1249

	 * TODO: When can we safely attach a snapshot?

1250

*/

1251

	return record_to_picture(&target->base, pattern, extents);

1252

1253

1254

3

    if (picture == NULL) {

1255

	cairo_image_surface_t *image;

1256

	void *image_extra;

1257

	cairo_status_t status;

1258

1259

	status = _cairo_surface_acquire_source_image (source, &image, &image_extra);

1260

	if (unlikely (status))

1261

	    return (cairo_xcb_picture_t *) _cairo_surface_create_in_error (status);

1262

1263

	if (image->format != CAIRO_FORMAT_INVALID &&

1264

	    image->format < ARRAY_LENGTH (target->screen->connection->standard_formats)) {

1265

	    xcb_render_pictformat_t format;

1266

1267

	    format = target->screen->connection->standard_formats[image->format];

1268

1269

	    picture = _picture_from_image (target, format, image, NULL);

1270

	    _cairo_surface_release_source_image (source, image, image_extra);

1271

	} else {

1272

	    cairo_image_surface_t *conv;

1273

	    xcb_render_pictformat_t render_format;

1274

1275

	    /* XXX XRenderPutImage! */

1276

1277

	    conv = _cairo_image_surface_coerce (image);

1278

	    _cairo_surface_release_source_image (source, image, image_extra);

1279

	    if (unlikely (conv->base.status))

1280

		return (cairo_xcb_picture_t *) conv;

1281

1282

	    render_format = target->screen->connection->standard_formats[conv->format];

1283

	    picture = _picture_from_image (target, render_format, conv, NULL);

1284

	    cairo_surface_destroy (&conv->base);

1285

1286

1287

	if (unlikely (picture->base.status))

1288

	    return picture;

1289

1290

1291

    /* XXX: This causes too many problems and bugs, let's skip it for now. */

1292

#if 0

1293

    _cairo_surface_attach_snapshot (source,

1294

				    &picture->base,

1295

				    NULL);

1296

#endif

1297

1298

3

    _cairo_xcb_surface_setup_surface_picture (picture, pattern, extents);

1299

3

    return picture;

1300

1301

1302

static cairo_xcb_picture_t *

1303

3

_cairo_xcb_picture_for_pattern (cairo_xcb_surface_t *target,

1304

				const cairo_pattern_t *pattern,

1305

				const cairo_rectangle_int_t *extents)

1306

1307

3

    if (pattern == NULL)

1308

	return _cairo_xcb_white_picture (target);

1309

1310

3

    if (! _pattern_is_supported (target->connection->flags, pattern))

1311

	return _render_to_picture (target, pattern, extents);

1312

1313

3

    switch (pattern->type) {

1314

    case CAIRO_PATTERN_TYPE_SOLID:

1315

	return _cairo_xcb_solid_picture (target, (cairo_solid_pattern_t *) pattern);

1316

1317

    case CAIRO_PATTERN_TYPE_LINEAR:

1318

	return _cairo_xcb_linear_picture (target,

1319

					  (cairo_linear_pattern_t *) pattern,

1320

					  extents);

1321

1322

    case CAIRO_PATTERN_TYPE_RADIAL:

1323

	return _cairo_xcb_radial_picture (target,

1324

					  (cairo_radial_pattern_t *) pattern,

1325

					  extents);

1326

1327

3

    case CAIRO_PATTERN_TYPE_SURFACE:

1328

3

	return _cairo_xcb_surface_picture (target,

1329

					   (cairo_surface_pattern_t *) pattern,

1330

					   extents);

1331

    default:

1332

	ASSERT_NOT_REACHED;

1333

    case CAIRO_PATTERN_TYPE_MESH:

1334

    case CAIRO_PATTERN_TYPE_RASTER_SOURCE:

1335

	return _render_to_picture (target, pattern, extents);

1336

1337

1338

1339

COMPILE_TIME_ASSERT (sizeof (xcb_rectangle_t) <= sizeof (cairo_box_t));

1340

1341

static cairo_status_t

1342

30

_render_fill_boxes (void			*abstract_dst,

1343

		    cairo_operator_t		 op,

1344

		    const cairo_color_t		*color,

1345

		    cairo_boxes_t		*boxes)

1346

1347

30

    cairo_xcb_surface_t *dst = abstract_dst;

1348

    xcb_rectangle_t stack_xrects[CAIRO_STACK_ARRAY_LENGTH (xcb_rectangle_t)];

1349

30

    xcb_rectangle_t *xrects = stack_xrects;

1350

    xcb_render_color_t render_color;

1351

30

    int render_op = _render_operator (op);

1352

    struct _cairo_boxes_chunk *chunk;

1353

    int max_count;

1354

1355

30

    render_color.red   = color->red_short;

1356

30

    render_color.green = color->green_short;

1357

30

    render_color.blue  = color->blue_short;

1358

30

    render_color.alpha = color->alpha_short;

1359

1360

30

    max_count = 0;

1361

60

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

1362

30

	if (chunk->count > max_count)

1363

30

	    max_count = chunk->count;

1364

1365

30

    if (max_count > ARRAY_LENGTH (stack_xrects)) {

1366

	xrects = _cairo_malloc_ab (max_count, sizeof (xcb_rectangle_t));

1367

	if (unlikely (xrects == NULL))

1368

	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);

1369

1370

1371

60

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

1372

	int i, j;

1373

1374

72

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

1375

42

	    int x1 = _cairo_fixed_integer_round_down (chunk->base[i].p1.x);

1376

42

	    int y1 = _cairo_fixed_integer_round_down (chunk->base[i].p1.y);

1377

42

	    int x2 = _cairo_fixed_integer_round_down (chunk->base[i].p2.x);

1378

42

	    int y2 = _cairo_fixed_integer_round_down (chunk->base[i].p2.y);

1379

1380

42

	    if (x2 > x1 && y2 > y1) {

1381

42

		xrects[j].x = x1;

1382

42

		xrects[j].y = y1;

1383

42

		xrects[j].width  = x2 - x1;

1384

42

		xrects[j].height = y2 - y1;

1385

42

		j++;

1386

1387

1388

1389

30

	if (j) {

1390

30

	    _cairo_xcb_connection_render_fill_rectangles

1391

		(dst->connection,

1392

		 render_op, dst->picture,

1393

		 render_color, j, xrects);

1394

1395

1396

1397

30

    if (xrects != stack_xrects)

1398

	free (xrects);

1399

1400

30

    return CAIRO_STATUS_SUCCESS;

1401

1402

1403

/* pixel aligned, non-overlapping boxes */

1404

static cairo_int_status_t

1405

3

_render_composite_boxes (cairo_xcb_surface_t	*dst,

1406

			 cairo_operator_t	 op,

1407

			 const cairo_pattern_t	*src_pattern,

1408

			 const cairo_pattern_t	*mask_pattern,

1409

			 const cairo_rectangle_int_t *extents,

1410

			 const cairo_boxes_t *boxes)

1411

1412

    cairo_xcb_picture_t *src, *mask;

1413

    const struct _cairo_boxes_chunk *chunk;

1414

    xcb_rectangle_t stack_boxes[CAIRO_STACK_ARRAY_LENGTH (xcb_rectangle_t)];

1415

    xcb_rectangle_t *clip_boxes;

1416

    cairo_rectangle_int_t stack_extents;

1417

    cairo_status_t status;

1418

    int num_boxes;

1419

    int render_op;

1420

1421

3

    render_op = _render_operator (op);

1422

1423

3

    if (src_pattern == NULL) {

1424

	src_pattern = mask_pattern;

1425

	mask_pattern = NULL;

1426

1427

1428

    /* amalgamate into a single Composite call by setting a clip region */

1429

3

    clip_boxes = stack_boxes;

1430

3

    if (boxes->num_boxes > ARRAY_LENGTH (stack_boxes)) {

1431

	clip_boxes = _cairo_malloc_ab (boxes->num_boxes, sizeof (xcb_rectangle_t));

1432

	if (unlikely (clip_boxes == NULL))

1433

	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);

1434

1435

1436

3

    src = _cairo_xcb_picture_for_pattern (dst, src_pattern, extents);

1437

3

    status = src->base.status;

1438

3

    if (unlikely (status))

1439

	goto cleanup_boxes;

1440

1441

3

    num_boxes = 0;

1442

6

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

1443

3

	const cairo_box_t *box = chunk->base;

1444

	int i;

1445

1446

6

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

1447

3

	    int x = _cairo_fixed_integer_round_down (box[i].p1.x);

1448

3

	    int y = _cairo_fixed_integer_round_down (box[i].p1.y);

1449

3

	    int width  = _cairo_fixed_integer_round_down (box[i].p2.x) - x;

1450

3

	    int height = _cairo_fixed_integer_round_down (box[i].p2.y) - y;

1451

1452

3

	    if (width && height) {

1453

3

		clip_boxes[num_boxes].x = x;

1454

3

		clip_boxes[num_boxes].y = y;

1455

3

		clip_boxes[num_boxes].width = width;

1456

3

		clip_boxes[num_boxes].height = height;

1457

3

		num_boxes++;

1458

1459

1460

1461

1462

3

    if (num_boxes) {

1463

3

	if (num_boxes > 1) {

1464

	    _cairo_xcb_connection_render_set_picture_clip_rectangles (dst->connection,

1465

								      dst->picture,

1466

								      0, 0,

1467

								      num_boxes,

1468

								      clip_boxes);

1469

	} else {

1470

3

	    stack_extents.x = clip_boxes[0].x;

1471

3

	    stack_extents.y = clip_boxes[0].y;

1472

3

	    stack_extents.width  = clip_boxes[0].width;

1473

3

	    stack_extents.height = clip_boxes[0].height;

1474

3

	    extents = &stack_extents;

1475

1476

1477

3

	if (mask_pattern != NULL) {

1478

	    mask = _cairo_xcb_picture_for_pattern (dst, mask_pattern, extents);

1479

	    status = mask->base.status;

1480

	    if (unlikely (status))

1481

		goto cleanup_clip;

1482

1483

	    _cairo_xcb_connection_render_composite (dst->connection,

1484

						    render_op,

1485

						    src->picture,

1486

						    mask->picture,

1487

						    dst->picture,

1488

						    src->x + extents->x, src->y + extents->y,

1489

						    mask->x + extents->x, mask->y + extents->y,

1490

						    extents->x, extents->y,

1491

						    extents->width, extents->height);

1492

1493

	    cairo_surface_destroy (&mask->base);

1494

	} else {

1495

3

	    _cairo_xcb_connection_render_composite (dst->connection,

1496

						    render_op,

1497

						    src->picture,

1498

						    XCB_NONE,

1499

						    dst->picture,

1500

3

						    src->x + extents->x, src->y + extents->y,

1501

						    0, 0,

1502

3

						    extents->x, extents->y,

1503

3

						    extents->width, extents->height);

1504

1505

1506

3

cleanup_clip:

1507

1508

3

	if (num_boxes > 1)

1509

	    _cairo_xcb_surface_clear_clip_region (dst);

1510

1511

1512

3

    cairo_surface_destroy (&src->base);

1513

1514

3

cleanup_boxes:

1515

1516

3

    if (clip_boxes != stack_boxes)

1517

	free (clip_boxes);

1518

1519

3

    return status;

1520

1521

1522

1523

#define CAIRO_FIXED_16_16_MIN _cairo_fixed_from_int (-32768)

1524

#define CAIRO_FIXED_16_16_MAX _cairo_fixed_from_int (32767)

1525

1526

static cairo_bool_t

1527

_line_exceeds_16_16 (const cairo_line_t *line)

1528

1529

    return

1530

	line->p1.x <= CAIRO_FIXED_16_16_MIN ||

1531

	line->p1.x >= CAIRO_FIXED_16_16_MAX ||

1532

1533

	line->p2.x <= CAIRO_FIXED_16_16_MIN ||

1534

	line->p2.x >= CAIRO_FIXED_16_16_MAX ||

1535

1536

	line->p1.y <= CAIRO_FIXED_16_16_MIN ||

1537

	line->p1.y >= CAIRO_FIXED_16_16_MAX ||

1538

1539

	line->p2.y <= CAIRO_FIXED_16_16_MIN ||

1540

	line->p2.y >= CAIRO_FIXED_16_16_MAX;

1541

1542

1543

static void

1544

_project_line_x_onto_16_16 (const cairo_line_t *line,

1545

			    cairo_fixed_t top,

1546

			    cairo_fixed_t bottom,

1547

			    xcb_render_linefix_t *out)

1548

1549

    cairo_point_double_t p1, p2;

1550

    double m;

1551

1552

    p1.x = _cairo_fixed_to_double (line->p1.x);

1553

    p1.y = _cairo_fixed_to_double (line->p1.y);

1554

1555

    p2.x = _cairo_fixed_to_double (line->p2.x);

1556

    p2.y = _cairo_fixed_to_double (line->p2.y);

1557

1558

    m = (p2.x - p1.x) / (p2.y - p1.y);

1559

    out->p1.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (top - line->p1.y));

1560

    out->p2.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (bottom - line->p1.y));

1561

1562

1563

typedef struct {

1564

    cairo_traps_t traps;

1565

    cairo_antialias_t antialias;

1566

} composite_traps_info_t;

1567

1568

COMPILE_TIME_ASSERT (sizeof (xcb_render_trapezoid_t) <= sizeof (cairo_trapezoid_t));

1569

1570

static cairo_int_status_t

1571

_composite_traps (void *closure,

1572

		  cairo_xcb_surface_t	*dst,

1573

		  cairo_operator_t	 op,

1574

		  const cairo_pattern_t	*pattern,

1575

		  int dst_x, int dst_y,

1576

		  const cairo_rectangle_int_t *extents,

1577

		  cairo_clip_t		*clip)

1578

1579

    composite_traps_info_t *info = closure;

1580

    const cairo_traps_t *traps = &info->traps;

1581

    cairo_xcb_picture_t *src;

1582

    cairo_format_t format;

1583

    xcb_render_pictformat_t xrender_format;

1584

    xcb_render_trapezoid_t *xtraps;

1585

    int render_reference_x, render_reference_y;

1586

    cairo_status_t status;

1587

    int i;

1588

1589

    if (dst->deferred_clear) {

1590

	status = _cairo_xcb_surface_clear (dst);

1591

	if (unlikely (status))

1592

		return status;

1593

1594

1595

    src = _cairo_xcb_picture_for_pattern (dst, pattern, extents);

1596

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

1597

	return src->base.status;

1598

1599

    if (info->antialias == CAIRO_ANTIALIAS_NONE)

1600

	format = CAIRO_FORMAT_A1;

1601

    else

1602

	format = CAIRO_FORMAT_A8;

1603

    xrender_format = dst->screen->connection->standard_formats[format];

1604

1605

    xtraps = (xcb_render_trapezoid_t *) traps->traps;

1606

    for (i = 0; i < traps->num_traps; i++) {

1607

	cairo_trapezoid_t t = traps->traps[i];

1608

1609

	/* top/bottom will be clamped to surface bounds */

1610

	xtraps[i].top = _cairo_fixed_to_16_16 (t.top);

1611

	xtraps[i].top -= dst_y << 16;

1612

	xtraps[i].bottom = _cairo_fixed_to_16_16 (t.bottom);

1613

	xtraps[i].bottom -= dst_y << 16;

1614

1615

	/* However, all the other coordinates will have been left untouched so

1616

	 * as not to introduce numerical error. Recompute them if they

1617

	 * exceed the 16.16 limits.

1618

*/

1619

	if (unlikely (_line_exceeds_16_16 (&t.left))) {

1620

	    _project_line_x_onto_16_16 (&t.left,

1621

					t.top,

1622

					t.bottom,

1623

					&xtraps[i].left);

1624

	    xtraps[i].left.p1.y = xtraps[i].top;

1625

	    xtraps[i].left.p2.y = xtraps[i].bottom;

1626

	} else {

1627

	    xtraps[i].left.p1.x = _cairo_fixed_to_16_16 (t.left.p1.x);

1628

	    xtraps[i].left.p1.y = _cairo_fixed_to_16_16 (t.left.p1.y);

1629

	    xtraps[i].left.p2.x = _cairo_fixed_to_16_16 (t.left.p2.x);

1630

	    xtraps[i].left.p2.y = _cairo_fixed_to_16_16 (t.left.p2.y);

1631

1632

	xtraps[i].left.p1.x -= dst_x << 16;

1633

	xtraps[i].left.p1.y -= dst_y << 16;

1634

	xtraps[i].left.p2.x -= dst_x << 16;

1635

	xtraps[i].left.p2.y -= dst_y << 16;

1636

1637

	if (unlikely (_line_exceeds_16_16 (&t.right))) {

1638

	    _project_line_x_onto_16_16 (&t.right,

1639

					t.top,

1640

					t.bottom,

1641

					&xtraps[i].right);

1642

	    xtraps[i].right.p1.y = xtraps[i].top;

1643

	    xtraps[i].right.p2.y = xtraps[i].bottom;

1644

	} else {

1645

	    xtraps[i].right.p1.x = _cairo_fixed_to_16_16 (t.right.p1.x);

1646

	    xtraps[i].right.p1.y = _cairo_fixed_to_16_16 (t.right.p1.y);

1647

	    xtraps[i].right.p2.x = _cairo_fixed_to_16_16 (t.right.p2.x);

1648

	    xtraps[i].right.p2.y = _cairo_fixed_to_16_16 (t.right.p2.y);

1649

1650

	xtraps[i].right.p1.x -= dst_x << 16;

1651

	xtraps[i].right.p1.y -= dst_y << 16;

1652

	xtraps[i].right.p2.x -= dst_x << 16;

1653

	xtraps[i].right.p2.y -= dst_y << 16;

1654

1655

1656

    if (xtraps[0].left.p1.y < xtraps[0].left.p2.y) {

1657

	render_reference_x = xtraps[0].left.p1.x >> 16;

1658

	render_reference_y = xtraps[0].left.p1.y >> 16;

1659

    } else {

1660

	render_reference_x = xtraps[0].left.p2.x >> 16;

1661

	render_reference_y = xtraps[0].left.p2.y >> 16;

1662

1663

    render_reference_x += src->x + dst_x;

1664

    render_reference_y += src->y + dst_y;

1665

1666

    _cairo_xcb_surface_set_precision (dst, info->antialias);

1667

    _cairo_xcb_connection_render_trapezoids (dst->connection,

1668

					     _render_operator (op),

1669

					     src->picture,

1670

					     dst->picture,

1671

					     xrender_format,

1672

					     render_reference_x,

1673

					     render_reference_y,

1674

					     traps->num_traps, xtraps);

1675

1676

    cairo_surface_destroy (&src->base);

1677

1678

    return CAIRO_STATUS_SUCCESS;

1679

1680

1681

/* low-level composite driver */

1682

1683

static cairo_xcb_surface_t *

1684

get_clip_surface (const cairo_clip_t *clip,

1685

		  cairo_xcb_surface_t *target,

1686

		  int *tx, int *ty)

1687

1688

    cairo_surface_t *surface;

1689

    cairo_status_t status;

1690

1691

    surface = _cairo_surface_create_scratch (&target->base,

1692

					    CAIRO_CONTENT_ALPHA,

1693

					    clip->extents.width,

1694

					    clip->extents.height,

1695

					    CAIRO_COLOR_WHITE);

1696

    if (unlikely (surface->status))

1697

	return (cairo_xcb_surface_t *) surface;

1698

1699

    assert (surface->backend == &_cairo_xcb_surface_backend);

1700

    status = _cairo_clip_combine_with_surface (clip, surface,

1701

					       clip->extents.x, clip->extents.y);

1702

    if (unlikely (status)) {

1703

	cairo_surface_destroy (surface);

1704

	surface = _cairo_surface_create_in_error (status);

1705

1706

1707

    *tx = clip->extents.x;

1708

    *ty = clip->extents.y;

1709

1710

    return (cairo_xcb_surface_t *) surface;

1711

1712

1713

typedef cairo_int_status_t

1714

(*xcb_draw_func_t) (void				*closure,

1715

		    cairo_xcb_surface_t			*dst,

1716

		    cairo_operator_t			 op,

1717

		    const cairo_pattern_t		*src,

1718

		    int					 dst_x,

1719

		    int					 dst_y,

1720

		    const cairo_rectangle_int_t		*extents,

1721

		    cairo_clip_t			*clip);

1722

1723

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

1724

					 int16_t x, int16_t y,

1725

					 int16_t w, int16_t h,

1726

					 uint16_t coverage),

1727

			     void *closure,

1728

			     const cairo_box_t *b,

1729

			     int tx, int y, int h,

1730

			     uint16_t coverage)

1731

1732

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

1733

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

1734

    if (x2 > x1) {

1735

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

1736

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

1737

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

1738

	    x1++;

1739

1740

1741

	if (x2 > x1)

1742

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

1743

1744

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

1745

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

1746

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

1747

    } else

1748

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

1749

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

1750

1751

1752

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

1753

					 int16_t x, int16_t y,

1754

					 int16_t w, int16_t h,

1755

					 uint16_t coverage),

1756

			     void *closure,

1757

			     const cairo_box_t *b, int tx, int ty)

1758

1759

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

1760

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

1761

    if (y2 > y1) {

1762

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

1763

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

1764

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

1765

	    y1++;

1766

1767

1768

	if (y2 > y1)

1769

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

1770

1771

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

1772

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

1773

			     _cairo_fixed_fractional_part (b->p2.y));

1774

    } else

1775

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

1776

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

1777

1778

1779

1780

static void blt_in(void *closure,

1781

		   int16_t x, int16_t y,

1782

		   int16_t w, int16_t h,

1783

		   uint16_t coverage)

1784

1785

    cairo_xcb_surface_t *mask = closure;

1786

    xcb_render_color_t color;

1787

    xcb_rectangle_t rect;

1788

1789

    if (coverage == 0xffff)

1790

	return;

1791

1792

    color.red = color.green = color.blue = 0;

1793

    color.alpha = coverage;

1794

1795

    rect.x = x;

1796

    rect.y = y;

1797

    rect.width  = w;

1798

    rect.height = h;

1799

1800

    _cairo_xcb_connection_render_fill_rectangles (mask->connection,

1801

						  XCB_RENDER_PICT_OP_IN,

1802

						  mask->picture,

1803

						  color, 1, &rect);

1804

1805

1806

static cairo_xcb_surface_t *

1807

_create_composite_mask (cairo_clip_t		*clip,

1808

			xcb_draw_func_t		 draw_func,

1809

			xcb_draw_func_t		 mask_func,

1810

			void			*draw_closure,

1811

			cairo_xcb_surface_t	*dst,

1812

			const cairo_rectangle_int_t*extents)

1813

1814

    cairo_xcb_surface_t *surface;

1815

    cairo_bool_t need_clip_combine;

1816

    cairo_int_status_t status;

1817

1818

    surface = (cairo_xcb_surface_t *)

1819

	_cairo_xcb_surface_create_similar (dst, CAIRO_CONTENT_ALPHA,

1820

					   extents->width, extents->height);

1821

    if (unlikely (surface->base.status))

1822

	return surface;

1823

1824

    _cairo_xcb_surface_ensure_picture (surface);

1825

1826

    surface->deferred_clear_color = *CAIRO_COLOR_TRANSPARENT;

1827

    surface->deferred_clear = TRUE;

1828

    surface->base.is_clear = TRUE;

1829

1830

    if (mask_func) {

1831

	status = mask_func (draw_closure, surface,

1832

			    CAIRO_OPERATOR_ADD, NULL,

1833

			    extents->x, extents->y,

1834

			    extents, clip);

1835

	if (likely (status != CAIRO_INT_STATUS_UNSUPPORTED))

1836

	    return surface;

1837

1838

1839

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

1840

    status = draw_func (draw_closure, surface,

1841

			CAIRO_OPERATOR_ADD, NULL,

1842

			extents->x, extents->y,

1843

			extents, NULL);

1844

    if (unlikely (status)) {

1845

	cairo_surface_destroy (&surface->base);

1846

	return (cairo_xcb_surface_t *) _cairo_surface_create_in_error (status);

1847

1848

1849

    if (surface->connection->flags & CAIRO_XCB_RENDER_HAS_FILL_RECTANGLES) {

1850

	int i;

1851

1852

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

1853

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

1854

1855

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

1856

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

1857

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

1858

		! _cairo_fixed_is_integer (b->p2.y))

1859

1860

		do_unaligned_box(blt_in, surface, b, extents->x, extents->y);

1861

1862

1863

1864

	need_clip_combine = clip->path != NULL;

1865

    } else

1866

	need_clip_combine = ! _cairo_clip_is_region (clip);

1867

1868

    if (need_clip_combine) {

1869

	status = _cairo_clip_combine_with_surface (clip, &surface->base,

1870

						   extents->x, extents->y);

1871

	if (unlikely (status)) {

1872

	    cairo_surface_destroy (&surface->base);

1873

	    return (cairo_xcb_surface_t *) _cairo_surface_create_in_error (status);

1874

1875

1876

1877

    return surface;

1878

1879

1880

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

1881

 * us to combine the clip with the mask

1882

*/

1883

static cairo_status_t

1884

_clip_and_composite_with_mask (cairo_clip_t		*clip,

1885

			       cairo_operator_t		 op,

1886

			       const cairo_pattern_t	*pattern,

1887

			       xcb_draw_func_t		 draw_func,

1888

			       xcb_draw_func_t		 mask_func,

1889

			       void			*draw_closure,

1890

			       cairo_xcb_surface_t	*dst,

1891

			       const cairo_rectangle_int_t*extents)

1892

1893

    cairo_xcb_surface_t *mask;

1894

    cairo_xcb_picture_t *src;

1895

1896

    mask = _create_composite_mask (clip,

1897

				   draw_func, mask_func, draw_closure,

1898

				   dst, extents);

1899

    if (unlikely (mask->base.status))

1900

	return mask->base.status;

1901

1902

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

1903

	src = _cairo_xcb_picture_for_pattern (dst, pattern, extents);

1904

	if (unlikely (src->base.status)) {

1905

	    cairo_surface_destroy (&mask->base);

1906

	    return src->base.status;

1907

1908

1909

	_cairo_xcb_connection_render_composite (dst->connection,

1910

						_render_operator (op),

1911

						src->picture,

1912

						mask->picture,

1913

						dst->picture,

1914

						extents->x + src->x, extents->y + src->y,

1915

						0, 0,

1916

						extents->x,      extents->y,

1917

						extents->width,  extents->height);

1918

1919

	cairo_surface_destroy (&src->base);

1920

    } else {

1921

	_cairo_xcb_connection_render_composite (dst->connection,

1922

						_render_operator (op),

1923

						mask->picture,

1924

						XCB_NONE,

1925

						dst->picture,

1926

						0, 0,

1927

						0, 0,

1928

						extents->x,      extents->y,

1929

						extents->width,  extents->height);

1930

1931

    cairo_surface_destroy (&mask->base);

1932

1933

    return CAIRO_STATUS_SUCCESS;

1934

1935

1936

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

1937

 * in two pieces and combine them together.

1938

*/

1939

static cairo_status_t

1940

_clip_and_composite_combine (cairo_clip_t		*clip,

1941

			     cairo_operator_t		 op,

1942

			     const cairo_pattern_t	*pattern,

1943

			     xcb_draw_func_t		 draw_func,

1944

			     void			*draw_closure,

1945

			     cairo_xcb_surface_t	*dst,

1946

			     const cairo_rectangle_int_t*extents)

1947

1948

    cairo_xcb_surface_t *tmp;

1949

    cairo_xcb_surface_t *clip_surface;

1950

    int clip_x = 0, clip_y = 0;

1951

    xcb_render_picture_t clip_picture;

1952

    cairo_status_t status;

1953

1954

    tmp = (cairo_xcb_surface_t *)

1955

	_cairo_xcb_surface_create_similar (dst, dst->base.content,

1956

					   extents->width, extents->height);

1957

    if (unlikely (tmp->base.status))

1958

	return tmp->base.status;

1959

1960

    /* create_similar() could have done a fallback to an image surface */

1961

    assert (tmp->base.backend == &_cairo_xcb_surface_backend);

1962

1963

    _cairo_xcb_surface_ensure_picture (tmp);

1964

1965

    if (pattern == NULL) {

1966

	status = (*draw_func) (draw_closure, tmp,

1967

			       CAIRO_OPERATOR_ADD, NULL,

1968

			       extents->x, extents->y,

1969

			       extents, NULL);

1970

    } else {

1971

	/* Initialize the temporary surface from the destination surface */

1972

	if (! dst->base.is_clear ||

1973

	    (dst->connection->flags & CAIRO_XCB_RENDER_HAS_FILL_RECTANGLES) == 0)

1974

1975

	    /* XCopyArea may actually be quicker here.

1976

	     * A good driver should translate if appropriate.

1977

*/

1978

	    _cairo_xcb_connection_render_composite (dst->connection,

1979

						    XCB_RENDER_PICT_OP_SRC,

1980

						    dst->picture,

1981

						    XCB_NONE,

1982

						    tmp->picture,

1983

						    extents->x,      extents->y,

1984

						    0, 0,

1985

						    0, 0,

1986

						    extents->width,  extents->height);

1987

1988

	else

1989

1990

	    xcb_render_color_t clear;

1991

	    xcb_rectangle_t xrect;

1992

1993

	    clear.red = clear.green = clear.blue = clear.alpha = 0;

1994

1995

	    xrect.x = xrect.y = 0;

1996

	    xrect.width  = extents->width;

1997

	    xrect.height = extents->height;

1998

1999

	    _cairo_xcb_connection_render_fill_rectangles (dst->connection,

2000

							  XCB_RENDER_PICT_OP_CLEAR,

2001

							  dst->picture,

2002

							  clear, 1, &xrect);

2003

2004

2005

	status = (*draw_func) (draw_closure, tmp, op, pattern,

2006

			       extents->x, extents->y,

2007

			       extents, NULL);

2008

2009

    if (unlikely (status))

2010

	goto CLEANUP_SURFACE;

2011

2012

    clip_surface = get_clip_surface (clip, dst, &clip_x, &clip_y);

2013

    status = clip_surface->base.status;

2014

    if (unlikely (status))

2015

	goto CLEANUP_SURFACE;

2016

2017

    assert (clip_surface->base.backend == &_cairo_xcb_surface_backend);

2018

    clip_picture = clip_surface->picture;

2019

    assert (clip_picture != XCB_NONE);

2020

2021

    if (dst->base.is_clear) {

2022

	_cairo_xcb_connection_render_composite (dst->connection,

2023

						XCB_RENDER_PICT_OP_SRC,

2024

						tmp->picture, clip_picture, dst->picture,

2025

						0, 0,

2026

						0, 0,

2027

						extents->x,      extents->y,

2028

						extents->width,  extents->height);

2029

    } else {

2030

	/* Punch the clip out of the destination */

2031

	_cairo_xcb_connection_render_composite (dst->connection,

2032

						XCB_RENDER_PICT_OP_OUT_REVERSE,

2033

						clip_picture, XCB_NONE, dst->picture,

2034

						extents->x - clip_x,

2035

						extents->y - clip_y,

2036

						0, 0,

2037

						extents->x,     extents->y,

2038

						extents->width, extents->height);

2039

2040

	/* Now add the two results together */

2041

	_cairo_xcb_connection_render_composite (dst->connection,

2042

						XCB_RENDER_PICT_OP_ADD,

2043

						tmp->picture, clip_picture, dst->picture,

2044

						0, 0,

2045

						extents->x - clip_x,

2046

						extents->y - clip_y,

2047

						extents->x,     extents->y,

2048

						extents->width, extents->height);

2049

2050

    cairo_surface_destroy (&clip_surface->base);

2051

2052

 CLEANUP_SURFACE:

2053

    cairo_surface_destroy (&tmp->base);

2054

2055

    return status;

2056

2057

2058

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

2059

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

2060

*/

2061

static cairo_status_t

2062

_clip_and_composite_source (cairo_clip_t		*clip,

2063

			    const cairo_pattern_t	*pattern,

2064

			    xcb_draw_func_t		 draw_func,

2065

			    xcb_draw_func_t		 mask_func,

2066

			    void			*draw_closure,

2067

			    cairo_xcb_surface_t		*dst,

2068

			    const cairo_rectangle_int_t	*extents)

2069

2070

    cairo_xcb_surface_t *mask;

2071

    cairo_xcb_picture_t *src;

2072

2073

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

2074

    mask = _create_composite_mask (clip,

2075

				   draw_func, mask_func, draw_closure,

2076

				   dst, extents);

2077

    if (unlikely (mask->base.status))

2078

	return mask->base.status;

2079

2080

    src = _cairo_xcb_picture_for_pattern (dst, pattern, extents);

2081

    if (unlikely (src->base.status)) {

2082

	cairo_surface_destroy (&mask->base);

2083

	return src->base.status;

2084

2085

2086

    if (dst->base.is_clear) {

2087

	_cairo_xcb_connection_render_composite (dst->connection,

2088

						XCB_RENDER_PICT_OP_SRC,

2089

						src->picture,

2090

						mask->picture,

2091

						dst->picture,

2092

						extents->x + src->x, extents->y + src->y,

2093

						0, 0,

2094

						extents->x,      extents->y,

2095

						extents->width,  extents->height);

2096

    } else {

2097

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

2098

	_cairo_xcb_connection_render_composite (dst->connection,

2099

						XCB_RENDER_PICT_OP_OUT_REVERSE,

2100

						mask->picture,

2101

						XCB_NONE,

2102

						dst->picture,

2103

						0, 0, 0, 0,

2104

						extents->x,     extents->y,

2105

						extents->width, extents->height);

2106

2107

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

2108

	_cairo_xcb_connection_render_composite (dst->connection,

2109

						XCB_RENDER_PICT_OP_ADD,

2110

						src->picture,

2111

						mask->picture,

2112

						dst->picture,

2113

						extents->x + src->x, extents->y + src->y,

2114

						0, 0,

2115

						extents->x,     extents->y,

2116

						extents->width, extents->height);

2117

2118

2119

    cairo_surface_destroy (&src->base);

2120

    cairo_surface_destroy (&mask->base);

2121

2122

    return CAIRO_STATUS_SUCCESS;

2123

2124

2125

static cairo_bool_t

2126

can_reduce_alpha_op (cairo_operator_t op)

2127

2128

    int iop = op;

2129

    switch (iop) {

2130

    case CAIRO_OPERATOR_OVER:

2131

    case CAIRO_OPERATOR_SOURCE:

2132

    case CAIRO_OPERATOR_ADD:

2133

	return TRUE;

2134

    default:

2135

	return FALSE;

2136

2137

2138

2139

static cairo_bool_t

2140

reduce_alpha_op (cairo_surface_t *dst,

2141

		 cairo_operator_t op,

2142

		 const cairo_pattern_t *pattern)

2143

2144

    return dst->is_clear &&

2145

	   dst->content == CAIRO_CONTENT_ALPHA &&

2146

	   _cairo_pattern_is_opaque_solid (pattern) &&

2147

	   can_reduce_alpha_op (op);

2148

2149

2150

static cairo_status_t

2151

_cairo_xcb_surface_fixup_unbounded (cairo_xcb_surface_t *dst,

2152

				    const cairo_composite_rectangles_t *rects)

2153

2154

    xcb_rectangle_t xrects[4];

2155

    int n;

2156

2157

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

2158

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

2159

2160

	return CAIRO_STATUS_SUCCESS;

2161

2162

2163

    n = 0;

2164

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

2165

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

2166

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

2167

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

2168

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

2169

	n++;

2170

    } else {

2171

	/* top */

2172

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

2173

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

2174

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

2175

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

2176

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

2177

	    n++;

2178

2179

	/* left */

2180

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

2181

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

2182

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

2183

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

2184

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

2185

	    n++;

2186

2187

	/* right */

2188

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

2189

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

2190

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

2191

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

2192

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

2193

	    n++;

2194

2195

	/* bottom */

2196

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

2197

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

2198

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

2199

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

2200

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

2201

	    n++;

2202

2203

2204

2205

    if (dst->connection->flags & CAIRO_XCB_RENDER_HAS_FILL_RECTANGLES) {

2206

	xcb_render_color_t color;

2207

2208

	color.red   = 0;

2209

	color.green = 0;

2210

	color.blue  = 0;

2211

	color.alpha = 0;

2212

2213

	_cairo_xcb_connection_render_fill_rectangles (dst->connection,

2214

						      XCB_RENDER_PICT_OP_CLEAR,

2215

						      dst->picture,

2216

						      color, n, xrects);

2217

    } else {

2218

	int i;

2219

	cairo_xcb_picture_t *src;

2220

2221

	src = _cairo_xcb_transparent_picture (dst);

2222

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

2223

	    return src->base.status;

2224

2225

	for (i = 0; i < n; i++) {

2226

	    _cairo_xcb_connection_render_composite (dst->connection,

2227

						    XCB_RENDER_PICT_OP_CLEAR,

2228

						    src->picture, XCB_NONE, dst->picture,

2229

						    0, 0,

2230

						    0, 0,

2231

						    xrects[i].x, xrects[i].y,

2232

						    xrects[i].width, xrects[i].height);

2233

2234

	cairo_surface_destroy (&src->base);

2235

2236

2237

    return CAIRO_STATUS_SUCCESS;

2238

2239

2240

static cairo_status_t

2241

_cairo_xcb_surface_fixup_unbounded_with_mask (cairo_xcb_surface_t *dst,

2242

					      const cairo_composite_rectangles_t *rects,

2243

					      cairo_clip_t *clip)

2244

2245

    cairo_xcb_surface_t *mask;

2246

    int mask_x = 0, mask_y = 0;

2247

2248

    mask = get_clip_surface (clip, dst, &mask_x, &mask_y);

2249

    if (unlikely (mask->base.status))

2250

	return mask->base.status;

2251

2252

    /* top */

2253

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

2254

	int x = rects->unbounded.x;

2255

	int y = rects->unbounded.y;

2256

	int width = rects->unbounded.width;

2257

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

2258

2259

	_cairo_xcb_connection_render_composite (dst->connection,

2260

						XCB_RENDER_PICT_OP_OUT_REVERSE,

2261

						mask->picture, XCB_NONE, dst->picture,

2262

						x - mask_x, y - mask_y,

2263

						0, 0,

2264

						x, y,

2265

						width, height);

2266

2267

2268

    /* left */

2269

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

2270

	int x = rects->unbounded.x;

2271

	int y = rects->bounded.y;

2272

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

2273

	int height = rects->bounded.height;

2274

2275

	_cairo_xcb_connection_render_composite (dst->connection,

2276

						XCB_RENDER_PICT_OP_OUT_REVERSE,

2277

						mask->picture, XCB_NONE, dst->picture,

2278

						x - mask_x, y - mask_y,

2279

						0, 0,

2280

						x, y,

2281

						width, height);

2282

2283

2284

    /* right */

2285

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

2286

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

2287

	int y = rects->bounded.y;

2288

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

2289

	int height = rects->bounded.height;

2290

2291

	_cairo_xcb_connection_render_composite (dst->connection,

2292

						XCB_RENDER_PICT_OP_OUT_REVERSE,

2293

						mask->picture, XCB_NONE, dst->picture,

2294

						x - mask_x, y - mask_y,

2295

						0, 0,

2296

						x, y,

2297

						width, height);

2298

2299

2300

    /* bottom */

2301

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

2302

	int x = rects->unbounded.x;

2303

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

2304

	int width = rects->unbounded.width;

2305

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

2306

2307

	_cairo_xcb_connection_render_composite (dst->connection,

2308

						XCB_RENDER_PICT_OP_OUT_REVERSE,

2309

						mask->picture, XCB_NONE, dst->picture,

2310

						x - mask_x, y - mask_y,

2311

						0, 0,

2312

						x, y,

2313

						width, height);

2314

2315

2316

    cairo_surface_destroy (&mask->base);

2317

2318

    return CAIRO_STATUS_SUCCESS;

2319

2320

2321

static cairo_status_t

2322

_cairo_xcb_surface_fixup_unbounded_boxes (cairo_xcb_surface_t *dst,

2323

					  const cairo_composite_rectangles_t *extents,

2324

					  cairo_clip_t *clip,

2325

					  cairo_boxes_t *boxes)

2326

2327

    cairo_boxes_t clear;

2328

    cairo_box_t box;

2329

    cairo_status_t status;

2330

    struct _cairo_boxes_chunk *chunk;

2331

    int i;

2332

2333

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

2334

	return _cairo_xcb_surface_fixup_unbounded (dst, extents);

2335

2336

    _cairo_boxes_init (&clear);

2337

2338

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

2339

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

2340

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

2341

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

2342

2343

    if (clip == NULL) {

2344

	cairo_boxes_t tmp;

2345

2346

	_cairo_boxes_init (&tmp);

2347

2348

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

2349

	assert (status == CAIRO_STATUS_SUCCESS);

2350

2351

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

2352

	tmp.num_boxes += boxes->num_boxes;

2353

2354

	status = _cairo_bentley_ottmann_tessellate_boxes (&tmp,

2355

							  CAIRO_FILL_RULE_WINDING,

2356

							  &clear);

2357

2358

	tmp.chunks.next = NULL;

2359

    } else {

2360

	_cairo_boxes_init_with_clip (&clear, clip);

2361

2362

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

2363

	assert (status == CAIRO_STATUS_SUCCESS);

2364

2365

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

2366

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

2367

		status = _cairo_boxes_add (&clear,

2368

					   CAIRO_ANTIALIAS_DEFAULT,

2369

					   &chunk->base[i]);

2370

		if (unlikely (status)) {

2371

		    _cairo_boxes_fini (&clear);

2372

		    return status;

2373

2374

2375

2376

2377

	status = _cairo_bentley_ottmann_tessellate_boxes (&clear,

2378

							  CAIRO_FILL_RULE_WINDING,

2379

							  &clear);

2380

2381

2382

    if (likely (status == CAIRO_STATUS_SUCCESS)) {

2383

	if (dst->connection->flags & CAIRO_XCB_RENDER_HAS_FILL_RECTANGLES)

2384

	    status = _render_fill_boxes (dst,

2385

					 CAIRO_OPERATOR_CLEAR,

2386

					 CAIRO_COLOR_TRANSPARENT,

2387

					 &clear);

2388

	else

2389

	    status = _cairo_xcb_surface_core_fill_boxes (dst,

2390

							 CAIRO_COLOR_TRANSPARENT,

2391

							 &clear);

2392

2393

2394

    _cairo_boxes_fini (&clear);

2395

2396

    return status;

2397

2398

2399

cairo_status_t

2400

_cairo_xcb_surface_clear (cairo_xcb_surface_t *dst)

2401

2402

    xcb_gcontext_t gc;

2403

    xcb_rectangle_t rect;

2404

    cairo_status_t status;

2405

2406

    status = _cairo_xcb_connection_acquire (dst->connection);

2407

    if (unlikely (status))

2408

	return status;

2409

2410

    rect.x = rect.y = 0;

2411

    rect.width  = dst->width;

2412

    rect.height = dst->height;

2413

2414

    if (dst->connection->flags & CAIRO_XCB_RENDER_HAS_FILL_RECTANGLES) {

2415

	xcb_render_color_t color;

2416

	uint8_t op;

2417

2418

	color.red   = dst->deferred_clear_color.red_short;

2419

	color.green = dst->deferred_clear_color.green_short;

2420

	color.blue  = dst->deferred_clear_color.blue_short;

2421

	color.alpha = dst->deferred_clear_color.alpha_short;

2422

2423

	if (color.alpha == 0)

2424

	    op = XCB_RENDER_PICT_OP_CLEAR;

2425

	else

2426

	    op = XCB_RENDER_PICT_OP_SRC;

2427

2428

	_cairo_xcb_surface_ensure_picture (dst);

2429

	_cairo_xcb_connection_render_fill_rectangles (dst->connection,

2430

						      op, dst->picture, color,

2431

						      1, &rect);

2432

    } else {

2433

	gc = _cairo_xcb_screen_get_gc (dst->screen, dst->drawable, dst->depth);

2434

2435

	/* XXX color */

2436

	_cairo_xcb_connection_poly_fill_rectangle (dst->connection,

2437

						   dst->drawable, gc,

2438

						   1, &rect);

2439

2440

	_cairo_xcb_screen_put_gc (dst->screen, dst->depth, gc);

2441

2442

2443

    _cairo_xcb_connection_release (dst->connection);

2444

2445

    dst->deferred_clear = FALSE;

2446

    return CAIRO_STATUS_SUCCESS;

2447

2448

2449

enum {

2450

    NEED_CLIP_REGION = 0x1,

2451

    NEED_CLIP_SURFACE = 0x2,

2452

    FORCE_CLIP_REGION = 0x4,

2453

};

2454

2455

static cairo_bool_t

2456

need_bounded_clip (cairo_composite_rectangles_t *extents)

2457

2458

    unsigned int flags = NEED_CLIP_REGION;

2459

    if (! _cairo_clip_is_region (extents->clip))

2460

	flags |= NEED_CLIP_SURFACE;

2461

    return flags;

2462

2463

2464

static cairo_bool_t

2465

need_unbounded_clip (cairo_composite_rectangles_t *extents)

2466

2467

    unsigned int flags = 0;

2468

    if (! extents->is_bounded) {

2469

	flags |= NEED_CLIP_REGION;

2470

	if (! _cairo_clip_is_region (extents->clip))

2471

	    flags |= NEED_CLIP_SURFACE;

2472

2473

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

2474

	flags |= NEED_CLIP_SURFACE;

2475

    return flags;

2476

2477

2478

static cairo_status_t

2479

_clip_and_composite (cairo_xcb_surface_t	*dst,

2480

		     cairo_operator_t		 op,

2481

		     const cairo_pattern_t	*src,

2482

		     xcb_draw_func_t		 draw_func,

2483

		     xcb_draw_func_t		 mask_func,

2484

		     void			*draw_closure,

2485

		     cairo_composite_rectangles_t*extents,

2486

		     unsigned int need_clip)

2487

2488

    cairo_region_t *clip_region = NULL;

2489

    cairo_status_t status;

2490

2491

    status = _cairo_xcb_connection_acquire (dst->connection);

2492

    if (unlikely (status))

2493

	return status;

2494

2495

    if (dst->deferred_clear) {

2496

	status = _cairo_xcb_surface_clear (dst);

2497

	if (unlikely (status)) {

2498

	    _cairo_xcb_connection_release (dst->connection);

2499

	    return status;

2500

2501

2502

2503

    _cairo_xcb_surface_ensure_picture (dst);

2504

2505

    if (need_clip & NEED_CLIP_REGION) {

2506

	clip_region = _cairo_clip_get_region (extents->clip);

2507

	if ((need_clip & FORCE_CLIP_REGION) == 0 && clip_region != NULL &&

2508

	    cairo_region_contains_rectangle (clip_region,

2509

					     &extents->unbounded) == CAIRO_REGION_OVERLAP_IN)

2510

	    clip_region = NULL;

2511

	if (clip_region != NULL) {

2512

	    status = _cairo_xcb_surface_set_clip_region (dst, clip_region);

2513

	    if (unlikely (status)) {

2514

		_cairo_xcb_connection_release (dst->connection);

2515

		return status;

2516

2517

2518

2519

2520

    if (reduce_alpha_op (&dst->base, op, src)) {

2521

	op = CAIRO_OPERATOR_ADD;

2522

	src = NULL;

2523

2524

2525

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

2526

	if (op == CAIRO_OPERATOR_SOURCE) {

2527

	    status = _clip_and_composite_source (extents->clip, src,

2528

						 draw_func, mask_func, draw_closure,

2529

						 dst, &extents->bounded);

2530

	} else {

2531

	    if (op == CAIRO_OPERATOR_CLEAR) {

2532

		op = CAIRO_OPERATOR_DEST_OUT;

2533

		src = NULL;

2534

2535

2536

	    if (need_clip & NEED_CLIP_SURFACE) {

2537

		if (extents->is_bounded) {

2538

		    status = _clip_and_composite_with_mask (extents->clip, op, src,

2539

							    draw_func,

2540

							    mask_func,

2541

							    draw_closure,

2542

							    dst, &extents->bounded);

2543

		} else {

2544

		    status = _clip_and_composite_combine (extents->clip, op, src,

2545

							  draw_func, draw_closure,

2546

							  dst, &extents->bounded);

2547

2548

	    } else {

2549

		status = draw_func (draw_closure,

2550

				    dst, op, src,

2551

				    0, 0,

2552

				    &extents->bounded,

2553

				    extents->clip);

2554

2555

2556

2557

2558

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

2559

	if (need_clip & NEED_CLIP_SURFACE)

2560

	    status = _cairo_xcb_surface_fixup_unbounded_with_mask (dst, extents, extents->clip);

2561

	else

2562

	    status = _cairo_xcb_surface_fixup_unbounded (dst, extents);

2563

2564

2565

    if (clip_region)

2566

	_cairo_xcb_surface_clear_clip_region (dst);

2567

2568

    _cairo_xcb_connection_release (dst->connection);

2569

2570

    return status;

2571

2572

2573

static cairo_status_t

2574

_core_boxes (cairo_xcb_surface_t *dst,

2575

	     cairo_operator_t op,

2576

	     const cairo_pattern_t *src,

2577

	     cairo_boxes_t *boxes,

2578

	     const cairo_composite_rectangles_t *extents)

2579

2580

    if (! boxes->is_pixel_aligned)

2581

	return CAIRO_INT_STATUS_UNSUPPORTED;

2582

2583

    if (! _cairo_clip_is_region (extents->clip))

2584

	return CAIRO_INT_STATUS_UNSUPPORTED;

2585

2586

    if (op == CAIRO_OPERATOR_CLEAR)

2587

	return _cairo_xcb_surface_core_fill_boxes (dst, CAIRO_COLOR_TRANSPARENT, boxes);

2588

2589

    if (op == CAIRO_OPERATOR_OVER) {

2590

	if (dst->base.is_clear || _cairo_pattern_is_opaque (src, &extents->bounded))

2591

	    op = CAIRO_OPERATOR_SOURCE;

2592

2593

    if (op != CAIRO_OPERATOR_SOURCE)

2594

	return CAIRO_INT_STATUS_UNSUPPORTED;

2595

2596

    if (src->type == CAIRO_PATTERN_TYPE_SOLID) {

2597

	return _cairo_xcb_surface_core_fill_boxes (dst,

2598

						   &((cairo_solid_pattern_t *) src)->color,

2599

						   boxes);

2600

2601

2602

    return _cairo_xcb_surface_core_copy_boxes (dst, src, &extents->bounded, boxes);

2603

2604

2605

static cairo_status_t

2606

33

_composite_boxes (cairo_xcb_surface_t *dst,

2607

		  cairo_operator_t op,

2608

		  const cairo_pattern_t *src,

2609

		  cairo_boxes_t *boxes,

2610

		  const cairo_composite_rectangles_t *extents)

2611

2612

33

    cairo_clip_t *clip = extents->clip;

2613

33

    cairo_bool_t need_clip_mask = ! _cairo_clip_is_region (clip);

2614

    cairo_status_t status;

2615

2616

    /* If the boxes are not pixel-aligned, we will need to compute a real mask */

2617

33

    if (! boxes->is_pixel_aligned)

2618

	return CAIRO_INT_STATUS_UNSUPPORTED;

2619

2620

33

    if (need_clip_mask &&

2621

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

2622

2623

	return CAIRO_INT_STATUS_UNSUPPORTED;

2624

2625

2626

33

    status = _cairo_xcb_connection_acquire (dst->connection);

2627

33

    if (unlikely (status))

2628

	return status;

2629

2630

33

    _cairo_xcb_surface_ensure_picture (dst);

2631

33

    if (dst->connection->flags & CAIRO_XCB_RENDER_HAS_FILL_RECTANGLES && ! need_clip_mask &&

2632

27

	(op == CAIRO_OPERATOR_CLEAR || src->type == CAIRO_PATTERN_TYPE_SOLID))

2633

30

2634

	const cairo_color_t *color;

2635

2636

30

	if (op == CAIRO_OPERATOR_CLEAR)

2637

6

	    color = CAIRO_COLOR_TRANSPARENT;

2638

	else

2639

24

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

2640

2641

30

	status = _render_fill_boxes (dst, op, color, boxes);

2642

2643

    else

2644

2645

	cairo_surface_pattern_t mask;

2646

2647

3

	if (need_clip_mask) {

2648

	    cairo_xcb_surface_t *clip_surface;

2649

	    int clip_x = 0, clip_y = 0;

2650

2651

	    clip_surface = get_clip_surface (extents->clip, dst,

2652

					     &clip_x, &clip_y);

2653

	    if (unlikely (clip_surface->base.status))

2654

		return clip_surface->base.status;

2655

2656

	    _cairo_pattern_init_for_surface (&mask, &clip_surface->base);

2657

	    mask.base.filter = CAIRO_FILTER_NEAREST;

2658

	    cairo_matrix_init_translate (&mask.base.matrix,

2659

					 -clip_x,

2660

					 -clip_y);

2661

	    cairo_surface_destroy (&clip_surface->base);

2662

2663

	    if (op == CAIRO_OPERATOR_CLEAR) {

2664

		src = NULL;

2665

		op = CAIRO_OPERATOR_DEST_OUT;

2666

2667

2668

2669

3

	status = _render_composite_boxes (dst, op, src,

2670

					  need_clip_mask ? &mask.base : NULL,

2671

					  &extents->bounded, boxes);

2672

2673

3

	if (need_clip_mask)

2674

	    _cairo_pattern_fini (&mask.base);

2675

2676

2677

33

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

2678

	status =

2679

	    _cairo_xcb_surface_fixup_unbounded_boxes (dst, extents,

2680

						      clip, boxes);

2681

2682

2683

33

    _cairo_xcb_connection_release (dst->connection);

2684

2685

33

    return status;

2686

2687

2688

static cairo_bool_t

2689

cairo_boxes_for_each_box (cairo_boxes_t *boxes,

2690

			  cairo_bool_t (*func) (cairo_box_t *box,

2691

						void *data),

2692

			  void *data)

2693

2694

    struct _cairo_boxes_chunk *chunk;

2695

    int i;

2696

2697

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

2698

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

2699

	    if (! func (&chunk->base[i], data))

2700

		return FALSE;

2701

2702

2703

    return TRUE;

2704

2705

2706

struct _image_contains_box {

2707

    int width, height;

2708

    int tx, ty;

2709

};

2710

2711

static cairo_bool_t image_contains_box (cairo_box_t *box, void *closure)

2712

2713

    struct _image_contains_box *data = closure;

2714

2715

    /* The box is pixel-aligned so the truncation is safe. */

2716

    return

2717

	_cairo_fixed_integer_part (box->p1.x) + data->tx >= 0 &&

2718

	_cairo_fixed_integer_part (box->p1.y) + data->ty >= 0 &&

2719

	_cairo_fixed_integer_part (box->p2.x) + data->tx <= data->width &&

2720

	_cairo_fixed_integer_part (box->p2.y) + data->ty <= data->height;

2721

2722

2723

struct _image_upload_box {

2724

    cairo_xcb_surface_t *surface;

2725

    cairo_image_surface_t *image;

2726

    xcb_gcontext_t gc;

2727

    int tx, ty;

2728

};

2729

2730

static cairo_bool_t image_upload_box (cairo_box_t *box, void *closure)

2731

2732

    const struct _image_upload_box *iub = closure;

2733

    /* The box is pixel-aligned so the truncation is safe. */

2734

    int x = _cairo_fixed_integer_part (box->p1.x);

2735

    int y = _cairo_fixed_integer_part (box->p1.y);

2736

    int width  = _cairo_fixed_integer_part (box->p2.x - box->p1.x);

2737

    int height = _cairo_fixed_integer_part (box->p2.y - box->p1.y);

2738

    int bpp = PIXMAN_FORMAT_BPP (iub->image->pixman_format);

2739

    int len = CAIRO_STRIDE_FOR_WIDTH_BPP (width, bpp);

2740

    if (len == iub->image->stride) {

2741

	_cairo_xcb_connection_put_image (iub->surface->connection,

2742

					 iub->surface->drawable,

2743

					 iub->gc,

2744

					 width, height,

2745

					 x, y,

2746

					 iub->image->depth,

2747

					 iub->image->stride,

2748

					 iub->image->data +

2749

					 (y + iub->ty) * iub->image->stride +

2750

					 (x + iub->tx) * bpp/8);

2751

    } else {

2752

	_cairo_xcb_connection_put_subimage (iub->surface->connection,

2753

					    iub->surface->drawable,

2754

					    iub->gc,

2755

					    x + iub->tx,

2756

					    y + iub->ty,

2757

					    width, height,

2758

					    bpp / 8,

2759

					    iub->image->stride,

2760

					    x, y,

2761

					    iub->image->depth,

2762

					    iub->image->data);

2763

2764

2765

    return TRUE;

2766

2767

2768

static cairo_status_t

2769

54

_upload_image_inplace (cairo_xcb_surface_t *surface,

2770

		       const cairo_pattern_t *source,

2771

		       cairo_boxes_t *boxes)

2772

2773

    const cairo_surface_pattern_t *pattern;

2774

    struct _image_contains_box icb;

2775

    struct _image_upload_box iub;

2776

    cairo_image_surface_t *image;

2777

    cairo_status_t status;

2778

    int tx, ty;

2779

2780

54

    if (! boxes->is_pixel_aligned)

2781

	return CAIRO_INT_STATUS_UNSUPPORTED;

2782

2783

54

    if (source->type != CAIRO_PATTERN_TYPE_SURFACE)

2784

48

	return CAIRO_INT_STATUS_UNSUPPORTED;

2785

2786

6

    pattern = (const cairo_surface_pattern_t *) source;

2787

6

    if (! _cairo_surface_is_image (pattern->surface))

2788

6

	return CAIRO_INT_STATUS_UNSUPPORTED;

2789

2790

    /* Have we already upload this image to a pixmap? */

2791

2792

	cairo_xcb_picture_t *snapshot;

2793

2794

	snapshot = (cairo_xcb_picture_t *)

2795

	    _cairo_surface_has_snapshot (pattern->surface, &_cairo_xcb_picture_backend);

2796

	if (snapshot != NULL) {

2797

	    if (snapshot->screen == surface->screen)

2798

		return CAIRO_INT_STATUS_UNSUPPORTED;

2799

2800

2801

2802

    image = (cairo_image_surface_t *) pattern->surface;

2803

    if (image->format == CAIRO_FORMAT_INVALID)

2804

	return CAIRO_INT_STATUS_UNSUPPORTED;

2805

2806

    if (image->depth != surface->depth)

2807

	return CAIRO_INT_STATUS_UNSUPPORTED;

2808

2809

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

2810

	return CAIRO_INT_STATUS_UNSUPPORTED;

2811

2812

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

2813

    icb.width = image->width;

2814

    icb.height = image->height;

2815

    icb.tx = tx;

2816

    icb.ty = ty;

2817

    if (! cairo_boxes_for_each_box (boxes, image_contains_box, &icb))

2818

	return CAIRO_INT_STATUS_UNSUPPORTED;

2819

2820

    if (surface->deferred_clear) {

2821

	status = _cairo_xcb_surface_clear (surface);

2822

	if (unlikely (status))

2823

	    return status;

2824

2825

2826

    status = _cairo_xcb_connection_acquire (surface->connection);

2827

    if (unlikely (status))

2828

	return status;

2829

2830

    iub.surface = surface;

2831

    iub.image = image;

2832

    iub.gc = _cairo_xcb_screen_get_gc (surface->screen,

2833

				       surface->drawable,

2834

				       image->depth);

2835

    iub.tx = tx;

2836

    iub.ty = ty;

2837

    cairo_boxes_for_each_box (boxes, image_upload_box, &iub);

2838

2839

    _cairo_xcb_screen_put_gc (surface->screen, image->depth, iub.gc);

2840

    _cairo_xcb_connection_release (surface->connection);

2841

2842

    return CAIRO_STATUS_SUCCESS;

2843

2844

2845

static cairo_int_status_t

2846

trim_extents_to_traps (cairo_composite_rectangles_t *extents,

2847

		       cairo_traps_t *traps)

2848

2849

    cairo_box_t box;

2850

2851

    /* X trims the affected area to the extents of the trapezoids, so

2852

     * we need to compensate when fixing up the unbounded area.

2853

*/

2854

    _cairo_traps_extents (traps, &box);

2855

    return _cairo_composite_rectangles_intersect_mask_extents (extents, &box);

2856

2857

2858

static cairo_bool_t

2859

_mono_edge_is_vertical (const cairo_line_t *line)

2860

2861

    return _cairo_fixed_integer_round_down (line->p1.x) == _cairo_fixed_integer_round_down (line->p2.x);

2862

2863

2864

static cairo_bool_t

2865

_traps_are_pixel_aligned (cairo_traps_t *traps,

2866

			  cairo_antialias_t antialias)

2867

2868

    int i;

2869

2870

    if (antialias == CAIRO_ANTIALIAS_NONE) {

2871

	for (i = 0; i < traps->num_traps; i++) {

2872

	    if (! _mono_edge_is_vertical (&traps->traps[i].left)   ||

2873

		! _mono_edge_is_vertical (&traps->traps[i].right))

2874

2875

		traps->maybe_region = FALSE;

2876

		return FALSE;

2877

2878

2879

    } else {

2880

	for (i = 0; i < traps->num_traps; i++) {

2881

	    if (traps->traps[i].left.p1.x != traps->traps[i].left.p2.x   ||

2882

		traps->traps[i].right.p1.x != traps->traps[i].right.p2.x ||

2883

		! _cairo_fixed_is_integer (traps->traps[i].top)          ||

2884

		! _cairo_fixed_is_integer (traps->traps[i].bottom)       ||

2885

		! _cairo_fixed_is_integer (traps->traps[i].left.p1.x)    ||

2886

		! _cairo_fixed_is_integer (traps->traps[i].right.p1.x))

2887

2888

		traps->maybe_region = FALSE;

2889

		return FALSE;

2890

2891

2892

2893

2894

    return TRUE;

2895

2896

2897

static void

2898

_boxes_for_traps (cairo_boxes_t *boxes,

2899

		  cairo_traps_t *traps,

2900

		  cairo_antialias_t antialias)

2901

2902

    int i, j;

2903

2904

    _cairo_boxes_init (boxes);

2905

2906

    boxes->chunks.base  = (cairo_box_t *) traps->traps;

2907

    boxes->chunks.size  = traps->num_traps;

2908

2909

    if (antialias != CAIRO_ANTIALIAS_NONE) {

2910

	for (i = j = 0; i < traps->num_traps; i++) {

2911

	    /* Note the traps and boxes alias so we need to take the local copies first. */

2912

	    cairo_fixed_t x1 = traps->traps[i].left.p1.x;

2913

	    cairo_fixed_t x2 = traps->traps[i].right.p1.x;

2914

	    cairo_fixed_t y1 = traps->traps[i].top;

2915

	    cairo_fixed_t y2 = traps->traps[i].bottom;

2916

2917

	    if (x1 == x2 || y1 == y2)

2918

		    continue;

2919

2920

	    boxes->chunks.base[j].p1.x = x1;

2921

	    boxes->chunks.base[j].p1.y = y1;

2922

	    boxes->chunks.base[j].p2.x = x2;

2923

	    boxes->chunks.base[j].p2.y = y2;

2924

	    j++;

2925

2926

	    if (boxes->is_pixel_aligned) {

2927

		boxes->is_pixel_aligned =

2928

		    _cairo_fixed_is_integer (x1) && _cairo_fixed_is_integer (y1) &&

2929

		    _cairo_fixed_is_integer (x2) && _cairo_fixed_is_integer (y2);

2930

2931

2932

    } else {

2933

	boxes->is_pixel_aligned = TRUE;

2934

2935

	for (i = j = 0; i < traps->num_traps; i++) {

2936

	    /* Note the traps and boxes alias so we need to take the local copies first. */

2937

	    cairo_fixed_t x1 = traps->traps[i].left.p1.x;

2938

	    cairo_fixed_t x2 = traps->traps[i].right.p1.x;

2939

	    cairo_fixed_t y1 = traps->traps[i].top;

2940

	    cairo_fixed_t y2 = traps->traps[i].bottom;

2941

2942

	    /* round down here to match Pixman's behavior when using traps. */

2943

	    boxes->chunks.base[j].p1.x = _cairo_fixed_round_down (x1);

2944

	    boxes->chunks.base[j].p1.y = _cairo_fixed_round_down (y1);

2945

	    boxes->chunks.base[j].p2.x = _cairo_fixed_round_down (x2);

2946

	    boxes->chunks.base[j].p2.y = _cairo_fixed_round_down (y2);

2947

2948

	    j += (boxes->chunks.base[j].p1.x != boxes->chunks.base[j].p2.x &&

2949

		  boxes->chunks.base[j].p1.y != boxes->chunks.base[j].p2.y);

2950

2951

2952

2953

    boxes->num_boxes    = j;

2954

    boxes->chunks.count = j;

2955

2956

2957

static cairo_status_t

2958

_composite_polygon (cairo_xcb_surface_t *dst,

2959

		    cairo_operator_t op,

2960

		    const cairo_pattern_t *source,

2961

		    cairo_polygon_t *polygon,

2962

		    cairo_antialias_t antialias,

2963

		    cairo_fill_rule_t fill_rule,

2964

		    cairo_composite_rectangles_t *extents)

2965

2966

    composite_traps_info_t traps;

2967

    cairo_bool_t clip_surface = ! _cairo_clip_is_region (extents->clip);

2968

    cairo_region_t *clip_region = _cairo_clip_get_region (extents->clip);

2969

    cairo_status_t status;

2970

2971

    if (polygon->num_edges == 0) {

2972

	status = CAIRO_STATUS_SUCCESS;

2973

2974

	if (! extents->is_bounded) {

2975

	    if (cairo_region_contains_rectangle (clip_region, &extents->unbounded) == CAIRO_REGION_OVERLAP_IN)

2976

		clip_region = NULL;

2977

2978

	    if (clip_surface == FALSE) {

2979

		if (clip_region != NULL) {

2980

		    status = _cairo_xcb_surface_set_clip_region (dst, clip_region);

2981

		    if (unlikely (status))

2982

			return status;

2983

2984

2985

		status = _cairo_xcb_surface_fixup_unbounded (dst, extents);

2986

2987

		if (clip_region != NULL)

2988

		    _cairo_xcb_surface_clear_clip_region (dst);

2989

	    } else {

2990

		status = _cairo_xcb_surface_fixup_unbounded_with_mask (dst,

2991

								       extents,

2992

								       extents->clip);

2993

2994

2995

2996

	return status;

2997

2998

2999

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

3000

	cairo_polygon_t clipper;

3001

	cairo_fill_rule_t clipper_fill_rule;

3002

	cairo_antialias_t clipper_antialias;

3003

3004

	status = _cairo_clip_get_polygon (extents->clip,

3005

					  &clipper,

3006

					  &clipper_fill_rule,

3007

					  &clipper_antialias);

3008

	if (likely (status == CAIRO_STATUS_SUCCESS)) {

3009

	    if (clipper_antialias == antialias) {

3010

		status = _cairo_polygon_intersect (polygon, fill_rule,

3011

						   &clipper, clipper_fill_rule);

3012

		if (likely (status == CAIRO_STATUS_SUCCESS)) {

3013

		    cairo_clip_t * clip = _cairo_clip_copy_region (extents->clip);

3014

		    _cairo_clip_destroy (extents->clip);

3015

		    extents->clip = clip;

3016

3017

		    fill_rule = CAIRO_FILL_RULE_WINDING;

3018

3019

		_cairo_polygon_fini (&clipper);

3020

3021

3022

3023

3024

    _cairo_traps_init (&traps.traps);

3025

3026

    status = _cairo_bentley_ottmann_tessellate_polygon (&traps.traps, polygon, fill_rule);

3027

    if (unlikely (status))

3028

	goto CLEANUP_TRAPS;

3029

3030

    if (traps.traps.has_intersections) {

3031

	if (traps.traps.is_rectangular)

3032

	    status = _cairo_bentley_ottmann_tessellate_rectangular_traps (&traps.traps, CAIRO_FILL_RULE_WINDING);

3033

	else if (traps.traps.is_rectilinear)

3034

	    status = _cairo_bentley_ottmann_tessellate_rectilinear_traps (&traps.traps, CAIRO_FILL_RULE_WINDING);

3035

	else

3036

	    status = _cairo_bentley_ottmann_tessellate_traps (&traps.traps, CAIRO_FILL_RULE_WINDING);

3037

	if (unlikely (status))

3038

	    goto CLEANUP_TRAPS;

3039

3040

3041

    /* Use a fast path if the trapezoids consist of a simple region,

3042

     * but we can only do this if we do not have a clip surface, or can

3043

     * substitute the mask with the clip.

3044

*/

3045

    if (traps.traps.maybe_region &&

3046

	_traps_are_pixel_aligned (&traps.traps, antialias) &&

3047

	(! clip_surface ||

3048

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

3049

3050

	cairo_boxes_t boxes;

3051

3052

	_boxes_for_traps (&boxes, &traps.traps, antialias);

3053

	status = _clip_and_composite_boxes (dst, op, source, &boxes, extents);

3054

3055

    else

3056

3057

	/* Otherwise render the trapezoids to a mask and composite in the usual

3058

	 * fashion.

3059

*/

3060

	traps.antialias = antialias;

3061

	status = trim_extents_to_traps (extents, &traps.traps);

3062

	if (likely (status == CAIRO_STATUS_SUCCESS)) {

3063

	    unsigned int flags = 0;

3064

3065

	    /* For unbounded operations, the X11 server will estimate the

3066

	     * affected rectangle and apply the operation to that. However,

3067

	     * there are cases where this is an overestimate (e.g. the

3068

	     * clip-fill-{eo,nz}-unbounded test).

3069

3070

	     * The clip will trim that overestimate to our expectations.

3071

*/

3072

	    if (! extents->is_bounded)

3073

		flags |= FORCE_CLIP_REGION;

3074

3075

	    status = _clip_and_composite (dst, op, source, _composite_traps,

3076

					  NULL, &traps, extents,

3077

					  need_unbounded_clip (extents) | flags);

3078

3079

3080

3081

CLEANUP_TRAPS:

3082

    _cairo_traps_fini (&traps.traps);

3083

3084

    return status;

3085

3086

3087

static cairo_status_t

3088

33

_clip_and_composite_boxes (cairo_xcb_surface_t *dst,

3089

			   cairo_operator_t op,

3090

			   const cairo_pattern_t *src,

3091

			   cairo_boxes_t *boxes,

3092

			   cairo_composite_rectangles_t *extents)

3093

3094

    composite_traps_info_t info;

3095

    cairo_int_status_t status;

3096

3097

33

    if (boxes->num_boxes == 0 && extents->is_bounded)

3098

	return CAIRO_STATUS_SUCCESS;

3099

3100

33

    if (boxes->is_pixel_aligned && _cairo_clip_is_region (extents->clip) &&

3101

9

	(op == CAIRO_OPERATOR_SOURCE ||

3102

9

	 (dst->base.is_clear && (op == CAIRO_OPERATOR_OVER || op == CAIRO_OPERATOR_ADD))))

3103

3104

27

	if (boxes->num_boxes == 1 &&

3105

15

	    extents->bounded.width  == dst->width &&

3106

3

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

3107

3108

3

	    op = CAIRO_OPERATOR_SOURCE;

3109

3

	    dst->deferred_clear = FALSE;

3110

3111

3112

27

	status = _upload_image_inplace (dst, src, boxes);

3113

27

	if (status != CAIRO_INT_STATUS_UNSUPPORTED)

3114

	    return status;

3115

3116

3117

    /* Can we reduce drawing through a clip-mask to simply drawing the clip? */

3118

33

    if (dst->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE_TRAPEZOIDS &&

3119

33

	    extents->clip->path != NULL && extents->is_bounded) {

3120

	cairo_polygon_t polygon;

3121

	cairo_fill_rule_t fill_rule;

3122

	cairo_antialias_t antialias;

3123

	cairo_clip_t *clip;

3124

3125

	clip = _cairo_clip_copy (extents->clip);

3126

	clip = _cairo_clip_intersect_boxes (clip, boxes);

3127

	if (_cairo_clip_is_all_clipped (clip))

3128

		return CAIRO_INT_STATUS_NOTHING_TO_DO;

3129

3130

	status = _cairo_clip_get_polygon (clip, &polygon,

3131

					  &fill_rule, &antialias);

3132

	_cairo_clip_path_destroy (clip->path);

3133

	clip->path = NULL;

3134

	if (likely (status == CAIRO_INT_STATUS_SUCCESS)) {

3135

	    cairo_clip_t *saved_clip = extents->clip;

3136

	    extents->clip = clip;

3137

	    status = _composite_polygon (dst, op, src,

3138

					 &polygon,

3139

					 antialias,

3140

					 fill_rule,

3141

					 extents);

3142

	    clip = extents->clip;

3143

	    extents->clip = saved_clip;

3144

	    _cairo_polygon_fini (&polygon);

3145

3146

	if (clip)

3147

	    _cairo_clip_destroy (clip);

3148

3149

	if (status != CAIRO_INT_STATUS_UNSUPPORTED)

3150

	    return status;

3151

3152

3153

33

    if (dst->deferred_clear) {

3154

	status = _cairo_xcb_surface_clear (dst);

3155

	if (unlikely (status))

3156

	    return status;

3157

3158

3159

66

    if (boxes->is_pixel_aligned &&

3160

66

	_cairo_clip_is_region (extents->clip) &&

3161

	op == CAIRO_OPERATOR_SOURCE) {

3162

27

	status = _upload_image_inplace (dst, src, boxes);

3163

27

	if (status != CAIRO_INT_STATUS_UNSUPPORTED)

3164

	    return status;

3165

3166

3167

33

    if ((dst->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE) == 0)

3168

	return _core_boxes (dst, op, src, boxes, extents);

3169

3170

    /* Use a fast path if the boxes are pixel aligned */

3171

33

    status = _composite_boxes (dst, op, src, boxes, extents);

3172

33

    if (status != CAIRO_INT_STATUS_UNSUPPORTED)

3173

33

	return status;

3174

3175

    if ((dst->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE_TRAPEZOIDS) == 0)

3176

	return CAIRO_INT_STATUS_UNSUPPORTED;

3177

3178

    /* Otherwise render via a mask and composite in the usual fashion.  */

3179

    status = _cairo_traps_init_boxes (&info.traps, boxes);

3180

    if (unlikely (status))

3181

	return status;

3182

3183

    info.antialias = CAIRO_ANTIALIAS_DEFAULT;

3184

    status = trim_extents_to_traps (extents, &info.traps);

3185

    if (status == CAIRO_INT_STATUS_SUCCESS) {

3186

	status = _clip_and_composite (dst, op, src,

3187

				      _composite_traps, NULL, &info,

3188

				      extents, need_unbounded_clip (extents));

3189

3190

3191

    _cairo_traps_fini (&info.traps);

3192

    return status;

3193

3194

3195

static cairo_int_status_t

3196

_composite_mask (void				*closure,

3197

		 cairo_xcb_surface_t		*dst,

3198

		 cairo_operator_t		 op,

3199

		 const cairo_pattern_t		*src_pattern,

3200

		 int				 dst_x,

3201

		 int				 dst_y,

3202

		 const cairo_rectangle_int_t	*extents,

3203

		 cairo_clip_t			*clip)

3204

3205

    const cairo_pattern_t *mask_pattern = closure;

3206

    cairo_xcb_picture_t *src, *mask = NULL;

3207

    cairo_status_t status;

3208

3209

    if (dst->base.is_clear) {

3210

	if (op == CAIRO_OPERATOR_OVER || op == CAIRO_OPERATOR_ADD)

3211

	    op = CAIRO_OPERATOR_SOURCE;

3212

3213

3214

    if (op == CAIRO_OPERATOR_SOURCE && clip == NULL)

3215

	dst->deferred_clear = FALSE;

3216

3217

    if (dst->deferred_clear) {

3218

	status = _cairo_xcb_surface_clear (dst);

3219

	if (unlikely (status))

3220

		return status;

3221

3222

3223

    if (src_pattern != NULL) {

3224

	src = _cairo_xcb_picture_for_pattern (dst, src_pattern, extents);

3225

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

3226

	    return src->base.status;

3227

3228

	mask = _cairo_xcb_picture_for_pattern (dst, mask_pattern, extents);

3229

	if (unlikely (mask->base.status)) {

3230

	    cairo_surface_destroy (&src->base);

3231

	    return mask->base.status;

3232

3233

3234

	_cairo_xcb_connection_render_composite (dst->connection,

3235

						_render_operator (op),

3236

						src->picture,

3237

						mask->picture,

3238

						dst->picture,

3239

						extents->x + src->x,  extents->y + src->y,

3240

						extents->x + mask->x, extents->y + mask->y,

3241

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

3242

						extents->width,       extents->height);

3243

	cairo_surface_destroy (&mask->base);

3244

	cairo_surface_destroy (&src->base);

3245

    } else {

3246

	src = _cairo_xcb_picture_for_pattern (dst, mask_pattern, extents);

3247

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

3248

	    return src->base.status;

3249

3250

	_cairo_xcb_connection_render_composite (dst->connection,

3251

						_render_operator (op),

3252

						src->picture,

3253

						XCB_NONE,

3254

						dst->picture,

3255

						extents->x + src->x,  extents->y + src->y,

3256

						0, 0,

3257

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

3258

						extents->width,       extents->height);

3259

	cairo_surface_destroy (&src->base);

3260

3261

3262

    return CAIRO_STATUS_SUCCESS;

3263

3264

3265

struct composite_box_info {

3266

    cairo_xcb_surface_t *dst;

3267

    cairo_xcb_picture_t *src;

3268

    uint8_t op;

3269

};

3270

3271

static void composite_box(void *closure,

3272

			  int16_t x, int16_t y,

3273

			  int16_t w, int16_t h,

3274

			  uint16_t coverage)

3275

3276

    struct composite_box_info *info = closure;

3277

3278

    if (coverage < 0xff00) {

3279

	cairo_xcb_picture_t *mask;

3280

	cairo_color_t color;

3281

3282

	color.red_short = color.green_short = color.blue_short = 0;

3283

	color.alpha_short = coverage;

3284

3285

	mask = _solid_picture (info->dst, &color);

3286

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

3287

	    _cairo_xcb_connection_render_composite (info->dst->connection,

3288

						    info->op,

3289

						    info->src->picture,

3290

						    mask->picture,

3291

						    info->dst->picture,

3292

						    x + info->src->x,  y + info->src->y,

3293

						    0,                 0,

3294

						    x,                 y,

3295

						    w,                 h);

3296

3297

	cairo_surface_destroy (&mask->base);

3298

    } else {

3299

	_cairo_xcb_connection_render_composite (info->dst->connection,

3300

						info->op,

3301

						info->src->picture,

3302

						XCB_NONE,

3303

						info->dst->picture,

3304

						x + info->src->x,  y + info->src->y,

3305

						0,                 0,

3306

						x,                 y,

3307

						w,                 h);

3308

3309

3310

3311

static cairo_int_status_t

3312

_composite_mask_clip_boxes (void			*closure,

3313

			    cairo_xcb_surface_t		*dst,

3314

			    cairo_operator_t		 op,

3315

			    const cairo_pattern_t	*src_pattern,

3316

			    int				 dst_x,

3317

			    int				 dst_y,

3318

			    const cairo_rectangle_int_t	*extents,

3319

			    cairo_clip_t		*clip)

3320

3321

    struct composite_box_info info;

3322

    cairo_status_t status;

3323

    int i;

3324

3325

    assert (src_pattern == NULL);

3326

    assert (op == CAIRO_OPERATOR_ADD);

3327

    assert (dst->base.is_clear);

3328

3329

    if (clip->num_boxes > 1) {

3330

	status = _cairo_xcb_surface_clear (dst);

3331

	if (unlikely (status))

3332

	    return status;

3333

3334

3335

    info.op = XCB_RENDER_PICT_OP_SRC;

3336

    info.dst = dst;

3337

    info.src = _cairo_xcb_picture_for_pattern (dst, closure, extents);

3338

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

3339

	return info.src->base.status;

3340

3341

    info.src->x += dst_x;

3342

    info.src->y += dst_y;

3343

3344

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

3345

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

3346

    cairo_surface_destroy (&info.src->base);

3347

3348

    return CAIRO_STATUS_SUCCESS;

3349

3350

3351

static cairo_int_status_t

3352

_composite_mask_clip (void				*closure,

3353

		      cairo_xcb_surface_t		*dst,

3354

		      cairo_operator_t			 op,

3355

		      const cairo_pattern_t		*src_pattern,

3356

		      int				 dst_x,

3357

		      int				 dst_y,

3358

		      const cairo_rectangle_int_t	*extents,

3359

		      cairo_clip_t			*clip)

3360

3361

    const cairo_pattern_t *mask_pattern = closure;

3362

    cairo_polygon_t polygon;

3363

    cairo_fill_rule_t fill_rule;

3364

    composite_traps_info_t info;

3365

    cairo_status_t status;

3366

3367

    assert (src_pattern == NULL);

3368

    assert (op == CAIRO_OPERATOR_ADD);

3369

    assert (dst->base.is_clear);

3370

3371

    status = _cairo_clip_get_polygon (clip, &polygon,

3372

				      &fill_rule, &info.antialias);

3373

    if (unlikely (status))

3374

	return status;

3375

3376

    _cairo_traps_init (&info.traps);

3377

    status = _cairo_bentley_ottmann_tessellate_polygon (&info.traps,

3378

							&polygon,

3379

							fill_rule);

3380

    _cairo_polygon_fini (&polygon);

3381

    if (unlikely (status))

3382

	return status;

3383

3384

    if (info.traps.has_intersections) {

3385

	if (info.traps.is_rectangular)

3386

	    status = _cairo_bentley_ottmann_tessellate_rectangular_traps (&info.traps, CAIRO_FILL_RULE_WINDING);

3387

	else if (info.traps.is_rectilinear)

3388

	    status = _cairo_bentley_ottmann_tessellate_rectilinear_traps (&info.traps, CAIRO_FILL_RULE_WINDING);

3389

	else

3390

	    status = _cairo_bentley_ottmann_tessellate_traps (&info.traps, CAIRO_FILL_RULE_WINDING);

3391

	if (unlikely (status)) {

3392

	    _cairo_traps_fini (&info.traps);

3393

	    return status;

3394

3395

3396

3397

    status = _composite_traps (&info,

3398

			       dst, CAIRO_OPERATOR_SOURCE, mask_pattern,

3399

			       dst_x, dst_y,

3400

			       extents, NULL);

3401

    _cairo_traps_fini (&info.traps);

3402

3403

    return status;

3404

3405

3406

struct composite_opacity_info {

3407

    uint8_t op;

3408

    cairo_xcb_surface_t *dst;

3409

    cairo_xcb_picture_t *src;

3410

    double opacity;

3411

};

3412

3413

static void composite_opacity(void *closure,

3414

			      int16_t x, int16_t y,

3415

			      int16_t w, int16_t h,

3416

			      uint16_t coverage)

3417

3418

    struct composite_opacity_info *info = closure;

3419

    cairo_xcb_picture_t *mask;

3420

    cairo_color_t color;

3421

3422

    color.red_short = color.green_short = color.blue_short = 0;

3423

    color.alpha_short = info->opacity * coverage;

3424

3425

    mask = _solid_picture (info->dst, &color);

3426

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

3427

	if (info->src) {

3428

	    _cairo_xcb_connection_render_composite (info->dst->connection,

3429

						    info->op,

3430

						    info->src->picture,

3431

						    mask->picture,

3432

						    info->dst->picture,

3433

						    x + info->src->x,  y + info->src->y,

3434

						    0,                 0,

3435

						    x,                 y,

3436

						    w,                 h);

3437

	} else {

3438

	    _cairo_xcb_connection_render_composite (info->dst->connection,

3439

						    info->op,

3440

						    mask->picture,

3441

						    XCB_NONE,

3442

						    info->dst->picture,

3443

						    0,                 0,

3444

						    0,                 0,

3445

						    x,                 y,

3446

						    w,                 h);

3447

3448

3449

3450

    cairo_surface_destroy (&mask->base);

3451

3452

3453

static cairo_int_status_t

3454

_composite_opacity_boxes (void				*closure,

3455

			  cairo_xcb_surface_t		*dst,

3456

			  cairo_operator_t		 op,

3457

			  const cairo_pattern_t		*src_pattern,

3458

			  int				 dst_x,

3459

			  int				 dst_y,

3460

			  const cairo_rectangle_int_t	*extents,

3461

			  cairo_clip_t			*clip)

3462

3463

    const cairo_solid_pattern_t *mask_pattern = closure;

3464

    struct composite_opacity_info info;

3465

    cairo_status_t status;

3466

    int i;

3467

3468

    if (dst->base.is_clear) {

3469

	if (op == CAIRO_OPERATOR_OVER || op == CAIRO_OPERATOR_ADD)

3470

	    op = CAIRO_OPERATOR_SOURCE;

3471

3472

3473

    if (op == CAIRO_OPERATOR_SOURCE &&

3474

	(clip == NULL ||

3475

	 (clip->extents.width >= extents->width &&

3476

	  clip->extents.height >= extents->height)))

3477

	dst->deferred_clear = FALSE;

3478

3479

    if (dst->deferred_clear) {

3480

	status = _cairo_xcb_surface_clear (dst);

3481

	if (unlikely (status))

3482

	    return status;

3483

3484

3485

    info.op = _render_operator (op);

3486

    info.dst = dst;

3487

3488

    if (src_pattern != NULL) {

3489

	info.src = _cairo_xcb_picture_for_pattern (dst, src_pattern, extents);

3490

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

3491

	    return info.src->base.status;

3492

    } else

3493

	info.src = NULL;

3494

3495

    info.opacity = mask_pattern->color.alpha;

3496

3497

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

3498

    if (clip) {

3499

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

3500

	    do_unaligned_box(composite_opacity, &info,

3501

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

3502

    } else {

3503

	composite_opacity(&info,

3504

			  extents->x - dst_x,

3505

			  extents->y - dst_y,

3506

			  extents->width,

3507

			  extents->height,

3508

			  0xffff);

3509

3510

    cairo_surface_destroy (&info.src->base);

3511

3512

    return CAIRO_STATUS_SUCCESS;

3513

3514

3515

/* high level rasteriser -> compositor */

3516

3517

cairo_int_status_t

3518

9

_cairo_xcb_render_compositor_paint (const cairo_compositor_t     *compositor,

3519

				    cairo_composite_rectangles_t *composite)

3520

3521

9

    cairo_xcb_surface_t *surface = (cairo_xcb_surface_t *) composite->surface;

3522

9

    cairo_operator_t op = composite->op;

3523

9

    cairo_pattern_t *source = &composite->source_pattern.base;

3524

    cairo_boxes_t boxes;

3525

    cairo_status_t status;

3526

3527

9

    if (unlikely (! _operator_is_supported (surface->connection->flags, op)))

3528

	return CAIRO_INT_STATUS_UNSUPPORTED;

3529

3530

9

    if ((surface->connection->flags & (CAIRO_XCB_RENDER_HAS_COMPOSITE_TRAPEZOIDS |

3531

				       CAIRO_XCB_RENDER_HAS_COMPOSITE)) == 0)

3532

3533

	return CAIRO_INT_STATUS_UNSUPPORTED;

3534

3535

3536

9

    if (composite->clip == NULL &&

3537

	source->type == CAIRO_PATTERN_TYPE_SOLID &&

3538

	(op == CAIRO_OPERATOR_SOURCE ||

3539

	 op == CAIRO_OPERATOR_CLEAR ||

3540

	 (surface->base.is_clear &&

3541

	  (op == CAIRO_OPERATOR_ADD || op == CAIRO_OPERATOR_OVER))))

3542

3543

	surface->deferred_clear = TRUE;

3544

	surface->deferred_clear_color = composite->source_pattern.solid.color;

3545

	return CAIRO_STATUS_SUCCESS;

3546

3547

3548

9

     _cairo_clip_steal_boxes(composite->clip, &boxes);

3549

9

     status = _clip_and_composite_boxes (surface, op, source, &boxes, composite);

3550

9

     _cairo_clip_unsteal_boxes (composite->clip, &boxes);

3551

3552

9

    return status;

3553

3554

3555

cairo_int_status_t

3556

_cairo_xcb_render_compositor_mask (const cairo_compositor_t     *compositor,

3557

				   cairo_composite_rectangles_t *composite)

3558

3559

    cairo_xcb_surface_t *surface = (cairo_xcb_surface_t *) composite->surface;

3560

    cairo_operator_t op = composite->op;

3561

    cairo_pattern_t *source = &composite->source_pattern.base;

3562

    cairo_pattern_t *mask = &composite->mask_pattern.base;

3563

    cairo_status_t status;

3564

3565

    if (unlikely (! _operator_is_supported (surface->connection->flags, op)))

3566

	return CAIRO_INT_STATUS_UNSUPPORTED;

3567

3568

    if ((surface->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE) == 0)

3569

	return CAIRO_INT_STATUS_UNSUPPORTED;

3570

3571

    if (mask->type == CAIRO_PATTERN_TYPE_SOLID &&

3572

	composite->clip->path == NULL &&

3573

	! _cairo_clip_is_region (composite->clip)) {

3574

	status = _clip_and_composite (surface, op, source,

3575

				      _composite_opacity_boxes,

3576

				      _composite_opacity_boxes,

3577

				      (void *) mask,

3578

				      composite, need_unbounded_clip (composite));

3579

    } else {

3580

	xcb_draw_func_t mask_func = NULL;

3581

	if (surface->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE_TRAPEZOIDS)

3582

	    mask_func = composite->clip->path ? _composite_mask_clip : _composite_mask_clip_boxes;

3583

	status = _clip_and_composite (surface, op, source,

3584

				      _composite_mask, mask_func,

3585

				      (void *) mask,

3586

				      composite, need_bounded_clip (composite));

3587

3588

3589

    return status;

3590

3591

3592

static cairo_int_status_t

3593

_cairo_xcb_surface_render_stroke_as_polygon (cairo_xcb_surface_t	*dst,

3594

					     cairo_operator_t		 op,

3595

					     const cairo_pattern_t	*source,

3596

					     const cairo_path_fixed_t		*path,

3597

					     const cairo_stroke_style_t	*stroke_style,

3598

					     const cairo_matrix_t	*ctm,

3599

					     const cairo_matrix_t	*ctm_inverse,

3600

					     double			 tolerance,

3601

					     cairo_antialias_t		 antialias,

3602

					     cairo_composite_rectangles_t *extents)

3603

3604

    cairo_polygon_t polygon;

3605

    cairo_status_t status;

3606

3607

    _cairo_polygon_init_with_clip (&polygon, extents->clip);

3608

    status = _cairo_path_fixed_stroke_to_polygon (path,

3609

						  stroke_style,

3610

						  ctm, ctm_inverse,

3611

						  tolerance,

3612

						  &polygon);

3613

    if (likely (status == CAIRO_STATUS_SUCCESS)) {

3614

	status = _composite_polygon (dst, op, source,

3615

				     &polygon, antialias,

3616

				     CAIRO_FILL_RULE_WINDING,

3617

				     extents);

3618

3619

    _cairo_polygon_fini (&polygon);

3620

3621

    return status;

3622

3623

3624

static cairo_status_t

3625

_cairo_xcb_surface_render_stroke_via_mask (cairo_xcb_surface_t		*dst,

3626

					   cairo_operator_t		 op,

3627

					   const cairo_pattern_t	*source,

3628

					   const cairo_path_fixed_t		*path,

3629

					   const cairo_stroke_style_t	*stroke_style,

3630

					   const cairo_matrix_t		*ctm,

3631

					   const cairo_matrix_t		*ctm_inverse,

3632

					   double			 tolerance,

3633

					   cairo_antialias_t		 antialias,

3634

					   cairo_composite_rectangles_t *extents)

3635

3636

    cairo_surface_t *image;

3637

    cairo_status_t status;

3638

    cairo_clip_t *clip;

3639

    int x, y;

3640

3641

    x = extents->bounded.x;

3642

    y = extents->bounded.y;

3643

    image = _cairo_xcb_surface_create_similar_image (dst, CAIRO_FORMAT_A8,

3644

						     extents->bounded.width,

3645

						     extents->bounded.height);

3646

    if (unlikely (image->status))

3647

	return image->status;

3648

3649

    clip = _cairo_clip_copy_region (extents->clip);

3650

    status = _cairo_surface_offset_stroke (image, x, y,

3651

					   CAIRO_OPERATOR_ADD,

3652

					   &_cairo_pattern_white.base,

3653

					   path, stroke_style,

3654

					   ctm, ctm_inverse,

3655

					   tolerance, antialias,

3656

					   clip);

3657

    _cairo_clip_destroy (clip);

3658

    if (likely (status == CAIRO_STATUS_SUCCESS)) {

3659

	cairo_surface_pattern_t mask;

3660

3661

	_cairo_pattern_init_for_surface (&mask, image);

3662

	mask.base.filter = CAIRO_FILTER_NEAREST;

3663

3664

	cairo_matrix_init_translate (&mask.base.matrix, -x, -y);

3665

	status = _clip_and_composite (dst, op, source,

3666

				      _composite_mask, NULL, &mask.base,

3667

				      extents, need_bounded_clip (extents));

3668

	_cairo_pattern_fini (&mask.base);

3669

3670

3671

    cairo_surface_finish (image);

3672

    cairo_surface_destroy (image);

3673

3674

    return status;

3675

3676

3677

cairo_int_status_t

3678

_cairo_xcb_render_compositor_stroke (const cairo_compositor_t     *compositor,

3679

				     cairo_composite_rectangles_t *composite,

3680

				     const cairo_path_fixed_t     *path,

3681

				     const cairo_stroke_style_t   *style,

3682

				     const cairo_matrix_t         *ctm,

3683

				     const cairo_matrix_t         *ctm_inverse,

3684

				     double                        tolerance,

3685

				     cairo_antialias_t             antialias)

3686

3687

    cairo_xcb_surface_t *surface = (cairo_xcb_surface_t *) composite->surface;

3688

    cairo_operator_t op = composite->op;

3689

    cairo_pattern_t *source = &composite->source_pattern.base;

3690

    cairo_int_status_t status;

3691

3692

    if (unlikely (! _operator_is_supported (surface->connection->flags, op)))

3693

	return CAIRO_INT_STATUS_UNSUPPORTED;

3694

3695

    if ((surface->connection->flags & (CAIRO_XCB_RENDER_HAS_COMPOSITE_TRAPEZOIDS |

3696

			   CAIRO_XCB_RENDER_HAS_COMPOSITE)) == 0)

3697

3698

	return CAIRO_INT_STATUS_UNSUPPORTED;

3699

3700

3701

    status = CAIRO_INT_STATUS_UNSUPPORTED;

3702

    if (_cairo_path_fixed_stroke_is_rectilinear (path)) {

3703

	cairo_boxes_t boxes;

3704

3705

	_cairo_boxes_init_with_clip (&boxes, composite->clip);

3706

	status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path,

3707

								style,

3708

								ctm,

3709

								antialias,

3710

								&boxes);

3711

	if (likely (status == CAIRO_INT_STATUS_SUCCESS)) {

3712

	    status = _clip_and_composite_boxes (surface, op, source,

3713

						&boxes, composite);

3714

3715

	_cairo_boxes_fini (&boxes);

3716

3717

3718

    if (status == CAIRO_INT_STATUS_UNSUPPORTED) {

3719

	if (surface->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE_TRAPEZOIDS) {

3720

	    status = _cairo_xcb_surface_render_stroke_as_polygon (surface, op, source,

3721

								  path, style,

3722

								  ctm, ctm_inverse,

3723

								  tolerance, antialias,

3724

								  composite);

3725

	} else if (surface->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE) {

3726

	    status = _cairo_xcb_surface_render_stroke_via_mask (surface, op, source,

3727

								path, style,

3728

								ctm, ctm_inverse,

3729

								tolerance, antialias,

3730

								composite);

3731

	} else {

3732

	    ASSERT_NOT_REACHED;

3733

3734

3735

3736

    return status;

3737

3738

3739

static cairo_status_t

3740

_cairo_xcb_surface_render_fill_as_polygon (cairo_xcb_surface_t	*dst,

3741

					   cairo_operator_t	 op,

3742

					   const cairo_pattern_t*source,

3743

					   const cairo_path_fixed_t	*path,

3744

					   cairo_fill_rule_t	 fill_rule,

3745

					   double		 tolerance,

3746

					   cairo_antialias_t	 antialias,

3747

					   cairo_composite_rectangles_t *extents)

3748

3749

    cairo_polygon_t polygon;

3750

    cairo_status_t status;

3751

3752

    _cairo_polygon_init_with_clip (&polygon, extents->clip);

3753

    status = _cairo_path_fixed_fill_to_polygon (path, tolerance, &polygon);

3754

    if (likely (status == CAIRO_STATUS_SUCCESS)) {

3755

	status = _composite_polygon (dst, op, source,

3756

				     &polygon,

3757

				     antialias,

3758

				     fill_rule,

3759

				     extents);

3760

3761

    _cairo_polygon_fini (&polygon);

3762

3763

    return status;

3764

3765

3766

static cairo_status_t

3767

_cairo_xcb_surface_render_fill_via_mask (cairo_xcb_surface_t	*dst,

3768

					 cairo_operator_t	 op,

3769

					 const cairo_pattern_t	*source,

3770

					 const cairo_path_fixed_t	*path,

3771

					 cairo_fill_rule_t	 fill_rule,

3772

					 double			 tolerance,

3773

					 cairo_antialias_t	 antialias,

3774

					 cairo_composite_rectangles_t *extents)

3775

3776

    cairo_surface_t *image;

3777

    cairo_status_t status;

3778

    cairo_clip_t *clip;

3779

    int x, y;

3780

3781

    x = extents->bounded.x;

3782

    y = extents->bounded.y;

3783

    image = _cairo_xcb_surface_create_similar_image (dst, CAIRO_FORMAT_A8,

3784

						     extents->bounded.width,

3785

						     extents->bounded.height);

3786

    if (unlikely (image->status))

3787

	return image->status;

3788

3789

    clip = _cairo_clip_copy_region (extents->clip);

3790

    status = _cairo_surface_offset_fill (image, x, y,

3791

					 CAIRO_OPERATOR_ADD,

3792

					 &_cairo_pattern_white.base,

3793

					 path, fill_rule, tolerance, antialias,

3794

					 clip);

3795

    _cairo_clip_destroy (clip);

3796

    if (likely (status == CAIRO_STATUS_SUCCESS)) {

3797

	cairo_surface_pattern_t mask;

3798

3799

	_cairo_pattern_init_for_surface (&mask, image);

3800

	mask.base.filter = CAIRO_FILTER_NEAREST;

3801

3802

	cairo_matrix_init_translate (&mask.base.matrix, -x, -y);

3803

	status = _clip_and_composite (dst, op, source,

3804

				      _composite_mask, NULL, &mask.base,

3805

				      extents, need_bounded_clip (extents));

3806

3807

	_cairo_pattern_fini (&mask.base);

3808

3809

3810

    cairo_surface_finish (image);

3811

    cairo_surface_destroy (image);

3812

3813

    return status;

3814

3815

3816

cairo_int_status_t

3817

24

_cairo_xcb_render_compositor_fill (const cairo_compositor_t     *compositor,

3818

				   cairo_composite_rectangles_t *composite,

3819

				   const cairo_path_fixed_t     *path,

3820

				   cairo_fill_rule_t             fill_rule,

3821

				   double                        tolerance,

3822

				   cairo_antialias_t             antialias)

3823

3824

24

    cairo_xcb_surface_t *surface = (cairo_xcb_surface_t *) composite->surface;

3825

24

    cairo_operator_t op = composite->op;

3826

24

    cairo_pattern_t *source = &composite->source_pattern.base;

3827

    cairo_int_status_t status;

3828

3829

24

    if (unlikely (! _operator_is_supported (surface->connection->flags, op)))

3830

	return CAIRO_INT_STATUS_UNSUPPORTED;

3831

3832

24

    if ((surface->connection->flags & (CAIRO_XCB_RENDER_HAS_COMPOSITE_TRAPEZOIDS |

3833

				       CAIRO_XCB_RENDER_HAS_COMPOSITE)) == 0)

3834

3835

	return CAIRO_INT_STATUS_UNSUPPORTED;

3836

3837

3838

24

    status = CAIRO_INT_STATUS_UNSUPPORTED;

3839

24

    if (_cairo_path_fixed_fill_is_rectilinear (path)) {

3840

	cairo_boxes_t boxes;

3841

3842

24

	_cairo_boxes_init_with_clip (&boxes, composite->clip);

3843

24

	status = _cairo_path_fixed_fill_rectilinear_to_boxes (path,

3844

							      fill_rule,

3845

							      antialias,

3846

							      &boxes);

3847

24

	if (likely (status == CAIRO_INT_STATUS_SUCCESS)) {

3848

24

	    status = _clip_and_composite_boxes (surface, op, source,

3849

						&boxes, composite);

3850

3851

24

	_cairo_boxes_fini (&boxes);

3852

3853

3854

24

    if (status == CAIRO_INT_STATUS_UNSUPPORTED) {

3855

	if (surface->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE_TRAPEZOIDS) {

3856

	    status = _cairo_xcb_surface_render_fill_as_polygon (surface, op, source, path,

3857

								fill_rule, tolerance, antialias,

3858

								composite);

3859

	} else if (surface->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE) {

3860

	    status = _cairo_xcb_surface_render_fill_via_mask (surface, op, source, path,

3861

							      fill_rule, tolerance, antialias,

3862

							      composite);

3863

	} else {

3864

	    ASSERT_NOT_REACHED;

3865

3866

3867

3868

24

    return status;

3869

3870

3871

static cairo_status_t

3872

_cairo_xcb_surface_render_glyphs_via_mask (cairo_xcb_surface_t		*dst,

3873

					   cairo_operator_t		 op,

3874

					   const cairo_pattern_t	*source,

3875

					   cairo_scaled_font_t		*scaled_font,

3876

					   cairo_glyph_t		*glyphs,

3877

					   int				 num_glyphs,

3878

					   cairo_composite_rectangles_t *extents)

3879

3880

    cairo_surface_t *image;

3881

    cairo_content_t content;

3882

    cairo_status_t status;

3883

    cairo_clip_t *clip;

3884

    int x, y;

3885

3886

    content = CAIRO_CONTENT_ALPHA;

3887

    if (scaled_font->options.antialias == CAIRO_ANTIALIAS_SUBPIXEL)

3888

	content = CAIRO_CONTENT_COLOR_ALPHA;

3889

3890

    x = extents->bounded.x;

3891

    y = extents->bounded.y;

3892

    image = _cairo_xcb_surface_create_similar_image (dst,

3893

						     _cairo_format_from_content (content),

3894

						     extents->bounded.width,

3895

						     extents->bounded.height);

3896

    if (unlikely (image->status))

3897

	return image->status;

3898

3899

    clip = _cairo_clip_copy_region (extents->clip);

3900

    status = _cairo_surface_offset_glyphs (image, x, y,

3901

					   CAIRO_OPERATOR_ADD,

3902

					   &_cairo_pattern_white.base,

3903

					   scaled_font, glyphs, num_glyphs,

3904

					   clip);

3905

    _cairo_clip_destroy (clip);

3906

    if (likely (status == CAIRO_STATUS_SUCCESS)) {

3907

	cairo_surface_pattern_t mask;

3908

3909

	_cairo_pattern_init_for_surface (&mask, image);

3910

	mask.base.filter = CAIRO_FILTER_NEAREST;

3911

	if (content & CAIRO_CONTENT_COLOR)

3912

	    mask.base.has_component_alpha = TRUE;

3913

3914

	cairo_matrix_init_translate (&mask.base.matrix, -x, -y);

3915

	status = _clip_and_composite (dst, op, source,

3916

				      _composite_mask, NULL, &mask.base,

3917

				      extents, need_bounded_clip (extents));

3918

3919

	_cairo_pattern_fini (&mask.base);

3920

3921

3922

    cairo_surface_finish (image);

3923

    cairo_surface_destroy (image);

3924

3925

    return status;

3926

3927

3928

/* Build a struct of the same size of #cairo_glyph_t that can be used both as

3929

 * an input glyph with double coordinates, and as "working" glyph with

3930

 * integer from-current-point offsets. */

3931

typedef union {

3932

    cairo_glyph_t d;

3933

    unsigned long index;

3934

    struct {

3935

        unsigned long index;

3936

        int x;

3937

        int y;

3938

    } i;

3939

} cairo_xcb_glyph_t;

3940

3941

/* compile-time assert that #cairo_xcb_glyph_t is the same size as #cairo_glyph_t */

3942

COMPILE_TIME_ASSERT (sizeof (cairo_xcb_glyph_t) == sizeof (cairo_glyph_t));

3943

3944

typedef struct {

3945

    cairo_scaled_font_t *font;

3946

    cairo_xcb_glyph_t *glyphs;

3947

    int num_glyphs;

3948

    cairo_bool_t use_mask;

3949

} composite_glyphs_info_t;

3950

3951

static cairo_status_t

3952

_can_composite_glyphs (cairo_xcb_surface_t *dst,

3953

		       cairo_rectangle_int_t *extents,

3954

		       cairo_scaled_font_t *scaled_font,

3955

		       cairo_glyph_t *glyphs,

3956

		       int *num_glyphs)

3957

3958

#define GLYPH_CACHE_SIZE 64

3959

    cairo_box_t bbox_cache[GLYPH_CACHE_SIZE];

3960

    unsigned long glyph_cache[GLYPH_CACHE_SIZE];

3961

#undef GLYPH_CACHE_SIZE

3962

    cairo_status_t status = CAIRO_STATUS_SUCCESS;

3963

    cairo_glyph_t *glyphs_end, *valid_glyphs;

3964

    const int max_glyph_size = dst->connection->maximum_request_length - 64;

3965

3966

    /* We must initialize the cache with values that cannot match the

3967

     * "hash" to guarantee that when compared for the first time they

3968

     * will result in a mismatch. The hash function is simply modulus,

3969

     * so we cannot use 0 in glyph_cache[0], but we can use it in all

3970

     * other array cells.

3971

*/

3972

    memset (glyph_cache, 0, sizeof (glyph_cache));

3973

    glyph_cache[0] = 1;

3974

3975

    /* Scan for oversized glyphs or glyphs outside the representable

3976

     * range and fallback in that case, discard glyphs outside of the

3977

     * image.

3978

*/

3979

    valid_glyphs = glyphs;

3980

    for (glyphs_end = glyphs + *num_glyphs; glyphs != glyphs_end; glyphs++) {

3981

	double x1, y1, x2, y2;

3982

	cairo_scaled_glyph_t *glyph;

3983

	cairo_box_t *bbox;

3984

	int width, height, len;

3985

	int g;

3986

3987

	g = glyphs->index % ARRAY_LENGTH (glyph_cache);

3988

	if (glyph_cache[g] != glyphs->index) {

3989

	    status = _cairo_scaled_glyph_lookup (scaled_font,

3990

						 glyphs->index,

3991

						 CAIRO_SCALED_GLYPH_INFO_METRICS,

3992

                                                 NULL, /* foreground color */

3993

						 &glyph);

3994

	    if (unlikely (status))

3995

		break;

3996

3997

	    glyph_cache[g] = glyphs->index;

3998

	    bbox_cache[g] = glyph->bbox;

3999

4000

	bbox = &bbox_cache[g];

4001

4002

	/* Drop glyphs outside the clipping */

4003

	x1 = _cairo_fixed_to_double (bbox->p1.x);

4004

	y1 = _cairo_fixed_to_double (bbox->p1.y);

4005

	y2 = _cairo_fixed_to_double (bbox->p2.y);

4006

	x2 = _cairo_fixed_to_double (bbox->p2.x);

4007

	if (unlikely (glyphs->x + x2 <= extents->x ||

4008

		      glyphs->y + y2 <= extents->y ||

4009

		      glyphs->x + x1 >= extents->x + extents->width ||

4010

		      glyphs->y + y1 >= extents->y + extents->height))

4011

4012

	    (*num_glyphs)--;

4013

	    continue;

4014

4015

4016

	/* XRenderAddGlyph does not handle a glyph surface larger than

4017

	 * the extended maximum XRequest size.

4018

*/

4019

	width  = _cairo_fixed_integer_ceil (bbox->p2.x - bbox->p1.x);

4020

	height = _cairo_fixed_integer_ceil (bbox->p2.y - bbox->p1.y);

4021

	len = CAIRO_STRIDE_FOR_WIDTH_BPP (width, 32) * height;

4022

	if (unlikely (len >= max_glyph_size)) {

4023

	    status = CAIRO_INT_STATUS_UNSUPPORTED;

4024

	    break;

4025

4026

4027

	/* The glyph coordinates must be representable in an int16_t.

4028

	 * When possible, they will be expressed as an offset from the

4029

	 * previous glyph, otherwise they will be an offset from the

4030

	 * operation extents or from the surface origin. If the last

4031

	 * two options are not valid, fallback.

4032

*/

4033

	if (unlikely (glyphs->x > INT16_MAX ||

4034

		      glyphs->y > INT16_MAX ||

4035

		      glyphs->x - extents->x < INT16_MIN ||

4036

		      glyphs->y - extents->y < INT16_MIN))

4037

4038

	    status = CAIRO_INT_STATUS_UNSUPPORTED;

4039

	    break;

4040

4041

4042

4043

	if (unlikely (valid_glyphs != glyphs))

4044

	    *valid_glyphs = *glyphs;

4045

	valid_glyphs++;

4046

4047

4048

    if (unlikely (valid_glyphs != glyphs)) {

4049

	for (; glyphs != glyphs_end; glyphs++) {

4050

	    *valid_glyphs = *glyphs;

4051

	    valid_glyphs++;

4052

4053

4054

4055

    return status;

4056

4057

4058

/* Start a new element for the first glyph,

4059

 * or for any glyph that has unexpected position,

4060

 * or if current element has too many glyphs

4061

 * (Xrender limits each element to 252 glyphs, we limit them to 128)

4062

4063

 * These same conditions need to be mirrored between

4064

 * _cairo_xcb_surface_emit_glyphs and _emit_glyph_chunks

4065

*/

4066

#define _start_new_glyph_elt(count, glyph) \

4067

    (((count) & 127) == 0 || (glyph)->i.x || (glyph)->i.y)

4068

4069

/* sz_xGlyphtElt required alignment to a 32-bit boundary, so ensure we have

4070

 * enough room for padding */

4071

typedef struct {

4072

    uint8_t   len;

4073

    uint8_t   pad1;

4074

    uint16_t  pad2;

4075

    int16_t   deltax;

4076

    int16_t   deltay;

4077

} x_glyph_elt_t;

4078

#define _cairo_sz_x_glyph_elt_t (sizeof (x_glyph_elt_t) + 4)

4079

4080

static void

4081

_cairo_xcb_font_destroy (cairo_xcb_font_t *font)

4082

4083

    int i;

4084

4085

    for (i = 0; i < NUM_GLYPHSETS; i++) {

4086

	cairo_xcb_font_glyphset_info_t *info;

4087

4088

	info = &font->glyphset_info[i];

4089

	free (info->pending_free_glyphs);

4090

4091

4092

    cairo_list_del (&font->base.link);

4093

    cairo_list_del (&font->link);

4094

4095

    _cairo_xcb_connection_destroy (font->connection);

4096

4097

    free (font);

4098

4099

4100

static void

4101

_cairo_xcb_font_fini (cairo_scaled_font_private_t *abstract_private,

4102

		      cairo_scaled_font_t *scaled_font)

4103

4104

    cairo_xcb_font_t *font_private = (cairo_xcb_font_t *)abstract_private;

4105

    cairo_xcb_connection_t *connection;

4106

    cairo_bool_t have_connection;

4107

    cairo_status_t status;

4108

    int i;

4109

4110

    connection = font_private->connection;

4111

4112

    status = _cairo_xcb_connection_acquire (connection);

4113

    have_connection = status == CAIRO_STATUS_SUCCESS;

4114

4115

    for (i = 0; i < NUM_GLYPHSETS; i++) {

4116

	cairo_xcb_font_glyphset_info_t *info;

4117

4118

	info = &font_private->glyphset_info[i];

4119

	if (info->glyphset && status == CAIRO_STATUS_SUCCESS) {

4120

	    _cairo_xcb_connection_render_free_glyph_set (connection,

4121

							 info->glyphset);

4122

4123

4124

4125

    if (have_connection)

4126

	_cairo_xcb_connection_release (connection);

4127

4128

    _cairo_xcb_font_destroy (font_private);

4129

4130

4131

4132

static cairo_xcb_font_t *

4133

_cairo_xcb_font_create (cairo_xcb_connection_t *connection,

4134

			cairo_scaled_font_t  *font)

4135

4136

    cairo_xcb_font_t	*priv;

4137

    int i;

4138

4139

    priv = _cairo_calloc (sizeof (cairo_xcb_font_t));

4140

    if (unlikely (priv == NULL))

4141

	return NULL;

4142

4143

    _cairo_scaled_font_attach_private (font, &priv->base, connection,

4144

				       _cairo_xcb_font_fini);

4145

4146

    priv->scaled_font = font;

4147

    priv->connection = _cairo_xcb_connection_reference (connection);

4148

    cairo_list_add (&priv->link, &connection->fonts);

4149

4150

    for (i = 0; i < NUM_GLYPHSETS; i++) {

4151

	cairo_xcb_font_glyphset_info_t *info = &priv->glyphset_info[i];

4152

	switch (i) {

4153

	case GLYPHSET_INDEX_ARGB32: info->format = CAIRO_FORMAT_ARGB32; break;

4154

	case GLYPHSET_INDEX_A8:     info->format = CAIRO_FORMAT_A8;     break;

4155

	case GLYPHSET_INDEX_A1:     info->format = CAIRO_FORMAT_A1;     break;

4156

	default:                    ASSERT_NOT_REACHED;                          break;

4157

4158

	info->xrender_format = 0;

4159

	info->glyphset = XCB_NONE;

4160

	info->pending_free_glyphs = NULL;

4161

4162

4163

    return priv;

4164

4165

4166

void

4167

_cairo_xcb_font_close (cairo_xcb_font_t *font)

4168

4169

    cairo_scaled_font_t	*scaled_font;

4170

4171

    scaled_font = font->scaled_font;

4172

4173

    //scaled_font->surface_private = NULL;

4174

    _cairo_scaled_font_reset_cache (scaled_font);

4175

4176

    _cairo_xcb_font_destroy (font);

4177

4178

4179

static void

4180

_cairo_xcb_render_free_glyphs (cairo_xcb_connection_t *connection,

4181

			       cairo_xcb_font_glyphset_free_glyphs_t *to_free)

4182

4183

    _cairo_xcb_connection_render_free_glyphs (connection,

4184

					      to_free->glyphset,

4185

					      to_free->glyph_count,

4186

					      to_free->glyph_indices);

4187

4188

4189

static int

4190

_cairo_xcb_get_glyphset_index_for_format (cairo_format_t format)

4191

4192

    if (format == CAIRO_FORMAT_A8)

4193

        return GLYPHSET_INDEX_A8;

4194

    if (format == CAIRO_FORMAT_A1)

4195

        return GLYPHSET_INDEX_A1;

4196

4197

    assert (format == CAIRO_FORMAT_ARGB32);

4198

    return GLYPHSET_INDEX_ARGB32;

4199

4200

4201

4202

4203

static inline cairo_xcb_font_t *

4204

_cairo_xcb_font_get (const cairo_xcb_connection_t *c,

4205

		     cairo_scaled_font_t *font)

4206

4207

    return (cairo_xcb_font_t *)_cairo_scaled_font_find_private (font, c);

4208

4209

4210

4211

static cairo_xcb_font_glyphset_info_t *

4212

_cairo_xcb_scaled_font_get_glyphset_info_for_format (cairo_xcb_connection_t *c,

4213

						     cairo_scaled_font_t *font,

4214

						     cairo_format_t       format)

4215

4216

    cairo_xcb_font_t *priv;

4217

    cairo_xcb_font_glyphset_info_t *info;

4218

    int glyphset_index;

4219

4220

    glyphset_index = _cairo_xcb_get_glyphset_index_for_format (format);

4221

4222

    priv = _cairo_xcb_font_get (c, font);

4223

    if (priv == NULL) {

4224

	priv = _cairo_xcb_font_create (c, font);

4225

	if (priv == NULL)

4226

	    return NULL;

4227

4228

4229

    info = &priv->glyphset_info[glyphset_index];

4230

    if (info->glyphset == XCB_NONE) {

4231

	info->glyphset = xcb_generate_id (c->xcb_connection);

4232

	info->xrender_format = c->standard_formats[info->format];

4233

4234

	_cairo_xcb_connection_render_create_glyph_set (c,

4235

						       info->glyphset,

4236

						       info->xrender_format);

4237

4238

4239

    return info;

4240

4241

4242

static cairo_bool_t

4243

_cairo_xcb_glyphset_info_has_pending_free_glyph (

4244

				cairo_xcb_font_glyphset_info_t *info,

4245

				unsigned long glyph_index)

4246

4247

    if (info->pending_free_glyphs != NULL) {

4248

	cairo_xcb_font_glyphset_free_glyphs_t *to_free;

4249

	int i;

4250

4251

	to_free = info->pending_free_glyphs;

4252

	for (i = 0; i < to_free->glyph_count; i++) {

4253

	    if (to_free->glyph_indices[i] == glyph_index) {

4254

		to_free->glyph_count--;

4255

		memmove (&to_free->glyph_indices[i],

4256

			 &to_free->glyph_indices[i+1],

4257

			 (to_free->glyph_count - i) * sizeof (to_free->glyph_indices[0]));

4258

		return TRUE;

4259

4260

4261

4262

4263

    return FALSE;

4264

4265

4266

typedef struct {

4267

    cairo_scaled_glyph_private_t base;

4268

4269

    cairo_xcb_font_glyphset_info_t *glyphset;

4270

} cairo_xcb_glyph_private_t;

4271

4272

static cairo_xcb_font_glyphset_info_t *

4273

_cairo_xcb_scaled_font_get_glyphset_info_for_pending_free_glyph (cairo_xcb_connection_t *c,

4274

					       cairo_scaled_font_t *font,

4275

					       unsigned long glyph_index,

4276

					       cairo_image_surface_t *surface)

4277

4278

    cairo_xcb_font_t *priv;

4279

    int i;

4280

4281

    priv = _cairo_xcb_font_get (c, font);

4282

    if (priv == NULL)

4283

	return NULL;

4284

4285

    if (surface != NULL) {

4286

        i = _cairo_xcb_get_glyphset_index_for_format (surface->format);

4287

4288

	if (_cairo_xcb_glyphset_info_has_pending_free_glyph (

4289

						&priv->glyphset_info[i],

4290

						glyph_index))

4291

4292

	    return &priv->glyphset_info[i];

4293

4294

    } else {

4295

	for (i = 0; i < NUM_GLYPHSETS; i++) {

4296

	    if (_cairo_xcb_glyphset_info_has_pending_free_glyph (

4297

						&priv->glyphset_info[i],

4298

						glyph_index))

4299

4300

		return &priv->glyphset_info[i];

4301

4302

4303

4304

4305

    return NULL;

4306

4307

4308

static void

4309

_cairo_xcb_glyph_fini (cairo_scaled_glyph_private_t *glyph_private,

4310

		       cairo_scaled_glyph_t *glyph,

4311

		       cairo_scaled_font_t  *font)

4312

4313

    cairo_xcb_glyph_private_t *priv = (cairo_xcb_glyph_private_t *)glyph_private;

4314

4315

    if (! font->finished) {

4316

	cairo_xcb_font_glyphset_info_t *info = priv->glyphset;

4317

	cairo_xcb_font_glyphset_free_glyphs_t *to_free;

4318

	cairo_xcb_font_t *font_private;

4319

4320

	font_private = _cairo_xcb_font_get (glyph_private->key, font);

4321

	assert (font_private);

4322

4323

	to_free = info->pending_free_glyphs;

4324

	if (to_free != NULL &&

4325

	    to_free->glyph_count == ARRAY_LENGTH (to_free->glyph_indices))

4326

4327

	    _cairo_xcb_render_free_glyphs (font_private->connection, to_free);

4328

	    to_free = info->pending_free_glyphs = NULL;

4329

4330

4331

	if (to_free == NULL) {

4332

	    to_free = _cairo_calloc (sizeof (cairo_xcb_font_glyphset_free_glyphs_t));

4333

	    if (unlikely (to_free == NULL)) {

4334

		_cairo_error_throw (CAIRO_STATUS_NO_MEMORY);

4335

		return; /* XXX cannot propagate failure */

4336

4337

4338

	    to_free->glyphset = info->glyphset;

4339

	    to_free->glyph_count = 0;

4340

	    info->pending_free_glyphs = to_free;

4341

4342

4343

	to_free->glyph_indices[to_free->glyph_count++] =

4344

	    _cairo_scaled_glyph_index (glyph);

4345

4346

4347

    cairo_list_del (&glyph_private->link);

4348

    free (glyph_private);

4349

4350

4351

4352

static cairo_status_t

4353

_cairo_xcb_glyph_attach (cairo_xcb_connection_t  *c,

4354

			 cairo_scaled_glyph_t  *glyph,

4355

			 cairo_xcb_font_glyphset_info_t *info)

4356

4357

    cairo_xcb_glyph_private_t *priv;

4358

4359

    priv = _cairo_calloc (sizeof (*priv));

4360

    if (unlikely (priv == NULL))

4361

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

4362

4363

    _cairo_scaled_glyph_attach_private (glyph, &priv->base, c,

4364

					_cairo_xcb_glyph_fini);

4365

    priv->glyphset = info;

4366

4367

    glyph->dev_private = info;

4368

    glyph->dev_private_key = c;

4369

    return CAIRO_STATUS_SUCCESS;

4370

4371

4372

static cairo_status_t

4373

_cairo_xcb_surface_add_glyph (cairo_xcb_connection_t *connection,

4374

			       cairo_scaled_font_t   *font,

4375

			       cairo_scaled_glyph_t **scaled_glyph_out)

4376

4377

    xcb_render_glyphinfo_t glyph_info;

4378

    uint32_t glyph_index;

4379

    uint8_t *data;

4380

    cairo_status_t status = CAIRO_STATUS_SUCCESS;

4381

    cairo_scaled_glyph_t *scaled_glyph = *scaled_glyph_out;

4382

    cairo_image_surface_t *glyph_surface = scaled_glyph->surface;

4383

    cairo_bool_t already_had_glyph_surface;

4384

    cairo_xcb_font_glyphset_info_t *info;

4385

4386

    glyph_index = _cairo_scaled_glyph_index (scaled_glyph);

4387

4388

    /* check to see if we have a pending XRenderFreeGlyph for this glyph */

4389

    info = _cairo_xcb_scaled_font_get_glyphset_info_for_pending_free_glyph (connection, font, glyph_index, glyph_surface);

4390

    if (info != NULL)

4391

	return _cairo_xcb_glyph_attach (connection, scaled_glyph, info);

4392

4393

    if (glyph_surface == NULL) {

4394

	status = _cairo_scaled_glyph_lookup (font,

4395

					     glyph_index,

4396

					     CAIRO_SCALED_GLYPH_INFO_METRICS |

4397

					     CAIRO_SCALED_GLYPH_INFO_SURFACE,

4398

                                             NULL, /* foreground color */

4399

					     scaled_glyph_out);

4400

	if (unlikely (status))

4401

	    return status;

4402

4403

	scaled_glyph = *scaled_glyph_out;

4404

	glyph_surface = scaled_glyph->surface;

4405

	already_had_glyph_surface = FALSE;

4406

    } else {

4407

	already_had_glyph_surface = TRUE;

4408

4409

4410

    info = _cairo_xcb_scaled_font_get_glyphset_info_for_format (connection,

4411

								font,

4412

								glyph_surface->format);

4413

    if (unlikely (info == NULL)) {

4414

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

4415

	goto BAIL;

4416

4417

4418

#if 0

4419

    /* If the glyph surface has zero height or width, we create

4420

     * a clear 1x1 surface, to avoid various X server bugs.

4421

*/

4422

    if (glyph_surface->width == 0 || glyph_surface->height == 0) {

4423

	cairo_surface_t *tmp_surface;

4424

4425

	tmp_surface = cairo_image_surface_create (info->format, 1, 1);

4426

	status = tmp_surface->status;

4427

	if (unlikely (status))

4428

	    goto BAIL;

4429

4430

	tmp_surface->device_transform = glyph_surface->base.device_transform;

4431

	tmp_surface->device_transform_inverse = glyph_surface->base.device_transform_inverse;

4432

4433

	glyph_surface = (cairo_image_surface_t *) tmp_surface;

4434

4435

#endif

4436

4437

    /* If the glyph format does not match the font format, then we

4438

     * create a temporary surface for the glyph image with the font's

4439

     * format.

4440

*/

4441

    if (glyph_surface->format != info->format) {

4442

	glyph_surface = _cairo_image_surface_coerce_to_format (glyph_surface,

4443

						               info->format);

4444

	status = glyph_surface->base.status;

4445

	if (unlikely (status))

4446

	    goto BAIL;

4447

4448

4449

    /* XXX: FRAGILE: We're ignore device_transform scaling here. A bug? */

4450

    glyph_info.x = _cairo_lround (glyph_surface->base.device_transform.x0);

4451

    glyph_info.y = _cairo_lround (glyph_surface->base.device_transform.y0);

4452

    glyph_info.width  = glyph_surface->width;

4453

    glyph_info.height = glyph_surface->height;

4454

    glyph_info.x_off = scaled_glyph->x_advance;

4455

    glyph_info.y_off = scaled_glyph->y_advance;

4456

4457

    data = glyph_surface->data;

4458

4459

    /* flip formats around */

4460

    switch (_cairo_xcb_get_glyphset_index_for_format (scaled_glyph->surface->format)) {

4461

    case GLYPHSET_INDEX_A1:

4462

	/* local bitmaps are always stored with bit == byte */

4463

	if (_cairo_is_little_endian() != (connection->root->bitmap_format_bit_order == XCB_IMAGE_ORDER_LSB_FIRST)) {

4464

	    int		    c = glyph_surface->stride * glyph_surface->height;

4465

	    const uint8_t *d;

4466

	    uint8_t *new, *n;

4467

4468

	    if (c == 0)

4469

		break;

4470

4471

	    new = _cairo_malloc (c);

4472

	    if (unlikely (new == NULL)) {

4473

		status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

4474

		goto BAIL;

4475

4476

4477

	    n = new;

4478

	    d = data;

4479

	    do {

4480

		uint8_t b = *d++;

4481

		b = ((b << 1) & 0xaa) | ((b >> 1) & 0x55);

4482

		b = ((b << 2) & 0xcc) | ((b >> 2) & 0x33);

4483

		b = ((b << 4) & 0xf0) | ((b >> 4) & 0x0f);

4484

		*n++ = b;

4485

	    } while (--c);

4486

	    data = new;

4487

4488

	break;

4489

4490

    case GLYPHSET_INDEX_A8:

4491

	break;

4492

4493

    case GLYPHSET_INDEX_ARGB32:

4494

	if (_cairo_is_little_endian() != (connection->root->image_byte_order == XCB_IMAGE_ORDER_LSB_FIRST)) {

4495

	    unsigned int c = glyph_surface->stride * glyph_surface->height / 4;

4496

	    const uint32_t *d;

4497

	    uint32_t *new, *n;

4498

4499

	    if (c == 0)

4500

		break;

4501

4502

	    new = _cairo_malloc (4 * c);

4503

	    if (unlikely (new == NULL)) {

4504

		status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

4505

		goto BAIL;

4506

4507

4508

	    n = new;

4509

	    d = (uint32_t *) data;

4510

	    do {

4511

		*n++ = bswap_32 (*d);

4512

		d++;

4513

	    } while (--c);

4514

	    data = (uint8_t *) new;

4515

4516

	break;

4517

4518

    default:

4519

	ASSERT_NOT_REACHED;

4520

	break;

4521

4522

    /* XXX assume X server wants pixman padding. Xft assumes this as well */

4523

4524

    _cairo_xcb_connection_render_add_glyphs (connection,

4525

					     info->glyphset,

4526

					     1, &glyph_index, &glyph_info,

4527

					     glyph_surface->stride * glyph_surface->height,

4528

					     data);

4529

4530

    if (data != glyph_surface->data)

4531

	free (data);

4532

4533

    status = _cairo_xcb_glyph_attach (connection, scaled_glyph, info);

4534

4535

 BAIL:

4536

    if (glyph_surface != scaled_glyph->surface)

4537

	cairo_surface_destroy (&glyph_surface->base);

4538

4539

    /* If the scaled glyph didn't already have a surface attached

4540

     * to it, release the created surface now that we have it

4541

     * uploaded to the X server.  If the surface has already been

4542

     * there (e.g. because image backend requested it), leave it in

4543

     * the cache

4544

*/

4545

    if (! already_had_glyph_surface)

4546

	_cairo_scaled_glyph_set_surface (scaled_glyph, font, NULL);

4547

4548

    return status;

4549

4550

4551

typedef void (*cairo_xcb_render_composite_text_func_t)

4552

	      (cairo_xcb_connection_t       *connection,

4553

	       uint8_t                          op,

4554

	       xcb_render_picture_t src,

4555

	       xcb_render_picture_t dst,

4556

	       xcb_render_pictformat_t mask_format,

4557

	       xcb_render_glyphset_t glyphset,

4558

	       int16_t                          src_x,

4559

	       int16_t                          src_y,

4560

	       uint32_t                          len,

4561

	       uint8_t                        *cmd);

4562

4563

4564

static cairo_status_t

4565

_emit_glyphs_chunk (cairo_xcb_surface_t *dst,

4566

		    cairo_operator_t op,

4567

		    cairo_xcb_picture_t *src,

4568

		    /* info for this chunk */

4569

		    cairo_xcb_glyph_t *glyphs,

4570

		    int num_glyphs,

4571

		    int width,

4572

		    int estimated_req_size,

4573

		    cairo_xcb_font_glyphset_info_t *info,

4574

		    xcb_render_pictformat_t mask_format)

4575

4576

    cairo_xcb_render_composite_text_func_t composite_text_func;

4577

    uint8_t stack_buf[CAIRO_STACK_BUFFER_SIZE];

4578

    uint8_t *buf = stack_buf;

4579

    x_glyph_elt_t *elt = NULL; /* silence compiler */

4580

    uint32_t len;

4581

    int i;

4582

4583

    if (estimated_req_size > ARRAY_LENGTH (stack_buf)) {

4584

	buf = _cairo_malloc (estimated_req_size);

4585

	if (unlikely (buf == NULL))

4586

	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);

4587

4588

4589

    len = 0;

4590

    for (i = 0; i < num_glyphs; i++) {

4591

      if (_start_new_glyph_elt (i, &glyphs[i])) {

4592

	  if (len & 3)

4593

	      len += 4 - (len & 3);

4594

4595

	  elt = (x_glyph_elt_t *) (buf + len);

4596

	  elt->len = 0;

4597

	  elt->deltax = glyphs[i].i.x;

4598

	  elt->deltay = glyphs[i].i.y;

4599

	  len += sizeof (x_glyph_elt_t);

4600

4601

4602

      switch (width) {

4603

      case 1: *(uint8_t *) (buf + len) = glyphs[i].index; break;

4604

      case 2: *(uint16_t *) (buf + len) = glyphs[i].index; break;

4605

      default:

4606

      case 4: *(uint32_t *) (buf + len) = glyphs[i].index; break;

4607

4608

      len += width;

4609

      elt->len++;

4610

4611

    if (len & 3)

4612

	len += 4 - (len & 3);

4613

4614

    switch (width) {

4615

    case 1:

4616

	composite_text_func = _cairo_xcb_connection_render_composite_glyphs_8;

4617

	break;

4618

    case 2:

4619

	composite_text_func = _cairo_xcb_connection_render_composite_glyphs_16;

4620

	break;

4621

    default:

4622

    case 4:

4623

	composite_text_func = _cairo_xcb_connection_render_composite_glyphs_32;

4624

	break;

4625

4626

    composite_text_func (dst->connection,

4627

			 _render_operator (op),

4628

			 src->picture,

4629

			 dst->picture,

4630

			 mask_format,

4631

			 info->glyphset,

4632

			 src->x + glyphs[0].i.x,

4633

			 src->y + glyphs[0].i.y,

4634

			 len, buf);

4635

4636

    if (buf != stack_buf)

4637

      free (buf);

4638

4639

    return CAIRO_STATUS_SUCCESS;

4640

4641

4642

static cairo_int_status_t

4643

_composite_glyphs (void				*closure,

4644

		  cairo_xcb_surface_t		*dst,

4645

		  cairo_operator_t		 op,

4646

		  const cairo_pattern_t		*pattern,

4647

		  int				 dst_x,

4648

		  int				 dst_y,

4649

		  const cairo_rectangle_int_t	*extents,

4650

		  cairo_clip_t			*clip)

4651

4652

    composite_glyphs_info_t *info = closure;

4653

    cairo_scaled_glyph_t *glyph_cache[64];

4654

    cairo_status_t status = CAIRO_STATUS_SUCCESS;

4655

    cairo_fixed_t x = 0, y = 0;

4656

    cairo_xcb_font_glyphset_info_t *glyphset_info = NULL, *this_glyphset_info;

4657

    const unsigned int max_request_size = dst->connection->maximum_request_length - 64;

4658

    cairo_xcb_picture_t *src;

4659

4660

    unsigned long max_index = 0;

4661

    int width = 1;

4662

4663

    unsigned int request_size = 0;

4664

    int i;

4665

4666

    if (dst->deferred_clear) {

4667

	status = _cairo_xcb_surface_clear (dst);

4668

	if (unlikely (status))

4669

		return status;

4670

4671

4672

    src = _cairo_xcb_picture_for_pattern (dst, pattern, extents);

4673

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

4674

	return src->base.status;

4675

4676

    memset (glyph_cache, 0, sizeof (glyph_cache));

4677

4678

    for (i = 0; i < info->num_glyphs; i++) {

4679

	cairo_scaled_glyph_t *glyph;

4680

	unsigned long glyph_index = info->glyphs[i].index;

4681

	int cache_index = glyph_index % ARRAY_LENGTH (glyph_cache);

4682

	int old_width = width;

4683

	int this_x, this_y;

4684

4685

	glyph = glyph_cache[cache_index];

4686

	if (glyph == NULL ||

4687

	    _cairo_scaled_glyph_index (glyph) != glyph_index)

4688

4689

	    status = _cairo_scaled_glyph_lookup (info->font,

4690

						 glyph_index,

4691

						 CAIRO_SCALED_GLYPH_INFO_METRICS,

4692

                                                 NULL, /* foreground color */

4693

						 &glyph);

4694

	    if (unlikely (status)) {

4695

		cairo_surface_destroy (&src->base);

4696

		return status;

4697

4698

4699

	    /* Send unseen glyphs to the server */

4700

	    if (glyph->dev_private_key != dst->connection) {

4701

		status = _cairo_xcb_surface_add_glyph (dst->connection,

4702

						       info->font,

4703

						       &glyph);

4704

		if (unlikely (status)) {

4705

		    cairo_surface_destroy (&src->base);

4706

		    return status;

4707

4708

4709

4710

	    glyph_cache[cache_index] = glyph;

4711

4712

4713

	this_x = _cairo_lround (info->glyphs[i].d.x) - dst_x;

4714

	this_y = _cairo_lround (info->glyphs[i].d.y) - dst_y;

4715

4716

	this_glyphset_info = glyph->dev_private;

4717

	if (glyphset_info == NULL)

4718

	    glyphset_info = this_glyphset_info;

4719

4720

	/* Update max glyph index */

4721

	if (glyph_index > max_index) {

4722

	    max_index = glyph_index;

4723

	    if (max_index >= 65536)

4724

		width = 4;

4725

	    else if (max_index >= 256)

4726

		width = 2;

4727

	    if (width != old_width)

4728

		request_size += (width - old_width) * i;

4729

4730

4731

	/* If we will pass the max request size by adding this glyph,

4732

	 * flush current glyphs.  Note that we account for a

4733

	 * possible element being added below.

4734

4735

	 * Also flush if changing glyphsets, as Xrender limits one mask

4736

	 * format per request, so we can either break up, or use a

4737

	 * wide-enough mask format.  We do the former.  One reason to

4738

	 * prefer the latter is the fact that Xserver ADDs all glyphs

4739

	 * to the mask first, and then composes that to final surface,

4740

	 * though it's not a big deal.

4741

4742

	 * If the glyph has a coordinate which cannot be represented

4743

	 * as a 16-bit offset from the previous glyph, flush the

4744

	 * current chunk. The current glyph will be the first one in

4745

	 * the next chunk, thus its coordinates will be an offset from

4746

	 * the destination origin. This offset is guaranteed to be

4747

	 * representable as 16-bit offset in _can_composite_glyphs().

4748

*/

4749

	if (request_size + width > max_request_size - _cairo_sz_x_glyph_elt_t ||

4750

	    this_x - x > INT16_MAX || this_x - x < INT16_MIN ||

4751

	    this_y - y > INT16_MAX || this_y - y < INT16_MIN ||

4752

	    this_glyphset_info != glyphset_info)

4753

4754

	    status = _emit_glyphs_chunk (dst, op, src,

4755

					 info->glyphs, i,

4756

					 old_width, request_size,

4757

					 glyphset_info,

4758

					 info->use_mask ? glyphset_info->xrender_format : 0);

4759

	    if (unlikely (status)) {

4760

		cairo_surface_destroy (&src->base);

4761

		return status;

4762

4763

4764

	    info->glyphs += i;

4765

	    info->num_glyphs -= i;

4766

	    i = 0;

4767

4768

	    max_index = info->glyphs[0].index;

4769

	    width = max_index < 256 ? 1 : max_index < 65536 ? 2 : 4;

4770

4771

	    request_size = 0;

4772

4773

	    x = y = 0;

4774

	    glyphset_info = this_glyphset_info;

4775

4776

4777

	/* Convert absolute glyph position to relative-to-current-point

4778

	 * position */

4779

	info->glyphs[i].i.x = this_x - x;

4780

	info->glyphs[i].i.y = this_y - y;

4781

4782

	/* Start a new element for the first glyph,

4783

	 * or for any glyph that has unexpected position,

4784

	 * or if current element has too many glyphs.

4785

4786

	 * These same conditions are mirrored in _emit_glyphs_chunk().

4787

*/

4788

      if (_start_new_glyph_elt (i, &info->glyphs[i]))

4789

	    request_size += _cairo_sz_x_glyph_elt_t;

4790

4791

	/* adjust current-position */

4792

	x = this_x + glyph->x_advance;

4793

	y = this_y + glyph->y_advance;

4794

4795

	request_size += width;

4796

4797

4798

    if (i) {

4799

	status = _emit_glyphs_chunk (dst, op, src,

4800

				     info->glyphs, i,

4801

				     width, request_size,

4802

				     glyphset_info,

4803

				     info->use_mask ? glyphset_info->xrender_format : 0);

4804

4805

4806

    cairo_surface_destroy (&src->base);

4807

4808

    return status;

4809

4810

4811

cairo_int_status_t

4812

_cairo_xcb_render_compositor_glyphs (const cairo_compositor_t     *compositor,

4813

				     cairo_composite_rectangles_t *composite,

4814

				     cairo_scaled_font_t          *scaled_font,

4815

				     cairo_glyph_t                *glyphs,

4816

				     int                           num_glyphs,

4817

				     cairo_bool_t                  overlap)

4818

4819

    cairo_xcb_surface_t *surface = (cairo_xcb_surface_t *) composite->surface;

4820

    cairo_operator_t op = composite->op;

4821

    cairo_pattern_t *source = &composite->source_pattern.base;

4822

    cairo_int_status_t status;

4823

4824

    if (unlikely (! _operator_is_supported (surface->connection->flags, op)))

4825

	return CAIRO_INT_STATUS_UNSUPPORTED;

4826

4827

    if ((surface->connection->flags & (CAIRO_XCB_RENDER_HAS_COMPOSITE_GLYPHS | CAIRO_XCB_RENDER_HAS_COMPOSITE)) == 0)

4828

	return CAIRO_INT_STATUS_UNSUPPORTED;

4829

4830

    status = CAIRO_INT_STATUS_UNSUPPORTED;

4831

    if (surface->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE_GLYPHS) {

4832

	_cairo_scaled_font_freeze_cache (scaled_font);

4833

4834

	status = _can_composite_glyphs (surface, &composite->bounded,

4835

					scaled_font, glyphs, &num_glyphs);

4836

	if (likely (status == CAIRO_INT_STATUS_SUCCESS)) {

4837

	    composite_glyphs_info_t info;

4838

	    unsigned flags = 0;

4839

4840

	    info.font = scaled_font;

4841

	    info.glyphs = (cairo_xcb_glyph_t *) glyphs;

4842

	    info.num_glyphs = num_glyphs;

4843

	    info.use_mask =

4844

		overlap ||

4845

		! composite->is_bounded ||

4846

		! _cairo_clip_is_region(composite->clip);

4847

4848

	    if (composite->mask.width  > composite->unbounded.width ||

4849

		composite->mask.height > composite->unbounded.height)

4850

4851

		/* Glyphs are tricky since we do not directly control the

4852

		 * geometry and their inked extents depend on the

4853

		 * individual glyph-surface size. We must set a clip region

4854

		 * so that the X server can trim the glyphs appropriately.

4855

*/

4856

		flags |= FORCE_CLIP_REGION;

4857

4858

	    status = _clip_and_composite (surface, op, source,

4859

					  _composite_glyphs, NULL,

4860

					  &info, composite,

4861

					  need_bounded_clip (composite) |

4862

					  flags);

4863

4864

4865

	_cairo_scaled_font_thaw_cache (scaled_font);

4866

4867

4868

    if (status == CAIRO_INT_STATUS_UNSUPPORTED) {

4869

	assert (surface->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE);

4870

	status =

4871

	    _cairo_xcb_surface_render_glyphs_via_mask (surface, op, source,

4872

						       scaled_font, glyphs, num_glyphs,

4873

						       composite);

4874

4875

4876

    return status;

4877