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 "SkCodecPriv.h"
9 #include "SkWebpCodec.h"
10 #include "SkTemplates.h"
11
12 // A WebP decoder on top of (subset of) libwebp
13 // For more information on WebP image format, and libwebp library, see:
14 // https://code.google.com/speed/webp/
15 // http://www.webmproject.org/code/#libwebp-webp-image-library
16 // https://chromium.googlesource.com/webm/libwebp
17
18 // If moving libwebp out of skia source tree, path for webp headers must be
19 // updated accordingly. Here, we enforce using local copy in webp sub-directory.
20 #include "webp/decode.h"
21 #include "webp/encode.h"
22
IsWebp(const void * buf,size_t bytesRead)23 bool SkWebpCodec::IsWebp(const void* buf, size_t bytesRead) {
24 // WEBP starts with the following:
25 // RIFFXXXXWEBPVP
26 // Where XXXX is unspecified.
27 const char* bytes = static_cast<const char*>(buf);
28 return bytesRead >= 14 && !memcmp(bytes, "RIFF", 4) && !memcmp(&bytes[8], "WEBPVP", 6);
29 }
30
31 // Parse headers of RIFF container, and check for valid Webp (VP8) content.
32 // NOTE: This calls peek instead of read, since onGetPixels will need these
33 // bytes again.
webp_parse_header(SkStream * stream,SkImageInfo * info)34 static bool webp_parse_header(SkStream* stream, SkImageInfo* info) {
35 unsigned char buffer[WEBP_VP8_HEADER_SIZE];
36 SkASSERT(WEBP_VP8_HEADER_SIZE <= SkCodec::MinBufferedBytesNeeded());
37
38 const size_t bytesPeeked = stream->peek(buffer, WEBP_VP8_HEADER_SIZE);
39 if (bytesPeeked != WEBP_VP8_HEADER_SIZE) {
40 // Use read + rewind as a backup
41 if (stream->read(buffer, WEBP_VP8_HEADER_SIZE) != WEBP_VP8_HEADER_SIZE
42 || !stream->rewind())
43 return false;
44 }
45
46 WebPBitstreamFeatures features;
47 VP8StatusCode status = WebPGetFeatures(buffer, WEBP_VP8_HEADER_SIZE, &features);
48 if (VP8_STATUS_OK != status) {
49 return false; // Invalid WebP file.
50 }
51
52 // sanity check for image size that's about to be decoded.
53 {
54 const int64_t size = sk_64_mul(features.width, features.height);
55 if (!sk_64_isS32(size)) {
56 return false;
57 }
58 // now check that if we are 4-bytes per pixel, we also don't overflow
59 if (sk_64_asS32(size) > (0x7FFFFFFF >> 2)) {
60 return false;
61 }
62 }
63
64 if (info) {
65 // FIXME: Is N32 the right type?
66 // Is unpremul the right type? Clients of SkCodec may assume it's the
67 // best type, when Skia currently cannot draw unpremul (and raster is faster
68 // with premul).
69 *info = SkImageInfo::Make(features.width, features.height, kN32_SkColorType,
70 SkToBool(features.has_alpha) ? kUnpremul_SkAlphaType
71 : kOpaque_SkAlphaType);
72 }
73 return true;
74 }
75
NewFromStream(SkStream * stream)76 SkCodec* SkWebpCodec::NewFromStream(SkStream* stream) {
77 SkAutoTDelete<SkStream> streamDeleter(stream);
78 SkImageInfo info;
79 if (webp_parse_header(stream, &info)) {
80 return new SkWebpCodec(info, streamDeleter.detach());
81 }
82 return nullptr;
83 }
84
85 // This version is slightly different from SkCodecPriv's version of conversion_possible. It
86 // supports both byte orders for 8888.
webp_conversion_possible(const SkImageInfo & dst,const SkImageInfo & src)87 static bool webp_conversion_possible(const SkImageInfo& dst, const SkImageInfo& src) {
88 if (dst.profileType() != src.profileType()) {
89 return false;
90 }
91
92 if (!valid_alpha(dst.alphaType(), src.alphaType())) {
93 return false;
94 }
95
96 switch (dst.colorType()) {
97 // Both byte orders are supported.
98 case kBGRA_8888_SkColorType:
99 case kRGBA_8888_SkColorType:
100 return true;
101 case kRGB_565_SkColorType:
102 return src.alphaType() == kOpaque_SkAlphaType;
103 default:
104 return false;
105 }
106 }
107
onGetScaledDimensions(float desiredScale) const108 SkISize SkWebpCodec::onGetScaledDimensions(float desiredScale) const {
109 SkISize dim = this->getInfo().dimensions();
110 // SkCodec treats zero dimensional images as errors, so the minimum size
111 // that we will recommend is 1x1.
112 dim.fWidth = SkTMax(1, SkScalarRoundToInt(desiredScale * dim.fWidth));
113 dim.fHeight = SkTMax(1, SkScalarRoundToInt(desiredScale * dim.fHeight));
114 return dim;
115 }
116
onDimensionsSupported(const SkISize & dim)117 bool SkWebpCodec::onDimensionsSupported(const SkISize& dim) {
118 const SkImageInfo& info = this->getInfo();
119 return dim.width() >= 1 && dim.width() <= info.width()
120 && dim.height() >= 1 && dim.height() <= info.height();
121 }
122
123
webp_decode_mode(SkColorType ct,bool premultiply)124 static WEBP_CSP_MODE webp_decode_mode(SkColorType ct, bool premultiply) {
125 switch (ct) {
126 case kBGRA_8888_SkColorType:
127 return premultiply ? MODE_bgrA : MODE_BGRA;
128 case kRGBA_8888_SkColorType:
129 return premultiply ? MODE_rgbA : MODE_RGBA;
130 case kRGB_565_SkColorType:
131 return MODE_RGB_565;
132 default:
133 return MODE_LAST;
134 }
135 }
136
137 // The WebP decoding API allows us to incrementally pass chunks of bytes as we receive them to the
138 // decoder with WebPIAppend. In order to do so, we need to read chunks from the SkStream. This size
139 // is arbitrary.
140 static const size_t BUFFER_SIZE = 4096;
141
onGetValidSubset(SkIRect * desiredSubset) const142 bool SkWebpCodec::onGetValidSubset(SkIRect* desiredSubset) const {
143 if (!desiredSubset) {
144 return false;
145 }
146
147 SkIRect dimensions = SkIRect::MakeSize(this->getInfo().dimensions());
148 if (!dimensions.contains(*desiredSubset)) {
149 return false;
150 }
151
152 // As stated below, libwebp snaps to even left and top. Make sure top and left are even, so we
153 // decode this exact subset.
154 // Leave right and bottom unmodified, so we suggest a slightly larger subset than requested.
155 desiredSubset->fLeft = (desiredSubset->fLeft >> 1) << 1;
156 desiredSubset->fTop = (desiredSubset->fTop >> 1) << 1;
157 return true;
158 }
159
onGetPixels(const SkImageInfo & dstInfo,void * dst,size_t rowBytes,const Options & options,SkPMColor *,int *,int * rowsDecoded)160 SkCodec::Result SkWebpCodec::onGetPixels(const SkImageInfo& dstInfo, void* dst, size_t rowBytes,
161 const Options& options, SkPMColor*, int*,
162 int* rowsDecoded) {
163 if (!webp_conversion_possible(dstInfo, this->getInfo())) {
164 return kInvalidConversion;
165 }
166
167 WebPDecoderConfig config;
168 if (0 == WebPInitDecoderConfig(&config)) {
169 // ABI mismatch.
170 // FIXME: New enum for this?
171 return kInvalidInput;
172 }
173
174 // Free any memory associated with the buffer. Must be called last, so we declare it first.
175 SkAutoTCallVProc<WebPDecBuffer, WebPFreeDecBuffer> autoFree(&(config.output));
176
177 SkIRect bounds = SkIRect::MakeSize(this->getInfo().dimensions());
178 if (options.fSubset) {
179 // Caller is requesting a subset.
180 if (!bounds.contains(*options.fSubset)) {
181 // The subset is out of bounds.
182 return kInvalidParameters;
183 }
184
185 bounds = *options.fSubset;
186
187 // This is tricky. libwebp snaps the top and left to even values. We could let libwebp
188 // do the snap, and return a subset which is a different one than requested. The problem
189 // with that approach is that the caller may try to stitch subsets together, and if we
190 // returned different subsets than requested, there would be artifacts at the boundaries.
191 // Instead, we report that we cannot support odd values for top and left..
192 if (!SkIsAlign2(bounds.fLeft) || !SkIsAlign2(bounds.fTop)) {
193 return kInvalidParameters;
194 }
195
196 #ifdef SK_DEBUG
197 {
198 // Make a copy, since getValidSubset can change its input.
199 SkIRect subset(bounds);
200 // That said, getValidSubset should *not* change its input, in this case; otherwise
201 // getValidSubset does not match the actual subsets we can do.
202 SkASSERT(this->getValidSubset(&subset) && subset == bounds);
203 }
204 #endif
205
206 config.options.use_cropping = 1;
207 config.options.crop_left = bounds.fLeft;
208 config.options.crop_top = bounds.fTop;
209 config.options.crop_width = bounds.width();
210 config.options.crop_height = bounds.height();
211 }
212
213 SkISize dstDimensions = dstInfo.dimensions();
214 if (bounds.size() != dstDimensions) {
215 // Caller is requesting scaling.
216 config.options.use_scaling = 1;
217 config.options.scaled_width = dstDimensions.width();
218 config.options.scaled_height = dstDimensions.height();
219 }
220
221 config.output.colorspace = webp_decode_mode(dstInfo.colorType(),
222 dstInfo.alphaType() == kPremul_SkAlphaType);
223 config.output.u.RGBA.rgba = (uint8_t*) dst;
224 config.output.u.RGBA.stride = (int) rowBytes;
225 config.output.u.RGBA.size = dstInfo.getSafeSize(rowBytes);
226 config.output.is_external_memory = 1;
227
228 SkAutoTCallVProc<WebPIDecoder, WebPIDelete> idec(WebPIDecode(nullptr, 0, &config));
229 if (!idec) {
230 return kInvalidInput;
231 }
232
233 SkAutoTMalloc<uint8_t> storage(BUFFER_SIZE);
234 uint8_t* buffer = storage.get();
235 while (true) {
236 const size_t bytesRead = stream()->read(buffer, BUFFER_SIZE);
237 if (0 == bytesRead) {
238 WebPIDecGetRGB(idec, rowsDecoded, NULL, NULL, NULL);
239 return kIncompleteInput;
240 }
241
242 switch (WebPIAppend(idec, buffer, bytesRead)) {
243 case VP8_STATUS_OK:
244 return kSuccess;
245 case VP8_STATUS_SUSPENDED:
246 // Break out of the switch statement. Continue the loop.
247 break;
248 default:
249 return kInvalidInput;
250 }
251 }
252 }
253
SkWebpCodec(const SkImageInfo & info,SkStream * stream)254 SkWebpCodec::SkWebpCodec(const SkImageInfo& info, SkStream* stream)
255 : INHERITED(info, stream) {}
256