• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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