//////////////////////////////////////////////////////////////////////////////
DEF_GM( return SkNEW(ColorFiltersGM); )
+
* ignored.
*/
const void* peekPixels(SkImageInfo* info, size_t* rowBytes) const;
-
+
/**
* Encode the image's pixels and return the result as a new SkData, which
* the caller must manage (i.e. call unref() when they are done).
static SkPicture* CreateFromStream(SkStream*,
InstallPixelRefProc proc = &SkImageDecoder::DecodeMemory);
- /**
- * Recreate a picture that was serialized into a buffer. If the creation requires bitmap
- * decoding, the decoder must be set on the SkReadBuffer parameter by calling
- * SkReadBuffer::setBitmapDecoder() before calling SkPicture::CreateFromBuffer().
- * @param SkReadBuffer Serialized picture data.
- * @return A new SkPicture representing the serialized data, or NULL if the buffer is
- * invalid.
- */
- static SkPicture* CreateFromBuffer(SkReadBuffer&);
-
virtual ~SkPicture();
/**
void serialize(SkWStream*, EncodeBitmap encoder = NULL) const;
/**
- * Serialize to a buffer.
- */
- void flatten(SkWriteBuffer&) const;
-
- /**
* Returns true if any bitmaps may be produced when this SkPicture
* is replayed.
* Returns false if called while still recording.
// V17: SkPixelRef now writes SkImageInfo
// V18: SkBitmap now records x,y for its pixelref origin, instead of offset.
// V19: encode matrices and regions into the ops stream
- // V20: added bool to SkPictureImageFilter's serialization (to allow SkPicture serialization)
- static const uint32_t PICTURE_VERSION = 20;
+ static const uint32_t PICTURE_VERSION = 19;
// fPlayback, fRecord, fWidth & fHeight are protected to allow derived classes to
// install their own SkPicturePlayback-derived players,SkPictureRecord-derived
// will be ready to be parsed to create an SkPicturePlayback.
// If false is returned, SkPictInfo is unmodified.
static bool StreamIsSKP(SkStream*, SkPictInfo*);
- static bool BufferIsSKP(SkReadBuffer&, SkPictInfo*);
private:
- void createHeader(void* header) const;
-
friend class SkFlatPicture;
friend class SkPicturePlayback;
kG_Scale = 6,
kB_Scale = 12,
kA_Scale = 18,
-
+
kR_Trans = 4,
kG_Trans = 9,
kB_Trans = 14,
protected:
virtual ~SkPictureImageFilter();
- /* Constructs an SkPictureImageFilter object from an SkReadBuffer.
- * Note: If the SkPictureImageFilter object construction requires bitmap
- * decoding, the decoder must be set on the SkReadBuffer parameter by calling
- * SkReadBuffer::setBitmapDecoder() before calling this constructor.
- * @param SkReadBuffer Serialized picture data.
- */
- explicit SkPictureImageFilter(SkReadBuffer&);
+ explicit SkPictureImageFilter(SkReadBuffer& buffer);
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
return bitmap[R(2)];
}
-#ifdef SK_ALLOW_PICTUREIMAGEFILTER_SERIALIZATION
-static void drawSomething(SkCanvas* canvas) {
- SkPaint paint;
-
- canvas->save();
- canvas->scale(0.5f, 0.5f);
- canvas->drawBitmap(make_bitmap(), 0, 0, NULL);
- canvas->restore();
-
- const char beforeStr[] = "before circle";
- const char afterStr[] = "after circle";
-
- paint.setAntiAlias(true);
-
- paint.setColor(SK_ColorRED);
- canvas->drawData(beforeStr, sizeof(beforeStr));
- canvas->drawCircle(SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/3), paint);
- canvas->drawData(afterStr, sizeof(afterStr));
- paint.setColor(SK_ColorBLACK);
- paint.setTextSize(SkIntToScalar(kBitmapSize/3));
- canvas->drawText("Picture", 7, SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
-}
-#endif
-
static SkImageFilter* make_image_filter(bool canBeNull = true) {
SkImageFilter* filter = 0;
filter = new SkTileImageFilter(make_rect(), make_rect(), make_image_filter(false));
break;
case PICTURE:
- {
- SkPicture* pict = NULL;
-#ifdef SK_ALLOW_PICTUREIMAGEFILTER_SERIALIZATION
- pict = new SkPicture;
- SkAutoUnref aur(pict);
- drawSomething(pict->beginRecording(kBitmapSize, kBitmapSize));
- pict->endRecording();
-#endif
- filter = new SkPictureImageFilter(pict, make_rect());
- }
+ filter = new SkPictureImageFilter(NULL, make_rect());
break;
default:
break;
#include "SkStream.h"
static const char kMagic[] = { 's', 'k', 'i', 'a', 'p', 'i', 'c', 't' };
-static const size_t kHeaderSize = sizeof(kMagic) + sizeof(SkPictInfo);
bool SkPicture::StreamIsSKP(SkStream* stream, SkPictInfo* pInfo) {
if (NULL == stream) {
// Check magic bytes.
char magic[sizeof(kMagic)];
- if (!stream->read(magic, sizeof(kMagic)) ||
- (0 != memcmp(magic, kMagic, sizeof(kMagic)))) {
+ stream->read(magic, sizeof(kMagic));
+ if (0 != memcmp(magic, kMagic, sizeof(kMagic))) {
return false;
}
return true;
}
-bool SkPicture::BufferIsSKP(SkReadBuffer& buffer, SkPictInfo* pInfo) {
- // Check magic bytes.
- char magic[sizeof(kMagic)];
-
- if (!buffer.readByteArray(magic, sizeof(kMagic)) ||
- (0 != memcmp(magic, kMagic, sizeof(kMagic)))) {
- return false;
- }
-
- SkPictInfo info;
- if (!buffer.readByteArray(&info, sizeof(SkPictInfo))) {
- return false;
- }
-
- if (PICTURE_VERSION != info.fVersion) {
- return false;
- }
-
- if (pInfo != NULL) {
- *pInfo = info;
- }
- return true;
-}
-
SkPicture::SkPicture(SkPicturePlayback* playback, int width, int height)
: fPlayback(playback)
, fRecord(NULL)
return SkNEW_ARGS(SkPicture, (playback, info.fWidth, info.fHeight));
}
-SkPicture* SkPicture::CreateFromBuffer(SkReadBuffer& buffer) {
- SkPictInfo info;
-
- if (!BufferIsSKP(buffer, &info)) {
- return NULL;
- }
+void SkPicture::serialize(SkWStream* stream, EncodeBitmap encoder) const {
+ SkPicturePlayback* playback = fPlayback;
- SkPicturePlayback* playback;
- // Check to see if there is a playback to recreate.
- if (buffer.readBool()) {
- playback = SkPicturePlayback::CreateFromBuffer(buffer);
- if (NULL == playback) {
- return NULL;
- }
- } else {
- playback = NULL;
+ if (NULL == playback && fRecord) {
+ playback = SkNEW_ARGS(SkPicturePlayback, (*fRecord));
}
- return SkNEW_ARGS(SkPicture, (playback, info.fWidth, info.fHeight));
-}
+ SkPictInfo info;
-void SkPicture::createHeader(void* header) const {
- // Copy magic bytes at the beginning of the header
- SkASSERT(sizeof(kMagic) == 8);
- memcpy(header, kMagic, sizeof(kMagic));
-
- // Set piture info after magic bytes in the header
- SkPictInfo* info = (SkPictInfo*)(((char*)header) + sizeof(kMagic));
- info->fVersion = PICTURE_VERSION;
- info->fWidth = fWidth;
- info->fHeight = fHeight;
- info->fFlags = SkPictInfo::kCrossProcess_Flag;
+ info.fVersion = PICTURE_VERSION;
+ info.fWidth = fWidth;
+ info.fHeight = fHeight;
+ info.fFlags = SkPictInfo::kCrossProcess_Flag;
// TODO: remove this flag, since we're always float (now)
- info->fFlags |= SkPictInfo::kScalarIsFloat_Flag;
+ info.fFlags |= SkPictInfo::kScalarIsFloat_Flag;
if (8 == sizeof(void*)) {
- info->fFlags |= SkPictInfo::kPtrIs64Bit_Flag;
+ info.fFlags |= SkPictInfo::kPtrIs64Bit_Flag;
}
-}
-
-void SkPicture::serialize(SkWStream* stream, EncodeBitmap encoder) const {
- SkPicturePlayback* playback = fPlayback;
- if (NULL == playback && fRecord) {
- playback = SkNEW_ARGS(SkPicturePlayback, (*fRecord));
- }
+ // Write 8 magic bytes to ID this file format.
+ SkASSERT(sizeof(kMagic) == 8);
+ stream->write(kMagic, sizeof(kMagic));
- char header[kHeaderSize];
- createHeader(&header);
- stream->write(header, kHeaderSize);
+ stream->write(&info, sizeof(info));
if (playback) {
stream->writeBool(true);
playback->serialize(stream, encoder);
}
}
-void SkPicture::flatten(SkWriteBuffer& buffer) const {
- SkPicturePlayback* playback = fPlayback;
-
- if (NULL == playback && fRecord) {
- playback = SkNEW_ARGS(SkPicturePlayback, (*fRecord));
- }
-
- char header[kHeaderSize];
- createHeader(&header);
- buffer.writeByteArray(header, kHeaderSize);
- if (playback) {
- buffer.writeBool(true);
- playback->flatten(buffer);
- // delete playback if it is a local version (i.e. cons'd up just now)
- if (playback != fPlayback) {
- SkDELETE(playback);
- }
- } else {
- buffer.writeBool(false);
- }
-}
-
bool SkPicture::willPlayBackBitmaps() const {
if (!fPlayback) return false;
return fPlayback->containsBitmaps();
stream->write32(PICT_EOF_TAG);
}
-void SkPicturePlayback::flatten(SkWriteBuffer& buffer) const {
- writeTagSize(buffer, PICT_READER_TAG, fOpData->size());
- buffer.writeByteArray(fOpData->bytes(), fOpData->size());
-
- if (fPictureCount > 0) {
- writeTagSize(buffer, PICT_PICTURE_TAG, fPictureCount);
- for (int i = 0; i < fPictureCount; i++) {
- fPictureRefs[i]->flatten(buffer);
- }
- }
-
- // Write this picture playback's data into a writebuffer
- this->flattenToBuffer(buffer);
- buffer.write32(PICT_EOF_TAG);
-}
-
///////////////////////////////////////////////////////////////////////////////
/**
return playback.detach();
}
-SkPicturePlayback* SkPicturePlayback::CreateFromBuffer(SkReadBuffer& buffer) {
- SkAutoTDelete<SkPicturePlayback> playback(SkNEW(SkPicturePlayback));
-
- if (!playback->parseBuffer(buffer)) {
- return NULL;
- }
- return playback.detach();
-}
-
bool SkPicturePlayback::parseStream(SkStream* stream, const SkPictInfo& info,
SkPicture::InstallPixelRefProc proc) {
for (;;) {
return true;
}
-bool SkPicturePlayback::parseBuffer(SkReadBuffer& buffer) {
- for (;;) {
- uint32_t tag = buffer.readUInt();
- if (PICT_EOF_TAG == tag) {
- break;
- }
-
- uint32_t size = buffer.readUInt();
- if (!this->parseBufferTag(buffer, tag, size)) {
- return false; // we're invalid
- }
- }
- return true;
-}
-
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
explicit SkPicturePlayback(const SkPictureRecord& record, bool deepCopy = false);
static SkPicturePlayback* CreateFromStream(SkStream*, const SkPictInfo&,
SkPicture::InstallPixelRefProc);
- static SkPicturePlayback* CreateFromBuffer(SkReadBuffer&);
virtual ~SkPicturePlayback();
void draw(SkCanvas& canvas, SkDrawPictureCallback*);
void serialize(SkWStream*, SkPicture::EncodeBitmap) const;
- void flatten(SkWriteBuffer&) const;
void dumpSize() const;
protected:
bool parseStream(SkStream*, const SkPictInfo&,
SkPicture::InstallPixelRefProc);
- bool parseBuffer(SkReadBuffer& buffer);
#ifdef SK_DEVELOPER
virtual bool preDraw(int opIndex, int type);
virtual void postDraw(int opIndex);
SkPictureImageFilter::SkPictureImageFilter(SkReadBuffer& buffer)
: INHERITED(0, buffer),
fPicture(NULL) {
-#ifdef SK_ALLOW_PICTUREIMAGEFILTER_SERIALIZATION
- if (buffer.readBool()) {
- fPicture = SkPicture::CreateFromBuffer(buffer);
- }
-#else
- buffer.readBool();
-#endif
+ // FIXME: unflatten picture here.
buffer.readRect(&fRect);
}
void SkPictureImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
-#ifdef SK_ALLOW_PICTUREIMAGEFILTER_SERIALIZATION
- bool hasPicture = (fPicture != NULL);
- buffer.writeBool(hasPicture);
- if (hasPicture) {
- fPicture->flatten(buffer);
- }
-#else
- buffer.writeBool(false);
-#endif
+ // FIXME: flatten picture here.
buffer.writeRect(fRect);
}
if (NULL == bitmap) {
return false;
}
-
+
SkIRect bounds = SkIRect::MakeWH(this->width(), this->height());
// trim against the bitmap, if its already been allocated
srcR.set(subset);
dstR = srcR;
dstR.offset(-dstR.left(), -dstR.top());
-
+
SkCanvas canvas(*bitmap);
SkPaint paint;
const_cast<SkImage_Base*>(this)->onDrawRectToRect(&canvas, &srcR, dstR, NULL);
return true;
}
+
// Structure methods only directly emit save and restores but call the
// ModelClip and Body helper methods to fill in the structure. Since they only
// emit saves and restores the operations emitted by the structure methods will
-// be completely removed by the matrix/clip collapse. Note: every save in
+// be completely removed by the matrix/clip collapse. Note: every save in
// a structure method is followed by a call to a ModelClip helper.
//
// Body methods only directly emit draw ops and saveLayer/restore pairs but call
// followed by a call to a ModelClip helper.
//
// The ModelClip methods output matrix and clip ops in various orders and
-// combinations. They contribute to the expected result by outputting the
+// combinations. They contribute to the expected result by outputting the
// expected matrix & clip ops. Note that, currently, the entire clip stack
// is output for each MC state so the clip operations accumulate down the
// save/restore stack.
// operations' offsets point to the correct follow-on operations. This
// could be difficult since there is no good way to communicate the
// offset stored in the SkPicture to the debugger's clip objects
-// add comparison of rendered before & after images?
+// add comparison of rendered before & after images?
// - not sure if this would be useful since it somewhat duplicates the
// correctness test of running render_pictures in record mode and
// rendering before and after images. Additionally the matrix/clip collapse
static const int kDrawOpTypeCount = kLast_DrawOpType + 1;
-typedef void (*PFEmitMC)(SkCanvas* canvas, MatType mat, ClipType clip,
- DrawOpType draw, SkTDArray<DrawType>* expected,
+typedef void (*PFEmitMC)(SkCanvas* canvas, MatType mat, ClipType clip,
+ DrawOpType draw, SkTDArray<DrawType>* expected,
int accumulatedClips);
-typedef void (*PFEmitBody)(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
- ClipType clip, DrawOpType draw,
+typedef void (*PFEmitBody)(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
+ ClipType clip, DrawOpType draw,
SkTDArray<DrawType>* expected, int accumulatedClips);
-typedef void (*PFEmitStruct)(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
- ClipType clip, PFEmitBody emitBody, DrawOpType draw,
+typedef void (*PFEmitStruct)(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
+ ClipType clip, PFEmitBody emitBody, DrawOpType draw,
SkTDArray<DrawType>* expected);
//////////////////////////////////////////////////////////////////////////////
case kSkew_MatType: // fall thru
case kRotate_MatType: // fall thru
case kConcat_MatType: // fall thru
- case kSetMatrix_MatType:
+ case kSetMatrix_MatType:
// TODO: this system currently converts a setMatrix to concat. If we wanted to
// really preserve the setMatrix semantics we should keep it a setMatrix. I'm
// not sure if this is a good idea though since this would keep things like pinch
default:
SkASSERT(0);
}
-}
+}
static void emit_draw(SkCanvas* canvas, DrawOpType draw, SkTDArray<DrawType>* expected) {
switch (draw) {
// clip
// matrix
// Simple case - the clip isn't effect by the matrix
-static void emit_clip_and_mat(SkCanvas* canvas, MatType mat, ClipType clip,
- DrawOpType draw, SkTDArray<DrawType>* expected,
+static void emit_clip_and_mat(SkCanvas* canvas, MatType mat, ClipType clip,
+ DrawOpType draw, SkTDArray<DrawType>* expected,
int accumulatedClips) {
if (kNone_DrawOpType == draw) {
return;
// clip
// Emitting the matrix first is more challenging since the matrix has to be
// pushed across (i.e., applied to) the clip.
-static void emit_mat_and_clip(SkCanvas* canvas, MatType mat, ClipType clip,
- DrawOpType draw, SkTDArray<DrawType>* expected,
+static void emit_mat_and_clip(SkCanvas* canvas, MatType mat, ClipType clip,
+ DrawOpType draw, SkTDArray<DrawType>* expected,
int accumulatedClips) {
if (kNone_DrawOpType == draw) {
return;
// matrix
// clip
// This tests that the matrices and clips coalesce when collapsed
-static void emit_double_mat_and_clip(SkCanvas* canvas, MatType mat, ClipType clip,
- DrawOpType draw, SkTDArray<DrawType>* expected,
+static void emit_double_mat_and_clip(SkCanvas* canvas, MatType mat, ClipType clip,
+ DrawOpType draw, SkTDArray<DrawType>* expected,
int accumulatedClips) {
if (kNone_DrawOpType == draw) {
return;
if (kNone_DrawOpType == draw) {
return;
}
-
+
emit_mat(canvas, mat);
emit_clip(canvas, clip);
emit_clip(canvas, clip);
// Emit:
// matrix & clip calls
// draw op
-static void emit_body0(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
+static void emit_body0(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
ClipType clip, DrawOpType draw,
SkTDArray<DrawType>* expected, int accumulatedClips) {
- bool needsSaveRestore = kNone_DrawOpType != draw &&
+ bool needsSaveRestore = kNone_DrawOpType != draw &&
(kNone_MatType != mat || kNone_ClipType != clip);
if (needsSaveRestore) {
// draw op
// matrix & clip calls
// draw op
-static void emit_body1(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
+static void emit_body1(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
ClipType clip, DrawOpType draw,
SkTDArray<DrawType>* expected, int accumulatedClips) {
- bool needsSaveRestore = kNone_DrawOpType != draw &&
+ bool needsSaveRestore = kNone_DrawOpType != draw &&
(kNone_MatType != mat || kNone_ClipType != clip);
if (needsSaveRestore) {
// matrix & clip calls
// draw op
// Restore
-static void emit_body2(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
+static void emit_body2(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
ClipType clip, DrawOpType draw,
SkTDArray<DrawType>* expected, int accumulatedClips) {
- bool needsSaveRestore = kNone_DrawOpType != draw &&
+ bool needsSaveRestore = kNone_DrawOpType != draw &&
(kNone_MatType != mat || kNone_ClipType != clip);
if (needsSaveRestore) {
// Restore
// matrix & clip calls (will be ignored)
// Restore
-static void emit_body3(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
+static void emit_body3(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
ClipType clip, DrawOpType draw,
SkTDArray<DrawType>* expected, int accumulatedClips) {
- bool needsSaveRestore = kNone_DrawOpType != draw &&
+ bool needsSaveRestore = kNone_DrawOpType != draw &&
(kNone_MatType != mat || kNone_ClipType != clip);
- // This saveLayer will always be forced b.c. we currently can't tell
+ // This saveLayer will always be forced b.c. we currently can't tell
// ahead of time if it will be empty (see comment in SkMatrixClipStateMgr::save)
*expected->append() = SAVE_LAYER;
// some body
// Restore
// Note: the outer save/restore are provided by beginRecording/endRecording
-static void emit_struct0(SkCanvas* canvas,
+static void emit_struct0(SkCanvas* canvas,
PFEmitMC emitMC, MatType mat, ClipType clip,
PFEmitBody emitBody, DrawOpType draw,
SkTDArray<DrawType>* expected) {
// matrix & clip calls (will be ignored)
// Restore
// Note: the outer save/restore are provided by beginRecording/endRecording
-static void emit_struct1(SkCanvas* canvas,
+static void emit_struct1(SkCanvas* canvas,
PFEmitMC emitMC, MatType mat, ClipType clip,
PFEmitBody emitBody, DrawOpType draw,
SkTDArray<DrawType>* expected) {
// matrix & clip calls (will be ignored)
// Restore
// Note: the outer save/restore are provided by beginRecording/endRecording
-static void emit_struct2(SkCanvas* canvas,
+static void emit_struct2(SkCanvas* canvas,
PFEmitMC emitMC, MatType mat, ClipType clip,
PFEmitBody emitBody, DrawOpType draw,
SkTDArray<DrawType>* expected) {
// matrix & clip calls (will be ignored)
// Restore
// Note: the outer save/restore are provided by beginRecording/endRecording
-static void emit_struct3(SkCanvas* canvas,
+static void emit_struct3(SkCanvas* canvas,
PFEmitMC emitMC, MatType mat, ClipType clip,
PFEmitBody emitBody, DrawOpType draw,
SkTDArray<DrawType>* expected) {
static void test_collapse(skiatest::Reporter* reporter) {
PFEmitStruct gStructure[] = { emit_struct0, emit_struct1, emit_struct2, emit_struct3 };
PFEmitBody gBody[] = { emit_body0, emit_body1, emit_body2, emit_body3 };
- PFEmitMC gMCs[] = { emit_clip_and_mat, emit_mat_and_clip,
+ PFEmitMC gMCs[] = { emit_clip_and_mat, emit_mat_and_clip,
emit_double_mat_and_clip, emit_mat_clip_clip };
for (size_t i = 0; i < SK_ARRAY_COUNT(gStructure); ++i) {
// Note: beginRecording/endRecording add a save/restore pair
SkCanvas* canvas = picture.beginRecording(100, 100);
- (*gStructure[i])(canvas,
- gMCs[k],
+ (*gStructure[i])(canvas,
+ gMCs[k],
(MatType) l,
(ClipType) m,
- gBody[j],
- (DrawOpType) n,
+ gBody[j],
+ (DrawOpType) n,
&expected);
picture.endRecording();
size_t size = info.getSafeSize(rowBytes);
void* addr = sk_malloc_throw(size);
SkData* data = SkData::NewFromMalloc(addr, size);
-
+
REPORTER_ASSERT(reporter, 1 == data->getRefCnt());
SkImage* image = SkImage::NewRasterData(info, data, rowBytes);
REPORTER_ASSERT(reporter, 2 == data->getRefCnt());
for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
SkImageInfo info;
size_t rowBytes;
-
+
SkAutoTUnref<SkImage> image(createImage(gRec[i].fType, NULL, color));
if (!image.get()) {
continue; // gpu may not be enabled
projects / platform / upstream / libSkiaSharp.git / commitdiff