| OLD | NEW |
|---|
| (Empty) |
| 1 #include "DMSrcSink.h" | |
| 2 #include "SamplePipeControllers.h" | |
| 3 #include "SkCommonFlags.h" | |
| 4 #include "SkDocument.h" | |
| 5 #include "SkMultiPictureDraw.h" | |
| 6 #include "SkOSFile.h" | |
| 7 #include "SkPictureRecorder.h" | |
| 8 #include "SkRandom.h" | |
| 9 #include "SkTLS.h" | |
| 10 | |
| 11 namespace DM { | |
| 12 | |
| 13 void SafeUnref(SkPicture* p) { SkSafeUnref(p); } | |
| 14 void SafeUnref(SkData* d) { SkSafeUnref(d); } | |
| 15 | |
| 16 // FIXME: the GM objects themselves are not threadsafe, so we create and destroy
them as needed. | |
| 17 | |
| 18 GMSrc::GMSrc(skiagm::GMRegistry::Factory factory) : fFactory(factory) {} | |
| 19 | |
| 20 Error GMSrc::draw(SkCanvas* canvas) const { | |
| 21 SkAutoTDelete<skiagm::GM> gm(fFactory(NULL)); | |
| 22 canvas->concat(gm->getInitialTransform()); | |
| 23 gm->draw(canvas); | |
| 24 return ""; | |
| 25 } | |
| 26 | |
| 27 SkISize GMSrc::size() const { | |
| 28 SkAutoTDelete<skiagm::GM> gm(fFactory(NULL)); | |
| 29 return gm->getISize(); | |
| 30 } | |
| 31 | |
| 32 Name GMSrc::name() const { | |
| 33 SkAutoTDelete<skiagm::GM> gm(fFactory(NULL)); | |
| 34 return gm->getName(); | |
| 35 } | |
| 36 | |
| 37 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~*/ | |
| 38 | |
| 39 // The first call to draw() or size() will mmap the file to an SkData. ~ImageSr
c unrefs it. | |
| 40 struct LazyLoadImage { | |
| 41 LazyLoadImage(const char* path) : path(path) {} | |
| 42 const char* path; | |
| 43 | |
| 44 SkData* operator()() const { return SkData::NewFromFileName(path); } | |
| 45 }; | |
| 46 | |
| 47 ImageSrc::ImageSrc(SkString path, int subsets) : fPath(path), fSubsets(subsets)
{} | |
| 48 | |
| 49 Error ImageSrc::draw(SkCanvas* canvas) const { | |
| 50 const SkData* encoded = fEncoded.get(LazyLoadImage(fPath.c_str())); | |
| 51 if (!encoded) { | |
| 52 return SkStringPrintf("Couldn't read %s.", fPath.c_str()); | |
| 53 } | |
| 54 if (fSubsets == 0) { | |
| 55 // Decode the full image. | |
| 56 SkBitmap bitmap; | |
| 57 if (!SkImageDecoder::DecodeMemory(encoded->data(), encoded->size(), &bit
map)) { | |
| 58 return SkStringPrintf("Couldn't decode %s.", fPath.c_str()); | |
| 59 } | |
| 60 canvas->drawBitmap(bitmap, 0,0); | |
| 61 return ""; | |
| 62 } | |
| 63 // Decode random subsets. This is a little involved. | |
| 64 SkMemoryStream stream(encoded->data(), encoded->size()); | |
| 65 SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(&stream)); | |
| 66 if (!decoder) { | |
| 67 return SkStringPrintf("Can't find a good decoder for %s.", fPath.c_str()
); | |
| 68 } | |
| 69 int w,h; | |
| 70 if (!decoder->buildTileIndex(&stream, &w, &h) || w*h == 1) { | |
| 71 return ""; // Not an error. Subset decoding is not always supported. | |
| 72 } | |
| 73 SkRandom rand; | |
| 74 for (int i = 0; i < fSubsets; i++) { | |
| 75 SkIRect rect; | |
| 76 do { | |
| 77 rect.fLeft = rand.nextULessThan(w); | |
| 78 rect.fTop = rand.nextULessThan(h); | |
| 79 rect.fRight = rand.nextULessThan(w); | |
| 80 rect.fBottom = rand.nextULessThan(h); | |
| 81 rect.sort(); | |
| 82 } while (rect.isEmpty()); | |
| 83 SkBitmap subset; | |
| 84 if (!decoder->decodeSubset(&subset, rect, kUnknown_SkColorType/*use best
fit*/)) { | |
| 85 return SkStringPrintf("Could not decode subset %d.\n", i); | |
| 86 } | |
| 87 canvas->drawBitmap(subset, SkIntToScalar(rect.fLeft), SkIntToScalar(rect
.fTop)); | |
| 88 } | |
| 89 return ""; | |
| 90 } | |
| 91 | |
| 92 SkISize ImageSrc::size() const { | |
| 93 const SkData* encoded = fEncoded.get(LazyLoadImage(fPath.c_str())); | |
| 94 SkBitmap bitmap; | |
| 95 if (!encoded || !SkImageDecoder::DecodeMemory(encoded->data(), | |
| 96 encoded->size(), | |
| 97 &bitmap, | |
| 98 kUnknown_SkColorType, | |
| 99 SkImageDecoder::kDecodeBounds_
Mode)) { | |
| 100 return SkISize::Make(0,0); | |
| 101 } | |
| 102 return bitmap.dimensions(); | |
| 103 } | |
| 104 | |
| 105 Name ImageSrc::name() const { return SkOSPath::Basename(fPath.c_str()); } | |
| 106 | |
| 107 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~*/ | |
| 108 | |
| 109 static const SkRect kSKPViewport = {0,0, 1000,1000}; | |
| 110 | |
| 111 // The first call to draw() or size() will read the file into an SkPicture. ~SK
PSrc unrefs it. | |
| 112 struct LazyLoadPicture { | |
| 113 LazyLoadPicture(const char* path) : path(path) {} | |
| 114 const char* path; | |
| 115 | |
| 116 SkPicture* operator()() const { | |
| 117 SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path)); | |
| 118 if (!stream) { | |
| 119 return NULL; | |
| 120 } | |
| 121 return SkPicture::CreateFromStream(stream); | |
| 122 } | |
| 123 }; | |
| 124 | |
| 125 SKPSrc::SKPSrc(SkString path) : fPath(path) {} | |
| 126 | |
| 127 Error SKPSrc::draw(SkCanvas* canvas) const { | |
| 128 const SkPicture* pic = fPic.get(LazyLoadPicture(fPath.c_str())); | |
| 129 if (!pic) { | |
| 130 return SkStringPrintf("Couldn't read %s.", fPath.c_str()); | |
| 131 } | |
| 132 canvas->clipRect(kSKPViewport); | |
| 133 canvas->drawPicture(pic); | |
| 134 return ""; | |
| 135 } | |
| 136 | |
| 137 SkISize SKPSrc::size() const { | |
| 138 const SkPicture* pic = fPic.get(LazyLoadPicture(fPath.c_str())); | |
| 139 if (!pic) { | |
| 140 return SkISize::Make(0,0); | |
| 141 } | |
| 142 SkRect cull = pic->cullRect(); | |
| 143 if (!cull.intersect(kSKPViewport)) { | |
| 144 sk_throw(); | |
| 145 } | |
| 146 SkIRect bounds; | |
| 147 cull.roundOut(&bounds); | |
| 148 SkISize size = { bounds.width(), bounds.height() }; | |
| 149 return size; | |
| 150 } | |
| 151 | |
| 152 Name SKPSrc::name() const { return SkOSPath::Basename(fPath.c_str()); } | |
| 153 | |
| 154 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~*/ | |
| 155 | |
| 156 DEFINE_string(gpu_threading, "none", | |
| 157 "none: single thread,\n" | |
| 158 "tls: any thread, GrContextFactory in TLS (crashy),\n" | |
| 159 "stack: any thread, GrContextFactory on stack (less crashy, differently
so)"); | |
| 160 | |
| 161 GPUSink::GPUSink(GrContextFactory::GLContextType ct, GrGLStandard api, int sampl
es, bool dfText) | |
| 162 : fContextType(ct) | |
| 163 , fGpuAPI(api) | |
| 164 , fSampleCount(samples) | |
| 165 , fUseDFText(dfText) {} | |
| 166 | |
| 167 int GPUSink::enclave() const { | |
| 168 return FLAGS_gpu_threading.contains("none") ? kGPUSink_Enclave : kAnyThread_
Enclave; | |
| 169 } | |
| 170 | |
| 171 static void* CreateGrFactory() { return new GrContextFactory; } | |
| 172 static void DeleteGrFactory(void* p) { delete (GrContextFactory*)p; } | |
| 173 | |
| 174 Error GPUSink::draw(const Src& src, SkBitmap* dst, SkWStream*) const { | |
| 175 GrContextFactory local, *factory = &local; | |
| 176 if (!FLAGS_gpu_threading.contains("stack")) { | |
| 177 factory = (GrContextFactory*)SkTLS::Get(CreateGrFactory, DeleteGrFactory
); | |
| 178 } | |
| 179 // Does abandoning / resetting contexts make any sense if we have stack-scop
ed factories? | |
| 180 if (FLAGS_abandonGpuContext) { | |
| 181 factory->abandonContexts(); | |
| 182 } | |
| 183 if (FLAGS_resetGpuContext || FLAGS_abandonGpuContext) { | |
| 184 factory->destroyContexts(); | |
| 185 } | |
| 186 const SkISize size = src.size(); | |
| 187 const SkImageInfo info = | |
| 188 SkImageInfo::Make(size.width(), size.height(), kN32_SkColorType, kPremul
_SkAlphaType); | |
| 189 SkAutoTUnref<SkSurface> surface( | |
| 190 NewGpuSurface(factory, fContextType, fGpuAPI, info, fSampleCount, fU
seDFText)); | |
| 191 if (!surface) { | |
| 192 return "Could not create a surface."; | |
| 193 } | |
| 194 SkCanvas* canvas = surface->getCanvas(); | |
| 195 Error err = src.draw(canvas); | |
| 196 if (!err.isEmpty()) { | |
| 197 return err; | |
| 198 } | |
| 199 canvas->flush(); | |
| 200 dst->allocPixels(info); | |
| 201 canvas->readPixels(dst, 0,0); | |
| 202 return ""; | |
| 203 } | |
| 204 | |
| 205 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~*/ | |
| 206 | |
| 207 PDFSink::PDFSink() {} | |
| 208 | |
| 209 Error PDFSink::draw(const Src& src, SkBitmap*, SkWStream* dst) const { | |
| 210 SkSize size; | |
| 211 size = src.size(); | |
| 212 SkAutoTUnref<SkDocument> doc(SkDocument::CreatePDF(dst)); | |
| 213 SkCanvas* canvas = doc->beginPage(size.width(), size.height()); | |
| 214 | |
| 215 Error err = src.draw(canvas); | |
| 216 if (!err.isEmpty()) { | |
| 217 return err; | |
| 218 } | |
| 219 canvas->flush(); | |
| 220 doc->endPage(); | |
| 221 doc->close(); | |
| 222 return ""; | |
| 223 } | |
| 224 | |
| 225 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~*/ | |
| 226 | |
| 227 RasterSink::RasterSink(SkColorType colorType) : fColorType(colorType) {} | |
| 228 | |
| 229 Error RasterSink::draw(const Src& src, SkBitmap* dst, SkWStream*) const { | |
| 230 const SkISize size = src.size(); | |
| 231 // If there's an appropriate alpha type for this color type, use it, otherwi
se use premul. | |
| 232 SkAlphaType alphaType = kPremul_SkAlphaType; | |
| 233 (void)SkColorTypeValidateAlphaType(fColorType, alphaType, &alphaType); | |
| 234 | |
| 235 dst->allocPixels(SkImageInfo::Make(size.width(), size.height(), fColorType,
alphaType)); | |
| 236 dst->eraseColor(SK_ColorTRANSPARENT); | |
| 237 SkCanvas canvas(*dst); | |
| 238 return src.draw(&canvas); | |
| 239 } | |
| 240 | |
| 241 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~*/ | |
| 242 | |
| 243 ViaMatrix::ViaMatrix(SkMatrix matrix, Sink* sink) : fMatrix(matrix), fSink(sink)
{} | |
| 244 | |
| 245 Error ViaMatrix::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const
{ | |
| 246 // We turn our arguments into a Src, then draw that Src into our Sink to fil
l bitmap or stream. | |
| 247 struct ProxySrc : public Src { | |
| 248 const Src& fSrc; | |
| 249 SkMatrix fMatrix; | |
| 250 ProxySrc(const Src& src, SkMatrix matrix) : fSrc(src), fMatrix(matrix) {
} | |
| 251 | |
| 252 Error draw(SkCanvas* canvas) const SK_OVERRIDE { | |
| 253 canvas->concat(fMatrix); | |
| 254 return fSrc.draw(canvas); | |
| 255 } | |
| 256 SkISize size() const SK_OVERRIDE { return fSrc.size(); } | |
| 257 Name name() const SK_OVERRIDE { sk_throw(); return ""; } // No one shou
ld be calling this. | |
| 258 } proxy(src, fMatrix); | |
| 259 return fSink->draw(proxy, bitmap, stream); | |
| 260 } | |
| 261 | |
| 262 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~*/ | |
| 263 | |
| 264 ViaPipe::ViaPipe(int flags, Sink* sink) : fFlags((SkGPipeWriter::Flags)flags), f
Sink(sink) {} | |
| 265 | |
| 266 Error ViaPipe::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const { | |
| 267 // We turn our arguments into a Src, then draw that Src into our Sink to fil
l bitmap or stream. | |
| 268 struct ProxySrc : public Src { | |
| 269 const Src& fSrc; | |
| 270 SkGPipeWriter::Flags fFlags; | |
| 271 ProxySrc(const Src& src, SkGPipeWriter::Flags flags) : fSrc(src), fFlags
(flags) {} | |
| 272 | |
| 273 Error draw(SkCanvas* canvas) const SK_OVERRIDE { | |
| 274 SkISize size = this->size(); | |
| 275 // TODO: is DecodeMemory really required? Might help RAM usage to be
lazy if we can. | |
| 276 PipeController controller(canvas, &SkImageDecoder::DecodeMemory); | |
| 277 SkGPipeWriter pipe; | |
| 278 return fSrc.draw(pipe.startRecording(&controller, fFlags, size.width
(), size.height())); | |
| 279 } | |
| 280 SkISize size() const SK_OVERRIDE { return fSrc.size(); } | |
| 281 Name name() const SK_OVERRIDE { sk_throw(); return ""; } // No one shou
ld be calling this. | |
| 282 } proxy(src, fFlags); | |
| 283 return fSink->draw(proxy, bitmap, stream); | |
| 284 } | |
| 285 | |
| 286 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~*/ | |
| 287 | |
| 288 ViaSerialization::ViaSerialization(Sink* sink) : fSink(sink) {} | |
| 289 | |
| 290 Error ViaSerialization::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream
) const { | |
| 291 // Record our Src into a picture. | |
| 292 SkSize size; | |
| 293 size = src.size(); | |
| 294 SkPictureRecorder recorder; | |
| 295 Error err = src.draw(recorder.beginRecording(size.width(), size.height())); | |
| 296 if (!err.isEmpty()) { | |
| 297 return err; | |
| 298 } | |
| 299 SkAutoTUnref<SkPicture> pic(recorder.endRecording()); | |
| 300 | |
| 301 // Serialize it and then deserialize it. | |
| 302 SkDynamicMemoryWStream wStream; | |
| 303 pic->serialize(&wStream); | |
| 304 SkAutoTUnref<SkStream> rStream(wStream.detachAsStream()); | |
| 305 SkAutoTUnref<SkPicture> deserialized(SkPicture::CreateFromStream(rStream)); | |
| 306 | |
| 307 // Turn that deserialized picture into a Src, draw it into our Sink to fill
bitmap or stream. | |
| 308 struct ProxySrc : public Src { | |
| 309 const SkPicture* fPic; | |
| 310 const SkISize fSize; | |
| 311 ProxySrc(const SkPicture* pic, SkISize size) : fPic(pic), fSize(size) {} | |
| 312 | |
| 313 Error draw(SkCanvas* canvas) const SK_OVERRIDE { | |
| 314 canvas->drawPicture(fPic); | |
| 315 return ""; | |
| 316 } | |
| 317 SkISize size() const SK_OVERRIDE { return fSize; } | |
| 318 Name name() const SK_OVERRIDE { sk_throw(); return ""; } // No one shou
ld be calling this. | |
| 319 } proxy(deserialized, src.size()); | |
| 320 return fSink->draw(proxy, bitmap, stream); | |
| 321 } | |
| 322 | |
| 323 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~*/ | |
| 324 | |
| 325 ViaTiles::ViaTiles(int w, int h, SkBBHFactory* factory, Sink* sink) | |
| 326 : fW(w) | |
| 327 , fH(h) | |
| 328 , fFactory(factory) | |
| 329 , fSink(sink) {} | |
| 330 | |
| 331 Error ViaTiles::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const
{ | |
| 332 // Record our Src into a picture. | |
| 333 SkSize size; | |
| 334 size = src.size(); | |
| 335 SkPictureRecorder recorder; | |
| 336 Error err = src.draw(recorder.beginRecording(size.width(), size.height(), fF
actory.get())); | |
| 337 if (!err.isEmpty()) { | |
| 338 return err; | |
| 339 } | |
| 340 SkAutoTUnref<SkPicture> pic(recorder.endRecording()); | |
| 341 | |
| 342 // Turn that picture into a Src that draws into our Sink via tiles + MPD. | |
| 343 struct ProxySrc : public Src { | |
| 344 const int fW, fH; | |
| 345 const SkPicture* fPic; | |
| 346 const SkISize fSize; | |
| 347 ProxySrc(int w, int h, const SkPicture* pic, SkISize size) | |
| 348 : fW(w), fH(h), fPic(pic), fSize(size) {} | |
| 349 | |
| 350 Error draw(SkCanvas* canvas) const SK_OVERRIDE { | |
| 351 const int xTiles = (fSize.width() + fW - 1) / fW, | |
| 352 yTiles = (fSize.height() + fH - 1) / fH; | |
| 353 SkMultiPictureDraw mpd(xTiles*yTiles); | |
| 354 SkTDArray<SkSurface*> surfaces; | |
| 355 surfaces.setReserve(xTiles*yTiles); | |
| 356 | |
| 357 SkImageInfo info = canvas->imageInfo().makeWH(fW, fH); | |
| 358 for (int j = 0; j < yTiles; j++) { | |
| 359 for (int i = 0; i < xTiles; i++) { | |
| 360 // This lets our ultimate Sink determine the best kind of su
rface. | |
| 361 // E.g., if it's a GpuSink, the surfaces and images are text
ures. | |
| 362 SkSurface* s = canvas->newSurface(info); | |
| 363 if (!s) { | |
| 364 s = SkSurface::NewRaster(info); // Some canvases can't
create surfaces. | |
| 365 } | |
| 366 surfaces.push(s); | |
| 367 SkCanvas* c = s->getCanvas(); | |
| 368 c->translate(SkIntToScalar(-i * fW), | |
| 369 SkIntToScalar(-j * fH)); // Line up the canvas
with this tile. | |
| 370 mpd.add(c, fPic); | |
| 371 } | |
| 372 } | |
| 373 mpd.draw(); | |
| 374 for (int j = 0; j < yTiles; j++) { | |
| 375 for (int i = 0; i < xTiles; i++) { | |
| 376 SkAutoTUnref<SkImage> image(surfaces[i+xTiles*j]->newImageSn
apshot()); | |
| 377 canvas->drawImage(image, SkIntToScalar(i*fW), SkIntToScalar(
j*fH)); | |
| 378 } | |
| 379 } | |
| 380 surfaces.unrefAll(); | |
| 381 return ""; | |
| 382 } | |
| 383 SkISize size() const SK_OVERRIDE { return fSize; } | |
| 384 Name name() const SK_OVERRIDE { sk_throw(); return ""; } // No one shou
ld be calling this. | |
| 385 } proxy(fW, fH, pic, src.size()); | |
| 386 return fSink->draw(proxy, bitmap, stream); | |
| 387 } | |
| 388 | |
| 389 } // namespace DM | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 853883004:
Revert of Sketch DM refactor. (Closed)
Base URL: https://skia.googlesource.com/skia.git@master