// Add several layers to the cache static void create_layers(skiatest::Reporter* reporter, GrLayerCache* cache, const SkPicture& picture, unsigned numToAdd, unsigned idOffset) { for (unsigned i = 0; i < numToAdd; ++i) { unsigned indices[1] = { idOffset+i+1 }; GrCachedLayer* layer = cache->findLayerOrCreate(picture.uniqueID(), idOffset+i+1, idOffset+i+2, SkIRect::MakeEmpty(), SkIRect::MakeEmpty(), SkMatrix::I(), indices, 1, NULL); REPORTER_ASSERT(reporter, layer); GrCachedLayer* temp = TestingAccess::Find(cache, picture.uniqueID(), SkMatrix::I(), indices, 1); REPORTER_ASSERT(reporter, temp == layer); REPORTER_ASSERT(reporter, TestingAccess::NumLayers(cache) == idOffset + i + 1); REPORTER_ASSERT(reporter, picture.uniqueID() == layer->pictureID()); REPORTER_ASSERT(reporter, layer->start() == idOffset + i + 1); REPORTER_ASSERT(reporter, layer->stop() == idOffset + i + 2); REPORTER_ASSERT(reporter, NULL == layer->texture()); REPORTER_ASSERT(reporter, NULL == layer->paint()); REPORTER_ASSERT(reporter, !layer->isAtlased()); } }
static SkPicture* inspect(const char path[]) { SkFILEStream stream(path); if (!stream.isValid()) { printf("-- Can't open '%s'\n", path); return nullptr; } printf("Opening '%s'...\n", path); { int32_t header[3]; if (stream.read(header, sizeof(header)) != sizeof(header)) { printf("-- Failed to read header (12 bytes)\n"); return nullptr; } printf("version:%d width:%d height:%d\n", header[0], header[1], header[2]); } stream.rewind(); SkPicture* pic = SkPicture::CreateFromStream(&stream); if (nullptr == pic) { SkDebugf("Could not create SkPicture: %s\n", path); return nullptr; } printf("picture cullRect: [%f %f %f %f]\n", pic->cullRect().fLeft, pic->cullRect().fTop, pic->cullRect().fRight, pic->cullRect().fBottom); return pic; }
void ImageBuffer::copyRecordingToCanvas(GraphicsContext* paintContext, const IntRect& r) const { SkCanvas* paintCanvas = paintContext->platformContext()->mCanvas; SkPicture* canvasRecording = context()->platformContext()->getRecordingPicture(); SkPaint paint; paint.setXfermodeMode(SkXfermode::kSrcOver_Mode); const SkIRect& clipBounds = paintCanvas->getTotalClip().getBounds(); SkRect rect; int saveCount = 0; if( (clipBounds.width() > r.width() * 2 ) || (clipBounds.height() > r.height() * 2)) { rect.set(r.location().x(), r.location().y(),r.width(), r.height()); saveCount = paintCanvas->saveLayer(&rect, &paint); } else saveCount = paintCanvas->saveLayer(0, &paint); paintCanvas->translate(r.location().x(), r.location().y()); // Resize to the now known viewport. paintCanvas->scale(r.width() / width(), r.height() / height()); // Draw the canvas recording into the layer recording canvas. canvasRecording->draw(paintCanvas); context()->platformContext()->clearRecording(); paintCanvas->restoreToCount(saveCount); }
virtual void onDraw(SkCanvas* canvas) { this->drawBG(canvas); SkMatrix saveM = *fMatrixRefs[3]; SkScalar c = SkIntToScalar(50); fMatrixRefs[3]->preRotate(SkIntToScalar(30), c, c); SkMatrix matrix; SkGroupShape* gs = new SkGroupShape; SkAutoUnref aur(gs); gs->appendShape(&fGroup); matrix.setScale(-SK_Scalar1, SK_Scalar1); matrix.postTranslate(SkIntToScalar(220), SkIntToScalar(240)); gs->appendShape(&fGroup, matrix); matrix.setTranslate(SkIntToScalar(240), 0); matrix.preScale(SK_Scalar1*2, SK_Scalar1*2); gs->appendShape(&fGroup, matrix); #if 0 canvas->drawShape(gs); #else SkPicture pict; SkCanvas* cv = pict.beginRecording(1000, 1000); cv->scale(SK_ScalarHalf, SK_ScalarHalf); cv->drawShape(gs); cv->translate(SkIntToScalar(680), SkIntToScalar(480)); cv->scale(-SK_Scalar1, SK_Scalar1); cv->drawShape(gs); pict.endRecording(); canvas->drawPicture(pict); #endif *fMatrixRefs[3] = saveM; }
virtual void onDraw(SkCanvas* canvas) { this->drawBG(canvas); SkMatrix matrix; SkGroupShape* gs = new SkGroupShape; SkAutoUnref aur(gs); gs->appendShape(&fGroup); matrix.setScale(-SK_Scalar1, SK_Scalar1); matrix.postTranslate(SkIntToScalar(220), SkIntToScalar(240)); gs->appendShape(&fGroup, matrix); matrix.setTranslate(SkIntToScalar(240), 0); matrix.preScale(SK_Scalar1*2, SK_Scalar1*2); gs->appendShape(&fGroup, matrix); #if 1 SkPicture* pict = new SkPicture; SkCanvas* cv = pict->beginRecording(1000, 1000); cv->scale(SK_ScalarHalf, SK_ScalarHalf); gs->draw(cv); cv->translate(SkIntToScalar(680), SkIntToScalar(480)); cv->scale(-SK_Scalar1, SK_Scalar1); gs->draw(cv); pict->endRecording(); canvas->drawPicture(*pict); pict->unref(); #endif }
static bool nativeSerializeViewState(JNIEnv* env, jobject, jint jbaseLayer, jobject jstream, jbyteArray jstorage) { BaseLayerAndroid* baseLayer = (BaseLayerAndroid*) jbaseLayer; if (!baseLayer) return false; SkWStream *stream = CreateJavaOutputStreamAdaptor(env, jstream, jstorage); #if USE(ACCELERATED_COMPOSITING) // SAMSUNG CHANGE >> White flickering issue. // WAS:stream->write32(baseLayer->getBackgroundColor().rgb()); stream->write32(baseLayer->getBackgroundColor()); // SAMSUNG CHANGE << #else stream->write32(0); #endif SkPicture picture; PictureSet* content = baseLayer->content(); baseLayer->drawCanvas(picture.beginRecording(content->width(), content->height(), SkPicture::kUsePathBoundsForClip_RecordingFlag)); picture.endRecording(); if (!stream) return false; picture.serialize(stream); int childCount = baseLayer->countChildren(); XLOG("BaseLayer has %d child(ren)", childCount); stream->write32(childCount); for (int i = 0; i < childCount; i++) { LayerAndroid* layer = static_cast<LayerAndroid*>(baseLayer->getChild(i)); serializeLayer(layer, stream); } delete stream; return true; }
static SkPicture* inspect(const char path[]) { SkFILEStream stream(path); if (!stream.isValid()) { printf("-- Can't open '%s'\n", path); return NULL; } printf("Opening '%s'...\n", path); { int32_t header[3]; if (stream.read(header, sizeof(header)) != sizeof(header)) { printf("-- Failed to read header (12 bytes)\n"); return NULL; } printf("version:%d width:%d height:%d\n", header[0], header[1], header[2]); } stream.rewind(); SkPicture* pic = SkPicture::CreateFromStream(&stream, &sk_tools::LazyDecodeBitmap); if (NULL == pic) { SkDebugf("Could not create SkPicture: %s\n", path); return NULL; } printf("picture size:[%d %d]\n", pic->width(), pic->height()); return pic; }
// Ensure that serializing an empty picture does not assert. Likewise only runs in debug mode. static void test_serializing_empty_picture() { SkPicture picture; picture.beginRecording(0, 0); picture.endRecording(); SkDynamicMemoryWStream stream; picture.serialize(&stream); }
static SkData* serialized_picture_from_bitmap(const SkBitmap& bitmap) { SkPicture picture; SkCanvas* canvas = picture.beginRecording(bitmap.width(), bitmap.height()); canvas->drawBitmap(bitmap, 0, 0); SkDynamicMemoryWStream wStream; picture.serialize(&wStream, &encode_bitmap_to_data); return wStream.copyToData(); }
static SkBitmap draw_picture(SkPicture& picture) { SkBitmap bitmap; bitmap.allocN32Pixels(SkScalarCeilToInt(picture.cullRect().width()), SkScalarCeilToInt(picture.cullRect().height())); SkCanvas canvas(bitmap); picture.playback(&canvas); return bitmap; }
static void draw(JNIEnv* env, jobject, jlong canvasHandle, jlong pictureHandle) { SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); SkPicture* picture = reinterpret_cast<SkPicture*>(pictureHandle); SkASSERT(canvas); SkASSERT(picture); picture->draw(canvas); }
bool ImageBuffer::canUseGpuRendering() { SkPicture* canvasRecording = context()->platformContext()->getRecordingPicture(); if(canvasRecording != NULL) return canvasRecording->canUseGpuRendering(); else return false; }
void SkDumpCanvas::drawPicture(SkPicture& picture) { this->dump(kDrawPicture_Verb, NULL, "drawPicture(%p) %d:%d", &picture, picture.width(), picture.height()); fNestLevel += 1; this->INHERITED::drawPicture(picture); fNestLevel -= 1; this->dump(kDrawPicture_Verb, NULL, "endPicture(%p) %d:%d", &picture, picture.width(), picture.height()); }
// Ensure that deleting SkPicturePlayback does not assert. Asserts only fire in debug mode, so only // run in debug mode. static void test_deleting_empty_playback() { SkPicture picture; // Creates an SkPictureRecord picture.beginRecording(0, 0); // Turns that into an SkPicturePlayback picture.endRecording(); // Deletes the old SkPicturePlayback, and creates a new SkPictureRecord picture.beginRecording(0, 0); }
void PicturePileLayerContent::serialize(SkWStream* stream) { if (!stream) return; SkPicture picture; draw(picture.beginRecording(width(), height(), SkPicture::kUsePathBoundsForClip_RecordingFlag)); picture.endRecording(); picture.serialize(stream); }
// Extract the command ops from the input SkPicture static void gets_ops(SkPicture& input, SkTDArray<DrawType>* ops) { SkDebugCanvas debugCanvas(input.width(), input.height()); debugCanvas.setBounds(input.width(), input.height()); input.draw(&debugCanvas); ops->setCount(debugCanvas.getSize()); for (int i = 0; i < debugCanvas.getSize(); ++i) { (*ops)[i] = debugCanvas.getDrawCommandAt(i)->getType(); } }
// Return a picture with the bitmaps drawn at the specified positions. static SkPicture* record_bitmaps(const SkBitmap bm[], const SkPoint pos[], int count, DrawBitmapProc proc) { SkPicture* pic = new SkPicture; SkCanvas* canvas = pic->beginRecording(1000, 1000); for (int i = 0; i < count; ++i) { proc(canvas, bm[i], pos[i]); } pic->endRecording(); return pic; }
static bool render_picture(const SkString& inputPath, const SkString* outputDir, sk_tools::PictureRenderer& renderer, SkBitmap** out, int clones) { SkString inputFilename; sk_tools::get_basename(&inputFilename, inputPath); SkFILEStream inputStream; inputStream.setPath(inputPath.c_str()); if (!inputStream.isValid()) { SkDebugf("Could not open file %s\n", inputPath.c_str()); return false; } bool success = false; SkPicture* picture = SkNEW_ARGS(SkPicture, (&inputStream, &success, &SkImageDecoder::DecodeStream)); if (!success) { SkDebugf("Could not read an SkPicture from %s\n", inputPath.c_str()); return false; } for (int i = 0; i < clones; ++i) { SkPicture* clone = picture->clone(); SkDELETE(picture); picture = clone; } SkDebugf("drawing... [%i %i] %s\n", picture->width(), picture->height(), inputPath.c_str()); renderer.init(picture); renderer.setup(); SkString* outputPath = NULL; if (NULL != outputDir) { outputPath = SkNEW(SkString); make_output_filepath(outputPath, *outputDir, inputFilename); } success = renderer.render(outputPath, out); if (outputPath) { if (!success) { SkDebugf("Could not write to file %s\n", outputPath->c_str()); } SkDELETE(outputPath); } renderer.resetState(); renderer.end(); SkDELETE(picture); return success; }
static jlong beginRecording(JNIEnv* env, jobject, jlong pictHandle, jint w, jint h) { SkPicture* pict = reinterpret_cast<SkPicture*>(pictHandle); // beginRecording does not ref its return value, it just returns it. SkCanvas* canvas = pict->beginRecording(w, h); // the java side will wrap this guy in a Canvas.java, which will call // unref in its finalizer, so we have to ref it here, so that both that // Canvas.java and our picture can both be owners canvas->ref(); return reinterpret_cast<jlong>(canvas); }
static jboolean serialize(JNIEnv* env, jobject, jlong pictureHandle, jobject jstream, jbyteArray jstorage) { SkPicture* picture = reinterpret_cast<SkPicture*>(pictureHandle); SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage); if (NULL != strm) { picture->serialize(strm); delete strm; return JNI_TRUE; } return JNI_FALSE; }
static void testOne(const SkString& filename) { #if DEBUG_SHOW_TEST_NAME SkString testName(filename); const char http[] = "http"; if (testName.startsWith(http)) { testName.remove(0, sizeof(http) - 1); } while (testName.startsWith("_")) { testName.remove(0, 1); } const char dotSkp[] = ".skp"; if (testName.endsWith(dotSkp)) { size_t len = testName.size(); testName.remove(len - (sizeof(dotSkp) - 1), sizeof(dotSkp) - 1); } testName.prepend("skp"); testName.append("1"); strncpy(DEBUG_FILENAME_STRING, testName.c_str(), DEBUG_FILENAME_STRING_LENGTH); #endif SkString path; make_filepath(&path, pictDir, filename); SkFILEStream stream(path.c_str()); if (!stream.isValid()) { return; } SkPicture* pic = SkPicture::CreateFromStream(&stream, &SkImageDecoder::DecodeMemory); if (!pic) { SkDebugf("unable to decode %s\n", filename.c_str()); return; } int width = pic->width(); int height = pic->height(); SkBitmap bitmap; bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height); bool success = bitmap.allocPixels(); if (!success) { SkDebugf("unable to allocate bitmap for %s\n", filename.c_str()); return; } SkCanvas canvas(bitmap); SkString pngName(filename); pngName.remove(pngName.size() - 3, 3); pngName.append("png"); for (int i = 0; i < 2; ++i) { bool useOp = i ? true : false; canvas.setAllowSimplifyClip(useOp); pic->draw(&canvas); SkString outFile; make_filepath(&outFile, useOp ? outSkpClipDir : outOldClipDir, pngName); SkImageEncoder::EncodeFile(outFile.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100); } SkDELETE(pic); }
/** Converts fPicture to a picture that uses a BBoxHierarchy. * PictureRenderer subclasses that are used to test picture playback * should call this method during init. */ void PictureRenderer::buildBBoxHierarchy() { SkASSERT(NULL != fPicture); if (kNone_BBoxHierarchyType != fBBoxHierarchyType && NULL != fPicture) { SkPicture* newPicture = this->createPicture(); SkCanvas* recorder = newPicture->beginRecording(fPicture->width(), fPicture->height(), this->recordFlags()); fPicture->draw(recorder); newPicture->endRecording(); fPicture->unref(); fPicture = newPicture; } }
static SkPicture* LoadPdf(const char path[]) { SkAutoTDelete<SkPdfRenderer> renderer(SkPdfRenderer::CreateFromFile(path)); if (NULL == renderer.get()) { return NULL; } SkPicture* pic = SkNEW(SkPicture); SkCanvas* canvas = pic->beginRecording((int) renderer->MediaBox(0).width(), (int) renderer->MediaBox(0).height()); renderer->renderPage(0, canvas, renderer->MediaBox(0)); pic->endRecording(); return pic; }
void drawpicture(SkCanvas* canvas, SkPicture& pict) { #if 0 SkDynamicMemoryWStream ostream; pict.serialize(&ostream); SkMemoryStream istream(ostream.getStream(), ostream.getOffset()); SkPicture* newPict = new SkPicture(&istream); canvas->drawPicture(*newPict); newPict->unref(); #else canvas->drawPicture(pict); #endif }
// Only test this is in release mode. We deliberately crash in debug mode, since a valid caller // should never do this. static void test_bad_bitmap() { // This bitmap has a width and height but no pixels. As a result, attempting to record it will // fail. SkBitmap bm; bm.setConfig(SkBitmap::kARGB_8888_Config, 100, 100); SkPicture picture; SkCanvas* recordingCanvas = picture.beginRecording(100, 100); recordingCanvas->drawBitmap(bm, 0, 0); picture.endRecording(); SkCanvas canvas; canvas.drawPicture(picture); }
virtual void onDrawContent(SkCanvas* canvas) { SkPaint paint; paint.setShader(fGrad); // canvas->translate(this->width()/2, this->height()/2); canvas->translate(64, 64); canvas->drawPaint(paint); SkPicture pic; SkCanvas* c = pic.beginRecording(100, 100, 0); SkCanvas::LayerIter layerIterator(c, false); layerIterator.next(); layerIterator.done(); }
static void bench_record(SkPicture* src, const char* name) { const SkMSec start = SkTime::GetMSecs(); const int width = src ? src->width() : FLAGS_nullSize; const int height = src ? src->height() : FLAGS_nullSize; for (int i = 0; i < FLAGS_loops; i++) { SkPicture dst; SkCanvas* canvas = dst.beginRecording(width, height, FLAGS_flags); if (src) src->draw(canvas); if (FLAGS_endRecording) dst.endRecording(); } const SkMSec elapsed = SkTime::GetMSecs() - start; const double msPerLoop = elapsed / (double)FLAGS_loops; printf("%.2g\t%s\n", msPerLoop, name); }
// Add several layers to the cache static void create_layers(skiatest::Reporter* reporter, GrLayerCache* cache, const SkPicture& picture, int numToAdd, int idOffset) { for (int i = 0; i < numToAdd; ++i) { GrCachedLayer* layer = cache->findLayerOrCreate(&picture, idOffset+i+1, idOffset+i+2, SkMatrix::I()); REPORTER_ASSERT(reporter, NULL != layer); GrCachedLayer* temp = cache->findLayer(&picture, idOffset+i+1, idOffset+i+2, SkMatrix::I()); REPORTER_ASSERT(reporter, temp == layer); REPORTER_ASSERT(reporter, TestingAccess::NumLayers(cache) == idOffset + i + 1); REPORTER_ASSERT(reporter, picture.uniqueID() == layer->pictureID()); REPORTER_ASSERT(reporter, layer->start() == idOffset + i + 1); REPORTER_ASSERT(reporter, layer->stop() == idOffset + i + 2); REPORTER_ASSERT(reporter, layer->ctm() == SkMatrix::I()); REPORTER_ASSERT(reporter, NULL == layer->texture()); REPORTER_ASSERT(reporter, !layer->isAtlased()); } cache->trackPicture(&picture); }
static void draw(const EXPERIMENTAL::SkPlayback& skr, const SkPicture& skp, SkCanvas* canvas) { if (FLAGS_skr) { skr.draw(canvas); } else { skp.draw(canvas); } }
virtual void onDrawContent(SkCanvas* canvas) { SkScalar angle = SampleCode::GetAnimScalar(SkIntToScalar(180), SkIntToScalar(360)); SkMatrix saveM = *fMatrixRefs[3]; SkScalar c = SkIntToScalar(50); fMatrixRefs[3]->preRotate(angle, c, c); const SkScalar dx = 350; const SkScalar dy = 500; const int N = 1; for (int v = -N; v <= N; v++) { for (int h = -N; h <= N; h++) { SkAutoCanvasRestore acr(canvas, true); canvas->translate(h * dx, v * dy); SkMatrix matrix; SkGroupShape* gs = new SkGroupShape; SkAutoUnref aur(gs); gs->appendShape(&fGroup); matrix.setScale(-SK_Scalar1, SK_Scalar1); matrix.postTranslate(SkIntToScalar(220), SkIntToScalar(240)); gs->appendShape(&fGroup, matrix); matrix.setTranslate(SkIntToScalar(240), 0); matrix.preScale(SK_Scalar1*2, SK_Scalar1*2); gs->appendShape(&fGroup, matrix); #if 1 SkPicture* pict = new SkPicture; SkCanvas* cv = pict->beginRecording(1000, 1000); cv->scale(SK_ScalarHalf, SK_ScalarHalf); gs->draw(cv); cv->translate(SkIntToScalar(680), SkIntToScalar(480)); cv->scale(-SK_Scalar1, SK_Scalar1); gs->draw(cv); pict->endRecording(); drawpicture(canvas, *pict); pict->unref(); #endif }} *fMatrixRefs[3] = saveM; this->inval(NULL); }