static sk_sp<SkData> make_3Dlut(int* cubeDimension, bool invR, bool invG, bool invB) { int size = 4 << R(5); auto data = SkData::MakeUninitialized(sizeof(SkColor) * size * size * size); SkColor* pixels = (SkColor*)(data->writable_data()); SkAutoTMalloc<uint8_t> lutMemory(size); SkAutoTMalloc<uint8_t> invLutMemory(size); uint8_t* lut = lutMemory.get(); uint8_t* invLut = invLutMemory.get(); const int maxIndex = size - 1; for (int i = 0; i < size; i++) { lut[i] = (i * 255) / maxIndex; invLut[i] = ((maxIndex - i) * 255) / maxIndex; } for (int r = 0; r < size; ++r) { for (int g = 0; g < size; ++g) { for (int b = 0; b < size; ++b) { pixels[(size * ((size * b) + g)) + r] = SkColorSetARGB(0xFF, invR ? invLut[r] : lut[r], invG ? invLut[g] : lut[g], invB ? invLut[b] : lut[b]); } } } if (cubeDimension) { *cubeDimension = size; } return data; }
sk_sp<SkImage> SkImageMakeRasterCopyAndAssignColorSpace(const SkImage* src, SkColorSpace* colorSpace) { // Read the pixels out of the source image, with no conversion SkImageInfo info = as_IB(src)->onImageInfo(); if (kUnknown_SkColorType == info.colorType()) { SkDEBUGFAIL("Unexpected color type"); return nullptr; } size_t rowBytes = info.minRowBytes(); size_t size = info.computeByteSize(rowBytes); if (SkImageInfo::ByteSizeOverflowed(size)) { return nullptr; } auto data = SkData::MakeUninitialized(size); if (!data) { return nullptr; } SkPixmap pm(info, data->writable_data(), rowBytes); if (!src->readPixels(pm, 0, 0, SkImage::kDisallow_CachingHint)) { return nullptr; } // Wrap them in a new image with a different color space return SkImage::MakeRasterData(info.makeColorSpace(sk_ref_sp(colorSpace)), data, rowBytes); }
SkData* SkValidatingSerializeFlattenable(SkFlattenable* flattenable) { SkWriteBuffer writer; writer.writeFlattenable(flattenable); size_t size = writer.bytesWritten(); auto data = SkData::MakeUninitialized(size); writer.writeToMemory(data->writable_data()); return data.release(); }
sk_sp<SkData> SkFlattenable::serialize(const SkSerialProcs* procs) const { SkBinaryWriteBuffer writer; if (procs) { writer.setSerialProcs(*procs); } writer.writeFlattenable(this); size_t size = writer.bytesWritten(); auto data = SkData::MakeUninitialized(size); writer.writeToMemory(data->writable_data()); return data; }
sk_sp<SkImage> SkImage::makeNonTextureImage() const { if (!this->isTextureBacked()) { return sk_ref_sp(const_cast<SkImage*>(this)); } SkImageInfo info = as_IB(this)->onImageInfo(); size_t rowBytes = info.minRowBytes(); size_t size = info.getSafeSize(rowBytes); auto data = SkData::MakeUninitialized(size); if (!data) { return nullptr; } SkPixmap pm(info, data->writable_data(), rowBytes); if (!this->readPixels(pm, 0, 0, kDisallow_CachingHint)) { return nullptr; } return MakeRasterData(info, data, rowBytes); }
// SkCodec's wbmp decoder was initially unnecessarily restrictive. // It required the second byte to be zero. The wbmp specification allows // a couple of bits to be 1 (so long as they do not overlap with 0x9F). // Test that SkCodec now supports an image with these bits set. DEF_TEST(Codec_wbmp, r) { const char* path = "mandrill.wbmp"; SkAutoTDelete<SkStream> stream(resource(path)); if (!stream) { SkDebugf("Missing resource '%s'\n", path); return; } // Modify the stream to contain a second byte with some bits set. auto data = SkCopyStreamToData(stream); uint8_t* writeableData = static_cast<uint8_t*>(data->writable_data()); writeableData[1] = static_cast<uint8_t>(~0x9F); // SkCodec should support this. SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data.get())); REPORTER_ASSERT(r, codec); if (!codec) { return; } test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr); }