1/* 2 * Copyright 2013 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8#include "SkData.h" 9#include "SkDecodingImageGenerator.h" 10#include "SkImageDecoder.h" 11#include "SkImageInfo.h" 12#include "SkImageGenerator.h" 13#include "SkImagePriv.h" 14#include "SkStream.h" 15#include "SkUtils.h" 16 17namespace { 18bool equal_modulo_alpha(const SkImageInfo& a, const SkImageInfo& b) { 19 return a.width() == b.width() && a.height() == b.height() && 20 a.colorType() == b.colorType(); 21} 22 23class DecodingImageGenerator : public SkImageGenerator { 24public: 25 virtual ~DecodingImageGenerator(); 26 27 SkData* fData; 28 SkStreamRewindable* fStream; 29 const SkImageInfo fInfo; 30 const int fSampleSize; 31 const bool fDitherImage; 32 33 DecodingImageGenerator(SkData* data, 34 SkStreamRewindable* stream, 35 const SkImageInfo& info, 36 int sampleSize, 37 bool ditherImage); 38 39protected: 40 virtual SkData* onRefEncodedData() SK_OVERRIDE; 41 virtual bool onGetInfo(SkImageInfo* info) SK_OVERRIDE { 42 *info = fInfo; 43 return true; 44 } 45 virtual bool onGetPixels(const SkImageInfo& info, 46 void* pixels, size_t rowBytes, 47 SkPMColor ctable[], int* ctableCount) SK_OVERRIDE; 48 49private: 50 typedef SkImageGenerator INHERITED; 51}; 52 53/** 54 * Special allocator used by getPixels(). Uses preallocated memory 55 * provided if possible, else fall-back on the default allocator 56 */ 57class TargetAllocator : public SkBitmap::Allocator { 58public: 59 TargetAllocator(const SkImageInfo& info, 60 void* target, 61 size_t rowBytes) 62 : fInfo(info) 63 , fTarget(target) 64 , fRowBytes(rowBytes) 65 {} 66 67 bool isReady() { return (fTarget != NULL); } 68 69 virtual bool allocPixelRef(SkBitmap* bm, SkColorTable* ct) { 70 if (NULL == fTarget || !equal_modulo_alpha(fInfo, bm->info())) { 71 // Call default allocator. 72 return bm->allocPixels(NULL, ct); 73 } 74 75 // TODO(halcanary): verify that all callers of this function 76 // will respect new RowBytes. Will be moot once rowbytes belongs 77 // to PixelRef. 78 bm->installPixels(fInfo, fTarget, fRowBytes, ct, NULL, NULL); 79 80 fTarget = NULL; // never alloc same pixels twice! 81 return true; 82 } 83 84private: 85 const SkImageInfo fInfo; 86 void* fTarget; // Block of memory to be supplied as pixel memory 87 // in allocPixelRef. Must be large enough to hold 88 // a bitmap described by fInfo and fRowBytes 89 const size_t fRowBytes; // rowbytes for the destination bitmap 90 91 typedef SkBitmap::Allocator INHERITED; 92}; 93 94// TODO(halcanary): Give this macro a better name and move it into SkTypes.h 95#ifdef SK_DEBUG 96 #define SkCheckResult(expr, value) SkASSERT((value) == (expr)) 97#else 98 #define SkCheckResult(expr, value) (void)(expr) 99#endif 100 101#ifdef SK_DEBUG 102inline bool check_alpha(SkAlphaType reported, SkAlphaType actual) { 103 return ((reported == actual) 104 || ((reported == kPremul_SkAlphaType) 105 && (actual == kOpaque_SkAlphaType))); 106} 107#endif // SK_DEBUG 108 109//////////////////////////////////////////////////////////////////////////////// 110 111DecodingImageGenerator::DecodingImageGenerator( 112 SkData* data, 113 SkStreamRewindable* stream, 114 const SkImageInfo& info, 115 int sampleSize, 116 bool ditherImage) 117 : fData(data) 118 , fStream(stream) 119 , fInfo(info) 120 , fSampleSize(sampleSize) 121 , fDitherImage(ditherImage) 122{ 123 SkASSERT(stream != NULL); 124 SkSafeRef(fData); // may be NULL. 125} 126 127DecodingImageGenerator::~DecodingImageGenerator() { 128 SkSafeUnref(fData); 129 fStream->unref(); 130} 131 132SkData* DecodingImageGenerator::onRefEncodedData() { 133 // This functionality is used in `gm --serialize` 134 // Does not encode options. 135 if (fData != NULL) { 136 return SkSafeRef(fData); 137 } 138 // TODO(halcanary): SkStreamRewindable needs a refData() function 139 // which returns a cheap copy of the underlying data. 140 if (!fStream->rewind()) { 141 return NULL; 142 } 143 size_t length = fStream->getLength(); 144 if (0 == length) { 145 return NULL; 146 } 147 void* buffer = sk_malloc_flags(length, 0); 148 SkCheckResult(fStream->read(buffer, length), length); 149 fData = SkData::NewFromMalloc(buffer, length); 150 return SkSafeRef(fData); 151} 152 153bool DecodingImageGenerator::onGetPixels(const SkImageInfo& info, 154 void* pixels, size_t rowBytes, 155 SkPMColor ctableEntries[], int* ctableCount) { 156 if (fInfo != info) { 157 // The caller has specified a different info. This is an 158 // error for this kind of SkImageGenerator. Use the Options 159 // to change the settings. 160 return false; 161 } 162 163 SkAssertResult(fStream->rewind()); 164 SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(fStream)); 165 if (NULL == decoder.get()) { 166 return false; 167 } 168 decoder->setDitherImage(fDitherImage); 169 decoder->setSampleSize(fSampleSize); 170 decoder->setRequireUnpremultipliedColors( 171 info.fAlphaType == kUnpremul_SkAlphaType); 172 173 SkBitmap bitmap; 174 TargetAllocator allocator(fInfo, pixels, rowBytes); 175 decoder->setAllocator(&allocator); 176 bool success = decoder->decode(fStream, &bitmap, info.colorType(), 177 SkImageDecoder::kDecodePixels_Mode); 178 decoder->setAllocator(NULL); 179 if (!success) { 180 return false; 181 } 182 if (allocator.isReady()) { // Did not use pixels! 183 SkBitmap bm; 184 SkASSERT(bitmap.canCopyTo(info.colorType())); 185 bool copySuccess = bitmap.copyTo(&bm, info.colorType(), &allocator); 186 if (!copySuccess || allocator.isReady()) { 187 SkDEBUGFAIL("bitmap.copyTo(requestedConfig) failed."); 188 // Earlier we checked canCopyto(); we expect consistency. 189 return false; 190 } 191 SkASSERT(check_alpha(info.alphaType(), bm.alphaType())); 192 } else { 193 SkASSERT(check_alpha(info.alphaType(), bitmap.alphaType())); 194 } 195 196 if (kIndex_8_SkColorType == info.colorType()) { 197 if (kIndex_8_SkColorType != bitmap.colorType()) { 198 return false; // they asked for Index8, but we didn't receive that from decoder 199 } 200 SkColorTable* ctable = bitmap.getColorTable(); 201 if (NULL == ctable) { 202 return false; 203 } 204 const int count = ctable->count(); 205 memcpy(ctableEntries, ctable->lockColors(), count * sizeof(SkPMColor)); 206 ctable->unlockColors(); 207 *ctableCount = count; 208 } 209 return true; 210} 211 212// A contructor-type function that returns NULL on failure. This 213// prevents the returned SkImageGenerator from ever being in a bad 214// state. Called by both Create() functions 215SkImageGenerator* CreateDecodingImageGenerator( 216 SkData* data, 217 SkStreamRewindable* stream, 218 const SkDecodingImageGenerator::Options& opts) { 219 SkASSERT(stream); 220 SkAutoTUnref<SkStreamRewindable> autoStream(stream); // always unref this. 221 SkAssertResult(autoStream->rewind()); 222 SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(autoStream)); 223 if (NULL == decoder.get()) { 224 return NULL; 225 } 226 SkBitmap bitmap; 227 decoder->setSampleSize(opts.fSampleSize); 228 decoder->setRequireUnpremultipliedColors(opts.fRequireUnpremul); 229 if (!decoder->decode(stream, &bitmap, SkImageDecoder::kDecodeBounds_Mode)) { 230 return NULL; 231 } 232 if (kUnknown_SkColorType == bitmap.colorType()) { 233 return NULL; 234 } 235 236 SkImageInfo info = bitmap.info(); 237 238 if (opts.fUseRequestedColorType && (opts.fRequestedColorType != info.colorType())) { 239 if (!bitmap.canCopyTo(opts.fRequestedColorType)) { 240 SkASSERT(bitmap.colorType() != opts.fRequestedColorType); 241 return NULL; // Can not translate to needed config. 242 } 243 info.fColorType = opts.fRequestedColorType; 244 } 245 246 if (opts.fRequireUnpremul && info.fAlphaType != kOpaque_SkAlphaType) { 247 info.fAlphaType = kUnpremul_SkAlphaType; 248 } 249 return SkNEW_ARGS(DecodingImageGenerator, 250 (data, autoStream.detach(), info, 251 opts.fSampleSize, opts.fDitherImage)); 252} 253 254} // namespace 255 256//////////////////////////////////////////////////////////////////////////////// 257 258SkImageGenerator* SkDecodingImageGenerator::Create( 259 SkData* data, 260 const SkDecodingImageGenerator::Options& opts) { 261 SkASSERT(data != NULL); 262 if (NULL == data) { 263 return NULL; 264 } 265 SkStreamRewindable* stream = SkNEW_ARGS(SkMemoryStream, (data)); 266 SkASSERT(stream != NULL); 267 SkASSERT(stream->unique()); 268 return CreateDecodingImageGenerator(data, stream, opts); 269} 270 271SkImageGenerator* SkDecodingImageGenerator::Create( 272 SkStreamRewindable* stream, 273 const SkDecodingImageGenerator::Options& opts) { 274 SkASSERT(stream != NULL); 275 SkASSERT(stream->unique()); 276 if ((stream == NULL) || !stream->unique()) { 277 SkSafeUnref(stream); 278 return NULL; 279 } 280 return CreateDecodingImageGenerator(NULL, stream, opts); 281} 282