Grcov report - cairo-recording-surface.c

1

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

2

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

3

4

 * Copyright © 2005 Red Hat, Inc

5

 * Copyright © 2007 Adrian Johnson

6

7

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

8

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

9

 * License version 2.1 as published by the Free Software Foundation

10

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

11

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

12

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

13

 * the MPL or the LGPL.

14

15

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

16

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

17

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

18

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

19

 * in the file COPYING-MPL-1.1

20

21

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

22

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

23

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

24

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

25

26

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

27

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

28

 * the specific language governing rights and limitations.

29

30

 * The Original Code is the cairo graphics library.

31

32

 * The Initial Developer of the Original Code is Red Hat, Inc.

33

34

 * Contributor(s):

35

 *	Kristian Høgsberg <krh@redhat.com>

36

 *	Carl Worth <cworth@cworth.org>

37

 *	Adrian Johnson <ajohnson@redneon.com>

38

*/

39

40

/**

41

 * SECTION:cairo-recording

42

 * @Title: Recording Surfaces

43

 * @Short_Description: Records all drawing operations

44

 * @See_Also: #cairo_surface_t

45

46

 * A recording surface is a surface that records all drawing operations at

47

 * the highest level of the surface backend interface, (that is, the

48

 * level of paint, mask, stroke, fill, and show_text_glyphs). The recording

49

 * surface can then be "replayed" against any target surface by using it

50

 * as a source surface.

51

52

 * If you want to replay a surface so that the results in target will be

53

 * identical to the results that would have been obtained if the original

54

 * operations applied to the recording surface had instead been applied to the

55

 * target surface, you can use code like this:

56

 * <informalexample><programlisting>

57

 * cairo_t *cr;

58

59

 * cr = cairo_create (target);

60

 * cairo_set_source_surface (cr, recording_surface, 0.0, 0.0);

61

 * cairo_paint (cr);

62

 * cairo_destroy (cr);

63

 * </programlisting></informalexample>

64

65

 * A recording surface is logically unbounded, i.e. it has no implicit constraint

66

 * on the size of the drawing surface. However, in practice this is rarely

67

 * useful as you wish to replay against a particular target surface with

68

 * known bounds. For this case, it is more efficient to specify the target

69

 * extents to the recording surface upon creation.

70

71

 * The recording phase of the recording surface is careful to snapshot all

72

 * necessary objects (paths, patterns, etc.), in order to achieve

73

 * accurate replay. The efficiency of the recording surface could be

74

 * improved by improving the implementation of snapshot for the

75

 * various objects. For example, it would be nice to have a

76

 * copy-on-write implementation for _cairo_surface_snapshot.

77

**/

78

79

#include "cairoint.h"

80

81

#include "cairo-array-private.h"

82

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

83

#include "cairo-clip-private.h"

84

#include "cairo-combsort-inline.h"

85

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

86

#include "cairo-default-context-private.h"

87

#include "cairo-error-private.h"

88

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

89

#include "cairo-list-inline.h"

90

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

91

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

92

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

93

#include "cairo-traps-private.h"

94

95

typedef struct _cairo_recording_surface_replay_params {

96

    const cairo_rectangle_int_t *surface_extents;

97

    const cairo_matrix_t *surface_transform;

98

    cairo_surface_t	     *target;

99

    const cairo_clip_t *target_clip;

100

    cairo_bool_t surface_is_unbounded;

101

    cairo_recording_replay_type_t type;

102

    cairo_recording_region_type_t region;

103

    unsigned int regions_id;

104

    const cairo_color_t *foreground_color;

105

    cairo_bool_t foreground_used;

106

    cairo_bool_t replay_all;

107

} cairo_recording_surface_replay_params_t;

108

109

static const cairo_surface_backend_t cairo_recording_surface_backend;

110

111

/**

112

 * CAIRO_HAS_RECORDING_SURFACE:

113

114

 * Defined if the recording surface backend is available.

115

 * The recording surface backend is always built in.

116

 * This macro was added for completeness in cairo 1.10.

117

118

 * Since: 1.10

119

**/

120

121

/* Currently all recording surfaces do have a size which should be passed

122

 * in as the maximum size of any target surface against which the

123

 * recording-surface will ever be replayed.

124

125

 * XXX: The naming of "pixels" in the size here is a misnomer. It's

126

 * actually a size in whatever device-space units are desired (again,

127

 * according to the intended replay target).

128

*/

129

130

1594

static int bbtree_left_or_right (struct bbtree *bbt,

131

				 const cairo_box_t *box)

132

133

    int left, right;

134

135

1594

    if (bbt->left) {

136

983

	cairo_box_t *e = &bbt->left->extents;

137

	cairo_box_t b;

138

139

983

	b.p1.x = MIN (e->p1.x, box->p1.x);

140

983

	b.p1.y = MIN (e->p1.y, box->p1.y);

141

983

	b.p2.x = MAX (e->p2.x, box->p2.x);

142

983

	b.p2.y = MAX (e->p2.y, box->p2.y);

143

144

983

	left = _cairo_fixed_integer_part (b.p2.x - b.p1.x) * _cairo_fixed_integer_part (b.p2.y - b.p1.y);

145

983

	left -= _cairo_fixed_integer_part (e->p2.x - e->p1.x) * _cairo_fixed_integer_part (e->p2.y - e->p1.y);

146

    } else

147

611

	left = 0;

148

149

1594

    if (bbt->right) {

150

504

	cairo_box_t *e = &bbt->right->extents;

151

	cairo_box_t b;

152

153

504

	b.p1.x = MIN (e->p1.x, box->p1.x);

154

504

	b.p1.y = MIN (e->p1.y, box->p1.y);

155

504

	b.p2.x = MAX (e->p2.x, box->p2.x);

156

504

	b.p2.y = MAX (e->p2.y, box->p2.y);

157

158

504

	right = _cairo_fixed_integer_part (b.p2.x - b.p1.x) * _cairo_fixed_integer_part (b.p2.y - b.p1.y);

159

504

	right -= _cairo_fixed_integer_part (e->p2.x - e->p1.x) * _cairo_fixed_integer_part (e->p2.y - e->p1.y);

160

    } else

161

1090

	right = 0;

162

163

1594

    return left <= right;

164

165

166

#define INVALID_CHAIN ((cairo_command_header_t *)-1)

167

168

static struct bbtree *

169

1090

bbtree_new (const cairo_box_t *box, cairo_command_header_t *chain)

170

171

1090

    struct bbtree *bbt = _cairo_calloc (sizeof (*bbt));

172

1090

    if (bbt == NULL)

173

	return NULL;

174

1090

    bbt->extents = *box;

175

1090

    bbt->left = bbt->right = NULL;

176

1090

    bbt->chain = chain;

177

1090

    return bbt;

178

179

180

static void

181

1318

bbtree_init (struct bbtree *bbt, cairo_command_header_t *header)

182

183

1318

    _cairo_box_from_rectangle (&bbt->extents, &header->extents);

184

1318

    bbt->chain = header;

185

1318

186

187

static cairo_status_t

188

1239

bbtree_add (struct bbtree *bbt,

189

	    cairo_command_header_t *header,

190

	    const cairo_box_t *box)

191

192

1239

    if (box->p1.x < bbt->extents.p1.x || box->p1.y < bbt->extents.p1.y ||

193

745

	box->p2.x > bbt->extents.p2.x || box->p2.y > bbt->extents.p2.y)

194

195

