aboutsummaryrefslogtreecommitdiffhomepage
path: root/dm/DMSrcSink.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dm/DMSrcSink.cpp')
-rw-r--r--dm/DMSrcSink.cpp389
1 files changed, 0 insertions, 389 deletions
diff --git a/dm/DMSrcSink.cpp b/dm/DMSrcSink.cpp
deleted file mode 100644
index 4f272f11f8..0000000000
--- a/dm/DMSrcSink.cpp
+++ /dev/null
@@ -1,389 +0,0 @@
-#include "DMSrcSink.h"
-#include "SamplePipeControllers.h"
-#include "SkCommonFlags.h"
-#include "SkDocument.h"
-#include "SkMultiPictureDraw.h"
-#include "SkOSFile.h"
-#include "SkPictureRecorder.h"
-#include "SkRandom.h"
-#include "SkTLS.h"
-
-namespace DM {
-
-void SafeUnref(SkPicture* p) { SkSafeUnref(p); }
-void SafeUnref(SkData* d) { SkSafeUnref(d); }
-
-// FIXME: the GM objects themselves are not threadsafe, so we create and destroy them as needed.
-
-GMSrc::GMSrc(skiagm::GMRegistry::Factory factory) : fFactory(factory) {}
-
-Error GMSrc::draw(SkCanvas* canvas) const {
- SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
- canvas->concat(gm->getInitialTransform());
- gm->draw(canvas);
- return "";
-}
-
-SkISize GMSrc::size() const {
- SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
- return gm->getISize();
-}
-
-Name GMSrc::name() const {
- SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
- return gm->getName();
-}
-
-/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
-
-// The first call to draw() or size() will mmap the file to an SkData. ~ImageSrc unrefs it.
-struct LazyLoadImage {
- LazyLoadImage(const char* path) : path(path) {}
- const char* path;
-
- SkData* operator()() const { return SkData::NewFromFileName(path); }
-};
-
-ImageSrc::ImageSrc(SkString path, int subsets) : fPath(path), fSubsets(subsets) {}
-
-Error ImageSrc::draw(SkCanvas* canvas) const {
- const SkData* encoded = fEncoded.get(LazyLoadImage(fPath.c_str()));
- if (!encoded) {
- return SkStringPrintf("Couldn't read %s.", fPath.c_str());
- }
- if (fSubsets == 0) {
- // Decode the full image.
- SkBitmap bitmap;
- if (!SkImageDecoder::DecodeMemory(encoded->data(), encoded->size(), &bitmap)) {
- return SkStringPrintf("Couldn't decode %s.", fPath.c_str());
- }
- canvas->drawBitmap(bitmap, 0,0);
- return "";
- }
- // Decode random subsets. This is a little involved.
- SkMemoryStream stream(encoded->data(), encoded->size());
- SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(&stream));
- if (!decoder) {
- return SkStringPrintf("Can't find a good decoder for %s.", fPath.c_str());
- }
- int w,h;
- if (!decoder->buildTileIndex(&stream, &w, &h) || w*h == 1) {
- return ""; // Not an error. Subset decoding is not always supported.
- }
- SkRandom rand;
- for (int i = 0; i < fSubsets; i++) {
- SkIRect rect;
- do {
- rect.fLeft = rand.nextULessThan(w);
- rect.fTop = rand.nextULessThan(h);
- rect.fRight = rand.nextULessThan(w);
- rect.fBottom = rand.nextULessThan(h);
- rect.sort();
- } while (rect.isEmpty());
- SkBitmap subset;
- if (!decoder->decodeSubset(&subset, rect, kUnknown_SkColorType/*use best fit*/)) {
- return SkStringPrintf("Could not decode subset %d.\n", i);
- }
- canvas->drawBitmap(subset, SkIntToScalar(rect.fLeft), SkIntToScalar(rect.fTop));
- }
- return "";
-}
-
-SkISize ImageSrc::size() const {
- const SkData* encoded = fEncoded.get(LazyLoadImage(fPath.c_str()));
- SkBitmap bitmap;
- if (!encoded || !SkImageDecoder::DecodeMemory(encoded->data(),
- encoded->size(),
- &bitmap,
- kUnknown_SkColorType,
- SkImageDecoder::kDecodeBounds_Mode)) {
- return SkISize::Make(0,0);
- }
- return bitmap.dimensions();
-}
-
-Name ImageSrc::name() const { return SkOSPath::Basename(fPath.c_str()); }
-
-/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
-
-static const SkRect kSKPViewport = {0,0, 1000,1000};
-
-// The first call to draw() or size() will read the file into an SkPicture. ~SKPSrc unrefs it.
-struct LazyLoadPicture {
- LazyLoadPicture(const char* path) : path(path) {}
- const char* path;
-
- SkPicture* operator()() const {
- SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
- if (!stream) {
- return NULL;
- }
- return SkPicture::CreateFromStream(stream);
- }
-};
-
-SKPSrc::SKPSrc(SkString path) : fPath(path) {}
-
-Error SKPSrc::draw(SkCanvas* canvas) const {
- const SkPicture* pic = fPic.get(LazyLoadPicture(fPath.c_str()));
- if (!pic) {
- return SkStringPrintf("Couldn't read %s.", fPath.c_str());
- }
- canvas->clipRect(kSKPViewport);
- canvas->drawPicture(pic);
- return "";
-}
-
-SkISize SKPSrc::size() const {
- const SkPicture* pic = fPic.get(LazyLoadPicture(fPath.c_str()));
- if (!pic) {
- return SkISize::Make(0,0);
- }
- SkRect cull = pic->cullRect();
- if (!cull.intersect(kSKPViewport)) {
- sk_throw();
- }
- SkIRect bounds;
- cull.roundOut(&bounds);
- SkISize size = { bounds.width(), bounds.height() };
- return size;
-}
-
-Name SKPSrc::name() const { return SkOSPath::Basename(fPath.c_str()); }
-
-/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
-
-DEFINE_string(gpu_threading, "none",
- "none: single thread,\n"
- "tls: any thread, GrContextFactory in TLS (crashy),\n"
- "stack: any thread, GrContextFactory on stack (less crashy, differently so)");
-
-GPUSink::GPUSink(GrContextFactory::GLContextType ct, GrGLStandard api, int samples, bool dfText)
- : fContextType(ct)
- , fGpuAPI(api)
- , fSampleCount(samples)
- , fUseDFText(dfText) {}
-
-int GPUSink::enclave() const {
- return FLAGS_gpu_threading.contains("none") ? kGPUSink_Enclave : kAnyThread_Enclave;
-}
-
-static void* CreateGrFactory() { return new GrContextFactory; }
-static void DeleteGrFactory(void* p) { delete (GrContextFactory*)p; }
-
-Error GPUSink::draw(const Src& src, SkBitmap* dst, SkWStream*) const {
- GrContextFactory local, *factory = &local;
- if (!FLAGS_gpu_threading.contains("stack")) {
- factory = (GrContextFactory*)SkTLS::Get(CreateGrFactory, DeleteGrFactory);
- }
- // Does abandoning / resetting contexts make any sense if we have stack-scoped factories?
- if (FLAGS_abandonGpuContext) {
- factory->abandonContexts();
- }
- if (FLAGS_resetGpuContext || FLAGS_abandonGpuContext) {
- factory->destroyContexts();
- }
- const SkISize size = src.size();
- const SkImageInfo info =
- SkImageInfo::Make(size.width(), size.height(), kN32_SkColorType, kPremul_SkAlphaType);
- SkAutoTUnref<SkSurface> surface(
- NewGpuSurface(factory, fContextType, fGpuAPI, info, fSampleCount, fUseDFText));
- if (!surface) {
- return "Could not create a surface.";
- }
- SkCanvas* canvas = surface->getCanvas();
- Error err = src.draw(canvas);
- if (!err.isEmpty()) {
- return err;
- }
- canvas->flush();
- dst->allocPixels(info);
- canvas->readPixels(dst, 0,0);
- return "";
-}
-
-/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
-
-PDFSink::PDFSink() {}
-
-Error PDFSink::draw(const Src& src, SkBitmap*, SkWStream* dst) const {
- SkSize size;
- size = src.size();
- SkAutoTUnref<SkDocument> doc(SkDocument::CreatePDF(dst));
- SkCanvas* canvas = doc->beginPage(size.width(), size.height());
-
- Error err = src.draw(canvas);
- if (!err.isEmpty()) {
- return err;
- }
- canvas->flush();
- doc->endPage();
- doc->close();
- return "";
-}
-
-/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
-
-RasterSink::RasterSink(SkColorType colorType) : fColorType(colorType) {}
-
-Error RasterSink::draw(const Src& src, SkBitmap* dst, SkWStream*) const {
- const SkISize size = src.size();
- // If there's an appropriate alpha type for this color type, use it, otherwise use premul.
- SkAlphaType alphaType = kPremul_SkAlphaType;
- (void)SkColorTypeValidateAlphaType(fColorType, alphaType, &alphaType);
-
- dst->allocPixels(SkImageInfo::Make(size.width(), size.height(), fColorType, alphaType));
- dst->eraseColor(SK_ColorTRANSPARENT);
- SkCanvas canvas(*dst);
- return src.draw(&canvas);
-}
-
-/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
-
-ViaMatrix::ViaMatrix(SkMatrix matrix, Sink* sink) : fMatrix(matrix), fSink(sink) {}
-
-Error ViaMatrix::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
- // We turn our arguments into a Src, then draw that Src into our Sink to fill bitmap or stream.
- struct ProxySrc : public Src {
- const Src& fSrc;
- SkMatrix fMatrix;
- ProxySrc(const Src& src, SkMatrix matrix) : fSrc(src), fMatrix(matrix) {}
-
- Error draw(SkCanvas* canvas) const SK_OVERRIDE {
- canvas->concat(fMatrix);
- return fSrc.draw(canvas);
- }
- SkISize size() const SK_OVERRIDE { return fSrc.size(); }
- Name name() const SK_OVERRIDE { sk_throw(); return ""; } // No one should be calling this.
- } proxy(src, fMatrix);
- return fSink->draw(proxy, bitmap, stream);
-}
-
-/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
-
-ViaPipe::ViaPipe(int flags, Sink* sink) : fFlags((SkGPipeWriter::Flags)flags), fSink(sink) {}
-
-Error ViaPipe::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
- // We turn our arguments into a Src, then draw that Src into our Sink to fill bitmap or stream.
- struct ProxySrc : public Src {
- const Src& fSrc;
- SkGPipeWriter::Flags fFlags;
- ProxySrc(const Src& src, SkGPipeWriter::Flags flags) : fSrc(src), fFlags(flags) {}
-
- Error draw(SkCanvas* canvas) const SK_OVERRIDE {
- SkISize size = this->size();
- // TODO: is DecodeMemory really required? Might help RAM usage to be lazy if we can.
- PipeController controller(canvas, &SkImageDecoder::DecodeMemory);
- SkGPipeWriter pipe;
- return fSrc.draw(pipe.startRecording(&controller, fFlags, size.width(), size.height()));
- }
- SkISize size() const SK_OVERRIDE { return fSrc.size(); }
- Name name() const SK_OVERRIDE { sk_throw(); return ""; } // No one should be calling this.
- } proxy(src, fFlags);
- return fSink->draw(proxy, bitmap, stream);
-}
-
-/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
-
-ViaSerialization::ViaSerialization(Sink* sink) : fSink(sink) {}
-
-Error ViaSerialization::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
- // Record our Src into a picture.
- SkSize size;
- size = src.size();
- SkPictureRecorder recorder;
- Error err = src.draw(recorder.beginRecording(size.width(), size.height()));
- if (!err.isEmpty()) {
- return err;
- }
- SkAutoTUnref<SkPicture> pic(recorder.endRecording());
-
- // Serialize it and then deserialize it.
- SkDynamicMemoryWStream wStream;
- pic->serialize(&wStream);
- SkAutoTUnref<SkStream> rStream(wStream.detachAsStream());
- SkAutoTUnref<SkPicture> deserialized(SkPicture::CreateFromStream(rStream));
-
- // Turn that deserialized picture into a Src, draw it into our Sink to fill bitmap or stream.
- struct ProxySrc : public Src {
- const SkPicture* fPic;
- const SkISize fSize;
- ProxySrc(const SkPicture* pic, SkISize size) : fPic(pic), fSize(size) {}
-
- Error draw(SkCanvas* canvas) const SK_OVERRIDE {
- canvas->drawPicture(fPic);
- return "";
- }
- SkISize size() const SK_OVERRIDE { return fSize; }
- Name name() const SK_OVERRIDE { sk_throw(); return ""; } // No one should be calling this.
- } proxy(deserialized, src.size());
- return fSink->draw(proxy, bitmap, stream);
-}
-
-/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
-
-ViaTiles::ViaTiles(int w, int h, SkBBHFactory* factory, Sink* sink)
- : fW(w)
- , fH(h)
- , fFactory(factory)
- , fSink(sink) {}
-
-Error ViaTiles::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
- // Record our Src into a picture.
- SkSize size;
- size = src.size();
- SkPictureRecorder recorder;
- Error err = src.draw(recorder.beginRecording(size.width(), size.height(), fFactory.get()));
- if (!err.isEmpty()) {
- return err;
- }
- SkAutoTUnref<SkPicture> pic(recorder.endRecording());
-
- // Turn that picture into a Src that draws into our Sink via tiles + MPD.
- struct ProxySrc : public Src {
- const int fW, fH;
- const SkPicture* fPic;
- const SkISize fSize;
- ProxySrc(int w, int h, const SkPicture* pic, SkISize size)
- : fW(w), fH(h), fPic(pic), fSize(size) {}
-
- Error draw(SkCanvas* canvas) const SK_OVERRIDE {
- const int xTiles = (fSize.width() + fW - 1) / fW,
- yTiles = (fSize.height() + fH - 1) / fH;
- SkMultiPictureDraw mpd(xTiles*yTiles);
- SkTDArray<SkSurface*> surfaces;
- surfaces.setReserve(xTiles*yTiles);
-
- SkImageInfo info = canvas->imageInfo().makeWH(fW, fH);
- for (int j = 0; j < yTiles; j++) {
- for (int i = 0; i < xTiles; i++) {
- // This lets our ultimate Sink determine the best kind of surface.
- // E.g., if it's a GpuSink, the surfaces and images are textures.
- SkSurface* s = canvas->newSurface(info);
- if (!s) {
- s = SkSurface::NewRaster(info); // Some canvases can't create surfaces.
- }
- surfaces.push(s);
- SkCanvas* c = s->getCanvas();
- c->translate(SkIntToScalar(-i * fW),
- SkIntToScalar(-j * fH)); // Line up the canvas with this tile.
- mpd.add(c, fPic);
- }
- }
- mpd.draw();
- for (int j = 0; j < yTiles; j++) {
- for (int i = 0; i < xTiles; i++) {
- SkAutoTUnref<SkImage> image(surfaces[i+xTiles*j]->newImageSnapshot());
- canvas->drawImage(image, SkIntToScalar(i*fW), SkIntToScalar(j*fH));
- }
- }
- surfaces.unrefAll();
- return "";
- }
- SkISize size() const SK_OVERRIDE { return fSize; }
- Name name() const SK_OVERRIDE { sk_throw(); return ""; } // No one should be calling this.
- } proxy(fW, fH, pic, src.size());
- return fSink->draw(proxy, bitmap, stream);
-}
-
-} // namespace DM
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-11 14:56:11 +0000