1 /*
2 * Copyright 2015 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 "SkBmpRLECodec.h"
9 #include "SkCodecPriv.h"
10 #include "SkColorData.h"
11 #include "SkStream.h"
12
13 /*
14 * Creates an instance of the decoder
15 * Called only by NewFromStream
16 */
SkBmpRLECodec(int width,int height,const SkEncodedInfo & info,std::unique_ptr<SkStream> stream,uint16_t bitsPerPixel,uint32_t numColors,uint32_t bytesPerColor,uint32_t offset,SkCodec::SkScanlineOrder rowOrder)17 SkBmpRLECodec::SkBmpRLECodec(int width, int height, const SkEncodedInfo& info,
18 std::unique_ptr<SkStream> stream,
19 uint16_t bitsPerPixel, uint32_t numColors,
20 uint32_t bytesPerColor, uint32_t offset,
21 SkCodec::SkScanlineOrder rowOrder)
22 : INHERITED(width, height, info, std::move(stream), bitsPerPixel, rowOrder)
23 , fColorTable(nullptr)
24 , fNumColors(numColors)
25 , fBytesPerColor(bytesPerColor)
26 , fOffset(offset)
27 , fBytesBuffered(0)
28 , fCurrRLEByte(0)
29 , fSampleX(1)
30 {}
31
32 /*
33 * Initiates the bitmap decode
34 */
onGetPixels(const SkImageInfo & dstInfo,void * dst,size_t dstRowBytes,const Options & opts,int * rowsDecoded)35 SkCodec::Result SkBmpRLECodec::onGetPixels(const SkImageInfo& dstInfo,
36 void* dst, size_t dstRowBytes,
37 const Options& opts,
38 int* rowsDecoded) {
39 if (opts.fSubset) {
40 // Subsets are not supported.
41 return kUnimplemented;
42 }
43
44 Result result = this->prepareToDecode(dstInfo, opts);
45 if (kSuccess != result) {
46 return result;
47 }
48
49 // Perform the decode
50 int rows = this->decodeRows(dstInfo, dst, dstRowBytes, opts);
51 if (rows != dstInfo.height()) {
52 // We set rowsDecoded equal to the height because the background has already
53 // been filled. RLE encodings sometimes skip pixels, so we always start by
54 // filling the background.
55 *rowsDecoded = dstInfo.height();
56 return kIncompleteInput;
57 }
58
59 return kSuccess;
60 }
61
62 /*
63 * Process the color table for the bmp input
64 */
createColorTable(SkColorType dstColorType)65 bool SkBmpRLECodec::createColorTable(SkColorType dstColorType) {
66 // Allocate memory for color table
67 uint32_t colorBytes = 0;
68 SkPMColor colorTable[256];
69 if (this->bitsPerPixel() <= 8) {
70 // Inform the caller of the number of colors
71 uint32_t maxColors = 1 << this->bitsPerPixel();
72 // Don't bother reading more than maxColors.
73 const uint32_t numColorsToRead =
74 fNumColors == 0 ? maxColors : SkTMin(fNumColors, maxColors);
75
76 // Read the color table from the stream
77 colorBytes = numColorsToRead * fBytesPerColor;
78 std::unique_ptr<uint8_t[]> cBuffer(new uint8_t[colorBytes]);
79 if (stream()->read(cBuffer.get(), colorBytes) != colorBytes) {
80 SkCodecPrintf("Error: unable to read color table.\n");
81 return false;
82 }
83
84 // Fill in the color table
85 PackColorProc packARGB = choose_pack_color_proc(false, dstColorType);
86 uint32_t i = 0;
87 for (; i < numColorsToRead; i++) {
88 uint8_t blue = get_byte(cBuffer.get(), i*fBytesPerColor);
89 uint8_t green = get_byte(cBuffer.get(), i*fBytesPerColor + 1);
90 uint8_t red = get_byte(cBuffer.get(), i*fBytesPerColor + 2);
91 colorTable[i] = packARGB(0xFF, red, green, blue);
92 }
93
94 // To avoid segmentation faults on bad pixel data, fill the end of the
95 // color table with black. This is the same the behavior as the
96 // chromium decoder.
97 for (; i < maxColors; i++) {
98 colorTable[i] = SkPackARGB32NoCheck(0xFF, 0, 0, 0);
99 }
100
101 // Set the color table
102 fColorTable.reset(new SkColorTable(colorTable, maxColors));
103 }
104
105 // Check that we have not read past the pixel array offset
106 if(fOffset < colorBytes) {
107 // This may occur on OS 2.1 and other old versions where the color
108 // table defaults to max size, and the bmp tries to use a smaller
109 // color table. This is invalid, and our decision is to indicate
110 // an error, rather than try to guess the intended size of the
111 // color table.
112 SkCodecPrintf("Error: pixel data offset less than color table size.\n");
113 return false;
114 }
115
116 // After reading the color table, skip to the start of the pixel array
117 if (stream()->skip(fOffset - colorBytes) != fOffset - colorBytes) {
118 SkCodecPrintf("Error: unable to skip to image data.\n");
119 return false;
120 }
121
122 // Return true on success
123 return true;
124 }
125
initializeStreamBuffer()126 bool SkBmpRLECodec::initializeStreamBuffer() {
127 fBytesBuffered = this->stream()->read(fStreamBuffer, kBufferSize);
128 if (fBytesBuffered == 0) {
129 SkCodecPrintf("Error: could not read RLE image data.\n");
130 return false;
131 }
132 fCurrRLEByte = 0;
133 return true;
134 }
135
136 /*
137 * @return the number of bytes remaining in the stream buffer after
138 * attempting to read more bytes from the stream
139 */
checkForMoreData()140 size_t SkBmpRLECodec::checkForMoreData() {
141 const size_t remainingBytes = fBytesBuffered - fCurrRLEByte;
142 uint8_t* buffer = fStreamBuffer;
143
144 // We will be reusing the same buffer, starting over from the beginning.
145 // Move any remaining bytes to the start of the buffer.
146 // We use memmove() instead of memcpy() because there is risk that the dst
147 // and src memory will overlap in corrupt images.
148 memmove(buffer, SkTAddOffset<uint8_t>(buffer, fCurrRLEByte), remainingBytes);
149
150 // Adjust the buffer ptr to the start of the unfilled data.
151 buffer += remainingBytes;
152
153 // Try to read additional bytes from the stream. There are fCurrRLEByte
154 // bytes of additional space remaining in the buffer, assuming that we
155 // have already copied remainingBytes to the start of the buffer.
156 size_t additionalBytes = this->stream()->read(buffer, fCurrRLEByte);
157
158 // Update counters and return the number of bytes we currently have
159 // available. We are at the start of the buffer again.
160 fCurrRLEByte = 0;
161 fBytesBuffered = remainingBytes + additionalBytes;
162 return fBytesBuffered;
163 }
164
165 /*
166 * Set an RLE pixel using the color table
167 */
setPixel(void * dst,size_t dstRowBytes,const SkImageInfo & dstInfo,uint32_t x,uint32_t y,uint8_t index)168 void SkBmpRLECodec::setPixel(void* dst, size_t dstRowBytes,
169 const SkImageInfo& dstInfo, uint32_t x, uint32_t y,
170 uint8_t index) {
171 if (dst && is_coord_necessary(x, fSampleX, dstInfo.width())) {
172 // Set the row
173 uint32_t row = this->getDstRow(y, dstInfo.height());
174
175 // Set the pixel based on destination color type
176 const int dstX = get_dst_coord(x, fSampleX);
177 switch (dstInfo.colorType()) {
178 case kRGBA_8888_SkColorType:
179 case kBGRA_8888_SkColorType: {
180 SkPMColor* dstRow = SkTAddOffset<SkPMColor>(dst, row * (int) dstRowBytes);
181 dstRow[dstX] = fColorTable->operator[](index);
182 break;
183 }
184 case kRGB_565_SkColorType: {
185 uint16_t* dstRow = SkTAddOffset<uint16_t>(dst, row * (int) dstRowBytes);
186 dstRow[dstX] = SkPixel32ToPixel16(fColorTable->operator[](index));
187 break;
188 }
189 default:
190 // This case should not be reached. We should catch an invalid
191 // color type when we check that the conversion is possible.
192 SkASSERT(false);
193 break;
194 }
195 }
196 }
197
198 /*
199 * Set an RLE pixel from R, G, B values
200 */
setRGBPixel(void * dst,size_t dstRowBytes,const SkImageInfo & dstInfo,uint32_t x,uint32_t y,uint8_t red,uint8_t green,uint8_t blue)201 void SkBmpRLECodec::setRGBPixel(void* dst, size_t dstRowBytes,
202 const SkImageInfo& dstInfo, uint32_t x,
203 uint32_t y, uint8_t red, uint8_t green,
204 uint8_t blue) {
205 if (dst && is_coord_necessary(x, fSampleX, dstInfo.width())) {
206 // Set the row
207 uint32_t row = this->getDstRow(y, dstInfo.height());
208
209 // Set the pixel based on destination color type
210 const int dstX = get_dst_coord(x, fSampleX);
211 switch (dstInfo.colorType()) {
212 case kRGBA_8888_SkColorType: {
213 SkPMColor* dstRow = SkTAddOffset<SkPMColor>(dst, row * (int) dstRowBytes);
214 dstRow[dstX] = SkPackARGB_as_RGBA(0xFF, red, green, blue);
215 break;
216 }
217 case kBGRA_8888_SkColorType: {
218 SkPMColor* dstRow = SkTAddOffset<SkPMColor>(dst, row * (int) dstRowBytes);
219 dstRow[dstX] = SkPackARGB_as_BGRA(0xFF, red, green, blue);
220 break;
221 }
222 case kRGB_565_SkColorType: {
223 uint16_t* dstRow = SkTAddOffset<uint16_t>(dst, row * (int) dstRowBytes);
224 dstRow[dstX] = SkPack888ToRGB16(red, green, blue);
225 break;
226 }
227 default:
228 // This case should not be reached. We should catch an invalid
229 // color type when we check that the conversion is possible.
230 SkASSERT(false);
231 break;
232 }
233 }
234 }
235
onPrepareToDecode(const SkImageInfo & dstInfo,const SkCodec::Options & options)236 SkCodec::Result SkBmpRLECodec::onPrepareToDecode(const SkImageInfo& dstInfo,
237 const SkCodec::Options& options) {
238 // FIXME: Support subsets for scanline decodes.
239 if (options.fSubset) {
240 // Subsets are not supported.
241 return kUnimplemented;
242 }
243
244 // Reset fSampleX. If it needs to be a value other than 1, it will get modified by
245 // the sampler.
246 fSampleX = 1;
247 fLinesToSkip = 0;
248
249 SkColorType colorTableColorType = dstInfo.colorType();
250 if (this->colorXform()) {
251 // Just set a known colorType for the colorTable. No need to actually transform
252 // the colors in the colorTable.
253 colorTableColorType = kBGRA_8888_SkColorType;
254 }
255
256 // Create the color table if necessary and prepare the stream for decode
257 // Note that if it is non-NULL, inputColorCount will be modified
258 if (!this->createColorTable(colorTableColorType)) {
259 SkCodecPrintf("Error: could not create color table.\n");
260 return SkCodec::kInvalidInput;
261 }
262
263 // Initialize a buffer for encoded RLE data
264 if (!this->initializeStreamBuffer()) {
265 SkCodecPrintf("Error: cannot initialize stream buffer.\n");
266 return SkCodec::kInvalidInput;
267 }
268
269 return SkCodec::kSuccess;
270 }
271
272 /*
273 * Performs the bitmap decoding for RLE input format
274 * RLE decoding is performed all at once, rather than a one row at a time
275 */
decodeRows(const SkImageInfo & info,void * dst,size_t dstRowBytes,const Options & opts)276 int SkBmpRLECodec::decodeRows(const SkImageInfo& info, void* dst, size_t dstRowBytes,
277 const Options& opts) {
278 const int width = this->getInfo().width();
279 int height = info.height();
280
281 // Account for sampling.
282 SkImageInfo dstInfo = info.makeWH(get_scaled_dimension(width, fSampleX), height);
283
284 // Set the background as transparent. Then, if the RLE code skips pixels,
285 // the skipped pixels will be transparent.
286 if (dst) {
287 SkSampler::Fill(dstInfo, dst, dstRowBytes, SK_ColorTRANSPARENT, opts.fZeroInitialized);
288 }
289
290 // Adjust the height and the dst if the previous call to decodeRows() left us
291 // with lines that need to be skipped.
292 if (height > fLinesToSkip) {
293 height -= fLinesToSkip;
294 if (dst) {
295 dst = SkTAddOffset<void>(dst, fLinesToSkip * dstRowBytes);
296 }
297 fLinesToSkip = 0;
298
299 dstInfo = dstInfo.makeWH(dstInfo.width(), height);
300 } else {
301 fLinesToSkip -= height;
302 return height;
303 }
304
305 void* decodeDst = dst;
306 size_t decodeRowBytes = dstRowBytes;
307 SkImageInfo decodeInfo = dstInfo;
308 if (decodeDst) {
309 if (this->colorXform()) {
310 decodeInfo = decodeInfo.makeColorType(kXformSrcColorType);
311 if (kRGBA_F16_SkColorType == dstInfo.colorType()) {
312 int count = height * dstInfo.width();
313 this->resetXformBuffer(count);
314 sk_bzero(this->xformBuffer(), count * sizeof(uint32_t));
315 decodeDst = this->xformBuffer();
316 decodeRowBytes = dstInfo.width() * sizeof(uint32_t);
317 }
318 }
319 }
320
321 int decodedHeight = this->decodeRLE(decodeInfo, decodeDst, decodeRowBytes);
322 if (this->colorXform() && decodeDst) {
323 for (int y = 0; y < decodedHeight; y++) {
324 this->applyColorXform(dst, decodeDst, dstInfo.width());
325 decodeDst = SkTAddOffset<void>(decodeDst, decodeRowBytes);
326 dst = SkTAddOffset<void>(dst, dstRowBytes);
327 }
328 }
329
330 return decodedHeight;
331 }
332
decodeRLE(const SkImageInfo & dstInfo,void * dst,size_t dstRowBytes)333 int SkBmpRLECodec::decodeRLE(const SkImageInfo& dstInfo, void* dst, size_t dstRowBytes) {
334 // Use the original width to count the number of pixels in each row.
335 const int width = this->getInfo().width();
336
337 // This tells us the number of rows that we are meant to decode.
338 const int height = dstInfo.height();
339
340 // Set RLE flags
341 constexpr uint8_t RLE_ESCAPE = 0;
342 constexpr uint8_t RLE_EOL = 0;
343 constexpr uint8_t RLE_EOF = 1;
344 constexpr uint8_t RLE_DELTA = 2;
345
346 // Destination parameters
347 int x = 0;
348 int y = 0;
349
350 while (true) {
351 // If we have reached a row that is beyond the requested height, we have
352 // succeeded.
353 if (y >= height) {
354 // It would be better to check for the EOF marker before indicating
355 // success, but we may be performing a scanline decode, which
356 // would require us to stop before decoding the full height.
357 return height;
358 }
359
360 // Every entry takes at least two bytes
361 if ((int) fBytesBuffered - fCurrRLEByte < 2) {
362 if (this->checkForMoreData() < 2) {
363 return y;
364 }
365 }
366
367 // Read the next two bytes. These bytes have different meanings
368 // depending on their values. In the first interpretation, the first
369 // byte is an escape flag and the second byte indicates what special
370 // task to perform.
371 const uint8_t flag = fStreamBuffer[fCurrRLEByte++];
372 const uint8_t task = fStreamBuffer[fCurrRLEByte++];
373
374 // Perform decoding
375 if (RLE_ESCAPE == flag) {
376 switch (task) {
377 case RLE_EOL:
378 x = 0;
379 y++;
380 break;
381 case RLE_EOF:
382 return height;
383 case RLE_DELTA: {
384 // Two bytes are needed to specify delta
385 if ((int) fBytesBuffered - fCurrRLEByte < 2) {
386 if (this->checkForMoreData() < 2) {
387 return y;
388 }
389 }
390 // Modify x and y
391 const uint8_t dx = fStreamBuffer[fCurrRLEByte++];
392 const uint8_t dy = fStreamBuffer[fCurrRLEByte++];
393 x += dx;
394 y += dy;
395 if (x > width) {
396 SkCodecPrintf("Warning: invalid RLE input.\n");
397 return y - dy;
398 } else if (y > height) {
399 fLinesToSkip = y - height;
400 return height;
401 }
402 break;
403 }
404 default: {
405 // If task does not match any of the above signals, it
406 // indicates that we have a sequence of non-RLE pixels.
407 // Furthermore, the value of task is equal to the number
408 // of pixels to interpret.
409 uint8_t numPixels = task;
410 const size_t rowBytes = compute_row_bytes(numPixels,
411 this->bitsPerPixel());
412 // Abort if setting numPixels moves us off the edge of the
413 // image.
414 if (x + numPixels > width) {
415 SkCodecPrintf("Warning: invalid RLE input.\n");
416 return y;
417 }
418
419 // Also abort if there are not enough bytes
420 // remaining in the stream to set numPixels.
421
422 // At most, alignedRowBytes can be 255 (max uint8_t) *
423 // 3 (max bytes per pixel) + 1 (aligned) = 766. If
424 // fStreamBuffer was smaller than this,
425 // checkForMoreData would never succeed for some bmps.
426 static_assert(255 * 3 + 1 < kBufferSize,
427 "kBufferSize needs to be larger!");
428 const size_t alignedRowBytes = SkAlign2(rowBytes);
429 if ((int) fBytesBuffered - fCurrRLEByte < alignedRowBytes) {
430 SkASSERT(alignedRowBytes < kBufferSize);
431 if (this->checkForMoreData() < alignedRowBytes) {
432 return y;
433 }
434 }
435 // Set numPixels number of pixels
436 while (numPixels > 0) {
437 switch(this->bitsPerPixel()) {
438 case 4: {
439 SkASSERT(fCurrRLEByte < fBytesBuffered);
440 uint8_t val = fStreamBuffer[fCurrRLEByte++];
441 setPixel(dst, dstRowBytes, dstInfo, x++,
442 y, val >> 4);
443 numPixels--;
444 if (numPixels != 0) {
445 setPixel(dst, dstRowBytes, dstInfo,
446 x++, y, val & 0xF);
447 numPixels--;
448 }
449 break;
450 }
451 case 8:
452 SkASSERT(fCurrRLEByte < fBytesBuffered);
453 setPixel(dst, dstRowBytes, dstInfo, x++,
454 y, fStreamBuffer[fCurrRLEByte++]);
455 numPixels--;
456 break;
457 case 24: {
458 SkASSERT(fCurrRLEByte + 2 < fBytesBuffered);
459 uint8_t blue = fStreamBuffer[fCurrRLEByte++];
460 uint8_t green = fStreamBuffer[fCurrRLEByte++];
461 uint8_t red = fStreamBuffer[fCurrRLEByte++];
462 setRGBPixel(dst, dstRowBytes, dstInfo,
463 x++, y, red, green, blue);
464 numPixels--;
465 break;
466 }
467 default:
468 SkASSERT(false);
469 return y;
470 }
471 }
472 // Skip a byte if necessary to maintain alignment
473 if (!SkIsAlign2(rowBytes)) {
474 fCurrRLEByte++;
475 }
476 break;
477 }
478 }
479 } else {
480 // If the first byte read is not a flag, it indicates the number of
481 // pixels to set in RLE mode.
482 const uint8_t numPixels = flag;
483 const int endX = SkTMin<int>(x + numPixels, width);
484
485 if (24 == this->bitsPerPixel()) {
486 // In RLE24, the second byte read is part of the pixel color.
487 // There are two more required bytes to finish encoding the
488 // color.
489 if ((int) fBytesBuffered - fCurrRLEByte < 2) {
490 if (this->checkForMoreData() < 2) {
491 return y;
492 }
493 }
494
495 // Fill the pixels up to endX with the specified color
496 uint8_t blue = task;
497 uint8_t green = fStreamBuffer[fCurrRLEByte++];
498 uint8_t red = fStreamBuffer[fCurrRLEByte++];
499 while (x < endX) {
500 setRGBPixel(dst, dstRowBytes, dstInfo, x++, y, red, green, blue);
501 }
502 } else {
503 // In RLE8 or RLE4, the second byte read gives the index in the
504 // color table to look up the pixel color.
505 // RLE8 has one color index that gets repeated
506 // RLE4 has two color indexes in the upper and lower 4 bits of
507 // the bytes, which are alternated
508 uint8_t indices[2] = { task, task };
509 if (4 == this->bitsPerPixel()) {
510 indices[0] >>= 4;
511 indices[1] &= 0xf;
512 }
513
514 // Set the indicated number of pixels
515 for (int which = 0; x < endX; x++) {
516 setPixel(dst, dstRowBytes, dstInfo, x, y, indices[which]);
517 which = !which;
518 }
519 }
520 }
521 }
522 }
523
skipRows(int count)524 bool SkBmpRLECodec::skipRows(int count) {
525 const SkImageInfo rowInfo = SkImageInfo::Make(this->getInfo().width(), count, kN32_SkColorType,
526 kUnpremul_SkAlphaType);
527
528 return count == this->decodeRows(rowInfo, nullptr, 0, this->options());
529 }
530
531 // FIXME: Make SkBmpRLECodec have no knowledge of sampling.
532 // Or it should do all sampling natively.
533 // It currently is a hybrid that needs to know what SkScaledCodec is doing.
534 class SkBmpRLESampler : public SkSampler {
535 public:
SkBmpRLESampler(SkBmpRLECodec * codec)536 SkBmpRLESampler(SkBmpRLECodec* codec)
537 : fCodec(codec)
538 {
539 SkASSERT(fCodec);
540 }
541
542 private:
onSetSampleX(int sampleX)543 int onSetSampleX(int sampleX) override {
544 return fCodec->setSampleX(sampleX);
545 }
546
547 // Unowned pointer. fCodec will delete this class in its destructor.
548 SkBmpRLECodec* fCodec;
549 };
550
getSampler(bool)551 SkSampler* SkBmpRLECodec::getSampler(bool /*createIfNecessary*/) {
552 // We will always create an SkBmpRLESampler if one is requested.
553 // This allows clients to always use the SkBmpRLESampler's
554 // version of fill(), which does nothing since RLE decodes have
555 // already filled pixel memory. This seems fine, since creating
556 // an SkBmpRLESampler is pretty inexpensive.
557 if (!fSampler) {
558 fSampler.reset(new SkBmpRLESampler(this));
559 }
560
561 return fSampler.get();
562 }
563
setSampleX(int sampleX)564 int SkBmpRLECodec::setSampleX(int sampleX){
565 fSampleX = sampleX;
566 return get_scaled_dimension(this->getInfo().width(), sampleX);
567 }
568