887

	if (bbt->chain) {

196

584

	    if (bbtree_left_or_right (bbt, &bbt->extents)) {

197

584

		if (bbt->left == NULL) {

198

584

		    bbt->left = bbtree_new (&bbt->extents, bbt->chain);

199

584

		    if (unlikely (bbt->left == NULL))

200

			return _cairo_error (CAIRO_STATUS_NO_MEMORY);

201

		} else

202

		    bbtree_add (bbt->left, bbt->chain, &bbt->extents);

203

	    } else {

204

		if (bbt->right == NULL) {

205

		    bbt->right = bbtree_new (&bbt->extents, bbt->chain);

206

		    if (unlikely (bbt->right == NULL))

207

			return _cairo_error (CAIRO_STATUS_NO_MEMORY);

208

		} else

209

		    bbtree_add (bbt->right, bbt->chain, &bbt->extents);

210

211

212

584

	    bbt->chain = NULL;

213

214

215

887

	bbt->extents.p1.x = MIN (bbt->extents.p1.x, box->p1.x);

216

887

	bbt->extents.p1.y = MIN (bbt->extents.p1.y, box->p1.y);

217

887

	bbt->extents.p2.x = MAX (bbt->extents.p2.x, box->p2.x);

218

887

	bbt->extents.p2.y = MAX (bbt->extents.p2.y, box->p2.y);

219

220

221

1239

    if (box->p1.x == bbt->extents.p1.x && box->p1.y == bbt->extents.p1.y &&

222

414

	box->p2.x == bbt->extents.p2.x && box->p2.y == bbt->extents.p2.y)

223

224

229

	cairo_command_header_t *last = header;

225

229

	while (last->chain) /* expected to be infrequent */

226

	    last = last->chain;

227

229

	last->chain = bbt->chain;

228

229

	bbt->chain = header;

229

	return CAIRO_STATUS_SUCCESS;

230

231

232

1010

    if (bbtree_left_or_right (bbt, box)) {

233

297

	if (bbt->left == NULL) {

234

27

	    bbt->left = bbtree_new (box, header);

235

27

	    if (unlikely (bbt->left == NULL))

236

		return _cairo_error (CAIRO_STATUS_NO_MEMORY);

237

	} else

238

270

	    return bbtree_add (bbt->left, header, box);

239

    } else {

240

713

	if (bbt->right == NULL) {

241

479

	    bbt->right = bbtree_new (box, header);

242

479

	    if (unlikely (bbt->right == NULL))

243

		return _cairo_error (CAIRO_STATUS_NO_MEMORY);

244

	} else

245

234

	    return bbtree_add (bbt->right, header, box);

246

247

248

506

    return CAIRO_STATUS_SUCCESS;

249

250

251

601

static void bbtree_del (struct bbtree *bbt)

252

253

601

    if (bbt->left)

254

168

	bbtree_del (bbt->left);

255

601

    if (bbt->right)

256

156

	bbtree_del (bbt->right);

257

258

601

    free (bbt);

259

601

260

261

629510

static cairo_bool_t box_outside (const cairo_box_t *a, const cairo_box_t *b)

262

263

    return

264

527513

	a->p1.x >= b->p2.x || a->p1.y >= b->p2.y ||

265

1157023

	a->p2.x <= b->p1.x || a->p2.y <= b->p1.y;

266

267

268

static void

269

508088

bbtree_foreach_mark_visible (struct bbtree *bbt,

270

			     const cairo_box_t *box,

271

			     unsigned int **indices)

272

273

    cairo_command_header_t *chain;

274

275

879895

    for (chain = bbt->chain; chain; chain = chain->chain)

276

371807

	*(*indices)++ = chain->index;

277

278

508088

    if (bbt->left && ! box_outside (box, &bbt->left->extents))

279

171986

	bbtree_foreach_mark_visible (bbt->left, box, indices);

280

508088

    if (bbt->right && ! box_outside (box, &bbt->right->extents))

281

111506

	bbtree_foreach_mark_visible (bbt->right, box, indices);

282

508088

283

284

149101

static inline int intcmp (const unsigned int a, const unsigned int b)

285

286

149101

    return a - b;

287

288

296725

CAIRO_COMBSORT_DECLARE (sort_indices, unsigned int, intcmp)

289

290

1928

static inline int sizecmp (unsigned int a, unsigned int b, cairo_command_header_t **elements)

291

292

    const cairo_rectangle_int_t *r;

293

294

1928

    r = &elements[a]->extents;

295

1928

    a = r->width * r->height;

296

297

1928

    r = &elements[b]->extents;

298

1928

    b = r->width * r->height;

299

300

1928

    return b - a;

301

302

3707

CAIRO_COMBSORT_DECLARE_WITH_DATA (sort_commands, unsigned int, sizecmp)

303

304

static void

305

2345

_cairo_recording_surface_destroy_bbtree (cairo_recording_surface_t *surface)

306

307

    cairo_command_t **elements;

308

    int i, num_elements;

309

310

2345

    if (surface->bbtree.chain == INVALID_CHAIN)

311

2345

	return;

312

313

    if (surface->bbtree.left) {

314

	bbtree_del (surface->bbtree.left);

315

	surface->bbtree.left = NULL;

316

317

    if (surface->bbtree.right) {

318

	bbtree_del (surface->bbtree.right);

319

	surface->bbtree.right = NULL;

320

321

322

    elements = _cairo_array_index (&surface->commands, 0);

323

    num_elements = surface->commands.num_elements;

324

    for (i = 0; i < num_elements; i++)

325

	elements[i]->header.chain = NULL;

326

327

    surface->bbtree.chain = INVALID_CHAIN;

328

329

330

static cairo_status_t

331

1318

_cairo_recording_surface_create_bbtree (cairo_recording_surface_t *surface)

332

333

1318

    cairo_command_t **elements = _cairo_array_index (&surface->commands, 0);

334

    unsigned int *indices;

335

    cairo_status_t status;

336

    unsigned int i, count;

337

338

1318

    count = surface->commands.num_elements;

339

1318

    if (count > surface->num_indices) {

340

1318

	free (surface->indices);

341

1318

	surface->indices = _cairo_malloc_ab (count, sizeof (int));

342

1318

	if (unlikely (surface->indices == NULL))

343

	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);

344

345

1318

	surface->num_indices = count;

346

347

348

1318

    indices = surface->indices;

349

3371

    for (i = 0; i < count; i++)

350

2053

	indices[i] = i;

351

352

1318

    sort_commands (indices, count, elements);

353

354

1318

    bbtree_init (&surface->bbtree, &elements[indices[0]]->header);

355

2053

    for (i = 1; i < count; i++) {

356

735

	cairo_command_header_t *header = &elements[indices[i]]->header;

357

	cairo_box_t box;

358

359

735

	_cairo_box_from_rectangle (&box, &header->extents);

360

735

	status = bbtree_add (&surface->bbtree, header, &box);

361

735

	if (unlikely (status))

362

	    goto cleanup;

363

364

365

1318

    return CAIRO_STATUS_SUCCESS;

366

367

cleanup:

368

    if (surface->bbtree.left)

369

	bbtree_del (surface->bbtree.left);

370

    if (surface->bbtree.right)

371

	bbtree_del (surface->bbtree.right);

372

    return status;

373

374

375

/**

376

 * cairo_recording_surface_create:

377

 * @content: the content of the recording surface

378

 * @extents: the extents to record in pixels, can be %NULL to record

379

 *           unbounded operations.

380

381

 * Creates a recording-surface which can be used to record all drawing operations

382

 * at the highest level (that is, the level of paint, mask, stroke, fill

383

 * and show_text_glyphs). The recording surface can then be "replayed" against

384

 * any target surface by using it as a source to drawing operations.

385

386

 * The recording phase of the recording surface is careful to snapshot all

387

 * necessary objects (paths, patterns, etc.), in order to achieve

388

 * accurate replay.

389

390

 * Return value: a pointer to the newly created surface. The caller

391

 * owns the surface and should call cairo_surface_destroy() when done

392

 * with it.

393

394

 * Since: 1.10

395

**/

396

cairo_surface_t *

397

1799

cairo_recording_surface_create (cairo_content_t		 content,

398

				const cairo_rectangle_t	*extents)

399

400

    cairo_recording_surface_t *surface;

401

402

1799

    surface = _cairo_calloc (sizeof (cairo_recording_surface_t));

403

1799

    if (unlikely (surface == NULL))

404

	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));

405

406

1799

    _cairo_surface_init (&surface->base,

407

			 &cairo_recording_surface_backend,

408

			 NULL, /* device */

409

			 content,

410

			 TRUE); /* is_vector */

411

412

413

1799

    surface->unbounded = TRUE;

414

415

    /* unbounded -> 'infinite' extents */

416

1799

    if (extents != NULL) {

417

119

	surface->extents_pixels = *extents;

418

419

	/* XXX check for overflow */

420

119

	surface->extents.x = floor (extents->x);

421

119

	surface->extents.y = floor (extents->y);

422

119

	surface->extents.width = ceil (extents->x + extents->width) - surface->extents.x;

423

119

	surface->extents.height = ceil (extents->y + extents->height) - surface->extents.y;

424

425

119

	surface->unbounded = FALSE;

426

427

428

1799

    _cairo_array_init (&surface->commands, sizeof (cairo_command_t *));

429

430

1799

    surface->base.is_clear = TRUE;

431

432

1799

    surface->bbtree.left = surface->bbtree.right = NULL;

433

1799

    surface->bbtree.chain = INVALID_CHAIN;

434

435

1799

    surface->indices = NULL;

436

1799

    surface->num_indices = 0;

437

1799

    surface->optimize_clears = TRUE;

438

1799

    surface->has_bilevel_alpha = FALSE;

439

1799

    surface->has_only_op_over = FALSE;

440

1799

    surface->has_tags = FALSE;

441

442

1799

    CAIRO_MUTEX_INIT (surface->mutex);

443

444

1799

    cairo_list_init (&surface->region_array_list);

445

446

1799

    return &surface->base;

447

448

449

static cairo_surface_t *

450

12

_cairo_recording_surface_create_similar (void		       *abstract_surface,

451

					 cairo_content_t	content,

452

					 int			width,

453

					 int			height)

454

455

    cairo_rectangle_t extents;

456

12

    extents.x = extents.y = 0;

457

12

    extents.width = width;

458

12

    extents.height = height;

459

12

    return cairo_recording_surface_create (content, &extents);

460

461

462

static void

463

105

destroy_pattern_region_array (const cairo_pattern_t *pattern,

464

			      unsigned int region_id)

465

466

105

    if (region_id != 0) {

467

12

	if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE) {

468

12

	    cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) pattern;

469

12

	    if (_cairo_surface_is_recording (surface_pattern->surface))

470

		_cairo_recording_surface_region_array_remove (surface_pattern->surface, region_id);

471

472

473

105

474

475

static void

476

24

_cairo_recording_surface_region_array_destroy (cairo_recording_surface_t       *surface,

477

					       cairo_recording_regions_array_t *region_array)

478

479

    cairo_command_t **elements;

480

    cairo_recording_region_element_t *region_elements;

481

    int i, num_elements;

482

483

24

    num_elements = MIN(surface->commands.num_elements, _cairo_array_num_elements(&region_array->regions));

484

24

    elements = _cairo_array_index (&surface->commands, 0);

485

24

    region_elements = _cairo_array_index (&region_array->regions, 0);

486

129

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

487

105

	cairo_command_t *command = elements[i];

488

105

	cairo_recording_region_element_t *region_element = &region_elements[i];

489

490

105

	switch (command->header.type) {

491

21

	    case CAIRO_COMMAND_PAINT:

492

21

		destroy_pattern_region_array (&command->paint.source.base, region_element->source_id);

493

21

		break;

494

495

	    case CAIRO_COMMAND_MASK:

496

		destroy_pattern_region_array (&command->mask.source.base, region_element->source_id);

497

		destroy_pattern_region_array (&command->mask.mask.base, region_element->mask_id);

498

		break;

499

500

	    case CAIRO_COMMAND_STROKE:

501

		destroy_pattern_region_array (&command->stroke.source.base, region_element->source_id);

502

		break;

503

504

84

	    case CAIRO_COMMAND_FILL:

505

84

		destroy_pattern_region_array (&command->fill.source.base, region_element->source_id);

506

84

		break;

507

508

	    case CAIRO_COMMAND_SHOW_TEXT_GLYPHS:

509

		destroy_pattern_region_array (&command->show_text_glyphs.source.base, region_element->source_id);

510

		break;

511

512

	    case CAIRO_COMMAND_TAG:

513

		break;

514

515

	    default:

516

		ASSERT_NOT_REACHED;

517

518

519

520

24

    _cairo_array_fini (&region_array->regions);

521

24

    free (region_array);

522

24

523

524

static cairo_status_t

525

1112

_cairo_recording_surface_finish (void *abstract_surface)

526

527

1112

    cairo_recording_surface_t *surface = abstract_surface;

528

    cairo_command_t **elements;

529

    int i, num_elements;

530

    cairo_recording_regions_array_t *region_array, *region_next;

531

532

    /* Normally backend surfaces hold a reference to the surface as

533

     * well as the region and free the region before the surface. So

534

     * the regions should already be freed at this point but just in

535

     * case we ensure the regions are freed before destroying the

536

     * surface. */

537

1112

    cairo_list_foreach_entry_safe (region_array, region_next,

538

				   cairo_recording_regions_array_t,

539

				   &surface->region_array_list, link)

540

541

	cairo_list_del (&region_array->link);

542

	_cairo_recording_surface_region_array_destroy (surface, region_array);

543

544

545

1112

    num_elements = surface->commands.num_elements;

546

1112

    elements = _cairo_array_index (&surface->commands, 0);

547

2779

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

548

1667

	cairo_command_t *command = elements[i];

549

550

1667

	switch (command->header.type) {

551

369

	case CAIRO_COMMAND_PAINT:

552

369

	    _cairo_pattern_fini (&command->paint.source.base);

553

369

	    break;

554

555

54

	case CAIRO_COMMAND_MASK:

556

54

	    _cairo_pattern_fini (&command->mask.source.base);

557

54

	    _cairo_pattern_fini (&command->mask.mask.base);

558

54

	    break;

559

560

31

	case CAIRO_COMMAND_STROKE:

561

31

	    _cairo_pattern_fini (&command->stroke.source.base);

562

31

	    _cairo_path_fixed_fini (&command->stroke.path);

563

31

	    _cairo_stroke_style_fini (&command->stroke.style);

564

31

	    break;

565

566

1009

	case CAIRO_COMMAND_FILL:

567

1009

	    _cairo_pattern_fini (&command->fill.source.base);

568

1009

	    _cairo_path_fixed_fini (&command->fill.path);

569

1009

	    break;

570

571

198

	case CAIRO_COMMAND_SHOW_TEXT_GLYPHS:

572

198

	    _cairo_pattern_fini (&command->show_text_glyphs.source.base);

573

198

	    free (command->show_text_glyphs.utf8);

574

198

	    free (command->show_text_glyphs.glyphs);

575

198

	    free (command->show_text_glyphs.clusters);

576

198

	    cairo_scaled_font_destroy (command->show_text_glyphs.scaled_font);

577

198

	    break;

578

579

6

	case CAIRO_COMMAND_TAG:

580

6

	    free (command->tag.tag_name);

581

6

	    if (command->tag.begin) {

582

3

		free (command->tag.attributes);

583

584

6

	    break;

585

586

	    default:

587

	    ASSERT_NOT_REACHED;

588

589

590

1667

	_cairo_clip_destroy (command->header.clip);

591

1667

	free (command);

592

593

594

1112

    _cairo_array_fini (&surface->commands);

595

596

1112

    if (surface->bbtree.left)

597

188

	bbtree_del (surface->bbtree.left);

598

1112

    if (surface->bbtree.right)

599

89

	bbtree_del (surface->bbtree.right);

600

601

1112

    free (surface->indices);

602

603

1112

    return CAIRO_STATUS_SUCCESS;

604

605

606

struct proxy {

607

    cairo_surface_t base;

608

    cairo_surface_t *image;

609

};

610

611

static cairo_status_t

612

proxy_acquire_source_image (void			 *abstract_surface,

613

			    cairo_image_surface_t	**image_out,

614

			    void			**image_extra)

615

616

    struct proxy *proxy = abstract_surface;

617

    return _cairo_surface_acquire_source_image (proxy->image, image_out, image_extra);

618

619

620

static void

621

proxy_release_source_image (void			*abstract_surface,

622

			    cairo_image_surface_t	*image,

623

			    void			*image_extra)

624

625

    struct proxy *proxy = abstract_surface;

626

    _cairo_surface_release_source_image (proxy->image, image, image_extra);

627

628

629

static cairo_status_t

630

3

proxy_finish (void *abstract_surface)

631

632

3

    return CAIRO_STATUS_SUCCESS;

633

634

635

static const cairo_surface_backend_t proxy_backend  = {

636

    CAIRO_INTERNAL_SURFACE_TYPE_NULL,

637

    proxy_finish,

638

    NULL,

639

640

    NULL, /* create similar */

641

    NULL, /* create similar image */

642

    NULL, /* map to image */

643

    NULL, /* unmap image */

644

645

    _cairo_surface_default_source,

646

    proxy_acquire_source_image,

647

    proxy_release_source_image,

648

};

649

650

static cairo_surface_t *

651

3

attach_proxy (cairo_surface_t *source,

652

	      cairo_surface_t *image)

653

654

    struct proxy *proxy;

655

656

3

    proxy = _cairo_calloc (sizeof (*proxy));

657

3

    if (unlikely (proxy == NULL))

658

	return _cairo_surface_create_in_error (CAIRO_STATUS_NO_MEMORY);

659

660

3

    _cairo_surface_init (&proxy->base, &proxy_backend, NULL, image->content, FALSE);

661

662

3

    proxy->image = image;

663

3

    _cairo_surface_attach_snapshot (source, &proxy->base, NULL);

664

665

3

    return &proxy->base;

666

667

668

static void

669

3

detach_proxy (cairo_surface_t *source,

670

	      cairo_surface_t *proxy)

671

672

3

    cairo_surface_finish (proxy);

673

3

    cairo_surface_destroy (proxy);

674

3

675

676

static cairo_surface_t *

677

get_proxy (cairo_surface_t *proxy)

678

679

    return ((struct proxy *)proxy)->image;

680

681

682

static cairo_status_t

683

3

_cairo_recording_surface_acquire_source_image (void			 *abstract_surface,

684

					       cairo_image_surface_t	**image_out,

685

					       void			**image_extra)

686

687

3

    cairo_recording_surface_t *surface = abstract_surface;

688

    cairo_surface_t *image, *proxy;

689

    cairo_status_t status;

690

691

3

    proxy = _cairo_surface_has_snapshot (abstract_surface, &proxy_backend);

692

3

    if (proxy != NULL) {

693

	*image_out = (cairo_image_surface_t *)

694

	    cairo_surface_reference (get_proxy (proxy));

695

	*image_extra = NULL;

696

	return CAIRO_STATUS_SUCCESS;

697

698

699

3

    if (surface->unbounded)

700

	return CAIRO_INT_STATUS_UNSUPPORTED;

701

3

    image = _cairo_image_surface_create_with_content (surface->base.content,

702

						      surface->extents.width,

703

						      surface->extents.height);

704

3

    cairo_surface_set_device_offset (image, -surface->extents.x, -surface->extents.y);

705

3

    if (unlikely (image->status))

706

	return image->status;

707

708

3

    cairo_surface_set_device_offset(image, -surface->extents.x, -surface->extents.y);

709

710

    /* Handle recursion by returning future reads from the current image */

711

3

    proxy = attach_proxy (abstract_surface, image);

712

3

    status = _cairo_recording_surface_replay (&surface->base, image);

713

3

    detach_proxy (abstract_surface, proxy);

714

715

3

    if (unlikely (status)) {

716

	cairo_surface_destroy (image);

717

	return status;

718

719

720

3

    *image_out = (cairo_image_surface_t *) image;

721

3

    *image_extra = NULL;

722

3

    return CAIRO_STATUS_SUCCESS;

723

724

725

static void

726

3

_cairo_recording_surface_release_source_image (void			*abstract_surface,

727

					       cairo_image_surface_t	*image,

728

					       void			*image_extra)

729

730

3

    cairo_surface_destroy (&image->base);

731

3

732

733

static cairo_status_t

734

2642

_command_init (cairo_recording_surface_t *surface,

735

	       cairo_command_header_t *command,

736

	       cairo_command_type_t type,

737

	       cairo_operator_t op,

738

	       cairo_composite_rectangles_t *composite)

739

740

2642

    cairo_status_t status = CAIRO_STATUS_SUCCESS;

741

742

2642

    command->type = type;

743

2642

    command->op = op;

744

745

2642

    command->extents = composite ? composite->unbounded : _cairo_empty_rectangle;

746

2642

    command->chain = NULL;

747

2642

    command->index = surface->commands.num_elements;

748

749

    /* steal the clip */

750

2642

    command->clip = NULL;

751

2642

    if (composite && ! _cairo_composite_rectangles_can_reduce_clip (composite,

752

								    composite->clip))

753

754

231

	command->clip = composite->clip;

755

231

	composite->clip = NULL;

756

757

758

2642

    return status;

759

760

761

static void

762

3074

_cairo_recording_surface_break_self_copy_loop (cairo_recording_surface_t *surface)

763

764

3074

    cairo_surface_flush (&surface->base);

765

3074

766

767

static cairo_status_t

768

3074

_cairo_recording_surface_commit (cairo_recording_surface_t *surface,

769

				 cairo_command_header_t *command)

770

771

3074

    _cairo_recording_surface_break_self_copy_loop (surface);

772

3074

    return _cairo_array_append (&surface->commands, &command);

773

774

775

static void

776

336

_cairo_recording_surface_reset (cairo_recording_surface_t *surface)

777

778

    /* Reset the commands and temporaries */

779

336

    _cairo_recording_surface_finish (surface);

780

781

336

    surface->bbtree.left = surface->bbtree.right = NULL;

782

336

    surface->bbtree.chain = INVALID_CHAIN;

783

784

336

    surface->indices = NULL;

785

336

    surface->num_indices = 0;

786

787

336

    _cairo_array_init (&surface->commands, sizeof (cairo_command_t *));

788

336

789

790

static cairo_int_status_t

791

456

_cairo_recording_surface_paint (void			  *abstract_surface,

792

				cairo_operator_t	   op,

793

				const cairo_pattern_t	  *source,

794

				const cairo_clip_t	  *clip)

795

796

    cairo_status_t status;

797

456

    cairo_recording_surface_t *surface = abstract_surface;

798

    cairo_command_paint_t *command;

799

    cairo_composite_rectangles_t composite;

800

801

    TRACE ((stderr, "%s: surface=%d\n", __FUNCTION__, surface->base.unique_id));

802

803

456

    if (op == CAIRO_OPERATOR_CLEAR && clip == NULL) {

804

	if (surface->optimize_clears) {

805

	    _cairo_recording_surface_reset (surface);

806

	    return CAIRO_STATUS_SUCCESS;

807

808

809

810

456

    if (clip == NULL && surface->optimize_clears &&

811

381

	(op == CAIRO_OPERATOR_SOURCE ||

812

381

	 (op == CAIRO_OPERATOR_OVER &&

813

381

	  (surface->base.is_clear || _cairo_pattern_is_opaque_solid (source)))))

814

815

336

	_cairo_recording_surface_reset (surface);

816

817

818

456

    status = _cairo_composite_rectangles_init_for_paint (&composite,

819

							 &surface->base,

820

							 op, source,

821

							 clip);

822

456

    if (unlikely (status))

823

	return status;

824

825

456

    command = _cairo_calloc (sizeof (cairo_command_paint_t));

826

456

    if (unlikely (command == NULL)) {

827

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

828

	goto CLEANUP_COMPOSITE;

829

830

831

456

    status = _command_init (surface,

832

			    &command->header, CAIRO_COMMAND_PAINT, op,

833

			    &composite);

834

456

    if (unlikely (status))

835

	goto CLEANUP_COMMAND;

836

837

456

    status = _cairo_pattern_init_snapshot (&command->source.base, source);

838

456

    if (unlikely (status))

839

	goto CLEANUP_COMMAND;

840

841

456

    status = _cairo_recording_surface_commit (surface, &command->header);

842

456

    if (unlikely (status))

843

	goto CLEANUP_SOURCE;

844

845

456

    _cairo_recording_surface_destroy_bbtree (surface);

846

847

456

    _cairo_composite_rectangles_fini (&composite);

848

456

    return CAIRO_STATUS_SUCCESS;

849

850

  CLEANUP_SOURCE:

851

    _cairo_pattern_fini (&command->source.base);

852

  CLEANUP_COMMAND:

853

    _cairo_clip_destroy (command->header.clip);

854

    free (command);

855

CLEANUP_COMPOSITE:

856

    _cairo_composite_rectangles_fini (&composite);

857

    return status;

858

859

860

static cairo_int_status_t

861

75

_cairo_recording_surface_mask (void			*abstract_surface,

862

			       cairo_operator_t		 op,

863

			       const cairo_pattern_t	*source,

864

			       const cairo_pattern_t	*mask,

865

			       const cairo_clip_t	*clip)

866

867

    cairo_status_t status;

868

75

    cairo_recording_surface_t *surface = abstract_surface;

869

    cairo_command_mask_t *command;

870

    cairo_composite_rectangles_t composite;

871

872

    TRACE ((stderr, "%s: surface=%d\n", __FUNCTION__, surface->base.unique_id));

873

874

75

    status = _cairo_composite_rectangles_init_for_mask (&composite,

875

							&surface->base,

876

							op, source, mask,

877

							clip);

878

75

    if (unlikely (status))

879

	return status;

880

881

75

    command = _cairo_calloc (sizeof (cairo_command_mask_t));

882

75

    if (unlikely (command == NULL)) {

883

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

884

	goto CLEANUP_COMPOSITE;

885

886

887

75

    status = _command_init (surface,

888

			    &command->header, CAIRO_COMMAND_MASK, op,

889

			    &composite);

890

75

    if (unlikely (status))

891

	goto CLEANUP_COMMAND;

892

893

75

    status = _cairo_pattern_init_snapshot (&command->source.base, source);

894

75

    if (unlikely (status))

895

	goto CLEANUP_COMMAND;

896

897

75

    status = _cairo_pattern_init_snapshot (&command->mask.base, mask);

898

75

    if (unlikely (status))

899

	goto CLEANUP_SOURCE;

900

901

75

    status = _cairo_recording_surface_commit (surface, &command->header);

902

75

    if (unlikely (status))

903

	goto CLEANUP_MASK;

904

905

75

    _cairo_recording_surface_destroy_bbtree (surface);

906

907

75

    _cairo_composite_rectangles_fini (&composite);

908

75

    return CAIRO_STATUS_SUCCESS;

909

910

  CLEANUP_MASK:

911

    _cairo_pattern_fini (&command->mask.base);

912

  CLEANUP_SOURCE:

913

    _cairo_pattern_fini (&command->source.base);

914

  CLEANUP_COMMAND:

915

    _cairo_clip_destroy (command->header.clip);

916

    free (command);

917

CLEANUP_COMPOSITE:

918

    _cairo_composite_rectangles_fini (&composite);

919

    return status;

920

921

922

static cairo_int_status_t

923

733

_cairo_recording_surface_stroke (void			*abstract_surface,

924

				 cairo_operator_t	 op,

925

				 const cairo_pattern_t	*source,

926

				 const cairo_path_fixed_t	*path,

927

				 const cairo_stroke_style_t	*style,

928

				 const cairo_matrix_t		*ctm,

929

				 const cairo_matrix_t		*ctm_inverse,

930

				 double			 tolerance,

931

				 cairo_antialias_t	 antialias,

932

				 const cairo_clip_t	*clip)

933

934

    cairo_status_t status;

935

733

    cairo_recording_surface_t *surface = abstract_surface;

936

    cairo_command_stroke_t *command;

937

    cairo_composite_rectangles_t composite;

938

939

    TRACE ((stderr, "%s: surface=%d\n", __FUNCTION__, surface->base.unique_id));

940

941

733

    status = _cairo_composite_rectangles_init_for_stroke (&composite,

942

							  &surface->base,

943

							  op, source,

944

							  path, style, ctm,

945

							  clip);

946

733

    if (unlikely (status))

947

36

	return status;

948

949

697

    command = _cairo_calloc (sizeof (cairo_command_stroke_t));

950

697

    if (unlikely (command == NULL)) {

951

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

952

	goto CLEANUP_COMPOSITE;

953

954

955

697

    status = _command_init (surface,

956

			    &command->header, CAIRO_COMMAND_STROKE, op,

957

			    &composite);

958

697

    if (unlikely (status))

959

	goto CLEANUP_COMMAND;

960

961

697

    status = _cairo_pattern_init_snapshot (&command->source.base, source);

962

697

    if (unlikely (status))

963

	goto CLEANUP_COMMAND;

964

965

697

    status = _cairo_path_fixed_init_copy (&command->path, path);

966

697

    if (unlikely (status))

967

	goto CLEANUP_SOURCE;

968

969

697

    status = _cairo_stroke_style_init_copy (&command->style, style);

970

697

    if (unlikely (status))

971

	goto CLEANUP_PATH;

972

973

697

    command->ctm = *ctm;

974

697

    command->ctm_inverse = *ctm_inverse;

975

697

    command->tolerance = tolerance;

976

697

    command->antialias = antialias;

977

978

697

    status = _cairo_recording_surface_commit (surface, &command->header);

979

697

    if (unlikely (status))

980

	goto CLEANUP_STYLE;

981

982

697

    _cairo_recording_surface_destroy_bbtree (surface);

983

984

697

    _cairo_composite_rectangles_fini (&composite);

985

697

    return CAIRO_STATUS_SUCCESS;

986

987

  CLEANUP_STYLE:

988

    _cairo_stroke_style_fini (&command->style);

989

  CLEANUP_PATH:

990

    _cairo_path_fixed_fini (&command->path);

991

  CLEANUP_SOURCE:

992

    _cairo_pattern_fini (&command->source.base);

993

  CLEANUP_COMMAND:

994

    _cairo_clip_destroy (command->header.clip);

995

    free (command);

996

CLEANUP_COMPOSITE:

997

    _cairo_composite_rectangles_fini (&composite);

998

    return status;

999

1000

1001

static cairo_int_status_t

1002

1111

_cairo_recording_surface_fill (void			*abstract_surface,

1003

			       cairo_operator_t		 op,

1004

			       const cairo_pattern_t	*source,

1005

			       const cairo_path_fixed_t	*path,

1006

			       cairo_fill_rule_t	 fill_rule,

1007

			       double			 tolerance,

1008

			       cairo_antialias_t	 antialias,

1009

			       const cairo_clip_t	*clip)

1010

1011

    cairo_status_t status;

1012

1111

    cairo_recording_surface_t *surface = abstract_surface;

1013

    cairo_command_fill_t *command;

1014

    cairo_composite_rectangles_t composite;

1015

1016

    TRACE ((stderr, "%s: surface=%d\n", __FUNCTION__, surface->base.unique_id));

1017

1018

1111

    status = _cairo_composite_rectangles_init_for_fill (&composite,

1019

							&surface->base,

1020

							op, source, path,

1021

							clip);

1022

1111

    if (unlikely (status))

1023

	return status;

1024

1025

1111

    command = _cairo_calloc (sizeof (cairo_command_fill_t));

1026

1111

    if (unlikely (command == NULL)) {

1027

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1028

	goto CLEANUP_COMPOSITE;

1029

1030

1031

1111

    status =_command_init (surface,

1032

			   &command->header, CAIRO_COMMAND_FILL, op,

1033

			   &composite);

1034

1111

    if (unlikely (status))

1035

	goto CLEANUP_COMMAND;

1036

1037

1111

    status = _cairo_pattern_init_snapshot (&command->source.base, source);

1038

1111

    if (unlikely (status))

1039

	goto CLEANUP_COMMAND;

1040

1041

1111

    status = _cairo_path_fixed_init_copy (&command->path, path);

1042

1111

    if (unlikely (status))

1043

	goto CLEANUP_SOURCE;

1044

1045

1111

    command->fill_rule = fill_rule;

1046

1111

    command->tolerance = tolerance;

1047

1111

    command->antialias = antialias;

1048

1049

1111

    status = _cairo_recording_surface_commit (surface, &command->header);

1050

1111

    if (unlikely (status))

1051

	goto CLEANUP_PATH;

1052

1053

1111

    _cairo_recording_surface_destroy_bbtree (surface);

1054

1055

1111

    _cairo_composite_rectangles_fini (&composite);

1056

1111

    return CAIRO_STATUS_SUCCESS;

1057

1058

  CLEANUP_PATH:

1059

    _cairo_path_fixed_fini (&command->path);

1060

  CLEANUP_SOURCE:

1061

    _cairo_pattern_fini (&command->source.base);

1062

  CLEANUP_COMMAND:

1063

    _cairo_clip_destroy (command->header.clip);

1064

    free (command);

1065

CLEANUP_COMPOSITE:

1066

    _cairo_composite_rectangles_fini (&composite);

1067

    return status;

1068

1069

1070

static cairo_bool_t

1071

513

_cairo_recording_surface_has_show_text_glyphs (void *abstract_surface)

1072

1073

513

    return TRUE;

1074

1075

1076

static cairo_int_status_t

1077

303

_cairo_recording_surface_show_text_glyphs (void				*abstract_surface,

1078

					   cairo_operator_t		 op,

1079

					   const cairo_pattern_t	*source,

1080

					   const char			*utf8,

1081

					   int				 utf8_len,

1082

					   cairo_glyph_t		*glyphs,

1083

					   int				 num_glyphs,

1084

					   const cairo_text_cluster_t	*clusters,

1085

					   int				 num_clusters,

1086

					   cairo_text_cluster_flags_t	 cluster_flags,

1087

					   cairo_scaled_font_t		*scaled_font,

1088

					   const cairo_clip_t		*clip)

1089

1090

    cairo_status_t status;

1091

303

    cairo_recording_surface_t *surface = abstract_surface;

1092

    cairo_command_show_text_glyphs_t *command;

1093

    cairo_composite_rectangles_t composite;

1094

1095

    TRACE ((stderr, "%s: surface=%d\n", __FUNCTION__, surface->base.unique_id));

1096

1097

303

    status = _cairo_composite_rectangles_init_for_glyphs (&composite,

1098

							  &surface->base,

1099

							  op, source,

1100

							  scaled_font,

1101

							  glyphs, num_glyphs,

1102

							  clip,

1103

							  NULL);

1104

303

    if (unlikely (status))

1105

6

	return status;

1106

1107

297

    command = _cairo_calloc (sizeof (cairo_command_show_text_glyphs_t));

1108

297

    if (unlikely (command == NULL)) {

1109

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1110

	goto CLEANUP_COMPOSITE;

1111

1112

1113

297

    status = _command_init (surface,

1114

			    &command->header, CAIRO_COMMAND_SHOW_TEXT_GLYPHS,

1115

			    op, &composite);

1116

297

    if (unlikely (status))

1117

	goto CLEANUP_COMMAND;

1118

1119

297

    status = _cairo_pattern_init_snapshot (&command->source.base, source);

1120

297

    if (unlikely (status))

1121

	goto CLEANUP_COMMAND;

1122

1123

297

    command->utf8 = NULL;

1124

297

    command->utf8_len = utf8_len;

1125

297

    command->glyphs = NULL;

1126

297

    command->num_glyphs = num_glyphs;

1127

297

    command->clusters = NULL;

1128

297

    command->num_clusters = num_clusters;

1129

1130

297

    if (utf8_len) {

1131

210

	command->utf8 = _cairo_malloc (utf8_len);

1132

210

	if (unlikely (command->utf8 == NULL)) {

1133

	    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1134

	    goto CLEANUP_ARRAYS;

1135

1136

210

	memcpy (command->utf8, utf8, utf8_len);

1137

1138

297

    if (num_glyphs) {

1139

297

	command->glyphs = _cairo_malloc_ab (num_glyphs, sizeof (glyphs[0]));

1140

297

	if (unlikely (command->glyphs == NULL)) {

1141

	    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1142

	    goto CLEANUP_ARRAYS;

1143

1144

297

	memcpy (command->glyphs, glyphs, sizeof (glyphs[0]) * num_glyphs);

1145

1146

297

    if (num_clusters) {

1147

210

	command->clusters = _cairo_malloc_ab (num_clusters, sizeof (clusters[0]));

1148

210

	if (unlikely (command->clusters == NULL)) {

1149

	    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1150

	    goto CLEANUP_ARRAYS;

1151

1152

210

	memcpy (command->clusters, clusters, sizeof (clusters[0]) * num_clusters);

1153

1154

1155

297

    command->cluster_flags = cluster_flags;

1156

1157

297

    status = scaled_font->status;

1158

297

    if (unlikely (status))

1159

	goto CLEANUP_ARRAYS;

1160

1161

297

    command->scaled_font = cairo_scaled_font_reference (scaled_font);

1162

1163

297

    status = _cairo_recording_surface_commit (surface, &command->header);

1164

297

    if (unlikely (status))

1165

	goto CLEANUP_SCALED_FONT;

1166

1167

297

    _cairo_composite_rectangles_fini (&composite);

1168

297

    return CAIRO_STATUS_SUCCESS;

1169

1170

  CLEANUP_SCALED_FONT:

1171

    cairo_scaled_font_destroy (command->scaled_font);

1172

  CLEANUP_ARRAYS:

1173

    free (command->utf8);

1174

    free (command->glyphs);

1175

    free (command->clusters);

1176

1177

    _cairo_pattern_fini (&command->source.base);

1178

  CLEANUP_COMMAND:

1179

    _cairo_clip_destroy (command->header.clip);

1180

    free (command);

1181

CLEANUP_COMPOSITE:

1182

    _cairo_composite_rectangles_fini (&composite);

1183

    return status;

1184

1185

1186

static cairo_int_status_t

1187

6

_cairo_recording_surface_tag (void			 *abstract_surface,

1188

			      cairo_bool_t                begin,

1189

			      const char                 *tag_name,

1190

			      const char                 *attributes)

1191

1192

    cairo_status_t status;

1193

6

    cairo_recording_surface_t *surface = abstract_surface;

1194

    cairo_command_tag_t *command;

1195

1196

    TRACE ((stderr, "%s: surface=%d\n", __FUNCTION__, surface->base.unique_id));

1197

1198

6

    surface->has_tags = TRUE;

1199

1200

6

    command = _cairo_calloc (sizeof (cairo_command_tag_t));

1201

6

    if (unlikely (command == NULL)) {

1202

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

1203

1204

1205

6

    status = _command_init (surface,

1206

			    &command->header, CAIRO_COMMAND_TAG, CAIRO_OPERATOR_SOURCE,

1207

			    NULL);

1208

6

    if (unlikely (status))

1209

	goto CLEANUP_COMMAND;

1210

1211

6

    command->begin = begin;

1212

6

    command->tag_name = strdup (tag_name);

1213

6

    if (unlikely (command->tag_name == NULL)) {

1214

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1215

	goto CLEANUP_COMMAND;

1216

1217

6

    if (begin) {

1218

3

	if (attributes) {

1219

3

	    command->attributes = strdup (attributes);

1220

3

	    if (unlikely (command->attributes == NULL)) {

1221

		status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1222

		goto CLEANUP_STRINGS;

1223

1224

1225

1226

1227

6

    status = _cairo_recording_surface_commit (surface, &command->header);

1228

6

    if (unlikely (status))

1229

	goto CLEANUP_STRINGS;

1230

1231

6

    _cairo_recording_surface_destroy_bbtree (surface);

1232

1233

6

    return CAIRO_STATUS_SUCCESS;

1234

1235

  CLEANUP_STRINGS:

1236

    free (command->tag_name);

1237

    free (command->attributes);

1238

  CLEANUP_COMMAND:

1239

    _cairo_clip_destroy (command->header.clip);

1240

    free (command);

1241

    return status;

1242

1243

1244

static cairo_bool_t

1245

_cairo_recording_surface_supports_color_glyph (void                 *abstract_surface,

1246

                                               cairo_scaled_font_t  *scaled_font,

1247

                                               unsigned long         glyph_index)

1248

1249

    return TRUE;

1250

1251

1252

static void

1253

432

_command_init_copy (cairo_recording_surface_t *surface,

1254

		    cairo_command_header_t *dst,

1255

		    const cairo_command_header_t *src)

1256

1257

432

    dst->type = src->type;

1258

432

    dst->op = src->op;

1259

1260

432

    dst->extents = src->extents;

1261

432

    dst->chain = NULL;

1262

432

    dst->index = surface->commands.num_elements;

1263

1264

432

    dst->clip = _cairo_clip_copy (src->clip);

1265

432

1266

1267

static cairo_status_t

1268

36

_cairo_recording_surface_copy__paint (cairo_recording_surface_t *surface,

1269

				      const cairo_command_t *src)

1270

1271

    cairo_command_paint_t *command;

1272

    cairo_status_t status;

1273

1274

36

    command = _cairo_calloc (sizeof (*command));

1275

36

    if (unlikely (command == NULL)) {

1276

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1277

	goto err;

1278

1279

1280

36

    _command_init_copy (surface, &command->header, &src->header);

1281

1282

36

    status = _cairo_pattern_init_copy (&command->source.base,

1283

				       &src->paint.source.base);

1284

36

    if (unlikely (status))

1285

	goto err_command;

1286

1287

36

    status = _cairo_recording_surface_commit (surface, &command->header);

1288

36

    if (unlikely (status))

1289

	goto err_source;

1290

1291

36

    return CAIRO_STATUS_SUCCESS;

1292

1293

err_source:

1294

    _cairo_pattern_fini (&command->source.base);

1295

err_command:

1296

    free(command);

1297

err:

1298

    return status;

1299

1300

1301

static cairo_status_t

1302

_cairo_recording_surface_copy__mask (cairo_recording_surface_t *surface,

1303

				     const cairo_command_t *src)

1304

1305

    cairo_command_mask_t *command;

1306

    cairo_status_t status;

1307

1308

    command = _cairo_calloc (sizeof (*command));

1309

    if (unlikely (command == NULL)) {

1310

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1311

	goto err;

1312

1313

1314

    _command_init_copy (surface, &command->header, &src->header);

1315

1316

    status = _cairo_pattern_init_copy (&command->source.base,

1317

				       &src->mask.source.base);

1318

    if (unlikely (status))

1319

	goto err_command;

1320

1321

    status = _cairo_pattern_init_copy (&command->mask.base,

1322

				       &src->mask.mask.base);

1323

    if (unlikely (status))

1324

	goto err_source;

1325

1326

    status = _cairo_recording_surface_commit (surface, &command->header);

1327

    if (unlikely (status))

1328

	goto err_mask;

1329

1330

    return CAIRO_STATUS_SUCCESS;

1331

1332

err_mask:

1333

    _cairo_pattern_fini (&command->mask.base);

1334

err_source:

1335

    _cairo_pattern_fini (&command->source.base);

1336

err_command:

1337

    free(command);

1338

err:

1339

    return status;

1340

1341

1342

static cairo_status_t

1343

6

_cairo_recording_surface_copy__stroke (cairo_recording_surface_t *surface,

1344

				     const cairo_command_t *src)

1345

1346

    cairo_command_stroke_t *command;

1347

    cairo_status_t status;

1348

1349

6

    command = _cairo_calloc (sizeof (*command));

1350

6

    if (unlikely (command == NULL)) {

1351

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1352

	goto err;

1353

1354

1355

6

    _command_init_copy (surface, &command->header, &src->header);

1356

1357

6

    status = _cairo_pattern_init_copy (&command->source.base,

1358

				       &src->stroke.source.base);

1359

6

    if (unlikely (status))

1360

	goto err_command;

1361

1362

6

    status = _cairo_path_fixed_init_copy (&command->path, &src->stroke.path);

1363

6

    if (unlikely (status))

1364

	goto err_source;

1365

1366

6

    status = _cairo_stroke_style_init_copy (&command->style,

1367

					    &src->stroke.style);

1368

6

    if (unlikely (status))

1369

	goto err_path;

1370

1371

6

    command->ctm = src->stroke.ctm;

1372

6

    command->ctm_inverse = src->stroke.ctm_inverse;

1373

6

    command->tolerance = src->stroke.tolerance;

1374

6

    command->antialias = src->stroke.antialias;

1375

1376

6

    status = _cairo_recording_surface_commit (surface, &command->header);

1377

6

    if (unlikely (status))

1378

	goto err_style;

1379

1380

6

    return CAIRO_STATUS_SUCCESS;

1381

1382

err_style:

1383

    _cairo_stroke_style_fini (&command->style);

1384

err_path:

1385

    _cairo_path_fixed_fini (&command->path);

1386

err_source:

1387

    _cairo_pattern_fini (&command->source.base);

1388

err_command:

1389

    free(command);

1390

err:

1391

    return status;

1392

1393

1394

static cairo_status_t

1395

366

_cairo_recording_surface_copy__fill (cairo_recording_surface_t *surface,

1396

				     const cairo_command_t *src)

1397

1398

    cairo_command_fill_t *command;

1399

    cairo_status_t status;

1400

1401

366

    command = _cairo_calloc (sizeof (*command));

1402

366

    if (unlikely (command == NULL)) {

1403

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1404

	goto err;

1405

1406

1407

366

    _command_init_copy (surface, &command->header, &src->header);

1408

1409

366

    status = _cairo_pattern_init_copy (&command->source.base,

1410

				       &src->fill.source.base);

1411

366

    if (unlikely (status))

1412

	goto err_command;

1413

1414

366

    status = _cairo_path_fixed_init_copy (&command->path, &src->fill.path);

1415

366

    if (unlikely (status))

1416

	goto err_source;

1417

1418

366

    command->fill_rule = src->fill.fill_rule;

1419

366

    command->tolerance = src->fill.tolerance;

1420

366

    command->antialias = src->fill.antialias;

1421

1422

366

    status = _cairo_recording_surface_commit (surface, &command->header);

1423

366

    if (unlikely (status))

1424

	goto err_path;

1425

1426

366

    return CAIRO_STATUS_SUCCESS;

1427

1428

err_path:

1429

    _cairo_path_fixed_fini (&command->path);

1430

err_source:

1431

    _cairo_pattern_fini (&command->source.base);

1432

err_command:

1433

    free(command);

1434

err:

1435

    return status;

1436

1437

1438

static cairo_status_t

1439

24

_cairo_recording_surface_copy__glyphs (cairo_recording_surface_t *surface,

1440

				       const cairo_command_t *src)

1441

1442

    cairo_command_show_text_glyphs_t *command;

1443

    cairo_status_t status;

1444

1445

24

    command = _cairo_calloc (sizeof (*command));

1446

24

    if (unlikely (command == NULL)) {

1447

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1448

	goto err;

1449

1450

1451

24

    _command_init_copy (surface, &command->header, &src->header);

1452

1453

24

    status = _cairo_pattern_init_copy (&command->source.base,

1454

				       &src->show_text_glyphs.source.base);

1455

24

    if (unlikely (status))

1456

	goto err_command;

1457

1458

24

    command->utf8 = NULL;

1459

24

    command->utf8_len = src->show_text_glyphs.utf8_len;

1460

24

    command->glyphs = NULL;

1461

24

    command->num_glyphs = src->show_text_glyphs.num_glyphs;

1462

24

    command->clusters = NULL;

1463

24

    command->num_clusters = src->show_text_glyphs.num_clusters;

1464

1465

24

    if (command->utf8_len) {

1466

24

	command->utf8 = _cairo_malloc (command->utf8_len);

1467

24

	if (unlikely (command->utf8 == NULL)) {

1468

	    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1469

	    goto err_arrays;

1470

1471

24

	memcpy (command->utf8, src->show_text_glyphs.utf8, command->utf8_len);

1472

1473

24

    if (command->num_glyphs) {

1474

24

	command->glyphs = _cairo_malloc_ab (command->num_glyphs,

1475

					    sizeof (command->glyphs[0]));

1476

24

	if (unlikely (command->glyphs == NULL)) {

1477

	    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1478

	    goto err_arrays;

1479

1480

24

	memcpy (command->glyphs, src->show_text_glyphs.glyphs,

1481

24

		sizeof (command->glyphs[0]) * command->num_glyphs);

1482

1483

24

    if (command->num_clusters) {

1484

24

	command->clusters = _cairo_malloc_ab (command->num_clusters,

1485

					      sizeof (command->clusters[0]));

1486

24

	if (unlikely (command->clusters == NULL)) {

1487

	    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1488

	    goto err_arrays;

1489

1490

24

	memcpy (command->clusters, src->show_text_glyphs.clusters,

1491

24

		sizeof (command->clusters[0]) * command->num_clusters);

1492

1493

1494

24

    command->cluster_flags = src->show_text_glyphs.cluster_flags;

1495

1496

24

    command->scaled_font =

1497

24

	cairo_scaled_font_reference (src->show_text_glyphs.scaled_font);

1498

1499

24

    status = _cairo_recording_surface_commit (surface, &command->header);

1500

24

    if (unlikely (status))

1501

	goto err_arrays;

1502

1503

24

    return CAIRO_STATUS_SUCCESS;

1504

1505

err_arrays:

1506

    free (command->utf8);

1507

    free (command->glyphs);

1508

    free (command->clusters);

1509

    _cairo_pattern_fini (&command->source.base);

1510

err_command:

1511

    free(command);

1512

err:

1513

    return status;

1514

1515

1516

static cairo_status_t

1517

_cairo_recording_surface_copy__tag (cairo_recording_surface_t *surface,

1518

				    const cairo_command_t *src)

1519

1520

    cairo_command_tag_t *command;

1521

    cairo_status_t status;

1522

1523

    command = _cairo_calloc (sizeof (*command));

1524

    if (unlikely (command == NULL)) {

1525

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1526

	goto err;

1527

1528

1529

    _command_init_copy (surface, &command->header, &src->header);

1530

1531

    command->begin = src->tag.begin;

1532

    command->tag_name = strdup (src->tag.tag_name);

1533

    if (unlikely (command->tag_name == NULL)) {

1534

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1535

	goto err_command;

1536

1537

    if (src->tag.begin) {

1538

	if (src->tag.attributes) {

1539

	    command->attributes = strdup (src->tag.attributes);

1540

	    if (unlikely (command->attributes == NULL)) {

1541

		status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1542

		goto err_command;

1543

1544

1545

1546

1547

    status = _cairo_recording_surface_commit (surface, &command->header);

1548

    if (unlikely (status))

1549

	goto err_command;

1550

1551

    return CAIRO_STATUS_SUCCESS;

1552

1553

err_command:

1554

    free(command->tag_name);

1555

    free(command->attributes);

1556

    free(command);

1557

err:

1558

    return status;

1559

1560

1561

static cairo_status_t

1562

159

_cairo_recording_surface_copy (cairo_recording_surface_t *dst,

1563

			       cairo_recording_surface_t *src)

1564

1565

    cairo_command_t **elements;

1566

    int i, num_elements;

1567

    cairo_status_t status;

1568

1569

159

    elements = _cairo_array_index (&src->commands, 0);

1570

159

    num_elements = src->commands.num_elements;

1571

591

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

1572

432

	const cairo_command_t *command = elements[i];

1573

1574

432

	switch (command->header.type) {

1575

36

	case CAIRO_COMMAND_PAINT:

1576

36

	    status = _cairo_recording_surface_copy__paint (dst, command);

1577

36

	    break;

1578

1579

	case CAIRO_COMMAND_MASK:

1580

	    status = _cairo_recording_surface_copy__mask (dst, command);

1581

	    break;

1582

1583

6

	case CAIRO_COMMAND_STROKE:

1584

6

	    status = _cairo_recording_surface_copy__stroke (dst, command);

1585

6

	    break;

1586

1587

366

	case CAIRO_COMMAND_FILL:

1588

366

	    status = _cairo_recording_surface_copy__fill (dst, command);

1589

366

	    break;

1590

1591

24

	case CAIRO_COMMAND_SHOW_TEXT_GLYPHS:

1592

24

	    status = _cairo_recording_surface_copy__glyphs (dst, command);

1593

24

	    break;

1594

1595

	case CAIRO_COMMAND_TAG:

1596

	    status = _cairo_recording_surface_copy__tag (dst, command);

1597

	    break;

1598

1599

	default:

1600

	    ASSERT_NOT_REACHED;

1601

1602

1603

432

	if (unlikely (status))

1604

	    return status;

1605

1606

1607

159

    return CAIRO_STATUS_SUCCESS;

1608

1609

1610

/**

1611

 * _cairo_recording_surface_snapshot:

1612

 * @surface: a #cairo_surface_t which must be a recording surface

1613

1614

 * Make an immutable copy of @surface. It is an error to call a

1615

 * surface-modifying function on the result of this function.

1616

1617

 * The caller owns the return value and should call

1618

 * cairo_surface_destroy() when finished with it. This function will not

1619

 * return %NULL, but will return a nil surface instead.

1620

1621

 * Return value: The snapshot surface.

1622

**/

1623

static cairo_surface_t *

1624

159

_cairo_recording_surface_snapshot (void *abstract_other)

1625

1626

159

    cairo_recording_surface_t *other = abstract_other;

1627

    cairo_recording_surface_t *surface;

1628

    cairo_status_t status;

1629

1630

159

    surface = _cairo_calloc (sizeof (cairo_recording_surface_t));

1631

159

    if (unlikely (surface == NULL))

1632

	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));

1633

1634

159

    _cairo_surface_init (&surface->base,

1635

			 &cairo_recording_surface_backend,

1636

			 NULL, /* device */

1637

			 other->base.content,

1638

159

			 other->base.is_vector);

1639

1640

159

    surface->extents_pixels = other->extents_pixels;

1641

159

    surface->extents = other->extents;

1642

159

    surface->unbounded = other->unbounded;

1643

159

    surface->has_bilevel_alpha = other->has_bilevel_alpha;

1644

159

    surface->has_only_op_over = other->has_only_op_over;

1645

159

    surface->has_tags = other->has_tags;

1646

1647

159

    surface->base.is_clear = other->base.is_clear;

1648

1649

159

    surface->bbtree.left = surface->bbtree.right = NULL;

1650

159

    surface->bbtree.chain = INVALID_CHAIN;

1651

1652

159

    surface->indices = NULL;

1653

159

    surface->num_indices = 0;

1654

159

    surface->optimize_clears = TRUE;

1655

1656

159

    CAIRO_MUTEX_INIT (surface->mutex);

1657

1658

159

    cairo_list_init (&surface->region_array_list);

1659

1660

159

    _cairo_array_init (&surface->commands, sizeof (cairo_command_t *));

1661

159

    status = _cairo_recording_surface_copy (surface, other);

1662

159

    if (unlikely (status)) {

1663

	cairo_surface_destroy (&surface->base);

1664

	return _cairo_surface_create_in_error (status);

1665

1666

1667

159

    return &surface->base;

1668

1669

1670

static cairo_bool_t

1671

1095768

_cairo_recording_surface_get_extents (void		    *abstract_surface,

1672

				      cairo_rectangle_int_t *rectangle)

1673

1674

1095768

    cairo_recording_surface_t *surface = abstract_surface;

1675

1676

1095768

    if (surface->unbounded)

1677

1050615

	return FALSE;

1678

1679

45153

    *rectangle = surface->extents;

1680

45153

    return TRUE;

1681

1682

1683

static const cairo_surface_backend_t cairo_recording_surface_backend = {

1684

    CAIRO_SURFACE_TYPE_RECORDING,

1685

    _cairo_recording_surface_finish,

1686

1687

    _cairo_default_context_create,

1688

1689

    _cairo_recording_surface_create_similar,

1690

    NULL, /* create similar image */

1691

    NULL, /* map to image */

1692

    NULL, /* unmap image */

1693

1694

    _cairo_surface_default_source,

1695

    _cairo_recording_surface_acquire_source_image,

1696

    _cairo_recording_surface_release_source_image,

1697

    _cairo_recording_surface_snapshot,

1698

1699

    NULL, /* copy_page */

1700

    NULL, /* show_page */

1701

1702

    _cairo_recording_surface_get_extents,

1703

    NULL, /* get_font_options */

1704

1705

    NULL, /* flush */

1706

    NULL, /* mark_dirty_rectangle */

1707

1708

    /* Here are the 5 basic drawing operations, (which are in some

1709

     * sense the only things that cairo_recording_surface should need to

1710

     * implement).  However, we implement the more generic show_text_glyphs

1711

     * instead of show_glyphs.  One or the other is eough. */

1712

1713

    _cairo_recording_surface_paint,

1714

    _cairo_recording_surface_mask,

1715

    _cairo_recording_surface_stroke,

1716

    _cairo_recording_surface_fill,

1717

    NULL, /* fill-stroke */

1718

    NULL,

1719

    _cairo_recording_surface_has_show_text_glyphs,

1720

    _cairo_recording_surface_show_text_glyphs,

1721

    NULL, /* get_supported_mime_types */

1722

    _cairo_recording_surface_tag,

1723

    _cairo_recording_surface_supports_color_glyph,

1724

    NULL, /* analyze_recording_surface */

1725

    NULL, /* command_id */

1726

};

1727

1728

static unsigned int

1729

42

_cairo_recording_surface_regions_allocate_unique_id (void)

1730

1731

    static cairo_atomic_int_t unique_id;

1732

1733

#if CAIRO_NO_MUTEX

1734

    if (++unique_id == 0)

1735

	unique_id = 1;

1736

    return unique_id;

1737

#else

1738

    int old, id;

1739

1740

    do {

1741

42

	old = _cairo_atomic_uint_get (&unique_id);

1742

42

	id = old + 1;

1743

42

	if (id == 0)

1744

	    id = 1;

1745

42

    } while (! _cairo_atomic_uint_cmpxchg (&unique_id, old, id));

1746

1747

42

    return id;

1748

#endif

1749

1750

1751

static cairo_recording_regions_array_t *

1752

96

_cairo_recording_surface_region_array_find (cairo_recording_surface_t *surface,

1753

					    unsigned int               id)

1754

1755

    cairo_recording_regions_array_t *regions;

1756

1757

100

    cairo_list_foreach_entry (regions, cairo_recording_regions_array_t,

1758

			      &surface->region_array_list, link)

1759

1760

100

	if (regions->id == id)

1761

96

	    return regions;

1762

1763

1764

    return NULL;

1765

1766

1767

/* Create and initialize a new #cairo_recording_regions_array_t. Attach

1768

 * it to the recording surface and return its id

1769

*/

1770

cairo_status_t

1771

42

_cairo_recording_surface_region_array_attach (cairo_surface_t *abstract_surface,

1772

                                              unsigned int    *id)

1773

1774

    cairo_recording_regions_array_t *region_array;

1775

42

    cairo_recording_surface_t *surface = (cairo_recording_surface_t *) abstract_surface;

1776

1777

42

    assert (_cairo_surface_is_recording (abstract_surface));

1778

1779

42

    region_array = _cairo_calloc (sizeof (cairo_recording_regions_array_t));

1780

42

    if (region_array == NULL) {

1781

	*id = 0;

1782

        return _cairo_error (CAIRO_STATUS_NO_MEMORY);

1783

1784

1785

42

    region_array->id = _cairo_recording_surface_regions_allocate_unique_id ();

1786

1787

42

    CAIRO_REFERENCE_COUNT_INIT (&region_array->ref_count, 1);

1788

1789

42

    _cairo_array_init (&region_array->regions, sizeof (cairo_recording_region_element_t));

1790

1791

42

    CAIRO_MUTEX_LOCK (surface->mutex);

1792

42

    cairo_list_add (&region_array->link, &surface->region_array_list);

1793

42

    CAIRO_MUTEX_UNLOCK (surface->mutex);

1794

1795

42

    *id = region_array->id;

1796

1797

42

    return CAIRO_STATUS_SUCCESS;

1798

1799

1800

void

1801

24

_cairo_recording_surface_region_array_remove (cairo_surface_t *abstract_surface,

1802

                                              unsigned int     id)

1803

1804

    cairo_recording_regions_array_t *region_array;

1805

24

    cairo_recording_surface_t *surface = (cairo_recording_surface_t *) abstract_surface;

1806

1807

24

    if (id == 0)

1808

	return;

1809

1810

24

    assert (_cairo_surface_is_recording (abstract_surface));

1811

1812

24

    CAIRO_MUTEX_LOCK (surface->mutex);

1813

24

    region_array = _cairo_recording_surface_region_array_find (surface, id);

1814

24

    if (region_array) {

1815

24

	if (_cairo_reference_count_dec_and_test (&region_array->ref_count))

1816

24

	    cairo_list_del (&region_array->link);

1817

	else

1818

	    region_array = NULL;

1819

1820

1821

24

    CAIRO_MUTEX_UNLOCK (surface->mutex);

1822

1823

24

    if (region_array)

1824

24

	_cairo_recording_surface_region_array_destroy (surface, region_array);

1825

1826

1827

void

1828

_cairo_recording_surface_region_array_reference (cairo_surface_t *abstract_surface,

1829

						 unsigned int     id)

1830

1831

    cairo_recording_regions_array_t *region_array;

1832

    cairo_recording_surface_t *surface = (cairo_recording_surface_t *) abstract_surface;

1833

1834

    assert (_cairo_surface_is_recording (abstract_surface));

1835

1836

    CAIRO_MUTEX_LOCK (surface->mutex);

1837

    region_array = _cairo_recording_surface_region_array_find (surface, id);

1838

    if (region_array) {

1839

	_cairo_reference_count_inc (&region_array->ref_count);

1840

1841

1842

    CAIRO_MUTEX_UNLOCK (surface->mutex);

1843

1844

1845

cairo_int_status_t

1846

327

_cairo_recording_surface_get_path (cairo_surface_t    *abstract_surface,

1847

				   cairo_path_fixed_t *path)

1848

1849

    cairo_recording_surface_t *surface;

1850

    cairo_command_t **elements;

1851

    int i, num_elements;

1852

    cairo_int_status_t status;

1853

1854

327

    if (unlikely (abstract_surface->status))

1855

	return abstract_surface->status;

1856

1857

327

    surface = (cairo_recording_surface_t *) abstract_surface;

1858

327

    status = CAIRO_STATUS_SUCCESS;

1859

1860

327

    num_elements = surface->commands.num_elements;

1861

327

    elements = _cairo_array_index (&surface->commands, 0);

1862

615

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

1863

324

	cairo_command_t *command = elements[i];

1864

1865

324

	switch (command->header.type) {

1866

36

	case CAIRO_COMMAND_PAINT:

1867

	case CAIRO_COMMAND_MASK:

1868

36

	    status = CAIRO_INT_STATUS_UNSUPPORTED;

1869

36

	    break;

1870

1871

213

	case CAIRO_COMMAND_STROKE:

1872

1873

	    cairo_traps_t traps;

1874

1875

213

	    _cairo_traps_init (&traps);

1876

1877

	    /* XXX call cairo_stroke_to_path() when that is implemented */

1878

213

	    status = _cairo_path_fixed_stroke_polygon_to_traps (&command->stroke.path,

1879

213

								&command->stroke.style,

1880

213

								&command->stroke.ctm,

1881

213

								&command->stroke.ctm_inverse,

1882

								command->stroke.tolerance,

1883

								&traps);

1884

1885

213

	    if (status == CAIRO_INT_STATUS_SUCCESS)

1886

213

		status = _cairo_traps_path (&traps, path);

1887

1888

213

	    _cairo_traps_fini (&traps);

1889

213

	    break;

1890

1891

24

	case CAIRO_COMMAND_FILL:

1892

1893

24

	    status = _cairo_path_fixed_append (path,

1894

24

					       &command->fill.path,

1895

					       0, 0);

1896

24

	    break;

1897

1898

51

	case CAIRO_COMMAND_SHOW_TEXT_GLYPHS:

1899

1900

51

	    status = _cairo_scaled_font_glyph_path (command->show_text_glyphs.scaled_font,

1901

51

						    command->show_text_glyphs.glyphs,

1902

51

						    command->show_text_glyphs.num_glyphs,

1903

						    path);

1904

51

	    break;

1905

1906

1907

	case CAIRO_COMMAND_TAG:

1908

	    break;

1909

1910

	default:

1911

	    ASSERT_NOT_REACHED;

1912

1913

1914

324

	if (unlikely (status))

1915

36

	    break;

1916

1917

1918

327

    return status;

1919

1920

1921

static int

1922

224596

_cairo_recording_surface_get_visible_commands (cairo_recording_surface_t *surface,

1923

					       const cairo_rectangle_int_t *extents)

1924

1925

    unsigned int num_visible, *indices;

1926

    cairo_box_t box;

1927

1928

224596

    if (surface->commands.num_elements == 0)

1929

	return 0;

1930

1931

224596

    _cairo_box_from_rectangle (&box, extents);

1932

1933

224596

    if (surface->bbtree.chain == INVALID_CHAIN)

1934

1318

	_cairo_recording_surface_create_bbtree (surface);

1935

1936

224596

    indices = surface->indices;

1937

224596

    bbtree_foreach_mark_visible (&surface->bbtree, &box, &indices);

1938

224596

    num_visible = indices - surface->indices;

1939

224596

    if (num_visible > 1)

1940

146688

	sort_indices (surface->indices, num_visible);

1941

1942

224596

    return num_visible;

1943

1944

1945

static void

1946

135

_cairo_recording_surface_merge_source_attributes (cairo_recording_surface_t  *surface,

1947

						  cairo_operator_t            op,

1948

						  const cairo_pattern_t      *source)

1949

1950

135

    if (op != CAIRO_OPERATOR_OVER)

1951

84

	surface->has_only_op_over = FALSE;

1952

1953

135

    if (source->type == CAIRO_PATTERN_TYPE_SURFACE) {

1954

27

	cairo_surface_pattern_t *surf_pat = (cairo_surface_pattern_t *) source;

1955

27

	cairo_surface_t *surf = surf_pat->surface;

1956

27

	cairo_surface_t *free_me = NULL;

1957

1958

27

	if (_cairo_surface_is_snapshot (surf))

1959

27

	    free_me = surf = _cairo_surface_snapshot_get_target (surf);

1960

1961

27

	if (unlikely (surf->status))

1962

	    // There was some kind of error and the surface could be a nil error

1963

	    // surface with various "problems" (e.g. ->backend == NULL).

1964

	    return;

1965

1966

27

	if (surf->type == CAIRO_SURFACE_TYPE_RECORDING) {

1967

27

	    cairo_recording_surface_t *rec_surf = (cairo_recording_surface_t *) surf;

1968

1969

27

	    if (! _cairo_recording_surface_has_only_bilevel_alpha (rec_surf))

1970

		surface->has_bilevel_alpha = FALSE;

1971

1972

27

	    if (! _cairo_recording_surface_has_only_op_over (rec_surf))

1973

12

		surface->has_only_op_over = FALSE;

1974

1975

	} else if (surf->type == CAIRO_SURFACE_TYPE_IMAGE) {

1976

	    cairo_image_surface_t *img_surf = (cairo_image_surface_t *) surf;

1977

1978

	    if (_cairo_image_analyze_transparency (img_surf) == CAIRO_IMAGE_HAS_ALPHA)

1979

		surface->has_bilevel_alpha = FALSE;

1980

1981

	} else {

1982

	    if (!_cairo_pattern_is_clear (source) && !_cairo_pattern_is_opaque (source, NULL))

1983

		surface->has_bilevel_alpha = FALSE;

1984

1985

1986

27

	cairo_surface_destroy (free_me);

1987

27

	return;

1988

1989

108

    } else if (source->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE) {

1990

	cairo_surface_t *image;

1991

	cairo_surface_t *raster;

1992

1993

	image = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 1, 1);

1994

	raster = _cairo_raster_source_pattern_acquire (source, image, NULL);

1995

	cairo_surface_destroy (image);

1996

	if (raster) {

1997

	    if (raster->type == CAIRO_SURFACE_TYPE_IMAGE) {

1998

		if (_cairo_image_analyze_transparency ((cairo_image_surface_t *)raster) == CAIRO_IMAGE_HAS_ALPHA)

1999

		    surface->has_bilevel_alpha = FALSE;

2000

2001

2002

	    _cairo_raster_source_pattern_release (source, raster);

2003

	    if (raster->type == CAIRO_SURFACE_TYPE_IMAGE)

2004

		return;

2005

2006

2007

2008

108

    if (!_cairo_pattern_is_clear (source) && !_cairo_pattern_is_opaque (source, NULL))

2009

36

	surface->has_bilevel_alpha = FALSE;

2010

2011

2012

static cairo_status_t

2013

237038

_cairo_recording_surface_replay_internal (cairo_recording_surface_t	*surface,

2014

					  cairo_recording_surface_replay_params_t *params)

2015

2016

    cairo_surface_wrapper_t wrapper;

2017

    cairo_command_t **elements;

2018

237038

    cairo_recording_regions_array_t *regions_array = NULL;

2019

237038

    cairo_recording_region_element_t *region_elements = NULL;

2020

237038

    cairo_int_status_t status = CAIRO_STATUS_SUCCESS;

2021

    cairo_rectangle_int_t extents;

2022

237038

    cairo_bool_t use_indices = FALSE;

2023

    const cairo_rectangle_int_t *r;

2024

    unsigned int i, num_elements;

2025

2026

237038

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

2027

	return surface->base.status;

2028

2029

237038

    if (unlikely (params->target->status))

2030

	return params->target->status;

2031

2032

237038

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

2033

	return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);

2034

2035

237038

    if (surface->base.is_clear)

2036

123

	return CAIRO_STATUS_SUCCESS;

2037

2038

236915

    assert (_cairo_surface_is_recording (&surface->base));

2039

2040

236915

    if (params->regions_id != 0) {

2041

72

	regions_array = _cairo_recording_surface_region_array_find (surface, params->regions_id);

2042

72

	assert (regions_array != NULL);

2043

2044

2045

236915

    _cairo_surface_wrapper_init (&wrapper, params->target);

2046

236915

    if (params->surface_extents)

2047

	_cairo_surface_wrapper_intersect_extents (&wrapper, params->surface_extents);

2048

236915

    r = &_cairo_unbounded_rectangle;

2049

236915

    if (! surface->unbounded && !params->surface_is_unbounded) {

2050

11163

	_cairo_surface_wrapper_intersect_extents (&wrapper, &surface->extents);

2051

11163

	r = &surface->extents;

2052

2053

236915

    _cairo_surface_wrapper_set_inverse_transform (&wrapper, params->surface_transform);

2054

236915

    _cairo_surface_wrapper_set_clip (&wrapper, params->target_clip);

2055

2056

236915

    if (params->foreground_color) {

2057

327

	params->target->foreground_source = _cairo_pattern_create_solid (params->foreground_color);

2058

327

	params->target->foreground_used = FALSE;

2059

2060

2061

    /* Compute the extents of the target clip in recorded device space */

2062

236915

    if (! _cairo_surface_wrapper_get_target_extents (&wrapper, params->surface_is_unbounded, &extents))

2063

8

	goto done;

2064

2065

236907

    surface->has_bilevel_alpha = TRUE;

2066

236907

    surface->has_only_op_over = TRUE;

2067

2068

236907

    num_elements = surface->commands.num_elements;

2069

236907

    if (regions_array) {

2070

72

	if (params->type == CAIRO_RECORDING_CREATE_REGIONS) {

2071

	    /* Re-running create regions with the same region id is not supported. */

2072

39

	    assert (_cairo_array_num_elements (&regions_array->regions) == 0);

2073

	    void *array_elems;

2074

39

	    status = _cairo_array_allocate (&regions_array->regions, num_elements, &array_elems);

2075

39

	    if (unlikely (status))

2076

		return status;

2077

2078

	    /* Set regions to CAIRO_RECORDING_REGION_ALL and ids to 0 */

2079

39

	    memset (array_elems, 0, num_elements * sizeof (cairo_recording_region_element_t));

2080

	} else {

2081

33

	    assert (_cairo_array_num_elements (&regions_array->regions) == num_elements);

2082

2083

2084

2085

236907

    elements = _cairo_array_index (&surface->commands, 0);

2086

236907

    if (regions_array)

2087

72

	region_elements = _cairo_array_index (&regions_array->regions, 0);

2088

2089

236907

    if (!params->replay_all && (extents.width < r->width || extents.height < r->height)) {

2090

224596

	num_elements =

2091

224596

	    _cairo_recording_surface_get_visible_commands (surface, &extents);

2092

224596

	use_indices = num_elements != surface->commands.num_elements;

2093

2094

2095

236907

    cairo_bool_t target_is_analysis = _cairo_surface_is_analysis (params->target);

2096

2097

654857

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

2098

417950

	cairo_command_t *command = elements[use_indices ? surface->indices[i] : i];

2099

417950

	cairo_recording_region_element_t *region_element = NULL;

2100

417950

	unsigned int source_region_id = 0;

2101

417950

	unsigned int mask_region_id = 0;

2102

2103

417950

	if (region_elements)

2104

260

	    region_element = &region_elements[use_indices ? surface->indices[i] : i];

2105

2106

417950

	if (region_element && params->type == CAIRO_RECORDING_REPLAY_REGION &&

2107

125

            region_element->region != params->region)

2108

2109

20

	    continue;

2110

2111

2112

417930

	if (! _cairo_rectangle_intersects (&extents, &command->header.extents)) {

2113

6

	    if (command->header.type != CAIRO_COMMAND_TAG)

2114

		continue;

2115

2116

2117

2118

417930

	if (params->target->backend->command_id) {

2119

1626

	    status = params->target->backend->command_id (params->target, params->regions_id, i);

2120

1626

	    if (unlikely (status))

2121

		return status;

2122

2123

2124

417930

	switch (command->header.type) {

2125

266412

	case CAIRO_COMMAND_PAINT:

2126

266412

	    if (region_element)

2127

46

		source_region_id = region_element->source_id;

2128

2129

266412

	    status = _cairo_surface_wrapper_paint (&wrapper,

2130

						   command->header.op,

2131

266412

						   &command->paint.source.base,

2132

						   source_region_id,

2133

266412

						   command->header.clip);

2134

266412

	    if (params->type == CAIRO_RECORDING_CREATE_REGIONS) {

2135

27

		_cairo_recording_surface_merge_source_attributes (surface,

2136

								  command->header.op,

2137

27

								  &command->paint.source.base);

2138

27

		if (region_element && target_is_analysis)

2139

27

		    region_element->source_id = _cairo_analysis_surface_get_source_region_id (params->target);

2140

2141

266412

	    break;

2142

2143

2976

	case CAIRO_COMMAND_MASK:

2144

2976

	    if (region_element) {

2145

		source_region_id = region_element->source_id;

2146

		mask_region_id = region_element->mask_id;

2147

2148

2149

2976

	    status = _cairo_surface_wrapper_mask (&wrapper,

2150

						  command->header.op,

2151

2976

						  &command->mask.source.base,

2152

						  source_region_id,

2153

2976

						  &command->mask.mask.base,

2154

						  mask_region_id,

2155

2976

						  command->header.clip);

2156

2976

	    if (params->type == CAIRO_RECORDING_CREATE_REGIONS) {

2157

		_cairo_recording_surface_merge_source_attributes (surface,

2158

								  command->header.op,

2159

								  &command->mask.source.base);

2160

		_cairo_recording_surface_merge_source_attributes (surface,

2161

								  command->header.op,

2162

								  &command->mask.mask.base);

2163

		if (region_element && target_is_analysis) {

2164

		    region_element->source_id = _cairo_analysis_surface_get_source_region_id (params->target);

2165

		    region_element->mask_id = _cairo_analysis_surface_get_mask_region_id (params->target);

2166

2167

2168

2976

	    break;

2169

2170

1771

	case CAIRO_COMMAND_STROKE:

2171

1771

	    if (region_element)

2172

		source_region_id = region_element->source_id;

2173

2174

1771

	    status = _cairo_surface_wrapper_stroke (&wrapper,

2175

						    command->header.op,

2176

1771

						    &command->stroke.source.base,

2177

						    source_region_id,

2178

1771

						    &command->stroke.path,

2179

1771

						    &command->stroke.style,

2180

1771

						    &command->stroke.ctm,

2181

1771

						    &command->stroke.ctm_inverse,

2182

						    command->stroke.tolerance,

2183

						    command->stroke.antialias,

2184

1771

						    command->header.clip);

2185

1771

	    if (params->type == CAIRO_RECORDING_CREATE_REGIONS) {

2186

		_cairo_recording_surface_merge_source_attributes (surface,

2187

								  command->header.op,

2188

								  &command->stroke.source.base);

2189

		if (region_element && target_is_analysis)

2190

		    region_element->source_id = _cairo_analysis_surface_get_source_region_id (params->target);

2191

2192

1771

	    break;

2193

2194

111101

	case CAIRO_COMMAND_FILL:

2195

111101

	    status = CAIRO_INT_STATUS_UNSUPPORTED;

2196

111101

	    if (region_element)

2197

194

		source_region_id = region_element->source_id;

2198

2199

111101

	    if (_cairo_surface_wrapper_has_fill_stroke (&wrapper)) {

2200

50

		cairo_command_t *stroke_command = NULL;

2201

50

		cairo_recording_region_element_t *stroke_region_element = NULL;

2202

50

		unsigned stroke_region_id = 0;

2203

2204

		/* The analysis surface does not implement

2205

		 * fill_stroke.  When creating regions the fill and

2206

		 * stroke commands are tested separately.

2207

*/

2208

50

		if (params->type != CAIRO_RECORDING_CREATE_REGIONS && i < num_elements - 1) {

2209

41

		    stroke_command = elements[i + 1];

2210

41

		    if (region_elements)

2211

41

			stroke_region_element = &region_elements[i + 1];

2212

2213

2214

50

		if (stroke_region_element)

2215

41

		    stroke_region_id = stroke_region_element->source_id;

2216

2217

50

		if (stroke_command && stroke_region_element &&

2218

41

		    params->type == CAIRO_RECORDING_REPLAY_REGION &&

2219

41

		    params->region != CAIRO_RECORDING_REGION_ALL)

2220

2221

41

		    if (stroke_region_element->region != params->region)

2222

5

			stroke_command = NULL;

2223

2224

2225

50

		if (stroke_command != NULL &&

2226

36

		    stroke_command->header.type == CAIRO_COMMAND_STROKE &&

2227

		    _cairo_path_fixed_equal (&command->fill.path,

2228

					     &stroke_command->stroke.path) &&

2229

		    _cairo_clip_equal (command->header.clip,

2230

				       stroke_command->header.clip))

2231

2232

		    status = _cairo_surface_wrapper_fill_stroke (&wrapper,

2233

								 command->header.op,

2234

								 &command->fill.source.base,

2235

								 source_region_id,

2236

								 command->fill.fill_rule,

2237

								 command->fill.tolerance,

2238

								 command->fill.antialias,

2239

								 &command->fill.path,

2240

								 stroke_command->header.op,

2241

								 &stroke_command->stroke.source.base,

2242

								 stroke_region_id,

2243

								 &stroke_command->stroke.style,

2244

								 &stroke_command->stroke.ctm,

2245

								 &stroke_command->stroke.ctm_inverse,

2246

								 stroke_command->stroke.tolerance,

2247

								 stroke_command->stroke.antialias,

2248

								 command->header.clip);

2249

		    if (params->type == CAIRO_RECORDING_CREATE_REGIONS) {

2250

			_cairo_recording_surface_merge_source_attributes (surface,

2251

									  command->header.op,

2252

									  &command->fill.source.base);

2253

			_cairo_recording_surface_merge_source_attributes (surface,

2254

									  command->header.op,

2255

									  &command->stroke.source.base);

2256

2257

		    i++;

2258

2259

2260

111101

	    if (status == CAIRO_INT_STATUS_UNSUPPORTED) {

2261

111101

		status = _cairo_surface_wrapper_fill (&wrapper,

2262

						      command->header.op,

2263

111101

						      &command->fill.source.base,

2264

						      source_region_id,

2265

111101

						      &command->fill.path,

2266

						      command->fill.fill_rule,

2267

						      command->fill.tolerance,

2268

						      command->fill.antialias,

2269

111101

						      command->header.clip);

2270

111101

		if (params->type == CAIRO_RECORDING_CREATE_REGIONS) {

2271

108

		    _cairo_recording_surface_merge_source_attributes (surface,

2272

								      command->header.op,

2273

108

								      &command->fill.source.base);

2274

108

		if (region_element && target_is_analysis)

2275

108

		    region_element->source_id = _cairo_analysis_surface_get_source_region_id (params->target);

2276

2277

2278

111101

	    break;

2279

2280

35664

	case CAIRO_COMMAND_SHOW_TEXT_GLYPHS:

2281

35664

	    if (region_element)

2282

		source_region_id = region_element->source_id;

2283

2284

35664

	    status = _cairo_surface_wrapper_show_text_glyphs (&wrapper,

2285

							      command->header.op,

2286

35664

							      &command->show_text_glyphs.source.base,

2287

							      source_region_id,

2288

35664

							      command->show_text_glyphs.utf8, command->show_text_glyphs.utf8_len,

2289

35664

							      command->show_text_glyphs.glyphs, command->show_text_glyphs.num_glyphs,

2290

35664

							      command->show_text_glyphs.clusters, command->show_text_glyphs.num_clusters,

2291

							      command->show_text_glyphs.cluster_flags,

2292

							      command->show_text_glyphs.scaled_font,

2293

35664

							      command->header.clip);

2294

35664

	    if (params->type == CAIRO_RECORDING_CREATE_REGIONS) {

2295

		_cairo_recording_surface_merge_source_attributes (surface,

2296

								  command->header.op,

2297

								  &command->show_text_glyphs.source.base);

2298

		if (region_element && target_is_analysis)

2299

		    region_element->source_id = _cairo_analysis_surface_get_source_region_id (params->target);

2300

2301

2302

35664

	    break;

2303

2304

6

	case CAIRO_COMMAND_TAG:

2305

6

	    status = _cairo_surface_wrapper_tag (&wrapper,

2306

						 command->tag.begin,

2307

6

						 command->tag.tag_name,

2308

6

						 command->tag.attributes);

2309

6

	    break;

2310

2311

	default:

2312

	    ASSERT_NOT_REACHED;

2313

2314

2315

	/* It's possible that a degenerate clip caused the command to end up doing nothing when replayed. */

2316

417930

	if (unlikely (status == CAIRO_INT_STATUS_NOTHING_TO_DO))

2317

210

	    status = CAIRO_INT_STATUS_SUCCESS;

2318

2319

417930

	if (params->type == CAIRO_RECORDING_CREATE_REGIONS && region_element) {

2320

135

	    if (status == CAIRO_INT_STATUS_SUCCESS) {

2321

106

		region_element->region = CAIRO_RECORDING_REGION_NATIVE;

2322

29

	    } else if (status == CAIRO_INT_STATUS_IMAGE_FALLBACK) {

2323

29

		region_element->region = CAIRO_RECORDING_REGION_IMAGE_FALLBACK;

2324

29

		status = CAIRO_INT_STATUS_SUCCESS;

2325

	    } else {

2326

		assert (_cairo_int_status_is_error (status));

2327

2328

2329

2330

417930

	if (unlikely (status))

2331

	    break;

2332

2333

2334

236907

done:

2335

236915

    if (params->foreground_color) {

2336

327

	cairo_pattern_destroy (params->target->foreground_source);

2337

327

	params->target->foreground_source = NULL;

2338

327

	params->foreground_used = params->target->foreground_used;

2339

2340

2341

236915

    _cairo_surface_wrapper_fini (&wrapper);

2342

236915

    return _cairo_surface_set_error (&surface->base, status);

2343

2344

2345

cairo_status_t

2346

_cairo_recording_surface_replay_one (cairo_recording_surface_t	*surface,

2347

				     long unsigned index,

2348

				     cairo_surface_t	     *target)

2349

2350

    cairo_surface_wrapper_t wrapper;

2351

    cairo_command_t **elements, *command;

2352

    cairo_int_status_t status = CAIRO_INT_STATUS_SUCCESS;

2353

2354

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

2355

	return surface->base.status;

2356

2357

    if (unlikely (target->status))

2358

	return target->status;

2359

2360

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

2361

	return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);

2362

2363

    assert (_cairo_surface_is_recording (&surface->base));

2364

2365

    /* XXX

2366

     * Use a surface wrapper because we may want to do transformed

2367

     * replay in the future.

2368

*/

2369

    _cairo_surface_wrapper_init (&wrapper, target);

2370

2371

    if (index > surface->commands.num_elements)

2372

	return _cairo_error (CAIRO_STATUS_READ_ERROR);

2373

2374

    elements = _cairo_array_index (&surface->commands, 0);

2375

    command = elements[index];

2376

    switch (command->header.type) {

2377

    case CAIRO_COMMAND_PAINT:

2378

	status = _cairo_surface_wrapper_paint (&wrapper,

2379

					       command->header.op,

2380

					       &command->paint.source.base,

2381

0,

2382

					       command->header.clip);

2383

	break;

2384

2385

    case CAIRO_COMMAND_MASK:

2386

	status = _cairo_surface_wrapper_mask (&wrapper,

2387

					      command->header.op,

2388

					      &command->mask.source.base,

2389

0,

2390

					      &command->mask.mask.base,

2391

0,

2392

					      command->header.clip);

2393

	break;

2394

2395

    case CAIRO_COMMAND_STROKE:

2396

	status = _cairo_surface_wrapper_stroke (&wrapper,

2397

						command->header.op,

2398

						&command->stroke.source.base,

2399

0,

2400

						&command->stroke.path,

2401

						&command->stroke.style,

2402

						&command->stroke.ctm,

2403

						&command->stroke.ctm_inverse,

2404

						command->stroke.tolerance,

2405

						command->stroke.antialias,

2406

						command->header.clip);

2407

	break;

2408

2409

    case CAIRO_COMMAND_FILL:

2410

	status = _cairo_surface_wrapper_fill (&wrapper,

2411

					      command->header.op,

2412

					      &command->fill.source.base,

2413

0,

2414

					      &command->fill.path,

2415

					      command->fill.fill_rule,

2416

					      command->fill.tolerance,

2417

					      command->fill.antialias,

2418

					      command->header.clip);

2419

	break;

2420

2421

    case CAIRO_COMMAND_SHOW_TEXT_GLYPHS:

2422

	status = _cairo_surface_wrapper_show_text_glyphs (&wrapper,

2423

							  command->header.op,

2424

							  &command->show_text_glyphs.source.base,

2425

0,

2426

							  command->show_text_glyphs.utf8, command->show_text_glyphs.utf8_len,

2427

							  command->show_text_glyphs.glyphs, command->show_text_glyphs.num_glyphs,

2428

							  command->show_text_glyphs.clusters, command->show_text_glyphs.num_clusters,

2429

							  command->show_text_glyphs.cluster_flags,

2430

							  command->show_text_glyphs.scaled_font,

2431

							  command->header.clip);

2432

	break;

2433

2434

    case CAIRO_COMMAND_TAG:

2435

	status = _cairo_surface_wrapper_tag (&wrapper,

2436

					     command->tag.begin,

2437

					     command->tag.tag_name,

2438

					     command->tag.attributes);

2439

	break;

2440

2441

    default:

2442

	ASSERT_NOT_REACHED;

2443

2444

2445

    _cairo_surface_wrapper_fini (&wrapper);

2446

    return _cairo_surface_set_error (&surface->base, status);

2447

2448

/**

2449

 * _cairo_recording_surface_replay:

2450

 * @surface: the #cairo_recording_surface_t

2451

 * @target: a target #cairo_surface_t onto which to replay the operations

2452

 * @width_pixels: width of the surface, in pixels

2453

 * @height_pixels: height of the surface, in pixels

2454

2455

 * A recording surface can be "replayed" against any target surface,

2456

 * after which the results in target will be identical to the results

2457

 * that would have been obtained if the original operations applied to

2458

 * the recording surface had instead been applied to the target surface.

2459

**/

2460

cairo_status_t

2461

1827

_cairo_recording_surface_replay (cairo_surface_t *surface,

2462

				 cairo_surface_t *target)

2463

2464

    cairo_recording_surface_replay_params_t params;

2465

2466

1827

    params.surface_extents = NULL;

2467

1827

    params.surface_transform = NULL;

2468

1827

    params.target = target;

2469

1827

    params.target_clip = NULL;

2470

1827

    params.surface_is_unbounded = FALSE;

2471

1827

    params.type = CAIRO_RECORDING_REPLAY;

2472

1827

    params.region = CAIRO_RECORDING_REGION_ALL;

2473

1827

    params.regions_id = 0;

2474

1827

    params.foreground_color = NULL;

2475

1827

    params.replay_all = FALSE;

2476

2477

1827

    return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, &params);

2478

2479

2480

cairo_status_t

2481

348

_cairo_recording_surface_replay_with_foreground_color (cairo_surface_t     *surface,

2482

                                                       cairo_surface_t     *target,

2483

						       const cairo_color_t *foreground_color,

2484

						       cairo_bool_t        *foreground_used)

2485

2486

    cairo_recording_surface_replay_params_t params;

2487

    cairo_status_t status;

2488

2489

348

    params.surface_extents = NULL;

2490

348

    params.surface_transform = NULL;

2491

348

    params.target = target;

2492

348

    params.target_clip = NULL;

2493

348

    params.surface_is_unbounded = FALSE;

2494

348

    params.type = CAIRO_RECORDING_REPLAY;

2495

348

    params.region = CAIRO_RECORDING_REGION_ALL;

2496

348

    params.regions_id = 0;

2497

348

    params.foreground_color = foreground_color;

2498

348

    params.foreground_used = FALSE;

2499

348

    params.replay_all = FALSE;

2500

2501

348

    status = _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, &params);

2502

348

    *foreground_used = params.foreground_used;

2503

2504

348

    return status;

2505

2506

2507

cairo_status_t

2508

140

_cairo_recording_surface_replay_with_transform (cairo_surface_t *surface,

2509

						const cairo_matrix_t *surface_transform,

2510

						cairo_surface_t *target,

2511

						cairo_bool_t surface_is_unbounded,

2512

						cairo_bool_t replay_all)

2513

2514

    cairo_recording_surface_replay_params_t params;

2515

2516

140

    params.surface_extents = NULL;

2517

140

    params.surface_transform = surface_transform;

2518

140

    params.target = target;

2519

140

    params.target_clip = NULL;

2520

140

    params.surface_is_unbounded = surface_is_unbounded;

2521

140

    params.type = CAIRO_RECORDING_REPLAY;

2522

140

    params.region = CAIRO_RECORDING_REGION_ALL;

2523

140

    params.regions_id = 0;

2524

140

    params.foreground_color = NULL;

2525

140

    params.replay_all = replay_all;

2526

2527

140

    return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, &params);

2528

2529

2530

cairo_status_t

2531

234648

_cairo_recording_surface_replay_with_clip (cairo_surface_t *surface,

2532

					   const cairo_matrix_t *surface_transform,

2533

					   cairo_surface_t *target,

2534

					   const cairo_clip_t *target_clip)

2535

2536

    cairo_recording_surface_replay_params_t params;

2537

2538

234648

    params.surface_extents = NULL;

2539

234648

    params.surface_transform = surface_transform;

2540

234648

    params.target = target;

2541

234648

    params.target_clip = target_clip;

2542

234648

    params.surface_is_unbounded = FALSE;

2543

234648

    params.type = CAIRO_RECORDING_REPLAY;

2544

234648

    params.region = CAIRO_RECORDING_REGION_ALL;

2545

234648

    params.regions_id = 0;

2546

234648

    params.foreground_color = NULL;

2547

234648

    params.replay_all = FALSE;

2548

2549

234648

    return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, &params);

2550

2551

2552

/* Replay recording to surface. When the return status of each operation is

2553

 * one of %CAIRO_STATUS_SUCCESS, %CAIRO_INT_STATUS_UNSUPPORTED, or

2554

 * %CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY the status of each operation

2555

 * will be stored in the recording surface. Any other status will abort the

2556

 * replay and return the status.

2557

*/

2558

cairo_status_t

2559

42

_cairo_recording_surface_replay_and_create_regions (cairo_surface_t *surface,

2560

						    unsigned int regions_id,

2561

						    const cairo_matrix_t *surface_transform,

2562

						    cairo_surface_t *target,

2563

						    cairo_bool_t surface_is_unbounded,

2564

						    cairo_bool_t replay_all)

2565

2566

    cairo_recording_surface_replay_params_t params;

2567

2568

42

    params.surface_extents = NULL;

2569

42

    params.surface_transform = surface_transform;

2570

42

    params.target = target;

2571

42

    params.target_clip = NULL;

2572

42

    params.surface_is_unbounded = surface_is_unbounded;

2573

42

    params.type = CAIRO_RECORDING_CREATE_REGIONS;

2574

42

    params.region = CAIRO_RECORDING_REGION_ALL;

2575

42

    params.regions_id = regions_id;

2576

42

    params.foreground_color = NULL;

2577

42

    params.replay_all = replay_all;

2578

2579

42

    return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, &params);

2580

2581

2582

cairo_status_t

2583

33

_cairo_recording_surface_replay_region (cairo_surface_t          *surface,

2584

					unsigned int regions_id,

2585

					const cairo_rectangle_int_t *surface_extents,

2586

					cairo_surface_t          *target,

2587

					cairo_recording_region_type_t  region)

2588

2589

    cairo_recording_surface_replay_params_t params;

2590

2591

33

    params.surface_extents = surface_extents;

2592

33

    params.surface_transform = NULL;

2593

33

    params.target = target;

2594

33

    params.target_clip = NULL;

2595

33

    params.surface_is_unbounded = FALSE;

2596

33

    params.type = CAIRO_RECORDING_REPLAY_REGION;

2597

33

    params.region = region;

2598

33

    params.regions_id = regions_id;

2599

33

    params.foreground_color = NULL;

2600

33

    params.replay_all = FALSE;

2601

2602

33

    return _cairo_recording_surface_replay_internal ((cairo_recording_surface_t *) surface, &params);

2603

2604

2605

static cairo_status_t

2606

1076

_recording_surface_get_ink_bbox (cairo_recording_surface_t *surface,

2607

				 cairo_box_t *bbox,

2608

				 const cairo_matrix_t *transform)

2609

2610

    cairo_surface_t *null_surface;

2611

    cairo_surface_t *analysis_surface;

2612

    cairo_status_t status;

2613

2614

1076

    null_surface = _cairo_null_surface_create (surface->base.content);

2615

1076

    analysis_surface = _cairo_analysis_surface_create (null_surface, FALSE);

2616

1076

    cairo_surface_destroy (null_surface);

2617

2618

1076

    status = analysis_surface->status;

2619

1076

    if (unlikely (status))

2620

	return status;

2621

2622

1076

    if (transform != NULL)

2623

1008

	_cairo_analysis_surface_set_ctm (analysis_surface, transform);

2624

2625

1076

    status = _cairo_recording_surface_replay (&surface->base, analysis_surface);

2626

1076

    _cairo_analysis_surface_get_bounding_box (analysis_surface, bbox);

2627

1076

    cairo_surface_destroy (analysis_surface);

2628

2629

1076

    return status;

2630

2631

2632

/**

2633

 * cairo_recording_surface_ink_extents:

2634

 * @surface: a #cairo_recording_surface_t

2635

 * @x0: the x-coordinate of the top-left of the ink bounding box

2636

 * @y0: the y-coordinate of the top-left of the ink bounding box

2637

 * @width: the width of the ink bounding box

2638

 * @height: the height of the ink bounding box

2639

2640

 * Measures the extents of the operations stored within the recording-surface.

2641

 * This is useful to compute the required size of an image surface (or

2642

 * equivalent) into which to replay the full sequence of drawing operations.

2643

2644

 * Since: 1.10

2645

**/

2646

void

2647

71

cairo_recording_surface_ink_extents (cairo_surface_t *surface,

2648

				     double *x0,

2649

				     double *y0,

2650

				     double *width,

2651

				     double *height)

2652

2653

    cairo_status_t status;

2654

    cairo_box_t bbox;

2655

2656

71

    memset (&bbox, 0, sizeof (bbox));

2657

2658

71

    if (surface->status || ! _cairo_surface_is_recording (surface)) {

2659

7

	_cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);

2660

7

	goto DONE;

2661

2662

2663

64

    status = _recording_surface_get_ink_bbox ((cairo_recording_surface_t *) surface,

2664

					 &bbox,

2665

					 NULL);

2666

64

    if (unlikely (status))

2667

	status = _cairo_surface_set_error (surface, status);

2668

2669

64

DONE:

2670

71

    if (x0)

2671

71

	*x0 = _cairo_fixed_to_double (bbox.p1.x);

2672

71

    if (y0)

2673

71

	*y0 = _cairo_fixed_to_double (bbox.p1.y);

2674

71

    if (width)

2675

71

	*width = _cairo_fixed_to_double (bbox.p2.x - bbox.p1.x);

2676

71

    if (height)

2677

71

	*height = _cairo_fixed_to_double (bbox.p2.y - bbox.p1.y);

2678

71

2679

2680

cairo_status_t

2681

1008

_cairo_recording_surface_get_bbox (cairo_recording_surface_t *surface,

2682

				   cairo_box_t *bbox,

2683

				   const cairo_matrix_t *transform)

2684

2685

1008

    if (! surface->unbounded) {

2686

	_cairo_box_from_rectangle (bbox, &surface->extents);

2687

	if (transform != NULL)

2688

	    _cairo_matrix_transform_bounding_box_fixed (transform, bbox, NULL);

2689

2690

	return CAIRO_STATUS_SUCCESS;

2691

2692

2693

1008

    return _recording_surface_get_ink_bbox (surface, bbox, transform);

2694

2695

2696

cairo_status_t

2697

4

_cairo_recording_surface_get_ink_bbox (cairo_recording_surface_t *surface,

2698

				       cairo_box_t *bbox,

2699

				       const cairo_matrix_t *transform)

2700

2701

4

    return _recording_surface_get_ink_bbox (surface, bbox, transform);

2702

2703

2704

/**

2705

 * cairo_recording_surface_get_extents:

2706

 * @surface: a #cairo_recording_surface_t

2707

 * @extents: the #cairo_rectangle_t to be assigned the extents

2708

2709

 * Get the extents of the recording-surface.

2710

2711

 * Return value: %TRUE if the surface is bounded, of recording type, and

2712

 * not in an error state, otherwise %FALSE

2713

2714

 * Since: 1.12

2715

**/

2716

cairo_bool_t

2717

cairo_recording_surface_get_extents (cairo_surface_t *surface,

2718

				     cairo_rectangle_t *extents)

2719

2720

    cairo_recording_surface_t *record;

2721

2722

    if (surface->status || ! _cairo_surface_is_recording (surface)) {

2723

	_cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);

2724

	return FALSE;

2725

2726

2727

    record = (cairo_recording_surface_t *)surface;

2728

    if (record->unbounded)

2729

	return FALSE;

2730

2731

    *extents = record->extents_pixels;

2732

    return TRUE;

2733

2734

2735

cairo_bool_t

2736

31

_cairo_recording_surface_has_only_bilevel_alpha (cairo_recording_surface_t *surface)

2737

2738

31

    return surface->has_bilevel_alpha;

2739

2740

2741

cairo_bool_t

2742

31

_cairo_recording_surface_has_only_op_over (cairo_recording_surface_t *surface)

2743

2744

31

    return surface->has_only_op_over;

2745

2746

2747

cairo_bool_t

2748

20

_cairo_recording_surface_has_tags (cairo_surface_t *surface)

2749

2750

    cairo_recording_surface_t *record;

2751

2752

20

    if (surface->status || ! _cairo_surface_is_recording (surface)) {

2753

	_cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);

2754

	return FALSE;

2755

2756

2757

20

    record = (cairo_recording_surface_t *)surface;

2758

2759

20

    return record->has_tags;

2760

2761

2762

static void

2763

print_indent (FILE *file, int indent)

2764

2765

    fprintf (file, "%*s", indent * 2, "");

2766

2767

2768

static void

2769

print_pattern (FILE                  *file,

2770

	       const cairo_pattern_t *pattern,

2771

	       unsigned int           region_id,

2772

	       int                    indent,

2773

	       cairo_bool_t           recurse)

2774

2775

    switch (pattern->type) {

2776

	case CAIRO_PATTERN_TYPE_SOLID: {

2777

	    cairo_solid_pattern_t *p = (cairo_solid_pattern_t *) pattern;

2778

	    if (pattern->is_foreground_marker) {

2779

		fprintf (file, "solid foreground\n");

2780

	    } else {

2781

		fprintf (file, "solid rgba: %f %f %f %f\n",

2782

			 p->color.red,

2783

			 p->color.green,

2784

			 p->color.blue,

2785

			 p->color.alpha);

2786

2787

	} break;

2788

	case CAIRO_PATTERN_TYPE_SURFACE: {

2789

	    cairo_surface_pattern_t *p = (cairo_surface_pattern_t *) pattern;

2790

	    fprintf (file, "surface ");

2791

	    if (p->surface->type == CAIRO_SURFACE_TYPE_RECORDING) {

2792

		fprintf (file, "recording id: %d\n", p->surface->unique_id);

2793

		if (recurse) {

2794

		    _cairo_debug_print_recording_surface (file, p->surface,

2795

							  region_id,

2796

							  indent + 1, recurse);

2797

2798

	    } else if (p->surface->type == CAIRO_SURFACE_TYPE_IMAGE) {

2799

		cairo_image_surface_t *image = (cairo_image_surface_t *)p->surface;

2800

		fprintf (file, "image format: ");

2801

		switch (image->format) {

2802

		    case CAIRO_FORMAT_INVALID: fputs ("INVALID", file); break;

2803

		    case CAIRO_FORMAT_ARGB32: fputs ("ARGB32", file); break;

2804

		    case CAIRO_FORMAT_RGB24: fputs ("RGB24", file); break;

2805

		    case CAIRO_FORMAT_A8: fputs ("A8", file); break;

2806

		    case CAIRO_FORMAT_A1: fputs ("A1", file); break;

2807

		    case CAIRO_FORMAT_RGB16_565: fputs ("RGB16_565", file); break;

2808

		    case CAIRO_FORMAT_RGB30: fputs ("RGB30", file); break;

2809

		    case CAIRO_FORMAT_RGB96F: fputs ("RGB96F", file); break;

2810

		    case CAIRO_FORMAT_RGBA128F: fputs ("RGBA128F", file); break;

2811

2812

		fprintf (file, " width: %d height: %d\n", image->width, image->height);

2813

	    } else {

2814

		fprintf (file, "type %d\n", p->surface->type);

2815

2816

	} break;

2817

	case CAIRO_PATTERN_TYPE_LINEAR:

2818

	    fprintf (file, "linear\n");

2819

	    break;

2820

	case CAIRO_PATTERN_TYPE_RADIAL:

2821

	    fprintf (file, "radial\n");

2822

	    break;

2823

	case CAIRO_PATTERN_TYPE_MESH:

2824

	    fprintf (file, "mesh\n");

2825

	    break;

2826

	case CAIRO_PATTERN_TYPE_RASTER_SOURCE:

2827

	    fprintf (file, "raster\n");

2828

	    break;

2829

2830

2831

2832

void

2833

_cairo_debug_print_recording_surface (FILE            *file,

2834

				      cairo_surface_t *surface,

2835

                                      unsigned int     regions_id,

2836

				      int              indent,

2837

				      cairo_bool_t     recurse)

2838

2839

    cairo_command_t **elements;

2840

    cairo_recording_region_element_t *region_elements = NULL;

2841

    unsigned int i, num_elements;

2842

    cairo_recording_surface_t *recording_surface;

2843

    cairo_surface_t *free_me = NULL;

2844

    char common[100];

2845

2846

    if (_cairo_surface_is_snapshot (surface))

2847

	free_me = surface = _cairo_surface_snapshot_get_target (surface);

2848

2849

    assert (_cairo_surface_is_recording (surface));

2850

    recording_surface = (cairo_recording_surface_t *)surface;

2851

2852

    print_indent (file, indent);

2853

    indent++;

2854

    fprintf(file, "recording surface id: %d   regions id: %d\n", recording_surface->base.unique_id, regions_id);

2855

    num_elements = recording_surface->commands.num_elements;

2856

    elements = _cairo_array_index (&recording_surface->commands, 0);

2857

2858

    if (regions_id != 0) {

2859

	cairo_recording_regions_array_t *regions_array;

2860

	regions_array = _cairo_recording_surface_region_array_find (recording_surface, regions_id);

2861

	assert (regions_array != NULL);

2862

	assert (_cairo_array_num_elements (&regions_array->regions) == num_elements);

2863

	region_elements = _cairo_array_index (&regions_array->regions, 0);

2864

2865

2866

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

2867

	cairo_command_t *command = elements[i];

2868

	unsigned int source_region_id = 0;

2869

	unsigned int mask_region_id = 0;

2870

2871

	common[0] = 0;

2872

	if (region_elements) {

2873

	    cairo_recording_region_element_t *region_element = &region_elements[i];

2874

	    strcpy (common, "region: ");

2875

	    switch (region_element->region) {

2876

		case CAIRO_RECORDING_REGION_ALL: strcat (common, "all"); break;

2877

		case CAIRO_RECORDING_REGION_NATIVE: strcat (common, "native"); break;

2878

		case CAIRO_RECORDING_REGION_IMAGE_FALLBACK: strcat (common, "fallback"); break;

2879

2880

	    source_region_id  = region_element->source_id;

2881

	    mask_region_id = region_element->mask_id;

2882

2883

	sprintf (common + strlen(common), " op: %s", _cairo_debug_operator_to_string (command->header.op));

2884

2885

	switch (command->header.type) {

2886

	    case CAIRO_COMMAND_PAINT:

2887

		print_indent (file, indent);

2888

		fprintf(file, "%d PAINT %s source: ", i, common);

2889

		print_pattern (file, &command->paint.source.base, source_region_id, indent + 1, recurse);

2890

		break;

2891

2892

	    case CAIRO_COMMAND_MASK:

2893

		print_indent (file, indent);

2894

		fprintf(file, "%d MASK %s\n", i, common);

2895

		print_indent (file, indent + 1);

2896

		fprintf(file, "source: ");

2897

		print_pattern (file, &command->mask.source.base, source_region_id, indent + 1, recurse);

2898

		print_indent (file, indent + 1);

2899

		fprintf(file, "mask: ");

2900

		print_pattern (file, &command->mask.mask.base, mask_region_id, indent + 1, recurse);

2901

		break;

2902

2903

	    case CAIRO_COMMAND_STROKE:

2904

		print_indent (file, indent);

2905

		fprintf(file, "%d STROKE %s source:", i, common);

2906

		print_pattern (file, &command->stroke.source.base, source_region_id, indent + 1, recurse);

2907

		break;

2908

2909

	    case CAIRO_COMMAND_FILL:

2910

		print_indent (file, indent);

2911

		fprintf(file, "%d FILL %s source: ", i, common);

2912

		print_pattern (file, &command->fill.source.base, source_region_id, indent + 1, recurse);

2913

		break;

2914

2915

	    case CAIRO_COMMAND_SHOW_TEXT_GLYPHS:

2916

		print_indent (file, indent);

2917

		fprintf(file, "%d SHOW_TEXT_GLYPHS %s font_type: ", i, common);

2918

		switch (command->show_text_glyphs.scaled_font->backend->type) {

2919

		    case CAIRO_FONT_TYPE_TOY: fputs ("toy", file); break;

2920

		    case CAIRO_FONT_TYPE_FT: fputs ("ft", file); break;

2921

		    case CAIRO_FONT_TYPE_WIN32: fputs ("win32", file); break;

2922

		    case CAIRO_FONT_TYPE_QUARTZ: fputs ("quartz", file); break;

2923

		    case CAIRO_FONT_TYPE_USER: fputs ("user", file); break;

2924

		    case CAIRO_FONT_TYPE_DWRITE: fputs ("dwrite", file); break;

2925

2926

		fprintf (file, " glyphs:");

2927

		for (unsigned j = 0; j < command->show_text_glyphs.num_glyphs; j++)

2928

		    fprintf (file, " %ld", command->show_text_glyphs.glyphs[j].index);

2929

		fprintf (file, " source:");

2930

		print_pattern (file, &command->show_text_glyphs.source.base, source_region_id, indent + 1, recurse);

2931

		break;

2932

2933

	    case CAIRO_COMMAND_TAG:

2934

		print_indent (file, indent);

2935

		fprintf(file, "%d %s %s '%s'\n",

2936

i,

2937

			command->tag.begin ? "BEGIN TAG" : "END TAG",

2938

			command->tag.tag_name, command->tag.attributes);

2939

		break;

2940

2941

	    default:

2942

		ASSERT_NOT_REACHED;

2943

2944

2945

    cairo_surface_destroy (free_me);

2946