blob: 19c8c7db37cbf69b4c0b1d246c41b3e0565b4726 [file] [log] [blame]
halcanarya096d7a2015-03-27 12:16:53 -07001/*
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 "SkCodec.h"
msarett99f567e2015-08-05 12:58:26 -07009#include "SkCodecPriv.h"
halcanarya096d7a2015-03-27 12:16:53 -070010#include "SkColorPriv.h"
msarett99f567e2015-08-05 12:58:26 -070011#include "SkColorTable.h"
scroggodb30be22015-12-08 18:54:13 -080012#include "SkData.h"
halcanarya096d7a2015-03-27 12:16:53 -070013#include "SkStream.h"
msarett1a464672016-01-07 13:17:19 -080014#include "SkWbmpCodec.h"
halcanarya096d7a2015-03-27 12:16:53 -070015
msarett99f567e2015-08-05 12:58:26 -070016// Each bit represents a pixel, so width is actually a number of bits.
17// A row will always be stored in bytes, so we round width up to the
18// nearest multiple of 8 to get the number of bits actually in the row.
19// We then divide by 8 to convert to bytes.
20static inline size_t get_src_row_bytes(int width) {
21 return SkAlign8(width) >> 3;
22}
23
24static inline void setup_color_table(SkColorType colorType,
25 SkPMColor* colorPtr, int* colorCount) {
26 if (kIndex_8_SkColorType == colorType) {
27 colorPtr[0] = SK_ColorBLACK;
28 colorPtr[1] = SK_ColorWHITE;
29 *colorCount = 2;
30 }
31}
32
Matt Saretta225e9b2016-11-07 10:26:17 -050033static inline bool valid_color_type(const SkImageInfo& dstInfo) {
34 switch (dstInfo.colorType()) {
msarett34e0ec42016-04-22 16:27:24 -070035 case kRGBA_8888_SkColorType:
36 case kBGRA_8888_SkColorType:
msarettb30d6982016-02-15 10:18:45 -080037 case kIndex_8_SkColorType:
msarettb30d6982016-02-15 10:18:45 -080038 case kGray_8_SkColorType:
39 case kRGB_565_SkColorType:
scroggoba584892016-05-20 13:56:13 -070040 return true;
Matt Saretta225e9b2016-11-07 10:26:17 -050041 case kRGBA_F16_SkColorType:
42 return dstInfo.colorSpace() && dstInfo.colorSpace()->gammaIsLinear();
msarettb30d6982016-02-15 10:18:45 -080043 default:
44 return false;
45 }
46}
47
scroggob9a1e342015-11-30 06:25:31 -080048static bool read_byte(SkStream* stream, uint8_t* data)
49{
50 return stream->read(data, 1) == 1;
51}
52
halcanarya096d7a2015-03-27 12:16:53 -070053// http://en.wikipedia.org/wiki/Variable-length_quantity
54static bool read_mbf(SkStream* stream, uint64_t* value) {
55 uint64_t n = 0;
56 uint8_t data;
57 const uint64_t kLimit = 0xFE00000000000000;
58 SkASSERT(kLimit == ~((~static_cast<uint64_t>(0)) >> 7));
59 do {
60 if (n & kLimit) { // Will overflow on shift by 7.
61 return false;
62 }
63 if (stream->read(&data, 1) != 1) {
64 return false;
65 }
66 n = (n << 7) | (data & 0x7F);
67 } while (data & 0x80);
68 *value = n;
69 return true;
70}
71
72static bool read_header(SkStream* stream, SkISize* size) {
scroggob9a1e342015-11-30 06:25:31 -080073 {
74 uint8_t data;
75 if (!read_byte(stream, &data) || data != 0) { // unknown type
76 return false;
77 }
78 if (!read_byte(stream, &data) || (data & 0x9F)) { // skip fixed header
79 return false;
80 }
halcanarya096d7a2015-03-27 12:16:53 -070081 }
scroggob9a1e342015-11-30 06:25:31 -080082
83 uint64_t width, height;
halcanarya096d7a2015-03-27 12:16:53 -070084 if (!read_mbf(stream, &width) || width > 0xFFFF || !width) {
85 return false;
86 }
msarett99f567e2015-08-05 12:58:26 -070087 if (!read_mbf(stream, &height) || height > 0xFFFF || !height) {
halcanarya096d7a2015-03-27 12:16:53 -070088 return false;
89 }
90 if (size) {
91 *size = SkISize::Make(SkToS32(width), SkToS32(height));
92 }
93 return true;
94}
95
scroggob427db12015-08-12 07:24:13 -070096bool SkWbmpCodec::onRewind() {
halcanary96fcdcc2015-08-27 07:41:13 -070097 return read_header(this->stream(), nullptr);
msarett99f567e2015-08-05 12:58:26 -070098}
99
msarettfdb47572015-10-13 12:50:14 -0700100SkSwizzler* SkWbmpCodec::initializeSwizzler(const SkImageInfo& info, const SkPMColor* ctable,
101 const Options& opts) {
msaretta45a6682016-04-22 13:18:37 -0700102 return SkSwizzler::CreateSwizzler(this->getEncodedInfo(), ctable, info, opts);
halcanarya096d7a2015-03-27 12:16:53 -0700103}
104
msarette6dd0042015-10-09 11:07:34 -0700105bool SkWbmpCodec::readRow(uint8_t* row) {
106 return this->stream()->read(row, fSrcRowBytes) == fSrcRowBytes;
msarett99f567e2015-08-05 12:58:26 -0700107}
108
msarettc30c4182016-04-20 11:53:35 -0700109SkWbmpCodec::SkWbmpCodec(int width, int height, const SkEncodedInfo& info, SkStream* stream)
Matt Sarett7f650bd2016-10-30 21:25:34 -0400110 : INHERITED(width, height, info, stream, SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named))
msarett99f567e2015-08-05 12:58:26 -0700111 , fSrcRowBytes(get_src_row_bytes(this->getInfo().width()))
scroggo46c57472015-09-30 08:57:13 -0700112 , fSwizzler(nullptr)
msarettf724b992015-10-15 06:41:06 -0700113 , fColorTable(nullptr)
msarett99f567e2015-08-05 12:58:26 -0700114{}
halcanarya096d7a2015-03-27 12:16:53 -0700115
116SkEncodedFormat SkWbmpCodec::onGetEncodedFormat() const {
117 return kWBMP_SkEncodedFormat;
118}
119
scroggoeb602a52015-07-09 08:16:03 -0700120SkCodec::Result SkWbmpCodec::onGetPixels(const SkImageInfo& info,
msarett99f567e2015-08-05 12:58:26 -0700121 void* dst,
scroggoeb602a52015-07-09 08:16:03 -0700122 size_t rowBytes,
scroggob636b452015-07-22 07:16:20 -0700123 const Options& options,
scroggoeb602a52015-07-09 08:16:03 -0700124 SkPMColor ctable[],
msarette6dd0042015-10-09 11:07:34 -0700125 int* ctableCount,
126 int* rowsDecoded) {
scroggob636b452015-07-22 07:16:20 -0700127 if (options.fSubset) {
128 // Subsets are not supported.
129 return kUnimplemented;
130 }
msarett99f567e2015-08-05 12:58:26 -0700131
Matt Saretta225e9b2016-11-07 10:26:17 -0500132 if (!valid_color_type(info) || !valid_alpha(info.alphaType(), this->getInfo().alphaType())) {
scroggo46c57472015-09-30 08:57:13 -0700133 return kInvalidConversion;
scroggod1bc5742015-08-12 08:31:44 -0700134 }
135
msarett99f567e2015-08-05 12:58:26 -0700136 // Prepare a color table if necessary
137 setup_color_table(info.colorType(), ctable, ctableCount);
138
msarett99f567e2015-08-05 12:58:26 -0700139 // Initialize the swizzler
Ben Wagner145dbcd2016-11-03 14:40:50 -0400140 std::unique_ptr<SkSwizzler> swizzler(this->initializeSwizzler(info, ctable, options));
msarettb30d6982016-02-15 10:18:45 -0800141 SkASSERT(swizzler);
msarett99f567e2015-08-05 12:58:26 -0700142
143 // Perform the decode
halcanarya096d7a2015-03-27 12:16:53 -0700144 SkISize size = info.dimensions();
msarett99f567e2015-08-05 12:58:26 -0700145 SkAutoTMalloc<uint8_t> src(fSrcRowBytes);
146 void* dstRow = dst;
halcanarya096d7a2015-03-27 12:16:53 -0700147 for (int y = 0; y < size.height(); ++y) {
msarette6dd0042015-10-09 11:07:34 -0700148 if (!this->readRow(src.get())) {
149 *rowsDecoded = y;
150 return kIncompleteInput;
halcanarya096d7a2015-03-27 12:16:53 -0700151 }
msarett99f567e2015-08-05 12:58:26 -0700152 swizzler->swizzle(dstRow, src.get());
153 dstRow = SkTAddOffset<void>(dstRow, rowBytes);
halcanarya096d7a2015-03-27 12:16:53 -0700154 }
scroggoeb602a52015-07-09 08:16:03 -0700155 return kSuccess;
halcanarya096d7a2015-03-27 12:16:53 -0700156}
157
scroggodb30be22015-12-08 18:54:13 -0800158bool SkWbmpCodec::IsWbmp(const void* buffer, size_t bytesRead) {
bungeman38d909e2016-08-02 14:40:46 -0700159 SkMemoryStream stream(buffer, bytesRead, false);
scroggodb30be22015-12-08 18:54:13 -0800160 return read_header(&stream, nullptr);
halcanarya096d7a2015-03-27 12:16:53 -0700161}
162
163SkCodec* SkWbmpCodec::NewFromStream(SkStream* stream) {
Ben Wagner145dbcd2016-11-03 14:40:50 -0400164 std::unique_ptr<SkStream> streamDeleter(stream);
halcanarya096d7a2015-03-27 12:16:53 -0700165 SkISize size;
166 if (!read_header(stream, &size)) {
halcanary96fcdcc2015-08-27 07:41:13 -0700167 return nullptr;
halcanarya096d7a2015-03-27 12:16:53 -0700168 }
msarettc30c4182016-04-20 11:53:35 -0700169 SkEncodedInfo info = SkEncodedInfo::Make(SkEncodedInfo::kGray_Color,
170 SkEncodedInfo::kOpaque_Alpha, 1);
171 return new SkWbmpCodec(size.width(), size.height(), info, streamDeleter.release());
halcanarya096d7a2015-03-27 12:16:53 -0700172}
msarett99f567e2015-08-05 12:58:26 -0700173
msarette6dd0042015-10-09 11:07:34 -0700174int SkWbmpCodec::onGetScanlines(void* dst, int count, size_t dstRowBytes) {
scroggo46c57472015-09-30 08:57:13 -0700175 void* dstRow = dst;
176 for (int y = 0; y < count; ++y) {
msarette6dd0042015-10-09 11:07:34 -0700177 if (!this->readRow(fSrcBuffer.get())) {
178 return y;
msarett99f567e2015-08-05 12:58:26 -0700179 }
scroggo46c57472015-09-30 08:57:13 -0700180 fSwizzler->swizzle(dstRow, fSrcBuffer.get());
181 dstRow = SkTAddOffset<void>(dstRow, dstRowBytes);
msarett99f567e2015-08-05 12:58:26 -0700182 }
msarette6dd0042015-10-09 11:07:34 -0700183 return count;
msarett99f567e2015-08-05 12:58:26 -0700184}
scroggo46c57472015-09-30 08:57:13 -0700185
msarett9b9497e2016-02-11 13:29:36 -0800186bool SkWbmpCodec::onSkipScanlines(int count) {
187 const size_t bytesToSkip = count * fSrcRowBytes;
188 return this->stream()->skip(bytesToSkip) == bytesToSkip;
189}
190
scroggo46c57472015-09-30 08:57:13 -0700191SkCodec::Result SkWbmpCodec::onStartScanlineDecode(const SkImageInfo& dstInfo,
192 const Options& options, SkPMColor inputColorTable[], int* inputColorCount) {
scroggo46c57472015-09-30 08:57:13 -0700193 if (options.fSubset) {
194 // Subsets are not supported.
195 return kUnimplemented;
196 }
scroggo46c57472015-09-30 08:57:13 -0700197
Matt Saretta225e9b2016-11-07 10:26:17 -0500198 if (!valid_color_type(dstInfo) ||
199 !valid_alpha(dstInfo.alphaType(), this->getInfo().alphaType()))
200 {
scroggo46c57472015-09-30 08:57:13 -0700201 return kInvalidConversion;
202 }
203
204 // Fill in the color table
205 setup_color_table(dstInfo.colorType(), inputColorTable, inputColorCount);
206
207 // Copy the color table to a pointer that can be owned by the scanline decoder
208 if (kIndex_8_SkColorType == dstInfo.colorType()) {
209 fColorTable.reset(new SkColorTable(inputColorTable, 2));
210 }
211
212 // Initialize the swizzler
msarettfdb47572015-10-13 12:50:14 -0700213 fSwizzler.reset(this->initializeSwizzler(dstInfo, get_color_ptr(fColorTable.get()), options));
msarettb30d6982016-02-15 10:18:45 -0800214 SkASSERT(fSwizzler);
scroggo46c57472015-09-30 08:57:13 -0700215
216 fSrcBuffer.reset(fSrcRowBytes);
217
218 return kSuccess;
219}