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 "src/codec/SkWebpCodec.h" |
9 | |
10 | #include "include/codec/SkCodecAnimation.h" |
11 | #include "include/core/SkBitmap.h" |
12 | #include "include/core/SkCanvas.h" |
13 | #include "include/private/SkTemplates.h" |
14 | #include "include/private/SkTo.h" |
15 | #include "src/codec/SkCodecAnimationPriv.h" |
16 | #include "src/codec/SkCodecPriv.h" |
17 | #include "src/codec/SkParseEncodedOrigin.h" |
18 | #include "src/codec/SkSampler.h" |
19 | #include "src/core/SkRasterPipeline.h" |
20 | #include "src/core/SkStreamPriv.h" |
21 | |
22 | // A WebP decoder on top of (subset of) libwebp |
23 | // For more information on WebP image format, and libwebp library, see: |
24 | // https://code.google.com/speed/webp/ |
25 | // http://www.webmproject.org/code/#libwebp-webp-image-library |
26 | // https://chromium.googlesource.com/webm/libwebp |
27 | |
28 | // If moving libwebp out of skia source tree, path for webp headers must be |
29 | // updated accordingly. Here, we enforce using local copy in webp sub-directory. |
30 | #include "webp/decode.h" |
31 | #include "webp/demux.h" |
32 | #include "webp/encode.h" |
33 | |
34 | bool SkWebpCodec::IsWebp(const void* buf, size_t bytesRead) { |
35 | // WEBP starts with the following: |
36 | // RIFFXXXXWEBPVP |
37 | // Where XXXX is unspecified. |
38 | const char* bytes = static_cast<const char*>(buf); |
39 | return bytesRead >= 14 && !memcmp(bytes, "RIFF" , 4) && !memcmp(&bytes[8], "WEBPVP" , 6); |
40 | } |
41 | |
42 | // Parse headers of RIFF container, and check for valid Webp (VP8) content. |
43 | // Returns an SkWebpCodec on success |
44 | std::unique_ptr<SkCodec> SkWebpCodec::MakeFromStream(std::unique_ptr<SkStream> stream, |
45 | Result* result) { |
46 | // Webp demux needs a contiguous data buffer. |
47 | sk_sp<SkData> data = nullptr; |
48 | if (stream->getMemoryBase()) { |
49 | // It is safe to make without copy because we'll hold onto the stream. |
50 | data = SkData::MakeWithoutCopy(stream->getMemoryBase(), stream->getLength()); |
51 | } else { |
52 | data = SkCopyStreamToData(stream.get()); |
53 | |
54 | // If we are forced to copy the stream to a data, we can go ahead and delete the stream. |
55 | stream.reset(nullptr); |
56 | } |
57 | |
58 | // It's a little strange that the |demux| will outlive |webpData|, though it needs the |
59 | // pointer in |webpData| to remain valid. This works because the pointer remains valid |
60 | // until the SkData is freed. |
61 | WebPData webpData = { data->bytes(), data->size() }; |
62 | WebPDemuxState state; |
63 | SkAutoTCallVProc<WebPDemuxer, WebPDemuxDelete> demux(WebPDemuxPartial(&webpData, &state)); |
64 | switch (state) { |
65 | case WEBP_DEMUX_PARSE_ERROR: |
66 | *result = kInvalidInput; |
67 | return nullptr; |
68 | case WEBP_DEMUX_PARSING_HEADER: |
69 | *result = kIncompleteInput; |
70 | return nullptr; |
71 | case WEBP_DEMUX_PARSED_HEADER: |
72 | case WEBP_DEMUX_DONE: |
73 | SkASSERT(demux); |
74 | break; |
75 | } |
76 | |
77 | const int width = WebPDemuxGetI(demux, WEBP_FF_CANVAS_WIDTH); |
78 | const int height = WebPDemuxGetI(demux, WEBP_FF_CANVAS_HEIGHT); |
79 | |
80 | // Validate the image size that's about to be decoded. |
81 | { |
82 | const int64_t size = sk_64_mul(width, height); |
83 | // now check that if we are 4-bytes per pixel, we also don't overflow |
84 | if (!SkTFitsIn<int32_t>(size) || SkTo<int32_t>(size) > (0x7FFFFFFF >> 2)) { |
85 | *result = kInvalidInput; |
86 | return nullptr; |
87 | } |
88 | } |
89 | |
90 | std::unique_ptr<SkEncodedInfo::ICCProfile> profile = nullptr; |
91 | { |
92 | WebPChunkIterator chunkIterator; |
93 | SkAutoTCallVProc<WebPChunkIterator, WebPDemuxReleaseChunkIterator> autoCI(&chunkIterator); |
94 | if (WebPDemuxGetChunk(demux, "ICCP" , 1, &chunkIterator)) { |
95 | // FIXME: I think this could be MakeWithoutCopy |
96 | auto chunk = SkData::MakeWithCopy(chunkIterator.chunk.bytes, chunkIterator.chunk.size); |
97 | profile = SkEncodedInfo::ICCProfile::Make(std::move(chunk)); |
98 | } |
99 | if (profile && profile->profile()->data_color_space != skcms_Signature_RGB) { |
100 | profile = nullptr; |
101 | } |
102 | } |
103 | |
104 | SkEncodedOrigin origin = kDefault_SkEncodedOrigin; |
105 | { |
106 | WebPChunkIterator chunkIterator; |
107 | SkAutoTCallVProc<WebPChunkIterator, WebPDemuxReleaseChunkIterator> autoCI(&chunkIterator); |
108 | if (WebPDemuxGetChunk(demux, "EXIF" , 1, &chunkIterator)) { |
109 | SkParseEncodedOrigin(chunkIterator.chunk.bytes, chunkIterator.chunk.size, &origin); |
110 | } |
111 | } |
112 | |
113 | // Get the first frame and its "features" to determine the color and alpha types. |
114 | WebPIterator frame; |
115 | SkAutoTCallVProc<WebPIterator, WebPDemuxReleaseIterator> autoFrame(&frame); |
116 | if (!WebPDemuxGetFrame(demux, 1, &frame)) { |
117 | *result = kIncompleteInput; |
118 | return nullptr; |
119 | } |
120 | |
121 | WebPBitstreamFeatures features; |
122 | switch (WebPGetFeatures(frame.fragment.bytes, frame.fragment.size, &features)) { |
123 | case VP8_STATUS_OK: |
124 | break; |
125 | case VP8_STATUS_SUSPENDED: |
126 | case VP8_STATUS_NOT_ENOUGH_DATA: |
127 | *result = kIncompleteInput; |
128 | return nullptr; |
129 | default: |
130 | *result = kInvalidInput; |
131 | return nullptr; |
132 | } |
133 | |
134 | const bool hasAlpha = SkToBool(frame.has_alpha) |
135 | || frame.width != width || frame.height != height; |
136 | SkEncodedInfo::Color color; |
137 | SkEncodedInfo::Alpha alpha; |
138 | switch (features.format) { |
139 | case 0: |
140 | // This indicates a "mixed" format. We could see this for |
141 | // animated webps (multiple fragments). |
142 | // We could also guess kYUV here, but I think it makes more |
143 | // sense to guess kBGRA which is likely closer to the final |
144 | // output. Otherwise, we might end up converting |
145 | // BGRA->YUVA->BGRA. |
146 | [[fallthrough]]; |
147 | case 2: |
148 | // This is the lossless format (BGRA). |
149 | if (hasAlpha) { |
150 | color = SkEncodedInfo::kBGRA_Color; |
151 | alpha = SkEncodedInfo::kUnpremul_Alpha; |
152 | } else { |
153 | color = SkEncodedInfo::kBGRX_Color; |
154 | alpha = SkEncodedInfo::kOpaque_Alpha; |
155 | } |
156 | break; |
157 | case 1: |
158 | // This is the lossy format (YUV). |
159 | if (hasAlpha) { |
160 | color = SkEncodedInfo::kYUVA_Color; |
161 | alpha = SkEncodedInfo::kUnpremul_Alpha; |
162 | } else { |
163 | color = SkEncodedInfo::kYUV_Color; |
164 | alpha = SkEncodedInfo::kOpaque_Alpha; |
165 | } |
166 | break; |
167 | default: |
168 | *result = kInvalidInput; |
169 | return nullptr; |
170 | } |
171 | |
172 | |
173 | *result = kSuccess; |
174 | SkEncodedInfo info = SkEncodedInfo::Make(width, height, color, alpha, 8, std::move(profile)); |
175 | return std::unique_ptr<SkCodec>(new SkWebpCodec(std::move(info), std::move(stream), |
176 | demux.release(), std::move(data), origin)); |
177 | } |
178 | |
179 | static WEBP_CSP_MODE webp_decode_mode(SkColorType dstCT, bool premultiply) { |
180 | switch (dstCT) { |
181 | case kBGRA_8888_SkColorType: |
182 | return premultiply ? MODE_bgrA : MODE_BGRA; |
183 | case kRGBA_8888_SkColorType: |
184 | return premultiply ? MODE_rgbA : MODE_RGBA; |
185 | case kRGB_565_SkColorType: |
186 | return MODE_RGB_565; |
187 | default: |
188 | return MODE_LAST; |
189 | } |
190 | } |
191 | |
192 | SkWebpCodec::Frame* SkWebpCodec::FrameHolder::appendNewFrame(bool hasAlpha) { |
193 | const int i = this->size(); |
194 | fFrames.emplace_back(i, hasAlpha ? SkEncodedInfo::kUnpremul_Alpha |
195 | : SkEncodedInfo::kOpaque_Alpha); |
196 | return &fFrames[i]; |
197 | } |
198 | |
199 | bool SkWebpCodec::onGetValidSubset(SkIRect* desiredSubset) const { |
200 | if (!desiredSubset) { |
201 | return false; |
202 | } |
203 | |
204 | if (!this->bounds().contains(*desiredSubset)) { |
205 | return false; |
206 | } |
207 | |
208 | // As stated below, libwebp snaps to even left and top. Make sure top and left are even, so we |
209 | // decode this exact subset. |
210 | // Leave right and bottom unmodified, so we suggest a slightly larger subset than requested. |
211 | desiredSubset->fLeft = (desiredSubset->fLeft >> 1) << 1; |
212 | desiredSubset->fTop = (desiredSubset->fTop >> 1) << 1; |
213 | return true; |
214 | } |
215 | |
216 | int SkWebpCodec::onGetRepetitionCount() { |
217 | auto flags = WebPDemuxGetI(fDemux.get(), WEBP_FF_FORMAT_FLAGS); |
218 | if (!(flags & ANIMATION_FLAG)) { |
219 | return 0; |
220 | } |
221 | |
222 | int loopCount = WebPDemuxGetI(fDemux.get(), WEBP_FF_LOOP_COUNT); |
223 | if (0 == loopCount) { |
224 | return kRepetitionCountInfinite; |
225 | } |
226 | |
227 | loopCount--; |
228 | return loopCount; |
229 | } |
230 | |
231 | int SkWebpCodec::onGetFrameCount() { |
232 | auto flags = WebPDemuxGetI(fDemux.get(), WEBP_FF_FORMAT_FLAGS); |
233 | if (!(flags & ANIMATION_FLAG)) { |
234 | return 1; |
235 | } |
236 | |
237 | const uint32_t oldFrameCount = fFrameHolder.size(); |
238 | if (fFailed) { |
239 | return oldFrameCount; |
240 | } |
241 | |
242 | const uint32_t frameCount = WebPDemuxGetI(fDemux, WEBP_FF_FRAME_COUNT); |
243 | if (oldFrameCount == frameCount) { |
244 | // We have already parsed this. |
245 | return frameCount; |
246 | } |
247 | |
248 | fFrameHolder.reserve(frameCount); |
249 | |
250 | for (uint32_t i = oldFrameCount; i < frameCount; i++) { |
251 | WebPIterator iter; |
252 | SkAutoTCallVProc<WebPIterator, WebPDemuxReleaseIterator> autoIter(&iter); |
253 | |
254 | if (!WebPDemuxGetFrame(fDemux.get(), i + 1, &iter)) { |
255 | fFailed = true; |
256 | break; |
257 | } |
258 | |
259 | // libwebp only reports complete frames of an animated image. |
260 | SkASSERT(iter.complete); |
261 | |
262 | Frame* frame = fFrameHolder.appendNewFrame(iter.has_alpha); |
263 | frame->setXYWH(iter.x_offset, iter.y_offset, iter.width, iter.height); |
264 | frame->setDisposalMethod(iter.dispose_method == WEBP_MUX_DISPOSE_BACKGROUND ? |
265 | SkCodecAnimation::DisposalMethod::kRestoreBGColor : |
266 | SkCodecAnimation::DisposalMethod::kKeep); |
267 | frame->setDuration(iter.duration); |
268 | if (WEBP_MUX_BLEND != iter.blend_method) { |
269 | frame->setBlend(SkCodecAnimation::Blend::kBG); |
270 | } |
271 | fFrameHolder.setAlphaAndRequiredFrame(frame); |
272 | } |
273 | |
274 | return fFrameHolder.size(); |
275 | |
276 | } |
277 | |
278 | const SkFrame* SkWebpCodec::FrameHolder::onGetFrame(int i) const { |
279 | return static_cast<const SkFrame*>(this->frame(i)); |
280 | } |
281 | |
282 | const SkWebpCodec::Frame* SkWebpCodec::FrameHolder::frame(int i) const { |
283 | SkASSERT(i >= 0 && i < this->size()); |
284 | return &fFrames[i]; |
285 | } |
286 | |
287 | bool SkWebpCodec::onGetFrameInfo(int i, FrameInfo* frameInfo) const { |
288 | if (i >= fFrameHolder.size()) { |
289 | return false; |
290 | } |
291 | |
292 | const Frame* frame = fFrameHolder.frame(i); |
293 | if (!frame) { |
294 | return false; |
295 | } |
296 | |
297 | if (frameInfo) { |
298 | frameInfo->fRequiredFrame = frame->getRequiredFrame(); |
299 | frameInfo->fDuration = frame->getDuration(); |
300 | // libwebp only reports fully received frames for an |
301 | // animated image. |
302 | frameInfo->fFullyReceived = true; |
303 | frameInfo->fAlphaType = frame->hasAlpha() ? kUnpremul_SkAlphaType |
304 | : kOpaque_SkAlphaType; |
305 | frameInfo->fDisposalMethod = frame->getDisposalMethod(); |
306 | } |
307 | |
308 | return true; |
309 | } |
310 | |
311 | static bool is_8888(SkColorType colorType) { |
312 | switch (colorType) { |
313 | case kRGBA_8888_SkColorType: |
314 | case kBGRA_8888_SkColorType: |
315 | return true; |
316 | default: |
317 | return false; |
318 | } |
319 | } |
320 | |
321 | // Requires that the src input be unpremultiplied (or opaque). |
322 | static void blend_line(SkColorType dstCT, void* dst, |
323 | SkColorType srcCT, const void* src, |
324 | SkAlphaType dstAt, |
325 | bool srcHasAlpha, |
326 | int width) { |
327 | SkRasterPipeline_MemoryCtx dst_ctx = { (void*)dst, 0 }, |
328 | src_ctx = { (void*)src, 0 }; |
329 | |
330 | SkRasterPipeline_<256> p; |
331 | |
332 | p.append_load_dst(dstCT, &dst_ctx); |
333 | if (kUnpremul_SkAlphaType == dstAt) { |
334 | p.append(SkRasterPipeline::premul_dst); |
335 | } |
336 | |
337 | p.append_load(srcCT, &src_ctx); |
338 | if (srcHasAlpha) { |
339 | p.append(SkRasterPipeline::premul); |
340 | } |
341 | |
342 | p.append(SkRasterPipeline::srcover); |
343 | |
344 | if (kUnpremul_SkAlphaType == dstAt) { |
345 | p.append(SkRasterPipeline::unpremul); |
346 | } |
347 | p.append_store(dstCT, &dst_ctx); |
348 | |
349 | p.run(0,0, width,1); |
350 | } |
351 | |
352 | SkCodec::Result SkWebpCodec::onGetPixels(const SkImageInfo& dstInfo, void* dst, size_t rowBytes, |
353 | const Options& options, int* rowsDecodedPtr) { |
354 | const int index = options.fFrameIndex; |
355 | SkASSERT(0 == index || index < fFrameHolder.size()); |
356 | SkASSERT(0 == index || !options.fSubset); |
357 | |
358 | WebPDecoderConfig config; |
359 | if (0 == WebPInitDecoderConfig(&config)) { |
360 | // ABI mismatch. |
361 | // FIXME: New enum for this? |
362 | return kInvalidInput; |
363 | } |
364 | |
365 | // Free any memory associated with the buffer. Must be called last, so we declare it first. |
366 | SkAutoTCallVProc<WebPDecBuffer, WebPFreeDecBuffer> autoFree(&(config.output)); |
367 | |
368 | WebPIterator frame; |
369 | SkAutoTCallVProc<WebPIterator, WebPDemuxReleaseIterator> autoFrame(&frame); |
370 | // If this succeeded in onGetFrameCount(), it should succeed again here. |
371 | SkAssertResult(WebPDemuxGetFrame(fDemux, index + 1, &frame)); |
372 | |
373 | const bool independent = index == 0 ? true : |
374 | (fFrameHolder.frame(index)->getRequiredFrame() == kNoFrame); |
375 | // Get the frameRect. libwebp will have already signaled an error if this is not fully |
376 | // contained by the canvas. |
377 | auto frameRect = SkIRect::MakeXYWH(frame.x_offset, frame.y_offset, frame.width, frame.height); |
378 | SkASSERT(this->bounds().contains(frameRect)); |
379 | const bool frameIsSubset = frameRect != this->bounds(); |
380 | if (independent && frameIsSubset) { |
381 | SkSampler::Fill(dstInfo, dst, rowBytes, options.fZeroInitialized); |
382 | } |
383 | |
384 | int dstX = frameRect.x(); |
385 | int dstY = frameRect.y(); |
386 | int subsetWidth = frameRect.width(); |
387 | int subsetHeight = frameRect.height(); |
388 | if (options.fSubset) { |
389 | SkIRect subset = *options.fSubset; |
390 | SkASSERT(this->bounds().contains(subset)); |
391 | SkASSERT(SkIsAlign2(subset.fLeft) && SkIsAlign2(subset.fTop)); |
392 | SkASSERT(this->getValidSubset(&subset) && subset == *options.fSubset); |
393 | |
394 | if (!SkIRect::Intersects(subset, frameRect)) { |
395 | return kSuccess; |
396 | } |
397 | |
398 | int minXOffset = std::min(dstX, subset.x()); |
399 | int minYOffset = std::min(dstY, subset.y()); |
400 | dstX -= minXOffset; |
401 | dstY -= minYOffset; |
402 | frameRect.offset(-minXOffset, -minYOffset); |
403 | subset.offset(-minXOffset, -minYOffset); |
404 | |
405 | // Just like we require that the requested subset x and y offset are even, libwebp |
406 | // guarantees that the frame x and y offset are even (it's actually impossible to specify |
407 | // an odd frame offset). So we can still guarantee that the adjusted offsets are even. |
408 | SkASSERT(SkIsAlign2(subset.fLeft) && SkIsAlign2(subset.fTop)); |
409 | |
410 | SkIRect intersection; |
411 | SkAssertResult(intersection.intersect(frameRect, subset)); |
412 | subsetWidth = intersection.width(); |
413 | subsetHeight = intersection.height(); |
414 | |
415 | config.options.use_cropping = 1; |
416 | config.options.crop_left = subset.x(); |
417 | config.options.crop_top = subset.y(); |
418 | config.options.crop_width = subsetWidth; |
419 | config.options.crop_height = subsetHeight; |
420 | } |
421 | |
422 | // Ignore the frame size and offset when determining if scaling is necessary. |
423 | int scaledWidth = subsetWidth; |
424 | int scaledHeight = subsetHeight; |
425 | SkISize srcSize = options.fSubset ? options.fSubset->size() : this->dimensions(); |
426 | if (srcSize != dstInfo.dimensions()) { |
427 | config.options.use_scaling = 1; |
428 | |
429 | if (frameIsSubset) { |
430 | float scaleX = ((float) dstInfo.width()) / srcSize.width(); |
431 | float scaleY = ((float) dstInfo.height()) / srcSize.height(); |
432 | |
433 | // We need to be conservative here and floor rather than round. |
434 | // Otherwise, we may find ourselves decoding off the end of memory. |
435 | dstX = scaleX * dstX; |
436 | scaledWidth = scaleX * scaledWidth; |
437 | dstY = scaleY * dstY; |
438 | scaledHeight = scaleY * scaledHeight; |
439 | if (0 == scaledWidth || 0 == scaledHeight) { |
440 | return kSuccess; |
441 | } |
442 | } else { |
443 | scaledWidth = dstInfo.width(); |
444 | scaledHeight = dstInfo.height(); |
445 | } |
446 | |
447 | config.options.scaled_width = scaledWidth; |
448 | config.options.scaled_height = scaledHeight; |
449 | } |
450 | |
451 | const bool blendWithPrevFrame = !independent && frame.blend_method == WEBP_MUX_BLEND |
452 | && frame.has_alpha; |
453 | |
454 | SkBitmap webpDst; |
455 | auto webpInfo = dstInfo; |
456 | if (!frame.has_alpha) { |
457 | webpInfo = webpInfo.makeAlphaType(kOpaque_SkAlphaType); |
458 | } |
459 | if (this->colorXform()) { |
460 | // Swizzling between RGBA and BGRA is zero cost in a color transform. So when we have a |
461 | // color transform, we should decode to whatever is easiest for libwebp, and then let the |
462 | // color transform swizzle if necessary. |
463 | // Lossy webp is encoded as YUV (so RGBA and BGRA are the same cost). Lossless webp is |
464 | // encoded as BGRA. This means decoding to BGRA is either faster or the same cost as RGBA. |
465 | webpInfo = webpInfo.makeColorType(kBGRA_8888_SkColorType); |
466 | |
467 | if (webpInfo.alphaType() == kPremul_SkAlphaType) { |
468 | webpInfo = webpInfo.makeAlphaType(kUnpremul_SkAlphaType); |
469 | } |
470 | } |
471 | |
472 | if ((this->colorXform() && !is_8888(dstInfo.colorType())) || blendWithPrevFrame) { |
473 | // We will decode the entire image and then perform the color transform. libwebp |
474 | // does not provide a row-by-row API. This is a shame particularly when we do not want |
475 | // 8888, since we will need to create another image sized buffer. |
476 | webpDst.allocPixels(webpInfo); |
477 | } else { |
478 | // libwebp can decode directly into the output memory. |
479 | webpDst.installPixels(webpInfo, dst, rowBytes); |
480 | } |
481 | |
482 | config.output.colorspace = webp_decode_mode(webpInfo.colorType(), |
483 | frame.has_alpha && dstInfo.alphaType() == kPremul_SkAlphaType && !this->colorXform()); |
484 | config.output.is_external_memory = 1; |
485 | |
486 | config.output.u.RGBA.rgba = reinterpret_cast<uint8_t*>(webpDst.getAddr(dstX, dstY)); |
487 | config.output.u.RGBA.stride = static_cast<int>(webpDst.rowBytes()); |
488 | config.output.u.RGBA.size = webpDst.computeByteSize(); |
489 | |
490 | SkAutoTCallVProc<WebPIDecoder, WebPIDelete> idec(WebPIDecode(nullptr, 0, &config)); |
491 | if (!idec) { |
492 | return kInvalidInput; |
493 | } |
494 | |
495 | int rowsDecoded = 0; |
496 | SkCodec::Result result; |
497 | switch (WebPIUpdate(idec, frame.fragment.bytes, frame.fragment.size)) { |
498 | case VP8_STATUS_OK: |
499 | rowsDecoded = scaledHeight; |
500 | result = kSuccess; |
501 | break; |
502 | case VP8_STATUS_SUSPENDED: |
503 | if (!WebPIDecGetRGB(idec, &rowsDecoded, nullptr, nullptr, nullptr) |
504 | || rowsDecoded <= 0) { |
505 | return kInvalidInput; |
506 | } |
507 | *rowsDecodedPtr = rowsDecoded + dstY; |
508 | result = kIncompleteInput; |
509 | break; |
510 | default: |
511 | return kInvalidInput; |
512 | } |
513 | |
514 | const size_t dstBpp = dstInfo.bytesPerPixel(); |
515 | dst = SkTAddOffset<void>(dst, dstBpp * dstX + rowBytes * dstY); |
516 | const size_t srcRowBytes = config.output.u.RGBA.stride; |
517 | |
518 | const auto dstCT = dstInfo.colorType(); |
519 | if (this->colorXform()) { |
520 | uint32_t* xformSrc = (uint32_t*) config.output.u.RGBA.rgba; |
521 | SkBitmap tmp; |
522 | void* xformDst; |
523 | |
524 | if (blendWithPrevFrame) { |
525 | // Xform into temporary bitmap big enough for one row. |
526 | tmp.allocPixels(dstInfo.makeWH(scaledWidth, 1)); |
527 | xformDst = tmp.getPixels(); |
528 | } else { |
529 | xformDst = dst; |
530 | } |
531 | |
532 | for (int y = 0; y < rowsDecoded; y++) { |
533 | this->applyColorXform(xformDst, xformSrc, scaledWidth); |
534 | if (blendWithPrevFrame) { |
535 | blend_line(dstCT, dst, dstCT, xformDst, |
536 | dstInfo.alphaType(), frame.has_alpha, scaledWidth); |
537 | dst = SkTAddOffset<void>(dst, rowBytes); |
538 | } else { |
539 | xformDst = SkTAddOffset<void>(xformDst, rowBytes); |
540 | } |
541 | xformSrc = SkTAddOffset<uint32_t>(xformSrc, srcRowBytes); |
542 | } |
543 | } else if (blendWithPrevFrame) { |
544 | const uint8_t* src = config.output.u.RGBA.rgba; |
545 | |
546 | for (int y = 0; y < rowsDecoded; y++) { |
547 | blend_line(dstCT, dst, webpDst.colorType(), src, |
548 | dstInfo.alphaType(), frame.has_alpha, scaledWidth); |
549 | src = SkTAddOffset<const uint8_t>(src, srcRowBytes); |
550 | dst = SkTAddOffset<void>(dst, rowBytes); |
551 | } |
552 | } |
553 | |
554 | return result; |
555 | } |
556 | |
557 | SkWebpCodec::SkWebpCodec(SkEncodedInfo&& info, std::unique_ptr<SkStream> stream, |
558 | WebPDemuxer* demux, sk_sp<SkData> data, SkEncodedOrigin origin) |
559 | : INHERITED(std::move(info), skcms_PixelFormat_BGRA_8888, std::move(stream), |
560 | origin) |
561 | , fDemux(demux) |
562 | , fData(std::move(data)) |
563 | , fFailed(false) |
564 | { |
565 | const auto& eInfo = this->getEncodedInfo(); |
566 | fFrameHolder.setScreenSize(eInfo.width(), eInfo.height()); |
567 | } |
568 | |