OLD | NEW |
---|---|
1 /* | 1 /* |
2 * Copyright 2014 Google Inc. | 2 * Copyright 2014 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkCanvas.h" | 8 #include "SkCanvas.h" |
9 #include "SkPictureData.h" | 9 #include "SkPictureData.h" |
10 #include "SkPicturePlayback.h" | 10 #include "SkPicturePlayback.h" |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
87 } else { | 87 } else { |
88 UNPACK_8_24(temp, op, *size); | 88 UNPACK_8_24(temp, op, *size); |
89 if (MASK_24 == *size) { | 89 if (MASK_24 == *size) { |
90 *size = reader->readInt(); | 90 *size = reader->readInt(); |
91 } | 91 } |
92 } | 92 } |
93 return (DrawType)op; | 93 return (DrawType)op; |
94 } | 94 } |
95 | 95 |
96 | 96 |
97 static const SkRect* get_rect_ptr(SkReader32& reader) { | 97 static const SkRect* get_rect_ptr(SkReader32* reader) { |
98 if (reader.readBool()) { | 98 if (reader->readBool()) { |
99 return &reader.skipT<SkRect>(); | 99 return &reader->skipT<SkRect>(); |
100 } else { | 100 } else { |
101 return NULL; | 101 return NULL; |
102 } | 102 } |
103 } | 103 } |
104 | 104 |
105 class TextContainer { | 105 class TextContainer { |
106 public: | 106 public: |
107 size_t length() { return fByteLength; } | 107 size_t length() { return fByteLength; } |
108 const void* text() { return (const void*)fText; } | 108 const void* text() { return (const void*)fText; } |
109 size_t fByteLength; | 109 size_t fByteLength; |
110 const char* fText; | 110 const char* fText; |
111 }; | 111 }; |
112 | 112 |
113 void get_text(SkReader32* reader, TextContainer* text) { | 113 void get_text(SkReader32* reader, TextContainer* text) { |
114 size_t length = text->fByteLength = reader->readInt(); | 114 size_t length = text->fByteLength = reader->readInt(); |
115 text->fText = (const char*)reader->skip(length); | 115 text->fText = (const char*)reader->skip(length); |
116 } | 116 } |
117 | 117 |
118 void SkPicturePlayback::draw(SkCanvas* canvas, SkDrawPictureCallback* callback) { | 118 void SkPicturePlayback::draw(SkCanvas* canvas, SkDrawPictureCallback* callback) { |
119 SkAutoResetOpID aroi(this); | 119 SkAutoResetOpID aroi(this); |
120 SkASSERT(0 == fCurOffset); | 120 SkASSERT(0 == fCurOffset); |
121 | 121 |
122 #ifdef ENABLE_TIME_DRAW | |
123 SkAutoTime at("SkPicture::draw", 50); | |
124 #endif | |
125 | |
126 #ifdef SPEW_CLIP_SKIPPING | |
127 SkipClipRec skipRect, skipRRect, skipRegion, skipPath, skipCull; | |
128 int opCount = 0; | |
129 #endif | |
130 | |
131 // kDrawComplete will be the signal that we have reached the end of | 122 // kDrawComplete will be the signal that we have reached the end of |
132 // the command stream | 123 // the command stream |
133 static const uint32_t kDrawComplete = SK_MaxU32; | 124 static const uint32_t kDrawComplete = SK_MaxU32; |
134 | 125 |
135 SkReader32 reader(fPictureData->fOpData->bytes(), fPictureData->fOpData->siz e()); | 126 SkReader32 reader(fPictureData->fOpData->bytes(), fPictureData->fOpData->siz e()); |
136 TextContainer text; | |
137 SkAutoTDelete<const SkPicture::OperationList> activeOpsList; | 127 SkAutoTDelete<const SkPicture::OperationList> activeOpsList; |
138 const SkTDArray<void*>* activeOps = NULL; | 128 const SkTDArray<void*>* activeOps = NULL; |
139 | 129 |
140 // When draw limits are enabled (i.e., 0 != fStart || 0 != fStop) the state | 130 // When draw limits are enabled (i.e., 0 != fStart || 0 != fStop) the state |
141 // tree isn't used to pick and choose the draw operations | 131 // tree isn't used to pick and choose the draw operations |
142 if (0 == fStart && 0 == fStop) { | 132 if (0 == fStart && 0 == fStop) { |
143 if (fUseBBH && NULL != fPictureData->fStateTree && NULL != fPictureData- >fBoundingHierarchy) { | 133 if (fUseBBH && NULL != fPictureData->fStateTree && NULL != fPictureData- >fBoundingHierarchy) { |
144 SkRect clipBounds; | 134 SkRect clipBounds; |
145 if (canvas->getClipBounds(&clipBounds)) { | 135 if (canvas->getClipBounds(&clipBounds)) { |
146 SkIRect query; | 136 SkIRect query; |
147 clipBounds.roundOut(&query); | 137 clipBounds.roundOut(&query); |
148 | 138 |
149 activeOpsList.reset(fPictureData->getActiveOps(query)); | 139 activeOpsList.reset(fPictureData->getActiveOps(query)); |
150 if (NULL != activeOpsList.get()) { | 140 if (NULL != activeOpsList.get()) { |
151 if (0 == activeOpsList->numOps()) { | 141 if (0 == activeOpsList->numOps()) { |
152 return; // nothing to draw | 142 return; // nothing to draw |
153 } | 143 } |
154 | 144 |
155 // Since the opList is valid we know it is our derived class | 145 // Since the opList is valid we know it is our derived class |
156 activeOps = &((const SkPictureData::OperationList*)activeOps List.get())->fOps; | 146 activeOps = &((const SkPicture::OperationList*)activeOpsList .get())->fOps; |
mtklein
2014/07/07 22:52:14
Isn't this cast a no-op now?
robertphillips
2014/07/08 12:50:43
Done.
| |
157 } | 147 } |
158 } | 148 } |
159 } | 149 } |
160 } | 150 } |
161 | 151 |
162 SkPictureStateTree::Iterator it = (NULL == activeOps) ? | 152 SkPictureStateTree::Iterator it = (NULL == activeOps) ? |
163 SkPictureStateTree::Iterator() : | 153 SkPictureStateTree::Iterator() : |
164 fPictureData->fStateTree->getIterator(*activeOps, canvas); | 154 fPictureData->fStateTree->getIterator(*activeOps, canvas); |
165 | 155 |
166 if (0 != fStart || 0 != fStop) { | 156 if (0 != fStart || 0 != fStop) { |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
260 } else { | 250 } else { |
261 reader.setOffset(temp->fStop); | 251 reader.setOffset(temp->fStop); |
262 uint32_t size; | 252 uint32_t size; |
263 SkDEBUGCODE(DrawType op = ) read_op_and_size(&reader, &size) ; | 253 SkDEBUGCODE(DrawType op = ) read_op_and_size(&reader, &size) ; |
264 SkASSERT(RESTORE == op); | 254 SkASSERT(RESTORE == op); |
265 } | 255 } |
266 continue; | 256 continue; |
267 } | 257 } |
268 } | 258 } |
269 | 259 |
270 #ifdef SPEW_CLIP_SKIPPING | |
271 opCount++; | |
272 #endif | |
273 | |
274 fCurOffset = reader.offset(); | 260 fCurOffset = reader.offset(); |
275 uint32_t size; | 261 uint32_t size; |
276 DrawType op = read_op_and_size(&reader, &size); | 262 DrawType op = read_op_and_size(&reader, &size); |
277 size_t skipTo = 0; | 263 size_t skipTo = 0; |
278 if (NOOP == op) { | 264 if (NOOP == op) { |
279 // NOOPs are to be ignored - do not propagate them any further | 265 // NOOPs are to be ignored - do not propagate them any further |
280 skipTo = fCurOffset + size; | 266 skipTo = fCurOffset + size; |
281 #ifdef SK_DEVELOPER | 267 #ifdef SK_DEVELOPER |
282 } else { | 268 } else { |
283 opIndex++; | 269 opIndex++; |
(...skipping 13 matching lines...) Expand all Loading... | |
297 } while (adjustedSkipTo < skipTo); | 283 } while (adjustedSkipTo < skipTo); |
298 skipTo = adjustedSkipTo; | 284 skipTo = adjustedSkipTo; |
299 } | 285 } |
300 if (kDrawComplete == skipTo) { | 286 if (kDrawComplete == skipTo) { |
301 break; | 287 break; |
302 } | 288 } |
303 reader.setOffset(skipTo); | 289 reader.setOffset(skipTo); |
304 continue; | 290 continue; |
305 } | 291 } |
306 | 292 |
307 switch (op) { | 293 this->handleOp(&reader, op, size, canvas, initialMatrix); |
294 | |
295 #ifdef SK_DEVELOPER | |
296 this->postDraw(opIndex); | |
297 #endif | |
298 | |
299 if (it.isValid()) { | |
300 uint32_t skipTo = it.nextDraw(); | |
301 if (kDrawComplete == skipTo) { | |
302 break; | |
303 } | |
304 reader.setOffset(skipTo); | |
305 } | |
306 } | |
307 } | |
308 | |
309 void SkPicturePlayback::handleOp(SkReader32* reader, | |
310 DrawType op, | |
311 uint32_t size, | |
312 SkCanvas* canvas, | |
313 const SkMatrix& initialMatrix) { | |
314 switch (op) { | |
308 case CLIP_PATH: { | 315 case CLIP_PATH: { |
309 const SkPath& path = fPictureData->getPath(reader); | 316 const SkPath& path = fPictureData->getPath(reader); |
310 uint32_t packed = reader.readInt(); | 317 uint32_t packed = reader->readInt(); |
311 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); | 318 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); |
312 bool doAA = ClipParams_unpackDoAA(packed); | 319 bool doAA = ClipParams_unpackDoAA(packed); |
313 size_t offsetToRestore = reader.readInt(); | 320 size_t offsetToRestore = reader->readInt(); |
314 SkASSERT(!offsetToRestore || offsetToRestore >= reader.offset()); | 321 SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset()); |
315 canvas->clipPath(path, regionOp, doAA); | 322 canvas->clipPath(path, regionOp, doAA); |
316 if (canvas->isClipEmpty() && offsetToRestore) { | 323 if (canvas->isClipEmpty() && offsetToRestore) { |
317 #ifdef SPEW_CLIP_SKIPPING | 324 reader->setOffset(offsetToRestore); |
318 skipPath.recordSkip(offsetToRestore - reader.offset()); | |
319 #endif | |
320 reader.setOffset(offsetToRestore); | |
321 } | 325 } |
322 } break; | 326 } break; |
323 case CLIP_REGION: { | 327 case CLIP_REGION: { |
324 SkRegion region; | 328 SkRegion region; |
325 reader.readRegion(®ion); | 329 reader->readRegion(®ion); |
326 uint32_t packed = reader.readInt(); | 330 uint32_t packed = reader->readInt(); |
327 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); | 331 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); |
328 size_t offsetToRestore = reader.readInt(); | 332 size_t offsetToRestore = reader->readInt(); |
329 SkASSERT(!offsetToRestore || offsetToRestore >= reader.offset()); | 333 SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset()); |
330 canvas->clipRegion(region, regionOp); | 334 canvas->clipRegion(region, regionOp); |
331 if (canvas->isClipEmpty() && offsetToRestore) { | 335 if (canvas->isClipEmpty() && offsetToRestore) { |
332 #ifdef SPEW_CLIP_SKIPPING | 336 reader->setOffset(offsetToRestore); |
333 skipRegion.recordSkip(offsetToRestore - reader.offset()); | |
334 #endif | |
335 reader.setOffset(offsetToRestore); | |
336 } | 337 } |
337 } break; | 338 } break; |
338 case CLIP_RECT: { | 339 case CLIP_RECT: { |
339 const SkRect& rect = reader.skipT<SkRect>(); | 340 const SkRect& rect = reader->skipT<SkRect>(); |
340 uint32_t packed = reader.readInt(); | 341 uint32_t packed = reader->readInt(); |
341 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); | 342 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); |
342 bool doAA = ClipParams_unpackDoAA(packed); | 343 bool doAA = ClipParams_unpackDoAA(packed); |
343 size_t offsetToRestore = reader.readInt(); | 344 size_t offsetToRestore = reader->readInt(); |
344 SkASSERT(!offsetToRestore || offsetToRestore >= reader.offset()); | 345 SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset()); |
345 canvas->clipRect(rect, regionOp, doAA); | 346 canvas->clipRect(rect, regionOp, doAA); |
346 if (canvas->isClipEmpty() && offsetToRestore) { | 347 if (canvas->isClipEmpty() && offsetToRestore) { |
347 #ifdef SPEW_CLIP_SKIPPING | 348 reader->setOffset(offsetToRestore); |
348 skipRect.recordSkip(offsetToRestore - reader.offset()); | |
349 #endif | |
350 reader.setOffset(offsetToRestore); | |
351 } | 349 } |
352 } break; | 350 } break; |
353 case CLIP_RRECT: { | 351 case CLIP_RRECT: { |
354 SkRRect rrect; | 352 SkRRect rrect; |
355 reader.readRRect(&rrect); | 353 reader->readRRect(&rrect); |
356 uint32_t packed = reader.readInt(); | 354 uint32_t packed = reader->readInt(); |
357 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); | 355 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); |
358 bool doAA = ClipParams_unpackDoAA(packed); | 356 bool doAA = ClipParams_unpackDoAA(packed); |
359 size_t offsetToRestore = reader.readInt(); | 357 size_t offsetToRestore = reader->readInt(); |
360 SkASSERT(!offsetToRestore || offsetToRestore >= reader.offset()); | 358 SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset()); |
361 canvas->clipRRect(rrect, regionOp, doAA); | 359 canvas->clipRRect(rrect, regionOp, doAA); |
362 if (canvas->isClipEmpty() && offsetToRestore) { | 360 if (canvas->isClipEmpty() && offsetToRestore) { |
363 #ifdef SPEW_CLIP_SKIPPING | 361 reader->setOffset(offsetToRestore); |
364 skipRRect.recordSkip(offsetToRestore - reader.offset()); | |
365 #endif | |
366 reader.setOffset(offsetToRestore); | |
367 } | 362 } |
368 } break; | 363 } break; |
369 case PUSH_CULL: { | 364 case PUSH_CULL: { |
370 const SkRect& cullRect = reader.skipT<SkRect>(); | 365 const SkRect& cullRect = reader->skipT<SkRect>(); |
371 size_t offsetToRestore = reader.readInt(); | 366 size_t offsetToRestore = reader->readInt(); |
372 if (offsetToRestore && canvas->quickReject(cullRect)) { | 367 if (offsetToRestore && canvas->quickReject(cullRect)) { |
373 #ifdef SPEW_CLIP_SKIPPING | 368 reader->setOffset(offsetToRestore); |
374 skipCull.recordSkip(offsetToRestore - reader.offset()); | |
375 #endif | |
376 reader.setOffset(offsetToRestore); | |
377 } else { | 369 } else { |
378 canvas->pushCull(cullRect); | 370 canvas->pushCull(cullRect); |
379 } | 371 } |
380 } break; | 372 } break; |
381 case POP_CULL: | 373 case POP_CULL: |
382 canvas->popCull(); | 374 canvas->popCull(); |
383 break; | 375 break; |
384 case CONCAT: { | 376 case CONCAT: { |
385 SkMatrix matrix; | 377 SkMatrix matrix; |
386 reader.readMatrix(&matrix); | 378 reader->readMatrix(&matrix); |
387 canvas->concat(matrix); | 379 canvas->concat(matrix); |
388 break; | 380 break; |
389 } | 381 } |
390 case DRAW_BITMAP: { | 382 case DRAW_BITMAP: { |
391 const SkPaint* paint = fPictureData->getPaint(reader); | 383 const SkPaint* paint = fPictureData->getPaint(reader); |
392 const SkBitmap& bitmap = fPictureData->getBitmap(reader); | 384 const SkBitmap& bitmap = fPictureData->getBitmap(reader); |
393 const SkPoint& loc = reader.skipT<SkPoint>(); | 385 const SkPoint& loc = reader->skipT<SkPoint>(); |
394 canvas->drawBitmap(bitmap, loc.fX, loc.fY, paint); | 386 canvas->drawBitmap(bitmap, loc.fX, loc.fY, paint); |
395 } break; | 387 } break; |
396 case DRAW_BITMAP_RECT_TO_RECT: { | 388 case DRAW_BITMAP_RECT_TO_RECT: { |
397 const SkPaint* paint = fPictureData->getPaint(reader); | 389 const SkPaint* paint = fPictureData->getPaint(reader); |
398 const SkBitmap& bitmap = fPictureData->getBitmap(reader); | 390 const SkBitmap& bitmap = fPictureData->getBitmap(reader); |
399 const SkRect* src = get_rect_ptr(reader); // may be null | 391 const SkRect* src = get_rect_ptr(reader); // may be null |
400 const SkRect& dst = reader.skipT<SkRect>(); // required | 392 const SkRect& dst = reader->skipT<SkRect>(); // required |
401 SkCanvas::DrawBitmapRectFlags flags; | 393 SkCanvas::DrawBitmapRectFlags flags; |
402 flags = (SkCanvas::DrawBitmapRectFlags) reader.readInt(); | 394 flags = (SkCanvas::DrawBitmapRectFlags) reader->readInt(); |
403 canvas->drawBitmapRectToRect(bitmap, src, dst, paint, flags); | 395 canvas->drawBitmapRectToRect(bitmap, src, dst, paint, flags); |
404 } break; | 396 } break; |
405 case DRAW_BITMAP_MATRIX: { | 397 case DRAW_BITMAP_MATRIX: { |
406 const SkPaint* paint = fPictureData->getPaint(reader); | 398 const SkPaint* paint = fPictureData->getPaint(reader); |
407 const SkBitmap& bitmap = fPictureData->getBitmap(reader); | 399 const SkBitmap& bitmap = fPictureData->getBitmap(reader); |
408 SkMatrix matrix; | 400 SkMatrix matrix; |
409 reader.readMatrix(&matrix); | 401 reader->readMatrix(&matrix); |
410 canvas->drawBitmapMatrix(bitmap, matrix, paint); | 402 canvas->drawBitmapMatrix(bitmap, matrix, paint); |
411 } break; | 403 } break; |
412 case DRAW_BITMAP_NINE: { | 404 case DRAW_BITMAP_NINE: { |
413 const SkPaint* paint = fPictureData->getPaint(reader); | 405 const SkPaint* paint = fPictureData->getPaint(reader); |
414 const SkBitmap& bitmap = fPictureData->getBitmap(reader); | 406 const SkBitmap& bitmap = fPictureData->getBitmap(reader); |
415 const SkIRect& src = reader.skipT<SkIRect>(); | 407 const SkIRect& src = reader->skipT<SkIRect>(); |
416 const SkRect& dst = reader.skipT<SkRect>(); | 408 const SkRect& dst = reader->skipT<SkRect>(); |
417 canvas->drawBitmapNine(bitmap, src, dst, paint); | 409 canvas->drawBitmapNine(bitmap, src, dst, paint); |
418 } break; | 410 } break; |
419 case DRAW_CLEAR: | 411 case DRAW_CLEAR: |
420 canvas->clear(reader.readInt()); | 412 canvas->clear(reader->readInt()); |
421 break; | 413 break; |
422 case DRAW_DATA: { | 414 case DRAW_DATA: { |
423 size_t length = reader.readInt(); | 415 size_t length = reader->readInt(); |
424 canvas->drawData(reader.skip(length), length); | 416 canvas->drawData(reader->skip(length), length); |
425 // skip handles padding the read out to a multiple of 4 | 417 // skip handles padding the read out to a multiple of 4 |
426 } break; | 418 } break; |
427 case DRAW_DRRECT: { | 419 case DRAW_DRRECT: { |
428 const SkPaint& paint = *fPictureData->getPaint(reader); | 420 const SkPaint& paint = *fPictureData->getPaint(reader); |
429 SkRRect outer, inner; | 421 SkRRect outer, inner; |
430 reader.readRRect(&outer); | 422 reader->readRRect(&outer); |
431 reader.readRRect(&inner); | 423 reader->readRRect(&inner); |
432 canvas->drawDRRect(outer, inner, paint); | 424 canvas->drawDRRect(outer, inner, paint); |
433 } break; | 425 } break; |
434 case BEGIN_COMMENT_GROUP: { | 426 case BEGIN_COMMENT_GROUP: { |
435 const char* desc = reader.readString(); | 427 const char* desc = reader->readString(); |
436 canvas->beginCommentGroup(desc); | 428 canvas->beginCommentGroup(desc); |
437 } break; | 429 } break; |
438 case COMMENT: { | 430 case COMMENT: { |
439 const char* kywd = reader.readString(); | 431 const char* kywd = reader->readString(); |
440 const char* value = reader.readString(); | 432 const char* value = reader->readString(); |
441 canvas->addComment(kywd, value); | 433 canvas->addComment(kywd, value); |
442 } break; | 434 } break; |
443 case END_COMMENT_GROUP: { | 435 case END_COMMENT_GROUP: { |
444 canvas->endCommentGroup(); | 436 canvas->endCommentGroup(); |
445 } break; | 437 } break; |
446 case DRAW_OVAL: { | 438 case DRAW_OVAL: { |
447 const SkPaint& paint = *fPictureData->getPaint(reader); | 439 const SkPaint& paint = *fPictureData->getPaint(reader); |
448 canvas->drawOval(reader.skipT<SkRect>(), paint); | 440 canvas->drawOval(reader->skipT<SkRect>(), paint); |
449 } break; | 441 } break; |
450 case DRAW_PAINT: | 442 case DRAW_PAINT: |
451 canvas->drawPaint(*fPictureData->getPaint(reader)); | 443 canvas->drawPaint(*fPictureData->getPaint(reader)); |
452 break; | 444 break; |
453 case DRAW_PATH: { | 445 case DRAW_PATH: { |
454 const SkPaint& paint = *fPictureData->getPaint(reader); | 446 const SkPaint& paint = *fPictureData->getPaint(reader); |
455 canvas->drawPath(fPictureData->getPath(reader), paint); | 447 canvas->drawPath(fPictureData->getPath(reader), paint); |
456 } break; | 448 } break; |
457 case DRAW_PICTURE: | 449 case DRAW_PICTURE: |
458 canvas->drawPicture(fPictureData->getPicture(reader)); | 450 canvas->drawPicture(fPictureData->getPicture(reader)); |
459 break; | 451 break; |
460 case DRAW_POINTS: { | 452 case DRAW_POINTS: { |
461 const SkPaint& paint = *fPictureData->getPaint(reader); | 453 const SkPaint& paint = *fPictureData->getPaint(reader); |
462 SkCanvas::PointMode mode = (SkCanvas::PointMode)reader.readInt(); | 454 SkCanvas::PointMode mode = (SkCanvas::PointMode)reader->readInt(); |
463 size_t count = reader.readInt(); | 455 size_t count = reader->readInt(); |
464 const SkPoint* pts = (const SkPoint*)reader.skip(sizeof(SkPoint)* co unt); | 456 const SkPoint* pts = (const SkPoint*)reader->skip(sizeof(SkPoint)* c ount); |
465 canvas->drawPoints(mode, count, pts, paint); | 457 canvas->drawPoints(mode, count, pts, paint); |
466 } break; | 458 } break; |
467 case DRAW_POS_TEXT: { | 459 case DRAW_POS_TEXT: { |
468 const SkPaint& paint = *fPictureData->getPaint(reader); | 460 const SkPaint& paint = *fPictureData->getPaint(reader); |
469 get_text(&reader, &text); | 461 TextContainer text; |
470 size_t points = reader.readInt(); | 462 get_text(reader, &text); |
471 const SkPoint* pos = (const SkPoint*)reader.skip(points * sizeof(SkP oint)); | 463 size_t points = reader->readInt(); |
464 const SkPoint* pos = (const SkPoint*)reader->skip(points * sizeof(Sk Point)); | |
472 canvas->drawPosText(text.text(), text.length(), pos, paint); | 465 canvas->drawPosText(text.text(), text.length(), pos, paint); |
473 } break; | 466 } break; |
474 case DRAW_POS_TEXT_TOP_BOTTOM: { | 467 case DRAW_POS_TEXT_TOP_BOTTOM: { |
475 const SkPaint& paint = *fPictureData->getPaint(reader); | 468 const SkPaint& paint = *fPictureData->getPaint(reader); |
476 get_text(&reader, &text); | 469 TextContainer text; |
477 size_t points = reader.readInt(); | 470 get_text(reader, &text); |
478 const SkPoint* pos = (const SkPoint*)reader.skip(points * sizeof(SkP oint)); | 471 size_t points = reader->readInt(); |
479 const SkScalar top = reader.readScalar(); | 472 const SkPoint* pos = (const SkPoint*)reader->skip(points * sizeof(Sk Point)); |
480 const SkScalar bottom = reader.readScalar(); | 473 const SkScalar top = reader->readScalar(); |
474 const SkScalar bottom = reader->readScalar(); | |
481 if (!canvas->quickRejectY(top, bottom)) { | 475 if (!canvas->quickRejectY(top, bottom)) { |
482 canvas->drawPosText(text.text(), text.length(), pos, paint); | 476 canvas->drawPosText(text.text(), text.length(), pos, paint); |
483 } | 477 } |
484 } break; | 478 } break; |
485 case DRAW_POS_TEXT_H: { | 479 case DRAW_POS_TEXT_H: { |
486 const SkPaint& paint = *fPictureData->getPaint(reader); | 480 const SkPaint& paint = *fPictureData->getPaint(reader); |
487 get_text(&reader, &text); | 481 TextContainer text; |
488 size_t xCount = reader.readInt(); | 482 get_text(reader, &text); |
489 const SkScalar constY = reader.readScalar(); | 483 size_t xCount = reader->readInt(); |
490 const SkScalar* xpos = (const SkScalar*)reader.skip(xCount * sizeof( SkScalar)); | 484 const SkScalar constY = reader->readScalar(); |
485 const SkScalar* xpos = (const SkScalar*)reader->skip(xCount * sizeof (SkScalar)); | |
491 canvas->drawPosTextH(text.text(), text.length(), xpos, constY, paint ); | 486 canvas->drawPosTextH(text.text(), text.length(), xpos, constY, paint ); |
492 } break; | 487 } break; |
493 case DRAW_POS_TEXT_H_TOP_BOTTOM: { | 488 case DRAW_POS_TEXT_H_TOP_BOTTOM: { |
494 const SkPaint& paint = *fPictureData->getPaint(reader); | 489 const SkPaint& paint = *fPictureData->getPaint(reader); |
495 get_text(&reader, &text); | 490 TextContainer text; |
496 size_t xCount = reader.readInt(); | 491 get_text(reader, &text); |
497 const SkScalar* xpos = (const SkScalar*)reader.skip((3 + xCount) * s izeof(SkScalar)); | 492 size_t xCount = reader->readInt(); |
493 const SkScalar* xpos = (const SkScalar*)reader->skip((3 + xCount) * sizeof(SkScalar)); | |
498 const SkScalar top = *xpos++; | 494 const SkScalar top = *xpos++; |
499 const SkScalar bottom = *xpos++; | 495 const SkScalar bottom = *xpos++; |
500 const SkScalar constY = *xpos++; | 496 const SkScalar constY = *xpos++; |
501 if (!canvas->quickRejectY(top, bottom)) { | 497 if (!canvas->quickRejectY(top, bottom)) { |
502 canvas->drawPosTextH(text.text(), text.length(), xpos, constY, p aint); | 498 canvas->drawPosTextH(text.text(), text.length(), xpos, constY, p aint); |
503 } | 499 } |
504 } break; | 500 } break; |
505 case DRAW_RECT: { | 501 case DRAW_RECT: { |
506 const SkPaint& paint = *fPictureData->getPaint(reader); | 502 const SkPaint& paint = *fPictureData->getPaint(reader); |
507 canvas->drawRect(reader.skipT<SkRect>(), paint); | 503 canvas->drawRect(reader->skipT<SkRect>(), paint); |
508 } break; | 504 } break; |
509 case DRAW_RRECT: { | 505 case DRAW_RRECT: { |
510 const SkPaint& paint = *fPictureData->getPaint(reader); | 506 const SkPaint& paint = *fPictureData->getPaint(reader); |
511 SkRRect rrect; | 507 SkRRect rrect; |
512 reader.readRRect(&rrect); | 508 reader->readRRect(&rrect); |
513 canvas->drawRRect(rrect, paint); | 509 canvas->drawRRect(rrect, paint); |
514 } break; | 510 } break; |
515 case DRAW_SPRITE: { | 511 case DRAW_SPRITE: { |
516 const SkPaint* paint = fPictureData->getPaint(reader); | 512 const SkPaint* paint = fPictureData->getPaint(reader); |
517 const SkBitmap& bitmap = fPictureData->getBitmap(reader); | 513 const SkBitmap& bitmap = fPictureData->getBitmap(reader); |
518 int left = reader.readInt(); | 514 int left = reader->readInt(); |
519 int top = reader.readInt(); | 515 int top = reader->readInt(); |
520 canvas->drawSprite(bitmap, left, top, paint); | 516 canvas->drawSprite(bitmap, left, top, paint); |
521 } break; | 517 } break; |
522 case DRAW_TEXT: { | 518 case DRAW_TEXT: { |
523 const SkPaint& paint = *fPictureData->getPaint(reader); | 519 const SkPaint& paint = *fPictureData->getPaint(reader); |
524 get_text(&reader, &text); | 520 TextContainer text; |
525 SkScalar x = reader.readScalar(); | 521 get_text(reader, &text); |
526 SkScalar y = reader.readScalar(); | 522 SkScalar x = reader->readScalar(); |
523 SkScalar y = reader->readScalar(); | |
527 canvas->drawText(text.text(), text.length(), x, y, paint); | 524 canvas->drawText(text.text(), text.length(), x, y, paint); |
528 } break; | 525 } break; |
529 case DRAW_TEXT_TOP_BOTTOM: { | 526 case DRAW_TEXT_TOP_BOTTOM: { |
530 const SkPaint& paint = *fPictureData->getPaint(reader); | 527 const SkPaint& paint = *fPictureData->getPaint(reader); |
531 get_text(&reader, &text); | 528 TextContainer text; |
532 const SkScalar* ptr = (const SkScalar*)reader.skip(4 * sizeof(SkScal ar)); | 529 get_text(reader, &text); |
530 const SkScalar* ptr = (const SkScalar*)reader->skip(4 * sizeof(SkSca lar)); | |
533 // ptr[0] == x | 531 // ptr[0] == x |
534 // ptr[1] == y | 532 // ptr[1] == y |
535 // ptr[2] == top | 533 // ptr[2] == top |
536 // ptr[3] == bottom | 534 // ptr[3] == bottom |
537 if (!canvas->quickRejectY(ptr[2], ptr[3])) { | 535 if (!canvas->quickRejectY(ptr[2], ptr[3])) { |
538 canvas->drawText(text.text(), text.length(), ptr[0], ptr[1], pai nt); | 536 canvas->drawText(text.text(), text.length(), ptr[0], ptr[1], pai nt); |
539 } | 537 } |
540 } break; | 538 } break; |
541 case DRAW_TEXT_ON_PATH: { | 539 case DRAW_TEXT_ON_PATH: { |
542 const SkPaint& paint = *fPictureData->getPaint(reader); | 540 const SkPaint& paint = *fPictureData->getPaint(reader); |
543 get_text(&reader, &text); | 541 TextContainer text; |
542 get_text(reader, &text); | |
544 const SkPath& path = fPictureData->getPath(reader); | 543 const SkPath& path = fPictureData->getPath(reader); |
545 SkMatrix matrix; | 544 SkMatrix matrix; |
546 reader.readMatrix(&matrix); | 545 reader->readMatrix(&matrix); |
547 canvas->drawTextOnPath(text.text(), text.length(), path, &matrix, pa int); | 546 canvas->drawTextOnPath(text.text(), text.length(), path, &matrix, pa int); |
548 } break; | 547 } break; |
549 case DRAW_VERTICES: { | 548 case DRAW_VERTICES: { |
550 SkAutoTUnref<SkXfermode> xfer; | 549 SkAutoTUnref<SkXfermode> xfer; |
551 const SkPaint& paint = *fPictureData->getPaint(reader); | 550 const SkPaint& paint = *fPictureData->getPaint(reader); |
552 DrawVertexFlags flags = (DrawVertexFlags)reader.readInt(); | 551 DrawVertexFlags flags = (DrawVertexFlags)reader->readInt(); |
553 SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader.readInt(); | 552 SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader->readInt() ; |
554 int vCount = reader.readInt(); | 553 int vCount = reader->readInt(); |
555 const SkPoint* verts = (const SkPoint*)reader.skip(vCount * sizeof(S kPoint)); | 554 const SkPoint* verts = (const SkPoint*)reader->skip(vCount * sizeof( SkPoint)); |
556 const SkPoint* texs = NULL; | 555 const SkPoint* texs = NULL; |
557 const SkColor* colors = NULL; | 556 const SkColor* colors = NULL; |
558 const uint16_t* indices = NULL; | 557 const uint16_t* indices = NULL; |
559 int iCount = 0; | 558 int iCount = 0; |
560 if (flags & DRAW_VERTICES_HAS_TEXS) { | 559 if (flags & DRAW_VERTICES_HAS_TEXS) { |
561 texs = (const SkPoint*)reader.skip(vCount * sizeof(SkPoint)); | 560 texs = (const SkPoint*)reader->skip(vCount * sizeof(SkPoint)); |
562 } | 561 } |
563 if (flags & DRAW_VERTICES_HAS_COLORS) { | 562 if (flags & DRAW_VERTICES_HAS_COLORS) { |
564 colors = (const SkColor*)reader.skip(vCount * sizeof(SkColor)); | 563 colors = (const SkColor*)reader->skip(vCount * sizeof(SkColor)); |
565 } | 564 } |
566 if (flags & DRAW_VERTICES_HAS_INDICES) { | 565 if (flags & DRAW_VERTICES_HAS_INDICES) { |
567 iCount = reader.readInt(); | 566 iCount = reader->readInt(); |
568 indices = (const uint16_t*)reader.skip(iCount * sizeof(uint16_t) ); | 567 indices = (const uint16_t*)reader->skip(iCount * sizeof(uint16_t )); |
569 } | 568 } |
570 if (flags & DRAW_VERTICES_HAS_XFER) { | 569 if (flags & DRAW_VERTICES_HAS_XFER) { |
571 int mode = reader.readInt(); | 570 int mode = reader->readInt(); |
572 if (mode < 0 || mode > SkXfermode::kLastMode) { | 571 if (mode < 0 || mode > SkXfermode::kLastMode) { |
573 mode = SkXfermode::kModulate_Mode; | 572 mode = SkXfermode::kModulate_Mode; |
574 } | 573 } |
575 xfer.reset(SkXfermode::Create((SkXfermode::Mode)mode)); | 574 xfer.reset(SkXfermode::Create((SkXfermode::Mode)mode)); |
576 } | 575 } |
577 canvas->drawVertices(vmode, vCount, verts, texs, colors, xfer, indic es, iCount, paint); | 576 canvas->drawVertices(vmode, vCount, verts, texs, colors, xfer, indic es, iCount, paint); |
578 } break; | 577 } break; |
579 case RESTORE: | 578 case RESTORE: |
580 canvas->restore(); | 579 canvas->restore(); |
581 break; | 580 break; |
582 case ROTATE: | 581 case ROTATE: |
583 canvas->rotate(reader.readScalar()); | 582 canvas->rotate(reader->readScalar()); |
584 break; | 583 break; |
585 case SAVE: | 584 case SAVE: |
586 // SKPs with version < 29 also store a SaveFlags param. | 585 // SKPs with version < 29 also store a SaveFlags param. |
587 if (size > 4) { | 586 if (size > 4) { |
588 SkASSERT(8 == size); | 587 SkASSERT(8 == size); |
589 reader.readInt(); | 588 reader->readInt(); |
590 } | 589 } |
591 canvas->save(); | 590 canvas->save(); |
592 break; | 591 break; |
593 case SAVE_LAYER: { | 592 case SAVE_LAYER: { |
594 const SkRect* boundsPtr = get_rect_ptr(reader); | 593 const SkRect* boundsPtr = get_rect_ptr(reader); |
595 const SkPaint* paint = fPictureData->getPaint(reader); | 594 const SkPaint* paint = fPictureData->getPaint(reader); |
596 canvas->saveLayer(boundsPtr, paint, (SkCanvas::SaveFlags) reader.rea dInt()); | 595 canvas->saveLayer(boundsPtr, paint, (SkCanvas::SaveFlags) reader->re adInt()); |
597 } break; | 596 } break; |
598 case SCALE: { | 597 case SCALE: { |
599 SkScalar sx = reader.readScalar(); | 598 SkScalar sx = reader->readScalar(); |
600 SkScalar sy = reader.readScalar(); | 599 SkScalar sy = reader->readScalar(); |
601 canvas->scale(sx, sy); | 600 canvas->scale(sx, sy); |
602 } break; | 601 } break; |
603 case SET_MATRIX: { | 602 case SET_MATRIX: { |
604 SkMatrix matrix; | 603 SkMatrix matrix; |
605 reader.readMatrix(&matrix); | 604 reader->readMatrix(&matrix); |
606 matrix.postConcat(initialMatrix); | 605 matrix.postConcat(initialMatrix); |
607 canvas->setMatrix(matrix); | 606 canvas->setMatrix(matrix); |
608 } break; | 607 } break; |
609 case SKEW: { | 608 case SKEW: { |
610 SkScalar sx = reader.readScalar(); | 609 SkScalar sx = reader->readScalar(); |
611 SkScalar sy = reader.readScalar(); | 610 SkScalar sy = reader->readScalar(); |
612 canvas->skew(sx, sy); | 611 canvas->skew(sx, sy); |
613 } break; | 612 } break; |
614 case TRANSLATE: { | 613 case TRANSLATE: { |
615 SkScalar dx = reader.readScalar(); | 614 SkScalar dx = reader->readScalar(); |
616 SkScalar dy = reader.readScalar(); | 615 SkScalar dy = reader->readScalar(); |
617 canvas->translate(dx, dy); | 616 canvas->translate(dx, dy); |
618 } break; | 617 } break; |
619 default: | 618 default: |
620 SkASSERT(0); | 619 SkASSERT(0); |
621 } | |
622 | |
623 #ifdef SK_DEVELOPER | |
624 this->postDraw(opIndex); | |
625 #endif | |
626 | |
627 if (it.isValid()) { | |
628 uint32_t skipTo = it.nextDraw(); | |
629 if (kDrawComplete == skipTo) { | |
630 break; | |
631 } | |
632 reader.setOffset(skipTo); | |
633 } | |
634 } | 620 } |
635 | |
636 #ifdef SPEW_CLIP_SKIPPING | |
637 { | |
638 size_t size = skipRect.fSize + skipRRect.fSize + skipPath.fSize + skipRe gion.fSize + | |
639 skipCull.fSize; | |
640 SkDebugf("--- Clip skips %d%% rect:%d rrect:%d path:%d rgn:%d cull:%d\n" , | |
641 size * 100 / reader.offset(), skipRect.fCount, skipRRect.fCount, | |
642 skipPath.fCount, skipRegion.fCount, skipCull.fCount); | |
643 SkDebugf("--- Total ops: %d\n", opCount); | |
644 } | |
645 #endif | |
646 // this->dumpSize(); | |
647 } | 621 } |
648 | 622 |
OLD | NEW |