nsBMPDecoder.h (8919B)
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */ 3 /* This Source Code Form is subject to the terms of the Mozilla Public 4 * License, v. 2.0. If a copy of the MPL was not distributed with this 5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 6 7 #ifndef mozilla_image_decoders_nsBMPDecoder_h 8 #define mozilla_image_decoders_nsBMPDecoder_h 9 10 #include "BMPHeaders.h" 11 #include "Decoder.h" 12 #include "gfxColor.h" 13 #include "StreamingLexer.h" 14 #include "SurfacePipe.h" 15 #include "mozilla/UniquePtr.h" 16 17 namespace mozilla { 18 namespace image { 19 20 namespace bmp { 21 22 struct CalRgbEndpoint { 23 uint32_t mGamma; 24 uint32_t mX; 25 uint32_t mY; 26 uint32_t mZ; 27 }; 28 29 /// This struct contains the fields from the file header and info header that 30 /// we use during decoding. (Excluding bitfields fields, which are kept in 31 /// BitFields.) 32 struct Header { 33 uint32_t mDataOffset; // Offset to raster data. 34 uint32_t mBIHSize; // Header size. 35 int32_t mWidth; // Image width. 36 int32_t mHeight; // Image height. 37 uint16_t mBpp; // Bits per pixel. 38 uint32_t mCompression; // See struct Compression for valid values. 39 uint32_t mImageSize; // (compressed) image size. Can be 0 if 40 // mCompression==0. 41 uint32_t mNumColors; // Used colors. 42 InfoColorSpace mCsType; // Color space type. 43 InfoColorIntent mCsIntent; // Color space intent. 44 45 union { 46 struct { 47 CalRgbEndpoint mRed; 48 CalRgbEndpoint mGreen; 49 CalRgbEndpoint mBlue; 50 } mCalibrated; 51 52 struct { 53 uint32_t mOffset; 54 uint32_t mLength; 55 } mProfile; 56 } mColorSpace; 57 58 Header() 59 : mDataOffset(0), 60 mBIHSize(0), 61 mWidth(0), 62 mHeight(0), 63 mBpp(0), 64 mCompression(0), 65 mImageSize(0), 66 mNumColors(0), 67 mCsType(InfoColorSpace::SRGB), 68 mCsIntent(InfoColorIntent::IMAGES) {} 69 }; 70 71 /// An entry in the color table. 72 struct ColorTableEntry { 73 uint8_t mRed; 74 uint8_t mGreen; 75 uint8_t mBlue; 76 }; 77 78 /// All the color-related bitfields for 16bpp and 32bpp images. We use this 79 /// even for older format BMPs that don't have explicit bitfields. 80 class BitFields { 81 class Value { 82 friend class BitFields; 83 84 uint32_t mMask; // The mask for the value. 85 uint8_t mRightShift; // The amount to right-shift after masking. 86 uint8_t mBitWidth; // The width (in bits) of the value. 87 88 /// Sets the mask (and thus the right-shift and bit-width as well). 89 void Set(uint32_t aMask); 90 91 public: 92 Value() { 93 mMask = 0; 94 mRightShift = 0; 95 mBitWidth = 0; 96 } 97 98 /// Returns true if this channel is used. Only used for alpha. 99 bool IsPresent() const { return mMask != 0x0; } 100 101 /// Extracts the single color value from the multi-color value. 102 uint8_t Get(uint32_t aVal) const; 103 104 /// Like Get(), but specially for alpha. 105 uint8_t GetAlpha(uint32_t aVal, bool& aHasAlphaOut) const; 106 107 /// Specialized versions of Get() for when the bit-width is 5 or 8. 108 /// (They will assert if called and the bit-width is not 5 or 8.) 109 uint8_t Get5(uint32_t aVal) const; 110 uint8_t Get8(uint32_t aVal) const; 111 }; 112 113 public: 114 /// The individual color channels. 115 Value mRed; 116 Value mGreen; 117 Value mBlue; 118 Value mAlpha; 119 120 /// Set bitfields to the standard 5-5-5 16bpp values. 121 void SetR5G5B5(); 122 123 /// Set bitfields to the standard 8-8-8 32bpp values. 124 void SetR8G8B8(); 125 126 /// Test if bitfields have the standard 5-5-5 16bpp values. 127 bool IsR5G5B5() const; 128 129 /// Test if bitfields have the standard 8-8-8 32bpp values. 130 bool IsR8G8B8() const; 131 132 /// Read the bitfields from a header. The reading of the alpha mask is 133 /// optional. 134 void ReadFromHeader(const char* aData, bool aReadAlpha); 135 136 /// Length of the bitfields structure in the BMP file. 137 static const size_t LENGTH = 12; 138 }; 139 140 } // namespace bmp 141 142 class RasterImage; 143 144 /// Decoder for BMP-Files, as used by Windows and OS/2. 145 146 class nsBMPDecoder : public Decoder { 147 public: 148 ~nsBMPDecoder(); 149 150 DecoderType GetType() const override { return DecoderType::BMP; } 151 152 /// @return true if this BMP is a valid ICO resource. 153 bool IsValidICOResource() const override { return true; } 154 155 /// Obtains the internal output image buffer. 156 uint32_t* GetImageData() { return reinterpret_cast<uint32_t*>(mImageData); } 157 158 /// Obtains the length of the internal output image buffer. 159 size_t GetImageDataLength() const { return mImageDataLength; } 160 161 /// Obtains the size of the compressed image resource. 162 int32_t GetCompressedImageSize() const; 163 164 /// Mark this BMP as being within an ICO file. Only used for testing purposes 165 /// because the ICO-specific constructor does this marking automatically. 166 void SetIsWithinICO() { mIsWithinICO = true; } 167 168 /// Did the BMP file have alpha data of any kind? (Only use this after the 169 /// bitmap has been fully decoded.) 170 bool HasTransparency() const { return mDoesHaveTransparency; } 171 172 LexerResult DoDecode(SourceBufferIterator& aIterator, 173 IResumable* aOnResume) override; 174 nsresult BeforeFinishInternal() override; 175 nsresult FinishInternal() override; 176 177 private: 178 friend class DecoderFactory; 179 180 enum class State { 181 FILE_HEADER, 182 INFO_HEADER_SIZE, 183 INFO_HEADER_REST, 184 BITFIELDS, 185 SKIP_TO_COLOR_PROFILE, 186 FOUND_COLOR_PROFILE, 187 COLOR_PROFILE, 188 ALLOCATE_SURFACE, 189 COLOR_TABLE, 190 GAP, 191 AFTER_GAP, 192 PIXEL_ROW, 193 RLE_SEGMENT, 194 RLE_DELTA, 195 RLE_ABSOLUTE 196 }; 197 198 // This is the constructor used for normal and clipboard BMP images. 199 explicit nsBMPDecoder(RasterImage* aImage, bool aForClipboard = false); 200 201 // This is the constructor used for BMP resources in ICO images. 202 nsBMPDecoder(RasterImage* aImage, uint32_t aDataOffset); 203 204 // Helper constructor called by the other two. 205 nsBMPDecoder(RasterImage* aImage, State aState, size_t aLength, 206 bool aForClipboard); 207 208 int32_t AbsoluteHeight() const { return abs(mH.mHeight); } 209 210 uint32_t* RowBuffer(); 211 void ClearRowBufferRemainder(); 212 213 void FinishRow(); 214 215 void PrepareCalibratedColorProfile(); 216 void PrepareColorProfileTransform(); 217 218 LexerTransition<State> ReadFileHeader(const char* aData, size_t aLength); 219 LexerTransition<State> ReadInfoHeaderSize(const char* aData, size_t aLength); 220 LexerTransition<State> ReadInfoHeaderRest(const char* aData, size_t aLength); 221 LexerTransition<State> ReadBitfields(const char* aData, size_t aLength); 222 LexerTransition<State> SeekColorProfile(size_t aLength); 223 LexerTransition<State> ReadColorProfile(const char* aData, size_t aLength); 224 LexerTransition<State> AllocateSurface(); 225 LexerTransition<State> ReadColorTable(const char* aData, size_t aLength); 226 LexerTransition<State> SkipGap(); 227 LexerTransition<State> AfterGap(); 228 LexerTransition<State> ReadPixelRow(const char* aData); 229 LexerTransition<State> ReadRLESegment(const char* aData); 230 LexerTransition<State> ReadRLEDelta(const char* aData); 231 LexerTransition<State> ReadRLEAbsolute(const char* aData, size_t aLength); 232 233 SurfacePipe mPipe; 234 235 StreamingLexer<State> mLexer; 236 237 // Iterator to save return point. 238 Maybe<SourceBufferIterator> mReturnIterator; 239 240 UniquePtr<uint32_t[]> mRowBuffer; 241 242 bmp::Header mH; 243 244 // If the BMP is within an ICO file our treatment of it differs slightly. 245 bool mIsWithinICO; 246 247 // If the BMP decoded from the clipboard, we don't start with a data offset. 248 bool mIsForClipboard; 249 250 bmp::BitFields mBitFields; 251 252 // Might the image have transparency? Determined from the headers during 253 // metadata decode. (Does not guarantee the image actually has transparency.) 254 bool mMayHaveTransparency; 255 256 // Does the image have transparency? Determined during full decoding, so only 257 // use this after that has been completed. 258 bool mDoesHaveTransparency; 259 260 uint32_t mNumColors; // The number of used colors, i.e. the number of 261 // entries in mColors, if it's present. 262 UniquePtr<bmp::ColorTableEntry[]> 263 mColors; // The color table, if it's present. 264 uint32_t mBytesPerColor; // 3 or 4, depending on the format 265 266 // The number of bytes prior to the optional gap that have been read. This 267 // is used to find the start of the pixel data. 268 uint32_t mPreGapLength; 269 270 uint32_t mPixelRowSize; // The number of bytes per pixel row. 271 272 int32_t mCurrentRow; // Index of the row of the image that's currently 273 // being decoded: [height,1]. 274 int32_t mCurrentPos; // Index into the current line. Used when 275 // doing RLE decoding and when filling in pixels 276 // for truncated files. 277 278 // Only used in RLE_ABSOLUTE state: the number of pixels to read. 279 uint32_t mAbsoluteModeNumPixels; 280 }; 281 282 } // namespace image 283 } // namespace mozilla 284 285 #endif // mozilla_image_decoders_nsBMPDecoder_h