updated pipe
git-svn-id: http://skia.googlecode.com/svn/trunk@1231 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/include/core/SkWriter32.h b/include/core/SkWriter32.h
index 7ec170c..8e133c2 100644
--- a/include/core/SkWriter32.h
+++ b/include/core/SkWriter32.h
@@ -32,9 +32,23 @@
fMinSize = minSize;
fSize = 0;
fHead = fTail = NULL;
+ fSingleBlock = NULL;
}
~SkWriter32();
+ /**
+ * Returns the single block backing the writer, or NULL if the memory is
+ * to be dynamically allocated.
+ */
+ void* getSingleBlock() const { return fSingleBlock; }
+
+ /**
+ * Specify the single block to back the writer, rathern than dynamically
+ * allocating the memory. If block == NULL, then the writer reverts to
+ * dynamic allocation (and resets).
+ */
+ void reset(void* block, size_t size);
+
bool writeBool(bool value) {
this->writeInt(value);
return value;
@@ -109,11 +123,14 @@
private:
size_t fMinSize;
uint32_t fSize;
+
+ char* fSingleBlock;
+ uint32_t fSingleBlockSize;
struct Block;
Block* fHead;
Block* fTail;
-
+
Block* newBlock(size_t bytes);
};
diff --git a/include/pipe/SkGPipe.h b/include/pipe/SkGPipe.h
index d6210ac..e9f8502 100644
--- a/include/pipe/SkGPipe.h
+++ b/include/pipe/SkGPipe.h
@@ -33,6 +33,8 @@
kError_Status //!< encountered error
};
+ // data must be 4-byte aligned
+ // length must be a multiple of 4
Status playback(const void* data, size_t length);
private:
@@ -42,34 +44,28 @@
///////////////////////////////////////////////////////////////////////////////
-class SkGPipeControler {
+class SkGPipeController {
public:
- struct Block {
- void* fAddr;
- size_t fSize;
- };
-
- enum Status {
- kSuccess_Status,
- kFailure_Status
- };
+ /**
+ * Called periodically by the writer, to get a working buffer of RAM to
+ * write into. The actual size of the block is also returned, and must be
+ * actual >= minRequest. If NULL is returned, then actual is ignored and
+ * writing will stop.
+ *
+ * The returned block must be 4-byte aligned, and actual must be a
+ * multiple of 4.
+ * minRequest will always be a multiple of 4.
+ */
+ virtual void* requestBlock(size_t minRequest, size_t* actual) = 0;
/**
- * To record drawing commands, we request blocks from the controller for
- * subsequent writes, and we want to send/flush blocks of commands we have
- * already written.
+ * This is called each time some atomic portion of the data has been
+ * written to the block (most recently returned by requestBlock()).
+ * If bytes == 0, then the writer has finished.
*
- * For each call to handleBlock, the send block will contain the block
- * (previously returned in a request parameter) that we have written, and
- * if there is more to be recorded, the request block will receive the
- * new block of memory to write into. When the writer detects that there
- * are no more drawing commands expected, it will call handleBlock with
- * NULL for the request parameter.
- *
- * If handleBlock ever returns kFailure_Status, the writer will cease to
- * call handleBlock.
+ * bytes will always be a multiple of 4.
*/
- virtual Status handleBlock(const Block& send, Block* request) = 0;
+ virtual void notifyWritten(size_t bytes) = 0;
};
class SkGPipeWriter {
@@ -78,14 +74,15 @@
~SkGPipeWriter();
bool isRecording() const { return NULL != fCanvas; }
- SkCanvas* startRecording(SkGPipeControler*);
- void endRecording();
+ SkCanvas* startRecording(SkGPipeController*);
- size_t flatten(void* buffer);
+ // called in destructor, but can be called sooner once you know there
+ // should be no more drawing calls made into the recording canvas.
+ void endRecording();
private:
class SkGPipeCanvas* fCanvas;
- SkGPipeControler* fControler;
+ SkGPipeController* fController;
SkWriter32 fWriter;
};
diff --git a/src/core/SkWriter32.cpp b/src/core/SkWriter32.cpp
index 819803f..9a05df9 100644
--- a/src/core/SkWriter32.cpp
+++ b/src/core/SkWriter32.cpp
@@ -9,8 +9,7 @@
char* base() { return (char*)(this + 1); }
const char* base() const { return (const char*)(this + 1); }
- uint32_t* alloc(size_t size)
- {
+ uint32_t* alloc(size_t size) {
SkASSERT(SkAlign4(size) == size);
SkASSERT(this->available() >= size);
void* ptr = this->base() + fAllocated;
@@ -19,15 +18,13 @@
return (uint32_t*)ptr;
}
- uint32_t* peek32(size_t offset)
- {
+ uint32_t* peek32(size_t offset) {
SkASSERT(offset <= fAllocated + 4);
void* ptr = this->base() + offset;
return (uint32_t*)ptr;
}
- static Block* Create(size_t size)
- {
+ static Block* Create(size_t size) {
SkASSERT(SkAlign4(size) == size);
Block* block = (Block*)sk_malloc_throw(sizeof(Block) + size);
block->fNext = NULL;
@@ -39,37 +36,46 @@
///////////////////////////////////////////////////////////////////////////////
-SkWriter32::~SkWriter32()
-{
+SkWriter32::~SkWriter32() {
this->reset();
}
-void SkWriter32::reset()
-{
+void SkWriter32::reset() {
Block* block = fHead;
- while (block)
- {
+ while (block) {
Block* next = block->fNext;
sk_free(block);
block = next;
}
- fHead = fTail = NULL;
+
fSize = 0;
+ fHead = fTail = NULL;
+ fSingleBlock = NULL;
}
-uint32_t* SkWriter32::reserve(size_t size)
-{
+void SkWriter32::reset(void* block, size_t size) {
+ this->reset();
+ SkASSERT(0 == (fSingleBlock - (char*)0) & 3); // need 4-byte alignment
+ fSingleBlock = (char*)block;
+ fSingleBlockSize = (size & ~3);
+}
+
+uint32_t* SkWriter32::reserve(size_t size) {
SkASSERT(SkAlign4(size) == size);
-
+
+ if (fSingleBlock) {
+ uint32_t* ptr = (uint32_t*)(fSingleBlock + fSize);
+ fSize += size;
+ SkASSERT(fSize <= fSingleBlockSize);
+ return ptr;
+ }
+
Block* block = fTail;
- if (NULL == block)
- {
+ if (NULL == block) {
SkASSERT(NULL == fHead);
fHead = fTail = block = Block::Create(SkMax32(size, fMinSize));
- }
- else if (block->available() < size)
- {
+ } else if (block->available() < size) {
fTail = Block::Create(SkMax32(size, fMinSize));
block->fNext = fTail;
block = fTail;
@@ -80,16 +86,18 @@
return block->alloc(size);
}
-uint32_t* SkWriter32::peek32(size_t offset)
-{
+uint32_t* SkWriter32::peek32(size_t offset) {
SkASSERT(SkAlign4(offset) == offset);
SkASSERT(offset <= fSize);
+ if (fSingleBlock) {
+ return (uint32_t*)(fSingleBlock + offset);
+ }
+
Block* block = fHead;
SkASSERT(NULL != block);
- while (offset >= block->fAllocated)
- {
+ while (offset >= block->fAllocated) {
offset -= block->fAllocated;
block = block->fNext;
SkASSERT(NULL != block);
@@ -97,13 +105,16 @@
return block->peek32(offset);
}
-void SkWriter32::flatten(void* dst) const
-{
+void SkWriter32::flatten(void* dst) const {
+ if (fSingleBlock) {
+ memcpy(dst, fSingleBlock, fSize);
+ return;
+ }
+
const Block* block = fHead;
SkDEBUGCODE(size_t total = 0;)
- while (block)
- {
+ while (block) {
size_t allocated = block->fAllocated;
memcpy(dst, block->base(), allocated);
dst = (char*)dst + allocated;
@@ -129,6 +140,17 @@
#include "SkStream.h"
size_t SkWriter32::readFromStream(SkStream* stream, size_t length) {
+ if (fSingleBlock) {
+ SkASSERT(fSingleBlockSize >= fSize);
+ size_t remaining = fSingleBlockSize - fSize;
+ if (length > remaining) {
+ length = remaining;
+ }
+ stream->read(fSingleBlock + fSize, length);
+ fSize += length;
+ return length;
+ }
+
char scratch[1024];
const size_t MAX = sizeof(scratch);
size_t remaining = length;
@@ -149,6 +171,10 @@
}
bool SkWriter32::writeToStream(SkWStream* stream) {
+ if (fSingleBlock) {
+ return stream->write(fSingleBlock, fSize);
+ }
+
const Block* block = fHead;
while (block) {
if (!stream->write(block->base(), block->fAllocated)) {
diff --git a/src/pipe/SkGPipePriv.h b/src/pipe/SkGPipePriv.h
index ceef2bb..7ce7f10 100644
--- a/src/pipe/SkGPipePriv.h
+++ b/src/pipe/SkGPipePriv.h
@@ -23,6 +23,8 @@
#define UNIMPLEMENTED
enum DrawOps {
+ kSkip_DrawOp, // skip an addition N bytes (N == data)
+
// these match Canvas apis
kClipPath_DrawOp,
kClipRegion_DrawOp,
diff --git a/src/pipe/SkGPipeRead.cpp b/src/pipe/SkGPipeRead.cpp
index 94f05da..f022277 100644
--- a/src/pipe/SkGPipeRead.cpp
+++ b/src/pipe/SkGPipeRead.cpp
@@ -17,6 +17,7 @@
#include "SkCanvas.h"
#include "SkPaint.h"
+#include "SkGPipe.h"
#include "SkGPipePriv.h"
#include "SkReader32.h"
@@ -156,7 +157,8 @@
static void saveLayer_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
SkGPipeState* state) {
- unsigned flags = DrawOp_unpackData(op32);
+ unsigned flags = DrawOp_unpackFlags(op32);
+ SkCanvas::SaveFlags saveFlags = (SkCanvas::SaveFlags)DrawOp_unpackData(op32);
const SkRect* bounds = NULL;
if (flags & kSaveLayer_HasBounds_DrawOpFlag) {
@@ -166,8 +168,7 @@
if (flags & kSaveLayer_HasPaint_DrawOpFlag) {
paint = &state->getPaint(reader->readU32());
}
- canvas->saveLayer(bounds, paint,
- (SkCanvas::SaveFlags)DrawOp_unpackFlags(op32));
+ canvas->saveLayer(bounds, paint, saveFlags);
}
static void restore_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
@@ -404,11 +405,17 @@
///////////////////////////////////////////////////////////////////////////////
+static void skip_rp(SkCanvas*, SkReader32* reader, uint32_t op32, SkGPipeState*) {
+ size_t bytes = DrawOp_unpackData(op32);
+ (void)reader->skip(bytes);
+}
+
static void done_rp(SkCanvas*, SkReader32*, uint32_t, SkGPipeState*) {}
typedef void (*ReadProc)(SkCanvas*, SkReader32*, uint32_t op32, SkGPipeState*);
static const ReadProc gReadTable[] = {
+ skip_rp,
clipPath_rp,
clipRegion_rp,
clipRect_rp,
diff --git a/src/pipe/SkGPipeWrite.cpp b/src/pipe/SkGPipeWrite.cpp
index a330713..03a0251 100644
--- a/src/pipe/SkGPipeWrite.cpp
+++ b/src/pipe/SkGPipeWrite.cpp
@@ -17,10 +17,26 @@
#include "SkCanvas.h"
#include "SkPaint.h"
+#include "SkGPipe.h"
#include "SkGPipePriv.h"
-#include "SkGPipeState.h"
#include "SkWriter32.h"
+static size_t estimateFlattenSize(const SkPath& path) {
+ int n = path.countPoints();
+ size_t bytes = 3 * sizeof(int32_t);
+ bytes += n * sizeof(SkPoint);
+ bytes += SkAlign4(n + 2); // verbs: add 2 for move/close extras
+
+#ifdef SK_DEBUG
+ {
+ SkWriter32 writer(1024);
+ path.flatten(writer);
+ SkASSERT(writer.size() <= bytes);
+ }
+#endif
+ return bytes;
+}
+
static void writeRegion(SkWriter32* writer, const SkRegion& rgn) {
size_t size = rgn.flatten(NULL);
SkASSERT(SkAlign4(size) == size);
@@ -37,7 +53,7 @@
class SkGPipeCanvas : public SkCanvas {
public:
- SkGPipeCanvas(SkWriter32* writer);
+ SkGPipeCanvas(SkGPipeController*, SkWriter32*);
virtual ~SkGPipeCanvas();
void finish() {
@@ -93,28 +109,55 @@
virtual void drawData(const void*, size_t);
private:
+ SkGPipeController* fController;
SkWriter32& fWriter;
+ size_t fBlockSize; // amount allocated for writer
+ size_t fBytesNotified;
bool fDone;
- void writeOp(DrawOps op, unsigned flags, unsigned data) {
+ inline void writeOp(DrawOps op, unsigned flags, unsigned data) {
fWriter.write32(DrawOp_packOpFlagData(op, flags, data));
}
- void writeOp(DrawOps op) {
+ inline void writeOp(DrawOps op) {
fWriter.write32(DrawOp_packOpFlagData(op, 0, 0));
}
+
+ bool needOpBytes(size_t size = 0);
+
+ inline void doNotify() {
+ if (!fDone) {
+ size_t bytes = fWriter.size() - fBytesNotified;
+ fController->notifyWritten(bytes);
+ fBytesNotified += bytes;
+ }
+ }
SkTDArray<SkPaint*> fPaints;
unsigned writePaint(const SkPaint&);
+ class AutoPipeNotify {
+ public:
+ AutoPipeNotify(SkGPipeCanvas* canvas) : fCanvas(canvas) {}
+ ~AutoPipeNotify() { fCanvas->doNotify(); }
+ private:
+ SkGPipeCanvas* fCanvas;
+ };
+ friend class AutoPipeNotify;
+
typedef SkCanvas INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
+#define MIN_BLOCK_SIZE (16 * 1024)
-SkGPipeCanvas::SkGPipeCanvas(SkWriter32* writer) : fWriter(*writer) {
+SkGPipeCanvas::SkGPipeCanvas(SkGPipeController* controller,
+ SkWriter32* writer) : fWriter(*writer) {
+ fController = controller;
fDone = false;
+ fBlockSize = 0; // need first block from controller
+
// always begin with 1 default paint
*fPaints.append() = SkNEW(SkPaint);
}
@@ -125,32 +168,62 @@
fPaints.deleteAll();
}
+bool SkGPipeCanvas::needOpBytes(size_t needed) {
+ if (fDone) {
+ return false;
+ }
+
+ needed += 4; // size of DrawOp atom
+ if (fWriter.size() + needed > fBlockSize) {
+ void* block = fController->requestBlock(MIN_BLOCK_SIZE, &fBlockSize);
+ if (NULL == block) {
+ fDone = true;
+ return false;
+ }
+ fWriter.reset(block, fBlockSize);
+ fBytesNotified = 0;
+ }
+ return true;
+}
+
///////////////////////////////////////////////////////////////////////////////
+#define NOTIFY_SETUP(canvas) \
+ AutoPipeNotify apn(canvas)
+
int SkGPipeCanvas::save(SaveFlags flags) {
- this->writeOp(kSave_DrawOp, 0, flags);
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes()) {
+ this->writeOp(kSave_DrawOp, 0, flags);
+ }
return this->INHERITED::save(flags);
}
int SkGPipeCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
SaveFlags saveFlags) {
+ NOTIFY_SETUP(this);
+ size_t size = 0;
unsigned index = 0; // just to avoid the warning
unsigned opFlags = 0;
-
+
if (bounds) {
opFlags |= kSaveLayer_HasBounds_DrawOpFlag;
+ size += sizeof(SkRect);
}
if (paint) {
opFlags |= kSaveLayer_HasPaint_DrawOpFlag;
index = this->writePaint(*paint);
+ size += 4;
}
- this->writeOp(kSaveLayer_DrawOp, opFlags, saveFlags);
- if (bounds) {
- fWriter.writeRect(*bounds);
- }
- if (paint) {
- fWriter.write32(index);
+ if (this->needOpBytes(size)) {
+ this->writeOp(kSaveLayer_DrawOp, opFlags, saveFlags);
+ if (bounds) {
+ fWriter.writeRect(*bounds);
+ }
+ if (paint) {
+ fWriter.write32(index);
+ }
}
// we just pass on the save, so we don't create a layer
@@ -158,116 +231,161 @@
}
void SkGPipeCanvas::restore() {
- this->writeOp(kRestore_DrawOp);
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes()) {
+ this->writeOp(kRestore_DrawOp);
+ }
this->INHERITED::restore();
}
bool SkGPipeCanvas::translate(SkScalar dx, SkScalar dy) {
if (dx || dy) {
- this->writeOp(kTranslate_DrawOp);
- fWriter.writeScalar(dx);
- fWriter.writeScalar(dy);
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(2 * sizeof(SkScalar))) {
+ this->writeOp(kTranslate_DrawOp);
+ fWriter.writeScalar(dx);
+ fWriter.writeScalar(dy);
+ }
}
return this->INHERITED::translate(dx, dy);
}
bool SkGPipeCanvas::scale(SkScalar sx, SkScalar sy) {
if (sx || sy) {
- this->writeOp(kScale_DrawOp);
- fWriter.writeScalar(sx);
- fWriter.writeScalar(sy);
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(2 * sizeof(SkScalar))) {
+ this->writeOp(kScale_DrawOp);
+ fWriter.writeScalar(sx);
+ fWriter.writeScalar(sy);
+ }
}
return this->INHERITED::scale(sx, sy);
}
bool SkGPipeCanvas::rotate(SkScalar degrees) {
if (degrees) {
- this->writeOp(kRotate_DrawOp);
- fWriter.writeScalar(degrees);
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(sizeof(SkScalar))) {
+ this->writeOp(kRotate_DrawOp);
+ fWriter.writeScalar(degrees);
+ }
}
return this->INHERITED::rotate(degrees);
}
bool SkGPipeCanvas::skew(SkScalar sx, SkScalar sy) {
if (sx || sy) {
- this->writeOp(kSkew_DrawOp);
- fWriter.writeScalar(sx);
- fWriter.writeScalar(sy);
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(2 * sizeof(SkScalar))) {
+ this->writeOp(kSkew_DrawOp);
+ fWriter.writeScalar(sx);
+ fWriter.writeScalar(sy);
+ }
}
return this->INHERITED::skew(sx, sy);
}
bool SkGPipeCanvas::concat(const SkMatrix& matrix) {
if (!matrix.isIdentity()) {
- this->writeOp(kConcat_DrawOp);
- writeMatrix(&fWriter, matrix);
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(matrix.flatten(NULL))) {
+ this->writeOp(kConcat_DrawOp);
+ writeMatrix(&fWriter, matrix);
+ }
}
return this->INHERITED::concat(matrix);
}
void SkGPipeCanvas::setMatrix(const SkMatrix& matrix) {
- this->writeOp(kSetMatrix_DrawOp);
- writeMatrix(&fWriter, matrix);
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(matrix.flatten(NULL))) {
+ this->writeOp(kSetMatrix_DrawOp);
+ writeMatrix(&fWriter, matrix);
+ }
this->INHERITED::setMatrix(matrix);
}
bool SkGPipeCanvas::clipRect(const SkRect& rect, SkRegion::Op rgnOp) {
- this->writeOp(kClipRect_DrawOp, 0, rgnOp);
- fWriter.writeRect(rect);
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(sizeof(SkRect))) {
+ this->writeOp(kClipRect_DrawOp, 0, rgnOp);
+ fWriter.writeRect(rect);
+ }
return this->INHERITED::clipRect(rect, rgnOp);
}
bool SkGPipeCanvas::clipPath(const SkPath& path, SkRegion::Op rgnOp) {
- this->writeOp(kClipPath_DrawOp, 0, rgnOp);
- path.flatten(fWriter);
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(estimateFlattenSize(path))) {
+ this->writeOp(kClipPath_DrawOp, 0, rgnOp);
+ path.flatten(fWriter);
+ }
// we just pass on the bounds of the path
return this->INHERITED::clipRect(path.getBounds(), rgnOp);
}
bool SkGPipeCanvas::clipRegion(const SkRegion& region, SkRegion::Op rgnOp) {
- this->writeOp(kClipRegion_DrawOp, 0, rgnOp);
- writeRegion(&fWriter, region);
+ NOTIFY_SETUP(this);
+ if (this->needOpBytes(region.flatten(NULL))) {
+ this->writeOp(kClipRegion_DrawOp, 0, rgnOp);
+ writeRegion(&fWriter, region);
+ }
return this->INHERITED::clipRegion(region, rgnOp);
}
///////////////////////////////////////////////////////////////////////////////
void SkGPipeCanvas::clear(SkColor color) {
+ NOTIFY_SETUP(this);
unsigned flags = 0;
if (color) {
flags |= kClear_HasColor_DrawOpFlag;
}
- this->writeOp(kDrawClear_DrawOp, flags, 0);
- if (color) {
- fWriter.write32(color);
+ if (this->needOpBytes(sizeof(SkColor))) {
+ this->writeOp(kDrawClear_DrawOp, flags, 0);
+ if (color) {
+ fWriter.write32(color);
+ }
}
}
void SkGPipeCanvas::drawPaint(const SkPaint& paint) {
+ NOTIFY_SETUP(this);
unsigned paintIndex = this->writePaint(paint);
- this->writeOp(kDrawPaint_DrawOp, 0, paintIndex);
+ if (this->needOpBytes()) {
+ this->writeOp(kDrawPaint_DrawOp, 0, paintIndex);
+ }
}
void SkGPipeCanvas::drawPoints(PointMode mode, size_t count,
const SkPoint pts[], const SkPaint& paint) {
if (count) {
+ NOTIFY_SETUP(this);
unsigned paintIndex = this->writePaint(paint);
- this->writeOp(kDrawPoints_DrawOp, mode, paintIndex);
- fWriter.write32(count);
- fWriter.write(pts, count * sizeof(SkPoint));
+ if (this->needOpBytes(4 + count * sizeof(SkPoint))) {
+ this->writeOp(kDrawPoints_DrawOp, mode, paintIndex);
+ fWriter.write32(count);
+ fWriter.write(pts, count * sizeof(SkPoint));
+ }
}
}
void SkGPipeCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
+ NOTIFY_SETUP(this);
unsigned paintIndex = this->writePaint(paint);
- this->writeOp(kDrawRect_DrawOp, 0, paintIndex);
- fWriter.writeRect(rect);
+ if (this->needOpBytes(sizeof(SkRect))) {
+ this->writeOp(kDrawRect_DrawOp, 0, paintIndex);
+ fWriter.writeRect(rect);
+ }
}
void SkGPipeCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
+ NOTIFY_SETUP(this);
unsigned paintIndex = this->writePaint(paint);
- this->writeOp(kDrawPath_DrawOp, 0, paintIndex);
- path.flatten(fWriter);
+ if (this->needOpBytes(estimateFlattenSize(path))) {
+ this->writeOp(kDrawPath_DrawOp, 0, paintIndex);
+ path.flatten(fWriter);
+ }
}
void SkGPipeCanvas::drawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
@@ -293,25 +411,31 @@
void SkGPipeCanvas::drawText(const void* text, size_t byteLength, SkScalar x,
SkScalar y, const SkPaint& paint) {
if (byteLength) {
+ NOTIFY_SETUP(this);
unsigned paintIndex = this->writePaint(paint);
- this->writeOp(kDrawText_DrawOp, 0, paintIndex);
- fWriter.write32(byteLength);
- fWriter.writePad(text, byteLength);
- fWriter.writeScalar(x);
- fWriter.writeScalar(y);
+ if (this->needOpBytes(4 + SkAlign4(byteLength) + 2 * sizeof(SkScalar))) {
+ this->writeOp(kDrawText_DrawOp, 0, paintIndex);
+ fWriter.write32(byteLength);
+ fWriter.writePad(text, byteLength);
+ fWriter.writeScalar(x);
+ fWriter.writeScalar(y);
+ }
}
}
void SkGPipeCanvas::drawPosText(const void* text, size_t byteLength,
const SkPoint pos[], const SkPaint& paint) {
if (byteLength) {
+ NOTIFY_SETUP(this);
unsigned paintIndex = this->writePaint(paint);
- this->writeOp(kDrawPosText_DrawOp, 0, paintIndex);
- fWriter.write32(byteLength);
- fWriter.writePad(text, byteLength);
int count = paint.textToGlyphs(text, byteLength, NULL);
- fWriter.write32(count);
- fWriter.write(pos, count * sizeof(SkPoint));
+ if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkPoint))) {
+ this->writeOp(kDrawPosText_DrawOp, 0, paintIndex);
+ fWriter.write32(byteLength);
+ fWriter.writePad(text, byteLength);
+ fWriter.write32(count);
+ fWriter.write(pos, count * sizeof(SkPoint));
+ }
}
}
@@ -319,14 +443,17 @@
const SkScalar xpos[], SkScalar constY,
const SkPaint& paint) {
if (byteLength) {
+ NOTIFY_SETUP(this);
unsigned paintIndex = this->writePaint(paint);
- this->writeOp(kDrawPosTextH_DrawOp, 0, paintIndex);
- fWriter.write32(byteLength);
- fWriter.writePad(text, byteLength);
int count = paint.textToGlyphs(text, byteLength, NULL);
- fWriter.write32(count);
- fWriter.write(xpos, count * sizeof(SkScalar));
- fWriter.writeScalar(constY);
+ if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkScalar) + 4)) {
+ this->writeOp(kDrawPosTextH_DrawOp, 0, paintIndex);
+ fWriter.write32(byteLength);
+ fWriter.writePad(text, byteLength);
+ fWriter.write32(count);
+ fWriter.write(xpos, count * sizeof(SkScalar));
+ fWriter.writeScalar(constY);
+ }
}
}
@@ -334,19 +461,24 @@
const SkPath& path, const SkMatrix* matrix,
const SkPaint& paint) {
if (byteLength) {
+ NOTIFY_SETUP(this);
unsigned flags = 0;
+ size_t size = 4 + SkAlign4(byteLength) + estimateFlattenSize(path);
if (matrix) {
flags |= kDrawTextOnPath_HasMatrix_DrawOpFlag;
+ size += matrix->flatten(NULL);
}
unsigned paintIndex = this->writePaint(paint);
- this->writeOp(kDrawTextOnPath_DrawOp, flags, paintIndex);
+ if (this->needOpBytes(size)) {
+ this->writeOp(kDrawTextOnPath_DrawOp, flags, paintIndex);
- fWriter.write32(byteLength);
- fWriter.writePad(text, byteLength);
+ fWriter.write32(byteLength);
+ fWriter.writePad(text, byteLength);
- path.flatten(fWriter);
- if (matrix) {
- writeMatrix(&fWriter, *matrix);
+ path.flatten(fWriter);
+ if (matrix) {
+ writeMatrix(&fWriter, *matrix);
+ }
}
}
}
@@ -368,46 +500,57 @@
return;
}
+ NOTIFY_SETUP(this);
+ size_t size = 4 + vertexCount * sizeof(SkPoint);
unsigned paintIndex = this->writePaint(paint);
unsigned flags = 0;
if (texs) {
flags |= kDrawVertices_HasTexs_DrawOpFlag;
+ size += vertexCount * sizeof(SkPoint);
}
if (colors) {
flags |= kDrawVertices_HasColors_DrawOpFlag;
+ size += vertexCount * sizeof(SkColor);
}
if (indices && indexCount > 0) {
flags |= kDrawVertices_HasIndices_DrawOpFlag;
+ size += 4 + SkAlign4(indexCount * sizeof(uint16_t));
}
- this->writeOp(kDrawVertices_DrawOp, flags, paintIndex);
- fWriter.write32(mode);
- fWriter.write32(vertexCount);
- fWriter.write(vertices, vertexCount * sizeof(SkPoint));
- if (texs) {
- fWriter.write(texs, vertexCount * sizeof(SkPoint));
- }
- if (colors) {
- fWriter.write(colors, vertexCount * sizeof(SkColor));
- }
+ if (this->needOpBytes(size)) {
+ this->writeOp(kDrawVertices_DrawOp, flags, paintIndex);
+ fWriter.write32(mode);
+ fWriter.write32(vertexCount);
+ fWriter.write(vertices, vertexCount * sizeof(SkPoint));
+ if (texs) {
+ fWriter.write(texs, vertexCount * sizeof(SkPoint));
+ }
+ if (colors) {
+ fWriter.write(colors, vertexCount * sizeof(SkColor));
+ }
- // TODO: flatten xfermode
+ // TODO: flatten xfermode
- if (indices && indexCount > 0) {
- fWriter.write32(indexCount);
- fWriter.writePad(indices, indexCount * sizeof(uint16_t));
+ if (indices && indexCount > 0) {
+ fWriter.write32(indexCount);
+ fWriter.writePad(indices, indexCount * sizeof(uint16_t));
+ }
}
}
-void SkGPipeCanvas::drawData(const void* data, size_t size) {
- if (size) {
+void SkGPipeCanvas::drawData(const void* ptr, size_t size) {
+ if (size && ptr) {
+ NOTIFY_SETUP(this);
unsigned data = 0;
if (size < (1 << DRAWOPS_DATA_BITS)) {
data = (unsigned)size;
}
- this->writeOp(kDrawData_DrawOp, 0, data);
- if (0 == data) {
- fWriter.write32(size);
+ if (this->needOpBytes(4 + SkAlign4(size))) {
+ this->writeOp(kDrawData_DrawOp, 0, data);
+ if (0 == data) {
+ fWriter.write32(size);
+ }
+ fWriter.write(ptr, size);
}
}
}
@@ -487,9 +630,11 @@
*ptr++ = PaintOp_packOp(kTextSkewX_PaintOp);
*ptr++ = castToU32(paint.getTextSkewX());
}
- *fPaints[0] = paint;
- if (ptr > storage) {
+ size_t size = (char*)ptr - (char*)storage;
+ if (size && this->needOpBytes(size)) {
+ *fPaints[0] = paint;
+
this->writeOp(kPaintOp_DrawOp, 0, 0);
size_t size = (char*)ptr - (char*)storage;
*last |= kLastOp_PaintOpFlag << PAINTOPS_DATA_BITS;
@@ -505,19 +650,19 @@
#include "SkGPipe.h"
-#define MIN_WRITE_BLOCK_SIZE (4 * 1024)
-
-SkGPipeWriter::SkGPipeWriter() : fWriter(MIN_WRITE_BLOCK_SIZE) {
+SkGPipeWriter::SkGPipeWriter() : fWriter(0) {
fCanvas = NULL;
}
SkGPipeWriter::~SkGPipeWriter() {
+ this->endRecording();
SkSafeUnref(fCanvas);
}
-SkCanvas* SkGPipeWriter::startRecording() {
+SkCanvas* SkGPipeWriter::startRecording(SkGPipeController* controller) {
if (NULL == fCanvas) {
- fCanvas = SkNEW_ARGS(SkGPipeCanvas, (&fWriter));
+ fWriter.reset(NULL, 0);
+ fCanvas = SkNEW_ARGS(SkGPipeCanvas, (controller, &fWriter));
}
return fCanvas;
}
@@ -530,10 +675,3 @@
}
}
-size_t SkGPipeWriter::flatten(void* buffer) {
- if (buffer) {
- fWriter.flatten(buffer);
- }
- return fWriter.size();
-}
-