msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 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 | |
msarett | b46e5e2 | 2015-07-30 11:36:40 -0700 | [diff] [blame] | 8 | #include "SkBmpCodec.h" |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 9 | #include "SkBmpMaskCodec.h" |
| 10 | #include "SkBmpRLECodec.h" |
| 11 | #include "SkBmpStandardCodec.h" |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 12 | #include "SkCodecPriv.h" |
Cary Clark | a4083c9 | 2017-09-15 11:59:23 -0400 | [diff] [blame] | 13 | #include "SkColorData.h" |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 14 | #include "SkStream.h" |
| 15 | |
| 16 | /* |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 17 | * Defines the version and type of the second bitmap header |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 18 | */ |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 19 | enum BmpHeaderType { |
| 20 | kInfoV1_BmpHeaderType, |
| 21 | kInfoV2_BmpHeaderType, |
| 22 | kInfoV3_BmpHeaderType, |
| 23 | kInfoV4_BmpHeaderType, |
| 24 | kInfoV5_BmpHeaderType, |
| 25 | kOS2V1_BmpHeaderType, |
| 26 | kOS2VX_BmpHeaderType, |
| 27 | kUnknown_BmpHeaderType |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 28 | }; |
| 29 | |
| 30 | /* |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 31 | * Possible bitmap compression types |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 32 | */ |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 33 | enum BmpCompressionMethod { |
| 34 | kNone_BmpCompressionMethod = 0, |
| 35 | k8BitRLE_BmpCompressionMethod = 1, |
| 36 | k4BitRLE_BmpCompressionMethod = 2, |
| 37 | kBitMasks_BmpCompressionMethod = 3, |
| 38 | kJpeg_BmpCompressionMethod = 4, |
| 39 | kPng_BmpCompressionMethod = 5, |
| 40 | kAlphaBitMasks_BmpCompressionMethod = 6, |
| 41 | kCMYK_BmpCompressionMethod = 11, |
| 42 | kCMYK8BitRLE_BmpCompressionMethod = 12, |
| 43 | kCMYK4BitRLE_BmpCompressionMethod = 13 |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 44 | }; |
| 45 | |
| 46 | /* |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 47 | * Used to define the input format of the bmp |
| 48 | */ |
| 49 | enum BmpInputFormat { |
| 50 | kStandard_BmpInputFormat, |
| 51 | kRLE_BmpInputFormat, |
| 52 | kBitMask_BmpInputFormat, |
| 53 | kUnknown_BmpInputFormat |
| 54 | }; |
| 55 | |
| 56 | /* |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 57 | * Checks the start of the stream to see if the image is a bitmap |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 58 | */ |
scroggo | db30be2 | 2015-12-08 18:54:13 -0800 | [diff] [blame] | 59 | bool SkBmpCodec::IsBmp(const void* buffer, size_t bytesRead) { |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 60 | // TODO: Support "IC", "PT", "CI", "CP", "BA" |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 61 | const char bmpSig[] = { 'B', 'M' }; |
scroggo | db30be2 | 2015-12-08 18:54:13 -0800 | [diff] [blame] | 62 | return bytesRead >= sizeof(bmpSig) && !memcmp(buffer, bmpSig, sizeof(bmpSig)); |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 63 | } |
| 64 | |
| 65 | /* |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 66 | * Assumes IsBmp was called and returned true |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 67 | * Creates a bmp decoder |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 68 | * Reads enough of the stream to determine the image format |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 69 | */ |
Mike Reed | ede7bac | 2017-07-23 15:30:02 -0400 | [diff] [blame] | 70 | std::unique_ptr<SkCodec> SkBmpCodec::MakeFromStream(std::unique_ptr<SkStream> stream, |
| 71 | Result* result) { |
| 72 | return SkBmpCodec::MakeFromStream(std::move(stream), result, false); |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 73 | } |
| 74 | |
| 75 | /* |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 76 | * Creates a bmp decoder for a bmp embedded in ico |
| 77 | * Reads enough of the stream to determine the image format |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 78 | */ |
Mike Reed | ede7bac | 2017-07-23 15:30:02 -0400 | [diff] [blame] | 79 | std::unique_ptr<SkCodec> SkBmpCodec::MakeFromIco(std::unique_ptr<SkStream> stream, Result* result) { |
| 80 | return SkBmpCodec::MakeFromStream(std::move(stream), result, true); |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 81 | } |
| 82 | |
Leon Scroggins III | 0b24cbd | 2016-12-15 15:58:22 -0500 | [diff] [blame] | 83 | // Header size constants |
Leon Scroggins III | 862c196 | 2017-10-02 16:28:49 -0400 | [diff] [blame] | 84 | static constexpr uint32_t kBmpHeaderBytes = 14; |
| 85 | static constexpr uint32_t kBmpHeaderBytesPlusFour = kBmpHeaderBytes + 4; |
| 86 | static constexpr uint32_t kBmpOS2V1Bytes = 12; |
| 87 | static constexpr uint32_t kBmpOS2V2Bytes = 64; |
| 88 | static constexpr uint32_t kBmpInfoBaseBytes = 16; |
| 89 | static constexpr uint32_t kBmpInfoV1Bytes = 40; |
| 90 | static constexpr uint32_t kBmpInfoV2Bytes = 52; |
| 91 | static constexpr uint32_t kBmpInfoV3Bytes = 56; |
| 92 | static constexpr uint32_t kBmpInfoV4Bytes = 108; |
| 93 | static constexpr uint32_t kBmpInfoV5Bytes = 124; |
| 94 | static constexpr uint32_t kBmpMaskBytes = 12; |
Leon Scroggins III | 0b24cbd | 2016-12-15 15:58:22 -0500 | [diff] [blame] | 95 | |
| 96 | static BmpHeaderType get_header_type(size_t infoBytes) { |
| 97 | if (infoBytes >= kBmpInfoBaseBytes) { |
| 98 | // Check the version of the header |
| 99 | switch (infoBytes) { |
| 100 | case kBmpInfoV1Bytes: |
| 101 | return kInfoV1_BmpHeaderType; |
| 102 | case kBmpInfoV2Bytes: |
| 103 | return kInfoV2_BmpHeaderType; |
| 104 | case kBmpInfoV3Bytes: |
| 105 | return kInfoV3_BmpHeaderType; |
| 106 | case kBmpInfoV4Bytes: |
| 107 | return kInfoV4_BmpHeaderType; |
| 108 | case kBmpInfoV5Bytes: |
| 109 | return kInfoV5_BmpHeaderType; |
| 110 | case 16: |
| 111 | case 20: |
| 112 | case 24: |
| 113 | case 28: |
| 114 | case 32: |
| 115 | case 36: |
| 116 | case 42: |
| 117 | case 46: |
| 118 | case 48: |
| 119 | case 60: |
| 120 | case kBmpOS2V2Bytes: |
| 121 | return kOS2VX_BmpHeaderType; |
| 122 | default: |
| 123 | SkCodecPrintf("Error: unknown bmp header format.\n"); |
| 124 | return kUnknown_BmpHeaderType; |
| 125 | } |
| 126 | } if (infoBytes >= kBmpOS2V1Bytes) { |
| 127 | // The OS2V1 is treated separately because it has a unique format |
| 128 | return kOS2V1_BmpHeaderType; |
| 129 | } else { |
| 130 | // There are no valid bmp headers |
| 131 | SkCodecPrintf("Error: second bitmap header size is invalid.\n"); |
| 132 | return kUnknown_BmpHeaderType; |
| 133 | } |
| 134 | } |
| 135 | |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 136 | SkCodec::Result SkBmpCodec::ReadHeader(SkStream* stream, bool inIco, |
Leon Scroggins III | fc4ee22 | 2017-07-14 11:48:52 -0400 | [diff] [blame] | 137 | std::unique_ptr<SkCodec>* codecOut) { |
tomhudson | 7aa846c | 2015-03-24 13:47:41 -0700 | [diff] [blame] | 138 | // The total bytes in the bmp file |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 139 | // We only need to use this value for RLE decoding, so we will only |
| 140 | // check that it is valid in the RLE case. |
| 141 | uint32_t totalBytes; |
tomhudson | 7aa846c | 2015-03-24 13:47:41 -0700 | [diff] [blame] | 142 | // The offset from the start of the file where the pixel data begins |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 143 | uint32_t offset; |
| 144 | // The size of the second (info) header in bytes |
| 145 | uint32_t infoBytes; |
| 146 | |
| 147 | // Bmps embedded in Icos skip the first Bmp header |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 148 | if (!inIco) { |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 149 | // Read the first header and the size of the second header |
Leon Scroggins III | ec4400b | 2017-06-01 14:06:35 -0400 | [diff] [blame] | 150 | uint8_t hBuffer[kBmpHeaderBytesPlusFour]; |
| 151 | if (stream->read(hBuffer, kBmpHeaderBytesPlusFour) != |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 152 | kBmpHeaderBytesPlusFour) { |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 153 | SkCodecPrintf("Error: unable to read first bitmap header.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 154 | return kIncompleteInput; |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 155 | } |
| 156 | |
Leon Scroggins III | ec4400b | 2017-06-01 14:06:35 -0400 | [diff] [blame] | 157 | totalBytes = get_int(hBuffer, 2); |
| 158 | offset = get_int(hBuffer, 10); |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 159 | if (offset < kBmpHeaderBytes + kBmpOS2V1Bytes) { |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 160 | SkCodecPrintf("Error: invalid starting location for pixel data\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 161 | return kInvalidInput; |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 162 | } |
| 163 | |
| 164 | // The size of the second (info) header in bytes |
| 165 | // The size is the first field of the second header, so we have already |
| 166 | // read the first four infoBytes. |
Leon Scroggins III | ec4400b | 2017-06-01 14:06:35 -0400 | [diff] [blame] | 167 | infoBytes = get_int(hBuffer, 14); |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 168 | if (infoBytes < kBmpOS2V1Bytes) { |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 169 | SkCodecPrintf("Error: invalid second header size.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 170 | return kInvalidInput; |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 171 | } |
| 172 | } else { |
| 173 | // This value is only used by RLE compression. Bmp in Ico files do not |
| 174 | // use RLE. If the compression field is incorrectly signaled as RLE, |
| 175 | // we will catch this and signal an error below. |
| 176 | totalBytes = 0; |
| 177 | |
| 178 | // Bmps in Ico cannot specify an offset. We will always assume that |
| 179 | // pixel data begins immediately after the color table. This value |
| 180 | // will be corrected below. |
| 181 | offset = 0; |
| 182 | |
| 183 | // Read the size of the second header |
Leon Scroggins III | ec4400b | 2017-06-01 14:06:35 -0400 | [diff] [blame] | 184 | uint8_t hBuffer[4]; |
| 185 | if (stream->read(hBuffer, 4) != 4) { |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 186 | SkCodecPrintf("Error: unable to read size of second bitmap header.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 187 | return kIncompleteInput; |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 188 | } |
Leon Scroggins III | ec4400b | 2017-06-01 14:06:35 -0400 | [diff] [blame] | 189 | infoBytes = get_int(hBuffer, 0); |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 190 | if (infoBytes < kBmpOS2V1Bytes) { |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 191 | SkCodecPrintf("Error: invalid second header size.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 192 | return kInvalidInput; |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 193 | } |
tomhudson | 7aa846c | 2015-03-24 13:47:41 -0700 | [diff] [blame] | 194 | } |
| 195 | |
Leon Scroggins III | 0b24cbd | 2016-12-15 15:58:22 -0500 | [diff] [blame] | 196 | // Determine image information depending on second header format |
| 197 | const BmpHeaderType headerType = get_header_type(infoBytes); |
| 198 | if (kUnknown_BmpHeaderType == headerType) { |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 199 | return kInvalidInput; |
Leon Scroggins III | 0b24cbd | 2016-12-15 15:58:22 -0500 | [diff] [blame] | 200 | } |
| 201 | |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 202 | // We already read the first four bytes of the info header to get the size |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 203 | const uint32_t infoBytesRemaining = infoBytes - 4; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 204 | |
| 205 | // Read the second header |
Ben Wagner | 7ecc596 | 2016-11-02 17:07:33 -0400 | [diff] [blame] | 206 | std::unique_ptr<uint8_t[]> iBuffer(new uint8_t[infoBytesRemaining]); |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 207 | if (stream->read(iBuffer.get(), infoBytesRemaining) != infoBytesRemaining) { |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 208 | SkCodecPrintf("Error: unable to read second bitmap header.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 209 | return kIncompleteInput; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 210 | } |
| 211 | |
| 212 | // The number of bits used per pixel in the pixel data |
| 213 | uint16_t bitsPerPixel; |
| 214 | |
| 215 | // The compression method for the pixel data |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 216 | uint32_t compression = kNone_BmpCompressionMethod; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 217 | |
| 218 | // Number of colors in the color table, defaults to 0 or max (see below) |
| 219 | uint32_t numColors = 0; |
| 220 | |
| 221 | // Bytes per color in the color table, early versions use 3, most use 4 |
| 222 | uint32_t bytesPerColor; |
| 223 | |
| 224 | // The image width and height |
| 225 | int width, height; |
| 226 | |
Leon Scroggins III | 0b24cbd | 2016-12-15 15:58:22 -0500 | [diff] [blame] | 227 | switch (headerType) { |
| 228 | case kInfoV1_BmpHeaderType: |
| 229 | case kInfoV2_BmpHeaderType: |
| 230 | case kInfoV3_BmpHeaderType: |
| 231 | case kInfoV4_BmpHeaderType: |
| 232 | case kInfoV5_BmpHeaderType: |
| 233 | case kOS2VX_BmpHeaderType: |
| 234 | // We check the size of the header before entering the if statement. |
| 235 | // We should not reach this point unless the size is large enough for |
| 236 | // these required fields. |
| 237 | SkASSERT(infoBytesRemaining >= 12); |
| 238 | width = get_int(iBuffer.get(), 0); |
| 239 | height = get_int(iBuffer.get(), 4); |
| 240 | bitsPerPixel = get_short(iBuffer.get(), 10); |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 241 | |
Leon Scroggins III | 0b24cbd | 2016-12-15 15:58:22 -0500 | [diff] [blame] | 242 | // Some versions do not have these fields, so we check before |
| 243 | // overwriting the default value. |
| 244 | if (infoBytesRemaining >= 16) { |
| 245 | compression = get_int(iBuffer.get(), 12); |
| 246 | if (infoBytesRemaining >= 32) { |
| 247 | numColors = get_int(iBuffer.get(), 28); |
| 248 | } |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 249 | } |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 250 | |
Leon Scroggins III | 0b24cbd | 2016-12-15 15:58:22 -0500 | [diff] [blame] | 251 | // All of the headers that reach this point, store color table entries |
| 252 | // using 4 bytes per pixel. |
| 253 | bytesPerColor = 4; |
| 254 | break; |
| 255 | case kOS2V1_BmpHeaderType: |
| 256 | // The OS2V1 is treated separately because it has a unique format |
| 257 | width = (int) get_short(iBuffer.get(), 0); |
| 258 | height = (int) get_short(iBuffer.get(), 2); |
| 259 | bitsPerPixel = get_short(iBuffer.get(), 6); |
| 260 | bytesPerColor = 3; |
| 261 | break; |
| 262 | case kUnknown_BmpHeaderType: |
| 263 | // We'll exit above in this case. |
| 264 | SkASSERT(false); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 265 | return kInvalidInput; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 266 | } |
| 267 | |
| 268 | // Check for valid dimensions from header |
scroggo | 46c5747 | 2015-09-30 08:57:13 -0700 | [diff] [blame] | 269 | SkCodec::SkScanlineOrder rowOrder = SkCodec::kBottomUp_SkScanlineOrder; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 270 | if (height < 0) { |
Leon Scroggins III | ce6d93a | 2018-02-15 09:25:11 -0500 | [diff] [blame] | 271 | // We can't negate INT32_MIN. |
| 272 | if (height == INT32_MIN) { |
| 273 | return kInvalidInput; |
| 274 | } |
| 275 | |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 276 | height = -height; |
scroggo | 46c5747 | 2015-09-30 08:57:13 -0700 | [diff] [blame] | 277 | rowOrder = SkCodec::kTopDown_SkScanlineOrder; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 278 | } |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 279 | // The height field for bmp in ico is double the actual height because they |
| 280 | // contain an XOR mask followed by an AND mask |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 281 | if (inIco) { |
msarett | 9bde918 | 2015-03-25 05:27:48 -0700 | [diff] [blame] | 282 | height /= 2; |
| 283 | } |
Leon Scroggins III | 0354c62 | 2017-02-24 15:33:24 -0500 | [diff] [blame] | 284 | |
| 285 | // Arbitrary maximum. Matches Chromium. |
| 286 | constexpr int kMaxDim = 1 << 16; |
| 287 | if (width <= 0 || height <= 0 || width >= kMaxDim || height >= kMaxDim) { |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 288 | SkCodecPrintf("Error: invalid bitmap dimensions.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 289 | return kInvalidInput; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 290 | } |
| 291 | |
| 292 | // Create mask struct |
| 293 | SkMasks::InputMasks inputMasks; |
msarett | eed039b | 2015-03-18 11:11:19 -0700 | [diff] [blame] | 294 | memset(&inputMasks, 0, sizeof(SkMasks::InputMasks)); |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 295 | |
| 296 | // Determine the input compression format and set bit masks if necessary |
| 297 | uint32_t maskBytes = 0; |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 298 | BmpInputFormat inputFormat = kUnknown_BmpInputFormat; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 299 | switch (compression) { |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 300 | case kNone_BmpCompressionMethod: |
| 301 | inputFormat = kStandard_BmpInputFormat; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 302 | |
| 303 | // In addition to more standard pixel compression formats, bmp supports |
| 304 | // the use of bit masks to determine pixel components. The standard |
| 305 | // format for representing 16-bit colors is 555 (XRRRRRGGGGGBBBBB), |
| 306 | // which does not map well to any Skia color formats. For this reason, |
| 307 | // we will always enable mask mode with 16 bits per pixel. |
| 308 | if (16 == bitsPerPixel) { |
| 309 | inputMasks.red = 0x7C00; |
| 310 | inputMasks.green = 0x03E0; |
| 311 | inputMasks.blue = 0x001F; |
| 312 | inputFormat = kBitMask_BmpInputFormat; |
| 313 | } |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 314 | break; |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 315 | case k8BitRLE_BmpCompressionMethod: |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 316 | if (bitsPerPixel != 8) { |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 317 | SkCodecPrintf("Warning: correcting invalid bitmap format.\n"); |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 318 | bitsPerPixel = 8; |
| 319 | } |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 320 | inputFormat = kRLE_BmpInputFormat; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 321 | break; |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 322 | case k4BitRLE_BmpCompressionMethod: |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 323 | if (bitsPerPixel != 4) { |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 324 | SkCodecPrintf("Warning: correcting invalid bitmap format.\n"); |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 325 | bitsPerPixel = 4; |
| 326 | } |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 327 | inputFormat = kRLE_BmpInputFormat; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 328 | break; |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 329 | case kAlphaBitMasks_BmpCompressionMethod: |
| 330 | case kBitMasks_BmpCompressionMethod: |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 331 | // Load the masks |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 332 | inputFormat = kBitMask_BmpInputFormat; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 333 | switch (headerType) { |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 334 | case kInfoV1_BmpHeaderType: { |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 335 | // The V1 header stores the bit masks after the header |
Leon Scroggins III | ec4400b | 2017-06-01 14:06:35 -0400 | [diff] [blame] | 336 | uint8_t buffer[kBmpMaskBytes]; |
| 337 | if (stream->read(buffer, kBmpMaskBytes) != kBmpMaskBytes) { |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 338 | SkCodecPrintf("Error: unable to read bit inputMasks.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 339 | return kIncompleteInput; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 340 | } |
| 341 | maskBytes = kBmpMaskBytes; |
Leon Scroggins III | ec4400b | 2017-06-01 14:06:35 -0400 | [diff] [blame] | 342 | inputMasks.red = get_int(buffer, 0); |
| 343 | inputMasks.green = get_int(buffer, 4); |
| 344 | inputMasks.blue = get_int(buffer, 8); |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 345 | break; |
| 346 | } |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 347 | case kInfoV2_BmpHeaderType: |
| 348 | case kInfoV3_BmpHeaderType: |
| 349 | case kInfoV4_BmpHeaderType: |
| 350 | case kInfoV5_BmpHeaderType: |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 351 | // Header types are matched based on size. If the header |
| 352 | // is V2+, we are guaranteed to be able to read at least |
| 353 | // this size. |
| 354 | SkASSERT(infoBytesRemaining >= 48); |
| 355 | inputMasks.red = get_int(iBuffer.get(), 36); |
| 356 | inputMasks.green = get_int(iBuffer.get(), 40); |
| 357 | inputMasks.blue = get_int(iBuffer.get(), 44); |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 358 | |
| 359 | if (kInfoV2_BmpHeaderType == headerType || |
| 360 | (kInfoV3_BmpHeaderType == headerType && !inIco)) { |
| 361 | break; |
| 362 | } |
| 363 | |
| 364 | // V3+ bmp files introduce an alpha mask and allow the creator of the image |
| 365 | // to use the alpha channels. However, many of these images leave the |
| 366 | // alpha channel blank and expect to be rendered as opaque. This is the |
| 367 | // case for almost all V3 images, so we ignore the alpha mask. For V4+ |
| 368 | // images in kMask mode, we will use the alpha mask. Additionally, V3 |
| 369 | // bmp-in-ico expect us to use the alpha mask. |
| 370 | // |
| 371 | // skbug.com/4116: We should perhaps also apply the alpha mask in kStandard |
| 372 | // mode. We just haven't seen any images that expect this |
| 373 | // behavior. |
| 374 | // |
| 375 | // Header types are matched based on size. If the header is |
| 376 | // V3+, we are guaranteed to be able to read at least this size. |
Leon Scroggins III | 57862f6 | 2018-10-23 11:17:38 -0400 | [diff] [blame] | 377 | SkASSERT(infoBytesRemaining >= 52); |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 378 | inputMasks.alpha = get_int(iBuffer.get(), 48); |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 379 | break; |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 380 | case kOS2VX_BmpHeaderType: |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 381 | // TODO: Decide if we intend to support this. |
| 382 | // It is unsupported in the previous version and |
| 383 | // in chromium. I have not come across a test case |
| 384 | // that uses this format. |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 385 | SkCodecPrintf("Error: huffman format unsupported.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 386 | return kUnimplemented; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 387 | default: |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 388 | SkCodecPrintf("Error: invalid bmp bit masks header.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 389 | return kInvalidInput; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 390 | } |
| 391 | break; |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 392 | case kJpeg_BmpCompressionMethod: |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 393 | if (24 == bitsPerPixel) { |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 394 | inputFormat = kRLE_BmpInputFormat; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 395 | break; |
| 396 | } |
| 397 | // Fall through |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 398 | case kPng_BmpCompressionMethod: |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 399 | // TODO: Decide if we intend to support this. |
| 400 | // It is unsupported in the previous version and |
| 401 | // in chromium. I think it is used mostly for printers. |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 402 | SkCodecPrintf("Error: compression format not supported.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 403 | return kUnimplemented; |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 404 | case kCMYK_BmpCompressionMethod: |
| 405 | case kCMYK8BitRLE_BmpCompressionMethod: |
| 406 | case kCMYK4BitRLE_BmpCompressionMethod: |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 407 | // TODO: Same as above. |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 408 | SkCodecPrintf("Error: CMYK not supported for bitmap decoding.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 409 | return kUnimplemented; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 410 | default: |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 411 | SkCodecPrintf("Error: invalid format for bitmap decoding.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 412 | return kInvalidInput; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 413 | } |
mtklein | 852f15d | 2016-03-17 10:51:27 -0700 | [diff] [blame] | 414 | iBuffer.reset(); |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 415 | |
msarett | eed039b | 2015-03-18 11:11:19 -0700 | [diff] [blame] | 416 | // Calculate the number of bytes read so far |
| 417 | const uint32_t bytesRead = kBmpHeaderBytes + infoBytes + maskBytes; |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 418 | if (!inIco && offset < bytesRead) { |
msarett | 9aa32d1 | 2015-09-01 14:40:46 -0700 | [diff] [blame] | 419 | // TODO (msarett): Do we really want to fail if the offset in the header is invalid? |
| 420 | // Seems like we can just assume that the offset is zero and try to decode? |
| 421 | // Maybe we don't want to try to decode corrupt images? |
scroggo | 230d4ac | 2015-03-26 07:15:55 -0700 | [diff] [blame] | 422 | SkCodecPrintf("Error: pixel data offset less than header size.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 423 | return kInvalidInput; |
msarett | eed039b | 2015-03-18 11:11:19 -0700 | [diff] [blame] | 424 | } |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 425 | |
msarett | 9aa32d1 | 2015-09-01 14:40:46 -0700 | [diff] [blame] | 426 | |
msarett | f4004f9 | 2016-02-11 10:49:31 -0800 | [diff] [blame] | 427 | |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 428 | switch (inputFormat) { |
| 429 | case kStandard_BmpInputFormat: { |
msarett | c30c418 | 2016-04-20 11:53:35 -0700 | [diff] [blame] | 430 | // BMPs are generally opaque, however BMPs-in-ICOs may contain |
| 431 | // a transparency mask after the image. Therefore, we mark the |
| 432 | // alpha as kBinary if the BMP is contained in an ICO. |
| 433 | // We use |isOpaque| to indicate if the BMP itself is opaque. |
| 434 | SkEncodedInfo::Alpha alpha = inIco ? SkEncodedInfo::kBinary_Alpha : |
| 435 | SkEncodedInfo::kOpaque_Alpha; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 436 | bool isOpaque = true; |
msarett | c30c418 | 2016-04-20 11:53:35 -0700 | [diff] [blame] | 437 | |
| 438 | SkEncodedInfo::Color color; |
| 439 | uint8_t bitsPerComponent; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 440 | switch (bitsPerPixel) { |
| 441 | // Palette formats |
| 442 | case 1: |
| 443 | case 2: |
| 444 | case 4: |
| 445 | case 8: |
msarett | c30c418 | 2016-04-20 11:53:35 -0700 | [diff] [blame] | 446 | // In the case of ICO, kBGRA is actually the closest match, |
| 447 | // since we will need to apply a transparency mask. |
| 448 | if (inIco) { |
| 449 | color = SkEncodedInfo::kBGRA_Color; |
| 450 | bitsPerComponent = 8; |
| 451 | } else { |
| 452 | color = SkEncodedInfo::kPalette_Color; |
| 453 | bitsPerComponent = (uint8_t) bitsPerPixel; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 454 | } |
| 455 | break; |
| 456 | case 24: |
msarett | 3e375b0 | 2016-05-04 13:03:48 -0700 | [diff] [blame] | 457 | // In the case of ICO, kBGRA is actually the closest match, |
| 458 | // since we will need to apply a transparency mask. |
| 459 | color = inIco ? SkEncodedInfo::kBGRA_Color : SkEncodedInfo::kBGR_Color; |
msarett | c30c418 | 2016-04-20 11:53:35 -0700 | [diff] [blame] | 460 | bitsPerComponent = 8; |
| 461 | break; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 462 | case 32: |
| 463 | // 32-bit BMP-in-ICOs actually use the alpha channel in place of a |
| 464 | // transparency mask. |
| 465 | if (inIco) { |
| 466 | isOpaque = false; |
msarett | c30c418 | 2016-04-20 11:53:35 -0700 | [diff] [blame] | 467 | alpha = SkEncodedInfo::kUnpremul_Alpha; |
| 468 | color = SkEncodedInfo::kBGRA_Color; |
| 469 | } else { |
| 470 | color = SkEncodedInfo::kBGRX_Color; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 471 | } |
msarett | c30c418 | 2016-04-20 11:53:35 -0700 | [diff] [blame] | 472 | bitsPerComponent = 8; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 473 | break; |
| 474 | default: |
| 475 | SkCodecPrintf("Error: invalid input value for bits per pixel.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 476 | return kInvalidInput; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 477 | } |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 478 | |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 479 | if (codecOut) { |
msarett | be8216a | 2015-12-04 08:00:50 -0800 | [diff] [blame] | 480 | // We require streams to have a memory base for Bmp-in-Ico decodes. |
| 481 | SkASSERT(!inIco || nullptr != stream->getMemoryBase()); |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 482 | |
| 483 | // Set the image info and create a codec. |
Leon Scroggins III | 5dd47e4 | 2018-09-27 15:26:48 -0400 | [diff] [blame] | 484 | auto info = SkEncodedInfo::Make(width, height, color, alpha, bitsPerComponent); |
Leon Scroggins III | 36f7e32 | 2018-08-27 11:55:46 -0400 | [diff] [blame] | 485 | codecOut->reset(new SkBmpStandardCodec(std::move(info), |
Mike Reed | ede7bac | 2017-07-23 15:30:02 -0400 | [diff] [blame] | 486 | std::unique_ptr<SkStream>(stream), |
| 487 | bitsPerPixel, numColors, bytesPerColor, |
| 488 | offset - bytesRead, rowOrder, isOpaque, |
| 489 | inIco)); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 490 | return static_cast<SkBmpStandardCodec*>(codecOut->get())->didCreateSrcBuffer() |
| 491 | ? kSuccess : kInvalidInput; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 492 | } |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 493 | return kSuccess; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 494 | } |
| 495 | |
| 496 | case kBitMask_BmpInputFormat: { |
| 497 | // Bmp-in-Ico must be standard mode |
| 498 | if (inIco) { |
| 499 | SkCodecPrintf("Error: Icos may not use bit mask format.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 500 | return kInvalidInput; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 501 | } |
| 502 | |
| 503 | switch (bitsPerPixel) { |
| 504 | case 16: |
| 505 | case 24: |
| 506 | case 32: |
| 507 | break; |
| 508 | default: |
| 509 | SkCodecPrintf("Error: invalid input value for bits per pixel.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 510 | return kInvalidInput; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 511 | } |
| 512 | |
| 513 | // Skip to the start of the pixel array. |
| 514 | // We can do this here because there is no color table to read |
| 515 | // in bit mask mode. |
| 516 | if (stream->skip(offset - bytesRead) != offset - bytesRead) { |
| 517 | SkCodecPrintf("Error: unable to skip to image data.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 518 | return kIncompleteInput; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 519 | } |
| 520 | |
| 521 | if (codecOut) { |
| 522 | // Check that input bit masks are valid and create the masks object |
Ben Wagner | 145dbcd | 2016-11-03 14:40:50 -0400 | [diff] [blame] | 523 | std::unique_ptr<SkMasks> masks(SkMasks::CreateMasks(inputMasks, bitsPerPixel)); |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 524 | if (nullptr == masks) { |
| 525 | SkCodecPrintf("Error: invalid input masks.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 526 | return kInvalidInput; |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 527 | } |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 528 | |
msarett | c30c418 | 2016-04-20 11:53:35 -0700 | [diff] [blame] | 529 | // Masked bmps are not a great fit for SkEncodedInfo, since they have |
| 530 | // arbitrary component orderings and bits per component. Here we choose |
| 531 | // somewhat reasonable values - it's ok that we don't match exactly |
| 532 | // because SkBmpMaskCodec has its own mask swizzler anyway. |
| 533 | SkEncodedInfo::Color color; |
| 534 | SkEncodedInfo::Alpha alpha; |
| 535 | if (masks->getAlphaMask()) { |
| 536 | color = SkEncodedInfo::kBGRA_Color; |
| 537 | alpha = SkEncodedInfo::kUnpremul_Alpha; |
| 538 | } else { |
| 539 | color = SkEncodedInfo::kBGR_Color; |
| 540 | alpha = SkEncodedInfo::kOpaque_Alpha; |
| 541 | } |
Leon Scroggins III | 5dd47e4 | 2018-09-27 15:26:48 -0400 | [diff] [blame] | 542 | auto info = SkEncodedInfo::Make(width, height, color, alpha, 8); |
Leon Scroggins III | 36f7e32 | 2018-08-27 11:55:46 -0400 | [diff] [blame] | 543 | codecOut->reset(new SkBmpMaskCodec(std::move(info), |
Mike Reed | ede7bac | 2017-07-23 15:30:02 -0400 | [diff] [blame] | 544 | std::unique_ptr<SkStream>(stream), bitsPerPixel, |
Leon Scroggins III | fc4ee22 | 2017-07-14 11:48:52 -0400 | [diff] [blame] | 545 | masks.release(), rowOrder)); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 546 | return static_cast<SkBmpMaskCodec*>(codecOut->get())->didCreateSrcBuffer() |
| 547 | ? kSuccess : kInvalidInput; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 548 | } |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 549 | return kSuccess; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 550 | } |
| 551 | |
| 552 | case kRLE_BmpInputFormat: { |
| 553 | // We should not reach this point without a valid value of bitsPerPixel. |
| 554 | SkASSERT(4 == bitsPerPixel || 8 == bitsPerPixel || 24 == bitsPerPixel); |
| 555 | |
| 556 | // Check for a valid number of total bytes when in RLE mode |
| 557 | if (totalBytes <= offset) { |
| 558 | SkCodecPrintf("Error: RLE requires valid input size.\n"); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 559 | return kInvalidInput; |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 560 | } |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 561 | |
| 562 | // Bmp-in-Ico must be standard mode |
| 563 | // When inIco is true, this line cannot be reached, since we |
| 564 | // require that RLE Bmps have a valid number of totalBytes, and |
| 565 | // Icos skip the header that contains totalBytes. |
| 566 | SkASSERT(!inIco); |
| 567 | |
| 568 | if (codecOut) { |
| 569 | // RLE inputs may skip pixels, leaving them as transparent. This |
| 570 | // is uncommon, but we cannot be certain that an RLE bmp will be |
msarett | c30c418 | 2016-04-20 11:53:35 -0700 | [diff] [blame] | 571 | // opaque or that we will be able to represent it with a palette. |
| 572 | // For that reason, we always indicate that we are kBGRA. |
Leon Scroggins III | 5dd47e4 | 2018-09-27 15:26:48 -0400 | [diff] [blame] | 573 | auto info = SkEncodedInfo::Make(width, height, SkEncodedInfo::kBGRA_Color, |
Leon Scroggins III | 36f7e32 | 2018-08-27 11:55:46 -0400 | [diff] [blame] | 574 | SkEncodedInfo::kBinary_Alpha, 8); |
| 575 | codecOut->reset(new SkBmpRLECodec(std::move(info), |
Mike Reed | ede7bac | 2017-07-23 15:30:02 -0400 | [diff] [blame] | 576 | std::unique_ptr<SkStream>(stream), bitsPerPixel, |
Leon Scroggins III | fc4ee22 | 2017-07-14 11:48:52 -0400 | [diff] [blame] | 577 | numColors, bytesPerColor, offset - bytesRead, |
| 578 | rowOrder)); |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 579 | } |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 580 | return kSuccess; |
msarett | 4ab9d5f | 2015-08-06 15:34:42 -0700 | [diff] [blame] | 581 | } |
msarett | 1088db9 | 2016-03-22 08:58:35 -0700 | [diff] [blame] | 582 | default: |
| 583 | SkASSERT(false); |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 584 | return kInvalidInput; |
scroggo | 79e378d | 2015-04-01 07:39:40 -0700 | [diff] [blame] | 585 | } |
scroggo | 79e378d | 2015-04-01 07:39:40 -0700 | [diff] [blame] | 586 | } |
| 587 | |
| 588 | /* |
scroggo | 79e378d | 2015-04-01 07:39:40 -0700 | [diff] [blame] | 589 | * Creates a bmp decoder |
| 590 | * Reads enough of the stream to determine the image format |
scroggo | 79e378d | 2015-04-01 07:39:40 -0700 | [diff] [blame] | 591 | */ |
Mike Reed | ede7bac | 2017-07-23 15:30:02 -0400 | [diff] [blame] | 592 | std::unique_ptr<SkCodec> SkBmpCodec::MakeFromStream(std::unique_ptr<SkStream> stream, |
| 593 | Result* result, bool inIco) { |
Leon Scroggins III | fc4ee22 | 2017-07-14 11:48:52 -0400 | [diff] [blame] | 594 | std::unique_ptr<SkCodec> codec; |
Mike Reed | ede7bac | 2017-07-23 15:30:02 -0400 | [diff] [blame] | 595 | *result = ReadHeader(stream.get(), inIco, &codec); |
Leon Scroggins III | fc4ee22 | 2017-07-14 11:48:52 -0400 | [diff] [blame] | 596 | if (codec) { |
Mike Reed | ede7bac | 2017-07-23 15:30:02 -0400 | [diff] [blame] | 597 | // codec has taken ownership of stream, so we do not need to delete it. |
| 598 | stream.release(); |
scroggo | 79e378d | 2015-04-01 07:39:40 -0700 | [diff] [blame] | 599 | } |
Mike Reed | ede7bac | 2017-07-23 15:30:02 -0400 | [diff] [blame] | 600 | return kSuccess == *result ? std::move(codec) : nullptr; |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 601 | } |
| 602 | |
Leon Scroggins III | 36f7e32 | 2018-08-27 11:55:46 -0400 | [diff] [blame] | 603 | SkBmpCodec::SkBmpCodec(SkEncodedInfo&& info, std::unique_ptr<SkStream> stream, |
scroggo | 46c5747 | 2015-09-30 08:57:13 -0700 | [diff] [blame] | 604 | uint16_t bitsPerPixel, SkCodec::SkScanlineOrder rowOrder) |
Leon Scroggins III | 36f7e32 | 2018-08-27 11:55:46 -0400 | [diff] [blame] | 605 | : INHERITED(std::move(info), kXformSrcColorFormat, std::move(stream)) |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 606 | , fBitsPerPixel(bitsPerPixel) |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 607 | , fRowOrder(rowOrder) |
Leon Scroggins III | 712476e | 2018-10-03 15:47:00 -0400 | [diff] [blame] | 608 | , fSrcRowBytes(SkAlign4(compute_row_bytes(this->dimensions().width(), fBitsPerPixel))) |
Matt Sarett | 1b96c6f | 2016-11-03 16:15:20 -0400 | [diff] [blame] | 609 | , fXformBuffer(nullptr) |
msarett | 7411438 | 2015-03-16 11:55:18 -0700 | [diff] [blame] | 610 | {} |
| 611 | |
scroggo | b427db1 | 2015-08-12 07:24:13 -0700 | [diff] [blame] | 612 | bool SkBmpCodec::onRewind() { |
Leon Scroggins III | 588fb04 | 2017-07-14 16:32:31 -0400 | [diff] [blame] | 613 | return SkBmpCodec::ReadHeader(this->stream(), this->inIco(), nullptr) == kSuccess; |
msarett | eed039b | 2015-03-18 11:11:19 -0700 | [diff] [blame] | 614 | } |
| 615 | |
scroggo | 46c5747 | 2015-09-30 08:57:13 -0700 | [diff] [blame] | 616 | int32_t SkBmpCodec::getDstRow(int32_t y, int32_t height) const { |
| 617 | if (SkCodec::kTopDown_SkScanlineOrder == fRowOrder) { |
msarett | 5406d6f | 2015-08-31 06:55:13 -0700 | [diff] [blame] | 618 | return y; |
| 619 | } |
scroggo | 46c5747 | 2015-09-30 08:57:13 -0700 | [diff] [blame] | 620 | SkASSERT(SkCodec::kBottomUp_SkScanlineOrder == fRowOrder); |
msarett | 5406d6f | 2015-08-31 06:55:13 -0700 | [diff] [blame] | 621 | return height - y - 1; |
| 622 | } |
| 623 | |
Matt Sarett | 1b96c6f | 2016-11-03 16:15:20 -0400 | [diff] [blame] | 624 | SkCodec::Result SkBmpCodec::prepareToDecode(const SkImageInfo& dstInfo, |
Leon Scroggins | 571b30f | 2017-07-11 17:35:31 +0000 | [diff] [blame] | 625 | const SkCodec::Options& options) { |
Leon Scroggins | 571b30f | 2017-07-11 17:35:31 +0000 | [diff] [blame] | 626 | return this->onPrepareToDecode(dstInfo, options); |
Matt Sarett | 1b96c6f | 2016-11-03 16:15:20 -0400 | [diff] [blame] | 627 | } |
| 628 | |
| 629 | SkCodec::Result SkBmpCodec::onStartScanlineDecode(const SkImageInfo& dstInfo, |
Leon Scroggins | 571b30f | 2017-07-11 17:35:31 +0000 | [diff] [blame] | 630 | const SkCodec::Options& options) { |
| 631 | return prepareToDecode(dstInfo, options); |
scroggo | 46c5747 | 2015-09-30 08:57:13 -0700 | [diff] [blame] | 632 | } |
msarett | 5406d6f | 2015-08-31 06:55:13 -0700 | [diff] [blame] | 633 | |
msarett | e6dd004 | 2015-10-09 11:07:34 -0700 | [diff] [blame] | 634 | int SkBmpCodec::onGetScanlines(void* dst, int count, size_t rowBytes) { |
scroggo | 46c5747 | 2015-09-30 08:57:13 -0700 | [diff] [blame] | 635 | // Create a new image info representing the portion of the image to decode |
| 636 | SkImageInfo rowInfo = this->dstInfo().makeWH(this->dstInfo().width(), count); |
msarett | 5406d6f | 2015-08-31 06:55:13 -0700 | [diff] [blame] | 637 | |
scroggo | 46c5747 | 2015-09-30 08:57:13 -0700 | [diff] [blame] | 638 | // Decode the requested rows |
| 639 | return this->decodeRows(rowInfo, dst, rowBytes, this->options()); |
| 640 | } |
msarett | 9b9497e | 2016-02-11 13:29:36 -0800 | [diff] [blame] | 641 | |
| 642 | bool SkBmpCodec::skipRows(int count) { |
| 643 | const size_t bytesToSkip = count * fSrcRowBytes; |
| 644 | return this->stream()->skip(bytesToSkip) == bytesToSkip; |
| 645 | } |
| 646 | |
| 647 | bool SkBmpCodec::onSkipScanlines(int count) { |
| 648 | return this->skipRows(count); |
| 649 | } |