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