xref: /aosp_15_r20/external/skia/src/codec/SkWuffsCodec.cpp (revision c8dee2aa9b3f27cf6c858bd81872bdeb2c07ed17)
1*c8dee2aaSAndroid Build Coastguard Worker /*
2*c8dee2aaSAndroid Build Coastguard Worker  * Copyright 2018 Google Inc.
3*c8dee2aaSAndroid Build Coastguard Worker  *
4*c8dee2aaSAndroid Build Coastguard Worker  * Use of this source code is governed by a BSD-style license that can be
5*c8dee2aaSAndroid Build Coastguard Worker  * found in the LICENSE file.
6*c8dee2aaSAndroid Build Coastguard Worker  */
7*c8dee2aaSAndroid Build Coastguard Worker 
8*c8dee2aaSAndroid Build Coastguard Worker #include "include/codec/SkCodec.h"
9*c8dee2aaSAndroid Build Coastguard Worker #include "include/codec/SkCodecAnimation.h"
10*c8dee2aaSAndroid Build Coastguard Worker #include "include/codec/SkEncodedImageFormat.h"
11*c8dee2aaSAndroid Build Coastguard Worker #include "include/codec/SkGifDecoder.h"
12*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkAlphaType.h"
13*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkBitmap.h"
14*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkBlendMode.h"
15*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkColorType.h"
16*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkData.h"
17*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkImageInfo.h"
18*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkMatrix.h"
19*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkPaint.h"
20*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkPixmap.h"
21*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkRect.h"
22*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkRefCnt.h"
23*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkSamplingOptions.h"
24*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkSize.h"
25*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkStream.h"
26*c8dee2aaSAndroid Build Coastguard Worker #include "include/core/SkTypes.h"
27*c8dee2aaSAndroid Build Coastguard Worker #include "include/private/SkEncodedInfo.h"
28*c8dee2aaSAndroid Build Coastguard Worker #include "include/private/base/SkMalloc.h"
29*c8dee2aaSAndroid Build Coastguard Worker #include "include/private/base/SkTo.h"
30*c8dee2aaSAndroid Build Coastguard Worker #include "modules/skcms/skcms.h"
31*c8dee2aaSAndroid Build Coastguard Worker #include "src/codec/SkCodecPriv.h"
32*c8dee2aaSAndroid Build Coastguard Worker #include "src/codec/SkFrameHolder.h"
33*c8dee2aaSAndroid Build Coastguard Worker #include "src/codec/SkSampler.h"
34*c8dee2aaSAndroid Build Coastguard Worker #include "src/codec/SkScalingCodec.h"
35*c8dee2aaSAndroid Build Coastguard Worker #include "src/core/SkDraw.h"
36*c8dee2aaSAndroid Build Coastguard Worker #include "src/core/SkRasterClip.h"
37*c8dee2aaSAndroid Build Coastguard Worker #include "src/core/SkStreamPriv.h"
38*c8dee2aaSAndroid Build Coastguard Worker 
39*c8dee2aaSAndroid Build Coastguard Worker #include <climits>
40*c8dee2aaSAndroid Build Coastguard Worker #include <cstdint>
41*c8dee2aaSAndroid Build Coastguard Worker #include <cstring>
42*c8dee2aaSAndroid Build Coastguard Worker #include <memory>
43*c8dee2aaSAndroid Build Coastguard Worker #include <utility>
44*c8dee2aaSAndroid Build Coastguard Worker #include <vector>
45*c8dee2aaSAndroid Build Coastguard Worker 
46*c8dee2aaSAndroid Build Coastguard Worker // Documentation on the Wuffs language and standard library (in general) and
47*c8dee2aaSAndroid Build Coastguard Worker // its image decoding API (in particular) is at:
48*c8dee2aaSAndroid Build Coastguard Worker //
49*c8dee2aaSAndroid Build Coastguard Worker //  - https://github.com/google/wuffs/tree/master/doc
50*c8dee2aaSAndroid Build Coastguard Worker //  - https://github.com/google/wuffs/blob/master/doc/std/image-decoders.md
51*c8dee2aaSAndroid Build Coastguard Worker 
52*c8dee2aaSAndroid Build Coastguard Worker // Wuffs ships as a "single file C library" or "header file library" as per
53*c8dee2aaSAndroid Build Coastguard Worker // https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
54*c8dee2aaSAndroid Build Coastguard Worker //
55*c8dee2aaSAndroid Build Coastguard Worker // As we have not #define'd WUFFS_IMPLEMENTATION, the #include here is
56*c8dee2aaSAndroid Build Coastguard Worker // including a header file, even though that file name ends in ".c".
57*c8dee2aaSAndroid Build Coastguard Worker #if defined(WUFFS_IMPLEMENTATION)
58*c8dee2aaSAndroid Build Coastguard Worker #error "SkWuffsCodec should not #define WUFFS_IMPLEMENTATION"
59*c8dee2aaSAndroid Build Coastguard Worker #endif
60*c8dee2aaSAndroid Build Coastguard Worker #include "wuffs-v0.3.c"  // NO_G3_REWRITE
61*c8dee2aaSAndroid Build Coastguard Worker // Commit count 2514 is Wuffs 0.3.0-alpha.4.
62*c8dee2aaSAndroid Build Coastguard Worker #if WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT < 2514
63*c8dee2aaSAndroid Build Coastguard Worker #error "Wuffs version is too old. Upgrade to the latest version."
64*c8dee2aaSAndroid Build Coastguard Worker #endif
65*c8dee2aaSAndroid Build Coastguard Worker 
66*c8dee2aaSAndroid Build Coastguard Worker #define SK_WUFFS_CODEC_BUFFER_SIZE 4096
67*c8dee2aaSAndroid Build Coastguard Worker 
68*c8dee2aaSAndroid Build Coastguard Worker // Configuring a Skia build with
69*c8dee2aaSAndroid Build Coastguard Worker // SK_WUFFS_FAVORS_PERFORMANCE_OVER_ADDITIONAL_MEMORY_SAFETY can improve decode
70*c8dee2aaSAndroid Build Coastguard Worker // performance by some fixed amount (independent of the image size), which can
71*c8dee2aaSAndroid Build Coastguard Worker // be a noticeable proportional improvement if the input is relatively small.
72*c8dee2aaSAndroid Build Coastguard Worker //
73*c8dee2aaSAndroid Build Coastguard Worker // The Wuffs library is still memory-safe either way, in that there are no
74*c8dee2aaSAndroid Build Coastguard Worker // out-of-bounds reads or writes, and the library endeavours not to read
75*c8dee2aaSAndroid Build Coastguard Worker // uninitialized memory. There are just fewer compiler-enforced guarantees
76*c8dee2aaSAndroid Build Coastguard Worker // against reading uninitialized memory. For more detail, see
77*c8dee2aaSAndroid Build Coastguard Worker // https://github.com/google/wuffs/blob/master/doc/note/initialization.md#partial-zero-initialization
78*c8dee2aaSAndroid Build Coastguard Worker #if defined(SK_WUFFS_FAVORS_PERFORMANCE_OVER_ADDITIONAL_MEMORY_SAFETY)
79*c8dee2aaSAndroid Build Coastguard Worker #define SK_WUFFS_INITIALIZE_FLAGS WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED
80*c8dee2aaSAndroid Build Coastguard Worker #else
81*c8dee2aaSAndroid Build Coastguard Worker #define SK_WUFFS_INITIALIZE_FLAGS WUFFS_INITIALIZE__DEFAULT_OPTIONS
82*c8dee2aaSAndroid Build Coastguard Worker #endif
83*c8dee2aaSAndroid Build Coastguard Worker 
fill_buffer(wuffs_base__io_buffer * b,SkStream * s)84*c8dee2aaSAndroid Build Coastguard Worker static bool fill_buffer(wuffs_base__io_buffer* b, SkStream* s) {
85*c8dee2aaSAndroid Build Coastguard Worker     b->compact();
86*c8dee2aaSAndroid Build Coastguard Worker     size_t num_read = s->read(b->data.ptr + b->meta.wi, b->data.len - b->meta.wi);
87*c8dee2aaSAndroid Build Coastguard Worker     b->meta.wi += num_read;
88*c8dee2aaSAndroid Build Coastguard Worker     // We hard-code false instead of s->isAtEnd(). In theory, Skia's
89*c8dee2aaSAndroid Build Coastguard Worker     // SkStream::isAtEnd() method has the same semantics as Wuffs'
90*c8dee2aaSAndroid Build Coastguard Worker     // wuffs_base__io_buffer_meta::closed field. Specifically, both are false
91*c8dee2aaSAndroid Build Coastguard Worker     // when reading from a network socket when all bytes *available right now*
92*c8dee2aaSAndroid Build Coastguard Worker     // have been read but there might be more later.
93*c8dee2aaSAndroid Build Coastguard Worker     //
94*c8dee2aaSAndroid Build Coastguard Worker     // However, SkStream is designed around synchronous I/O. The SkStream::read
95*c8dee2aaSAndroid Build Coastguard Worker     // method does not take a callback and, per its documentation comments, a
96*c8dee2aaSAndroid Build Coastguard Worker     // read request for N bytes should block until a full N bytes are
97*c8dee2aaSAndroid Build Coastguard Worker     // available. In practice, Blink's SkStream subclass builds on top of async
98*c8dee2aaSAndroid Build Coastguard Worker     // I/O and cannot afford to block. While it satisfies "the letter of the
99*c8dee2aaSAndroid Build Coastguard Worker     // law", in terms of what the C++ compiler needs, it does not satisfy "the
100*c8dee2aaSAndroid Build Coastguard Worker     // spirit of the law". Its read() can return short without blocking and its
101*c8dee2aaSAndroid Build Coastguard Worker     // isAtEnd() can return false positives.
102*c8dee2aaSAndroid Build Coastguard Worker     //
103*c8dee2aaSAndroid Build Coastguard Worker     // When closed is true, Wuffs treats incomplete input as a fatal error
104*c8dee2aaSAndroid Build Coastguard Worker     // instead of a recoverable "short read" suspension. We therefore hard-code
105*c8dee2aaSAndroid Build Coastguard Worker     // false and return kIncompleteInput (instead of kErrorInInput) up the call
106*c8dee2aaSAndroid Build Coastguard Worker     // stack even if the SkStream isAtEnd. The caller usually has more context
107*c8dee2aaSAndroid Build Coastguard Worker     // (more than what's in the SkStream) to differentiate the two, like this:
108*c8dee2aaSAndroid Build Coastguard Worker     // https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/platform/image-decoders/gif/gif_image_decoder.cc;l=115;drc=277dcc4d810ae4c0286d8af96d270ed9b686c5ff
109*c8dee2aaSAndroid Build Coastguard Worker     b->meta.closed = false;
110*c8dee2aaSAndroid Build Coastguard Worker     return num_read > 0;
111*c8dee2aaSAndroid Build Coastguard Worker }
112*c8dee2aaSAndroid Build Coastguard Worker 
seek_buffer(wuffs_base__io_buffer * b,SkStream * s,uint64_t pos)113*c8dee2aaSAndroid Build Coastguard Worker static bool seek_buffer(wuffs_base__io_buffer* b, SkStream* s, uint64_t pos) {
114*c8dee2aaSAndroid Build Coastguard Worker     // Try to re-position the io_buffer's meta.ri read-index first, which is
115*c8dee2aaSAndroid Build Coastguard Worker     // cheaper than seeking in the backing SkStream.
116*c8dee2aaSAndroid Build Coastguard Worker     if ((pos >= b->meta.pos) && (pos - b->meta.pos <= b->meta.wi)) {
117*c8dee2aaSAndroid Build Coastguard Worker         b->meta.ri = pos - b->meta.pos;
118*c8dee2aaSAndroid Build Coastguard Worker         return true;
119*c8dee2aaSAndroid Build Coastguard Worker     }
120*c8dee2aaSAndroid Build Coastguard Worker     // Seek in the backing SkStream.
121*c8dee2aaSAndroid Build Coastguard Worker     if ((pos > SIZE_MAX) || (!s->seek(pos))) {
122*c8dee2aaSAndroid Build Coastguard Worker         return false;
123*c8dee2aaSAndroid Build Coastguard Worker     }
124*c8dee2aaSAndroid Build Coastguard Worker     b->meta.wi = 0;
125*c8dee2aaSAndroid Build Coastguard Worker     b->meta.ri = 0;
126*c8dee2aaSAndroid Build Coastguard Worker     b->meta.pos = pos;
127*c8dee2aaSAndroid Build Coastguard Worker     b->meta.closed = false;
128*c8dee2aaSAndroid Build Coastguard Worker     return true;
129*c8dee2aaSAndroid Build Coastguard Worker }
130*c8dee2aaSAndroid Build Coastguard Worker 
wuffs_disposal_to_skia_disposal(wuffs_base__animation_disposal w)131*c8dee2aaSAndroid Build Coastguard Worker static SkCodecAnimation::DisposalMethod wuffs_disposal_to_skia_disposal(
132*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__animation_disposal w) {
133*c8dee2aaSAndroid Build Coastguard Worker     switch (w) {
134*c8dee2aaSAndroid Build Coastguard Worker         case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND:
135*c8dee2aaSAndroid Build Coastguard Worker             return SkCodecAnimation::DisposalMethod::kRestoreBGColor;
136*c8dee2aaSAndroid Build Coastguard Worker         case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS:
137*c8dee2aaSAndroid Build Coastguard Worker             return SkCodecAnimation::DisposalMethod::kRestorePrevious;
138*c8dee2aaSAndroid Build Coastguard Worker         default:
139*c8dee2aaSAndroid Build Coastguard Worker             return SkCodecAnimation::DisposalMethod::kKeep;
140*c8dee2aaSAndroid Build Coastguard Worker     }
141*c8dee2aaSAndroid Build Coastguard Worker }
142*c8dee2aaSAndroid Build Coastguard Worker 
to_alpha_type(bool opaque)143*c8dee2aaSAndroid Build Coastguard Worker static SkAlphaType to_alpha_type(bool opaque) {
144*c8dee2aaSAndroid Build Coastguard Worker     return opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
145*c8dee2aaSAndroid Build Coastguard Worker }
146*c8dee2aaSAndroid Build Coastguard Worker 
reset_and_decode_image_config(wuffs_gif__decoder * decoder,wuffs_base__image_config * imgcfg,wuffs_base__io_buffer * b,SkStream * s)147*c8dee2aaSAndroid Build Coastguard Worker static SkCodec::Result reset_and_decode_image_config(wuffs_gif__decoder*       decoder,
148*c8dee2aaSAndroid Build Coastguard Worker                                                      wuffs_base__image_config* imgcfg,
149*c8dee2aaSAndroid Build Coastguard Worker                                                      wuffs_base__io_buffer*    b,
150*c8dee2aaSAndroid Build Coastguard Worker                                                      SkStream*                 s) {
151*c8dee2aaSAndroid Build Coastguard Worker     // Calling decoder->initialize will memset most or all of it to zero,
152*c8dee2aaSAndroid Build Coastguard Worker     // depending on SK_WUFFS_INITIALIZE_FLAGS.
153*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__status status =
154*c8dee2aaSAndroid Build Coastguard Worker         decoder->initialize(sizeof__wuffs_gif__decoder(), WUFFS_VERSION, SK_WUFFS_INITIALIZE_FLAGS);
155*c8dee2aaSAndroid Build Coastguard Worker     if (status.repr != nullptr) {
156*c8dee2aaSAndroid Build Coastguard Worker         SkCodecPrintf("initialize: %s", status.message());
157*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kInternalError;
158*c8dee2aaSAndroid Build Coastguard Worker     }
159*c8dee2aaSAndroid Build Coastguard Worker 
160*c8dee2aaSAndroid Build Coastguard Worker     // See https://bugs.chromium.org/p/skia/issues/detail?id=12055
161*c8dee2aaSAndroid Build Coastguard Worker     decoder->set_quirk_enabled(WUFFS_GIF__QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA, true);
162*c8dee2aaSAndroid Build Coastguard Worker 
163*c8dee2aaSAndroid Build Coastguard Worker     while (true) {
164*c8dee2aaSAndroid Build Coastguard Worker         status = decoder->decode_image_config(imgcfg, b);
165*c8dee2aaSAndroid Build Coastguard Worker         if (status.repr == nullptr) {
166*c8dee2aaSAndroid Build Coastguard Worker             break;
167*c8dee2aaSAndroid Build Coastguard Worker         } else if (status.repr != wuffs_base__suspension__short_read) {
168*c8dee2aaSAndroid Build Coastguard Worker             SkCodecPrintf("decode_image_config: %s", status.message());
169*c8dee2aaSAndroid Build Coastguard Worker             return SkCodec::kErrorInInput;
170*c8dee2aaSAndroid Build Coastguard Worker         } else if (!fill_buffer(b, s)) {
171*c8dee2aaSAndroid Build Coastguard Worker             return SkCodec::kIncompleteInput;
172*c8dee2aaSAndroid Build Coastguard Worker         }
173*c8dee2aaSAndroid Build Coastguard Worker     }
174*c8dee2aaSAndroid Build Coastguard Worker 
175*c8dee2aaSAndroid Build Coastguard Worker     // A GIF image's natural color model is indexed color: 1 byte per pixel,
176*c8dee2aaSAndroid Build Coastguard Worker     // indexing a 256-element palette.
177*c8dee2aaSAndroid Build Coastguard Worker     //
178*c8dee2aaSAndroid Build Coastguard Worker     // For Skia, we override that to decode to 4 bytes per pixel, BGRA or RGBA.
179*c8dee2aaSAndroid Build Coastguard Worker     uint32_t pixfmt = WUFFS_BASE__PIXEL_FORMAT__INVALID;
180*c8dee2aaSAndroid Build Coastguard Worker     switch (kN32_SkColorType) {
181*c8dee2aaSAndroid Build Coastguard Worker         case kBGRA_8888_SkColorType:
182*c8dee2aaSAndroid Build Coastguard Worker             pixfmt = WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL;
183*c8dee2aaSAndroid Build Coastguard Worker             break;
184*c8dee2aaSAndroid Build Coastguard Worker         case kRGBA_8888_SkColorType:
185*c8dee2aaSAndroid Build Coastguard Worker             pixfmt = WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL;
186*c8dee2aaSAndroid Build Coastguard Worker             break;
187*c8dee2aaSAndroid Build Coastguard Worker         default:
188*c8dee2aaSAndroid Build Coastguard Worker             return SkCodec::kInternalError;
189*c8dee2aaSAndroid Build Coastguard Worker     }
190*c8dee2aaSAndroid Build Coastguard Worker     if (imgcfg) {
191*c8dee2aaSAndroid Build Coastguard Worker         imgcfg->pixcfg.set(pixfmt, WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, imgcfg->pixcfg.width(),
192*c8dee2aaSAndroid Build Coastguard Worker                            imgcfg->pixcfg.height());
193*c8dee2aaSAndroid Build Coastguard Worker     }
194*c8dee2aaSAndroid Build Coastguard Worker 
195*c8dee2aaSAndroid Build Coastguard Worker     return SkCodec::kSuccess;
196*c8dee2aaSAndroid Build Coastguard Worker }
197*c8dee2aaSAndroid Build Coastguard Worker 
198*c8dee2aaSAndroid Build Coastguard Worker // -------------------------------- Class definitions
199*c8dee2aaSAndroid Build Coastguard Worker 
200*c8dee2aaSAndroid Build Coastguard Worker class SkWuffsCodec;
201*c8dee2aaSAndroid Build Coastguard Worker 
202*c8dee2aaSAndroid Build Coastguard Worker class SkWuffsFrame final : public SkFrame {
203*c8dee2aaSAndroid Build Coastguard Worker public:
204*c8dee2aaSAndroid Build Coastguard Worker     SkWuffsFrame(wuffs_base__frame_config* fc);
205*c8dee2aaSAndroid Build Coastguard Worker 
206*c8dee2aaSAndroid Build Coastguard Worker     uint64_t ioPosition() const;
207*c8dee2aaSAndroid Build Coastguard Worker 
208*c8dee2aaSAndroid Build Coastguard Worker     // SkFrame overrides.
209*c8dee2aaSAndroid Build Coastguard Worker     SkEncodedInfo::Alpha onReportedAlpha() const override;
210*c8dee2aaSAndroid Build Coastguard Worker 
211*c8dee2aaSAndroid Build Coastguard Worker private:
212*c8dee2aaSAndroid Build Coastguard Worker     uint64_t             fIOPosition;
213*c8dee2aaSAndroid Build Coastguard Worker     SkEncodedInfo::Alpha fReportedAlpha;
214*c8dee2aaSAndroid Build Coastguard Worker 
215*c8dee2aaSAndroid Build Coastguard Worker     using INHERITED = SkFrame;
216*c8dee2aaSAndroid Build Coastguard Worker };
217*c8dee2aaSAndroid Build Coastguard Worker 
218*c8dee2aaSAndroid Build Coastguard Worker // SkWuffsFrameHolder is a trivial indirector that forwards its calls onto a
219*c8dee2aaSAndroid Build Coastguard Worker // SkWuffsCodec. It is a separate class as SkWuffsCodec would otherwise
220*c8dee2aaSAndroid Build Coastguard Worker // inherit from both SkCodec and SkFrameHolder, and Skia style discourages
221*c8dee2aaSAndroid Build Coastguard Worker // multiple inheritance (e.g. with its "typedef Foo INHERITED" convention).
222*c8dee2aaSAndroid Build Coastguard Worker class SkWuffsFrameHolder final : public SkFrameHolder {
223*c8dee2aaSAndroid Build Coastguard Worker public:
SkWuffsFrameHolder()224*c8dee2aaSAndroid Build Coastguard Worker     SkWuffsFrameHolder() : INHERITED() {}
225*c8dee2aaSAndroid Build Coastguard Worker 
226*c8dee2aaSAndroid Build Coastguard Worker     void init(SkWuffsCodec* codec, int width, int height);
227*c8dee2aaSAndroid Build Coastguard Worker 
228*c8dee2aaSAndroid Build Coastguard Worker     // SkFrameHolder overrides.
229*c8dee2aaSAndroid Build Coastguard Worker     const SkFrame* onGetFrame(int i) const override;
230*c8dee2aaSAndroid Build Coastguard Worker 
231*c8dee2aaSAndroid Build Coastguard Worker private:
232*c8dee2aaSAndroid Build Coastguard Worker     const SkWuffsCodec* fCodec;
233*c8dee2aaSAndroid Build Coastguard Worker 
234*c8dee2aaSAndroid Build Coastguard Worker     using INHERITED = SkFrameHolder;
235*c8dee2aaSAndroid Build Coastguard Worker };
236*c8dee2aaSAndroid Build Coastguard Worker 
237*c8dee2aaSAndroid Build Coastguard Worker class SkWuffsCodec final : public SkScalingCodec {
238*c8dee2aaSAndroid Build Coastguard Worker public:
239*c8dee2aaSAndroid Build Coastguard Worker     SkWuffsCodec(SkEncodedInfo&&                                         encodedInfo,
240*c8dee2aaSAndroid Build Coastguard Worker                  std::unique_ptr<SkStream>                               stream,
241*c8dee2aaSAndroid Build Coastguard Worker                  bool                                                    canSeek,
242*c8dee2aaSAndroid Build Coastguard Worker                  std::unique_ptr<wuffs_gif__decoder, decltype(&sk_free)> dec,
243*c8dee2aaSAndroid Build Coastguard Worker                  std::unique_ptr<uint8_t, decltype(&sk_free)>            workbuf_ptr,
244*c8dee2aaSAndroid Build Coastguard Worker                  size_t                                                  workbuf_len,
245*c8dee2aaSAndroid Build Coastguard Worker                  wuffs_base__image_config                                imgcfg,
246*c8dee2aaSAndroid Build Coastguard Worker                  wuffs_base__io_buffer                                   iobuf);
247*c8dee2aaSAndroid Build Coastguard Worker 
248*c8dee2aaSAndroid Build Coastguard Worker     const SkWuffsFrame* frame(int i) const;
249*c8dee2aaSAndroid Build Coastguard Worker 
250*c8dee2aaSAndroid Build Coastguard Worker     std::unique_ptr<SkStream> getEncodedData() const override;
251*c8dee2aaSAndroid Build Coastguard Worker 
252*c8dee2aaSAndroid Build Coastguard Worker private:
253*c8dee2aaSAndroid Build Coastguard Worker     // SkCodec overrides.
254*c8dee2aaSAndroid Build Coastguard Worker     SkEncodedImageFormat onGetEncodedFormat() const override;
255*c8dee2aaSAndroid Build Coastguard Worker     Result onGetPixels(const SkImageInfo&, void*, size_t, const Options&, int*) override;
256*c8dee2aaSAndroid Build Coastguard Worker     const SkFrameHolder* getFrameHolder() const override;
257*c8dee2aaSAndroid Build Coastguard Worker     Result               onStartIncrementalDecode(const SkImageInfo&      dstInfo,
258*c8dee2aaSAndroid Build Coastguard Worker                                                   void*                   dst,
259*c8dee2aaSAndroid Build Coastguard Worker                                                   size_t                  rowBytes,
260*c8dee2aaSAndroid Build Coastguard Worker                                                   const SkCodec::Options& options) override;
261*c8dee2aaSAndroid Build Coastguard Worker     Result               onIncrementalDecode(int* rowsDecoded) override;
262*c8dee2aaSAndroid Build Coastguard Worker     int                  onGetFrameCount() override;
263*c8dee2aaSAndroid Build Coastguard Worker     bool                 onGetFrameInfo(int, FrameInfo*) const override;
264*c8dee2aaSAndroid Build Coastguard Worker     int                  onGetRepetitionCount() override;
265*c8dee2aaSAndroid Build Coastguard Worker 
266*c8dee2aaSAndroid Build Coastguard Worker     // Two separate implementations of onStartIncrementalDecode and
267*c8dee2aaSAndroid Build Coastguard Worker     // onIncrementalDecode, named "one pass" and "two pass" decoding. One pass
268*c8dee2aaSAndroid Build Coastguard Worker     // decoding writes directly from the Wuffs image decoder to the dst buffer
269*c8dee2aaSAndroid Build Coastguard Worker     // (the dst argument to onStartIncrementalDecode). Two pass decoding first
270*c8dee2aaSAndroid Build Coastguard Worker     // writes into an intermediate buffer, and then composites and transforms
271*c8dee2aaSAndroid Build Coastguard Worker     // the intermediate buffer into the dst buffer.
272*c8dee2aaSAndroid Build Coastguard Worker     //
273*c8dee2aaSAndroid Build Coastguard Worker     // In the general case, we need the two pass decoder, because of Skia API
274*c8dee2aaSAndroid Build Coastguard Worker     // features that Wuffs doesn't support (e.g. color correction, scaling,
275*c8dee2aaSAndroid Build Coastguard Worker     // RGB565). But as an optimization, we use one pass decoding (it's faster
276*c8dee2aaSAndroid Build Coastguard Worker     // and uses less memory) if applicable (see the assignment to
277*c8dee2aaSAndroid Build Coastguard Worker     // fIncrDecOnePass that calculates when we can do so).
278*c8dee2aaSAndroid Build Coastguard Worker     Result onStartIncrementalDecodeOnePass(const SkImageInfo&      dstInfo,
279*c8dee2aaSAndroid Build Coastguard Worker                                            uint8_t*                dst,
280*c8dee2aaSAndroid Build Coastguard Worker                                            size_t                  rowBytes,
281*c8dee2aaSAndroid Build Coastguard Worker                                            const SkCodec::Options& options,
282*c8dee2aaSAndroid Build Coastguard Worker                                            uint32_t                pixelFormat,
283*c8dee2aaSAndroid Build Coastguard Worker                                            size_t                  bytesPerPixel);
284*c8dee2aaSAndroid Build Coastguard Worker     Result onStartIncrementalDecodeTwoPass();
285*c8dee2aaSAndroid Build Coastguard Worker     Result onIncrementalDecodeOnePass();
286*c8dee2aaSAndroid Build Coastguard Worker     Result onIncrementalDecodeTwoPass();
287*c8dee2aaSAndroid Build Coastguard Worker 
288*c8dee2aaSAndroid Build Coastguard Worker     void        onGetFrameCountInternal();
289*c8dee2aaSAndroid Build Coastguard Worker     Result      seekFrame(int frameIndex);
290*c8dee2aaSAndroid Build Coastguard Worker     Result      resetDecoder();
291*c8dee2aaSAndroid Build Coastguard Worker     const char* decodeFrameConfig();
292*c8dee2aaSAndroid Build Coastguard Worker     const char* decodeFrame();
293*c8dee2aaSAndroid Build Coastguard Worker     void        updateNumFullyReceivedFrames();
294*c8dee2aaSAndroid Build Coastguard Worker 
295*c8dee2aaSAndroid Build Coastguard Worker     SkWuffsFrameHolder                           fFrameHolder;
296*c8dee2aaSAndroid Build Coastguard Worker     std::unique_ptr<SkStream>                    fPrivStream;
297*c8dee2aaSAndroid Build Coastguard Worker     std::unique_ptr<uint8_t, decltype(&sk_free)> fWorkbufPtr;
298*c8dee2aaSAndroid Build Coastguard Worker     size_t                                       fWorkbufLen;
299*c8dee2aaSAndroid Build Coastguard Worker 
300*c8dee2aaSAndroid Build Coastguard Worker     std::unique_ptr<wuffs_gif__decoder, decltype(&sk_free)> fDecoder;
301*c8dee2aaSAndroid Build Coastguard Worker 
302*c8dee2aaSAndroid Build Coastguard Worker     const uint64_t           fFirstFrameIOPosition;
303*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__frame_config fFrameConfig;
304*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__pixel_config fPixelConfig;
305*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__pixel_buffer fPixelBuffer;
306*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__io_buffer    fIOBuffer;
307*c8dee2aaSAndroid Build Coastguard Worker 
308*c8dee2aaSAndroid Build Coastguard Worker     // Incremental decoding state.
309*c8dee2aaSAndroid Build Coastguard Worker     uint8_t*                fIncrDecDst;
310*c8dee2aaSAndroid Build Coastguard Worker     size_t                  fIncrDecRowBytes;
311*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__pixel_blend fIncrDecPixelBlend;
312*c8dee2aaSAndroid Build Coastguard Worker     bool                    fIncrDecOnePass;
313*c8dee2aaSAndroid Build Coastguard Worker     bool                    fFirstCallToIncrementalDecode;
314*c8dee2aaSAndroid Build Coastguard Worker 
315*c8dee2aaSAndroid Build Coastguard Worker     // Lazily allocated intermediate pixel buffer, for two pass decoding.
316*c8dee2aaSAndroid Build Coastguard Worker     std::unique_ptr<uint8_t, decltype(&sk_free)> fTwoPassPixbufPtr;
317*c8dee2aaSAndroid Build Coastguard Worker     size_t                                       fTwoPassPixbufLen;
318*c8dee2aaSAndroid Build Coastguard Worker 
319*c8dee2aaSAndroid Build Coastguard Worker     uint64_t                  fNumFullyReceivedFrames;
320*c8dee2aaSAndroid Build Coastguard Worker     std::vector<SkWuffsFrame> fFrames;
321*c8dee2aaSAndroid Build Coastguard Worker     bool                      fFramesComplete;
322*c8dee2aaSAndroid Build Coastguard Worker 
323*c8dee2aaSAndroid Build Coastguard Worker     // If calling an fDecoder method returns an incomplete status, then
324*c8dee2aaSAndroid Build Coastguard Worker     // fDecoder is suspended in a coroutine (i.e. waiting on I/O or halted on a
325*c8dee2aaSAndroid Build Coastguard Worker     // non-recoverable error). To keep its internal proof-of-safety invariants
326*c8dee2aaSAndroid Build Coastguard Worker     // consistent, there's only two things you can safely do with a suspended
327*c8dee2aaSAndroid Build Coastguard Worker     // Wuffs object: resume the coroutine, or reset all state (memset to zero
328*c8dee2aaSAndroid Build Coastguard Worker     // and start again).
329*c8dee2aaSAndroid Build Coastguard Worker     //
330*c8dee2aaSAndroid Build Coastguard Worker     // If fDecoderIsSuspended, and we aren't sure that we're going to resume
331*c8dee2aaSAndroid Build Coastguard Worker     // the coroutine, then we will need to call this->resetDecoder before
332*c8dee2aaSAndroid Build Coastguard Worker     // calling other fDecoder methods.
333*c8dee2aaSAndroid Build Coastguard Worker     bool fDecoderIsSuspended;
334*c8dee2aaSAndroid Build Coastguard Worker 
335*c8dee2aaSAndroid Build Coastguard Worker     uint8_t fBuffer[SK_WUFFS_CODEC_BUFFER_SIZE];
336*c8dee2aaSAndroid Build Coastguard Worker 
337*c8dee2aaSAndroid Build Coastguard Worker     const bool fCanSeek;
338*c8dee2aaSAndroid Build Coastguard Worker 
339*c8dee2aaSAndroid Build Coastguard Worker     using INHERITED = SkScalingCodec;
340*c8dee2aaSAndroid Build Coastguard Worker };
341*c8dee2aaSAndroid Build Coastguard Worker 
342*c8dee2aaSAndroid Build Coastguard Worker // -------------------------------- SkWuffsFrame implementation
343*c8dee2aaSAndroid Build Coastguard Worker 
SkWuffsFrame(wuffs_base__frame_config * fc)344*c8dee2aaSAndroid Build Coastguard Worker SkWuffsFrame::SkWuffsFrame(wuffs_base__frame_config* fc)
345*c8dee2aaSAndroid Build Coastguard Worker     : INHERITED(fc->index()),
346*c8dee2aaSAndroid Build Coastguard Worker       fIOPosition(fc->io_position()),
347*c8dee2aaSAndroid Build Coastguard Worker       fReportedAlpha(fc->opaque_within_bounds() ? SkEncodedInfo::kOpaque_Alpha
348*c8dee2aaSAndroid Build Coastguard Worker                                                 : SkEncodedInfo::kUnpremul_Alpha) {
349*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__rect_ie_u32 r = fc->bounds();
350*c8dee2aaSAndroid Build Coastguard Worker     this->setXYWH(r.min_incl_x, r.min_incl_y, r.width(), r.height());
351*c8dee2aaSAndroid Build Coastguard Worker     this->setDisposalMethod(wuffs_disposal_to_skia_disposal(fc->disposal()));
352*c8dee2aaSAndroid Build Coastguard Worker     this->setDuration(fc->duration() / WUFFS_BASE__FLICKS_PER_MILLISECOND);
353*c8dee2aaSAndroid Build Coastguard Worker     this->setBlend(fc->overwrite_instead_of_blend() ? SkCodecAnimation::Blend::kSrc
354*c8dee2aaSAndroid Build Coastguard Worker                                                     : SkCodecAnimation::Blend::kSrcOver);
355*c8dee2aaSAndroid Build Coastguard Worker }
356*c8dee2aaSAndroid Build Coastguard Worker 
ioPosition() const357*c8dee2aaSAndroid Build Coastguard Worker uint64_t SkWuffsFrame::ioPosition() const {
358*c8dee2aaSAndroid Build Coastguard Worker     return fIOPosition;
359*c8dee2aaSAndroid Build Coastguard Worker }
360*c8dee2aaSAndroid Build Coastguard Worker 
onReportedAlpha() const361*c8dee2aaSAndroid Build Coastguard Worker SkEncodedInfo::Alpha SkWuffsFrame::onReportedAlpha() const {
362*c8dee2aaSAndroid Build Coastguard Worker     return fReportedAlpha;
363*c8dee2aaSAndroid Build Coastguard Worker }
364*c8dee2aaSAndroid Build Coastguard Worker 
365*c8dee2aaSAndroid Build Coastguard Worker // -------------------------------- SkWuffsFrameHolder implementation
366*c8dee2aaSAndroid Build Coastguard Worker 
init(SkWuffsCodec * codec,int width,int height)367*c8dee2aaSAndroid Build Coastguard Worker void SkWuffsFrameHolder::init(SkWuffsCodec* codec, int width, int height) {
368*c8dee2aaSAndroid Build Coastguard Worker     fCodec = codec;
369*c8dee2aaSAndroid Build Coastguard Worker     // Initialize SkFrameHolder's (the superclass) fields.
370*c8dee2aaSAndroid Build Coastguard Worker     fScreenWidth = width;
371*c8dee2aaSAndroid Build Coastguard Worker     fScreenHeight = height;
372*c8dee2aaSAndroid Build Coastguard Worker }
373*c8dee2aaSAndroid Build Coastguard Worker 
onGetFrame(int i) const374*c8dee2aaSAndroid Build Coastguard Worker const SkFrame* SkWuffsFrameHolder::onGetFrame(int i) const {
375*c8dee2aaSAndroid Build Coastguard Worker     return fCodec->frame(i);
376*c8dee2aaSAndroid Build Coastguard Worker }
377*c8dee2aaSAndroid Build Coastguard Worker 
378*c8dee2aaSAndroid Build Coastguard Worker // -------------------------------- SkWuffsCodec implementation
379*c8dee2aaSAndroid Build Coastguard Worker 
SkWuffsCodec(SkEncodedInfo && encodedInfo,std::unique_ptr<SkStream> stream,bool canSeek,std::unique_ptr<wuffs_gif__decoder,decltype(& sk_free) > dec,std::unique_ptr<uint8_t,decltype(& sk_free) > workbuf_ptr,size_t workbuf_len,wuffs_base__image_config imgcfg,wuffs_base__io_buffer iobuf)380*c8dee2aaSAndroid Build Coastguard Worker SkWuffsCodec::SkWuffsCodec(SkEncodedInfo&& encodedInfo,
381*c8dee2aaSAndroid Build Coastguard Worker                            std::unique_ptr<SkStream> stream,
382*c8dee2aaSAndroid Build Coastguard Worker                            bool canSeek,
383*c8dee2aaSAndroid Build Coastguard Worker                            std::unique_ptr<wuffs_gif__decoder, decltype(&sk_free)> dec,
384*c8dee2aaSAndroid Build Coastguard Worker                            std::unique_ptr<uint8_t, decltype(&sk_free)> workbuf_ptr,
385*c8dee2aaSAndroid Build Coastguard Worker                            size_t workbuf_len,
386*c8dee2aaSAndroid Build Coastguard Worker                            wuffs_base__image_config imgcfg,
387*c8dee2aaSAndroid Build Coastguard Worker                            wuffs_base__io_buffer iobuf)
388*c8dee2aaSAndroid Build Coastguard Worker         : INHERITED(std::move(encodedInfo),
389*c8dee2aaSAndroid Build Coastguard Worker                     skcms_PixelFormat_RGBA_8888,
390*c8dee2aaSAndroid Build Coastguard Worker                     // Pass a nullptr SkStream to the SkCodec constructor. We
391*c8dee2aaSAndroid Build Coastguard Worker                     // manage the stream ourselves, as the default SkCodec behavior
392*c8dee2aaSAndroid Build Coastguard Worker                     // is too trigger-happy on rewinding the stream.
393*c8dee2aaSAndroid Build Coastguard Worker                     //
394*c8dee2aaSAndroid Build Coastguard Worker                     // TODO(https://crbug.com/370522089): See if `SkCodec` can be
395*c8dee2aaSAndroid Build Coastguard Worker                     // tweaked to avoid the need to hide the stream from it.
396*c8dee2aaSAndroid Build Coastguard Worker                     nullptr)
397*c8dee2aaSAndroid Build Coastguard Worker         , fFrameHolder()
398*c8dee2aaSAndroid Build Coastguard Worker         , fPrivStream(std::move(stream))
399*c8dee2aaSAndroid Build Coastguard Worker         , fWorkbufPtr(std::move(workbuf_ptr))
400*c8dee2aaSAndroid Build Coastguard Worker         , fWorkbufLen(workbuf_len)
401*c8dee2aaSAndroid Build Coastguard Worker         , fDecoder(std::move(dec))
402*c8dee2aaSAndroid Build Coastguard Worker         , fFirstFrameIOPosition(imgcfg.first_frame_io_position())
403*c8dee2aaSAndroid Build Coastguard Worker         , fFrameConfig(wuffs_base__null_frame_config())
404*c8dee2aaSAndroid Build Coastguard Worker         , fPixelConfig(imgcfg.pixcfg)
405*c8dee2aaSAndroid Build Coastguard Worker         , fPixelBuffer(wuffs_base__null_pixel_buffer())
406*c8dee2aaSAndroid Build Coastguard Worker         , fIOBuffer(wuffs_base__empty_io_buffer())
407*c8dee2aaSAndroid Build Coastguard Worker         , fIncrDecDst(nullptr)
408*c8dee2aaSAndroid Build Coastguard Worker         , fIncrDecRowBytes(0)
409*c8dee2aaSAndroid Build Coastguard Worker         , fIncrDecPixelBlend(WUFFS_BASE__PIXEL_BLEND__SRC)
410*c8dee2aaSAndroid Build Coastguard Worker         , fIncrDecOnePass(false)
411*c8dee2aaSAndroid Build Coastguard Worker         , fFirstCallToIncrementalDecode(false)
412*c8dee2aaSAndroid Build Coastguard Worker         , fTwoPassPixbufPtr(nullptr, &sk_free)
413*c8dee2aaSAndroid Build Coastguard Worker         , fTwoPassPixbufLen(0)
414*c8dee2aaSAndroid Build Coastguard Worker         , fNumFullyReceivedFrames(0)
415*c8dee2aaSAndroid Build Coastguard Worker         , fFramesComplete(false)
416*c8dee2aaSAndroid Build Coastguard Worker         , fDecoderIsSuspended(false)
417*c8dee2aaSAndroid Build Coastguard Worker         , fCanSeek(canSeek) {
418*c8dee2aaSAndroid Build Coastguard Worker     fFrameHolder.init(this, imgcfg.pixcfg.width(), imgcfg.pixcfg.height());
419*c8dee2aaSAndroid Build Coastguard Worker 
420*c8dee2aaSAndroid Build Coastguard Worker     // Initialize fIOBuffer's fields, copying any outstanding data from iobuf to
421*c8dee2aaSAndroid Build Coastguard Worker     // fIOBuffer, as iobuf's backing array may not be valid for the lifetime of
422*c8dee2aaSAndroid Build Coastguard Worker     // this SkWuffsCodec object, but fIOBuffer's backing array (fBuffer) is.
423*c8dee2aaSAndroid Build Coastguard Worker     SkASSERT(iobuf.data.len == SK_WUFFS_CODEC_BUFFER_SIZE);
424*c8dee2aaSAndroid Build Coastguard Worker     memmove(fBuffer, iobuf.data.ptr, iobuf.meta.wi);
425*c8dee2aaSAndroid Build Coastguard Worker     fIOBuffer.data = wuffs_base__make_slice_u8(fBuffer, SK_WUFFS_CODEC_BUFFER_SIZE);
426*c8dee2aaSAndroid Build Coastguard Worker     fIOBuffer.meta = iobuf.meta;
427*c8dee2aaSAndroid Build Coastguard Worker }
428*c8dee2aaSAndroid Build Coastguard Worker 
frame(int i) const429*c8dee2aaSAndroid Build Coastguard Worker const SkWuffsFrame* SkWuffsCodec::frame(int i) const {
430*c8dee2aaSAndroid Build Coastguard Worker     if ((0 <= i) && (static_cast<size_t>(i) < fFrames.size())) {
431*c8dee2aaSAndroid Build Coastguard Worker         return &fFrames[i];
432*c8dee2aaSAndroid Build Coastguard Worker     }
433*c8dee2aaSAndroid Build Coastguard Worker     return nullptr;
434*c8dee2aaSAndroid Build Coastguard Worker }
435*c8dee2aaSAndroid Build Coastguard Worker 
onGetEncodedFormat() const436*c8dee2aaSAndroid Build Coastguard Worker SkEncodedImageFormat SkWuffsCodec::onGetEncodedFormat() const {
437*c8dee2aaSAndroid Build Coastguard Worker     return SkEncodedImageFormat::kGIF;
438*c8dee2aaSAndroid Build Coastguard Worker }
439*c8dee2aaSAndroid Build Coastguard Worker 
onGetPixels(const SkImageInfo & dstInfo,void * dst,size_t rowBytes,const Options & options,int * rowsDecoded)440*c8dee2aaSAndroid Build Coastguard Worker SkCodec::Result SkWuffsCodec::onGetPixels(const SkImageInfo& dstInfo,
441*c8dee2aaSAndroid Build Coastguard Worker                                           void*              dst,
442*c8dee2aaSAndroid Build Coastguard Worker                                           size_t             rowBytes,
443*c8dee2aaSAndroid Build Coastguard Worker                                           const Options&     options,
444*c8dee2aaSAndroid Build Coastguard Worker                                           int*               rowsDecoded) {
445*c8dee2aaSAndroid Build Coastguard Worker     SkCodec::Result result = this->onStartIncrementalDecode(dstInfo, dst, rowBytes, options);
446*c8dee2aaSAndroid Build Coastguard Worker     if (result != kSuccess) {
447*c8dee2aaSAndroid Build Coastguard Worker         return result;
448*c8dee2aaSAndroid Build Coastguard Worker     }
449*c8dee2aaSAndroid Build Coastguard Worker     return this->onIncrementalDecode(rowsDecoded);
450*c8dee2aaSAndroid Build Coastguard Worker }
451*c8dee2aaSAndroid Build Coastguard Worker 
getFrameHolder() const452*c8dee2aaSAndroid Build Coastguard Worker const SkFrameHolder* SkWuffsCodec::getFrameHolder() const {
453*c8dee2aaSAndroid Build Coastguard Worker     return &fFrameHolder;
454*c8dee2aaSAndroid Build Coastguard Worker }
455*c8dee2aaSAndroid Build Coastguard Worker 
onStartIncrementalDecode(const SkImageInfo & dstInfo,void * dst,size_t rowBytes,const SkCodec::Options & options)456*c8dee2aaSAndroid Build Coastguard Worker SkCodec::Result SkWuffsCodec::onStartIncrementalDecode(const SkImageInfo&      dstInfo,
457*c8dee2aaSAndroid Build Coastguard Worker                                                        void*                   dst,
458*c8dee2aaSAndroid Build Coastguard Worker                                                        size_t                  rowBytes,
459*c8dee2aaSAndroid Build Coastguard Worker                                                        const SkCodec::Options& options) {
460*c8dee2aaSAndroid Build Coastguard Worker     if (!dst) {
461*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kInvalidParameters;
462*c8dee2aaSAndroid Build Coastguard Worker     }
463*c8dee2aaSAndroid Build Coastguard Worker     if (options.fSubset) {
464*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kUnimplemented;
465*c8dee2aaSAndroid Build Coastguard Worker     }
466*c8dee2aaSAndroid Build Coastguard Worker     SkCodec::Result result = this->seekFrame(options.fFrameIndex);
467*c8dee2aaSAndroid Build Coastguard Worker     if (result != SkCodec::kSuccess) {
468*c8dee2aaSAndroid Build Coastguard Worker         return result;
469*c8dee2aaSAndroid Build Coastguard Worker     }
470*c8dee2aaSAndroid Build Coastguard Worker 
471*c8dee2aaSAndroid Build Coastguard Worker     const char* status = this->decodeFrameConfig();
472*c8dee2aaSAndroid Build Coastguard Worker     if (status == wuffs_base__suspension__short_read) {
473*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kIncompleteInput;
474*c8dee2aaSAndroid Build Coastguard Worker     } else if (status != nullptr) {
475*c8dee2aaSAndroid Build Coastguard Worker         SkCodecPrintf("decodeFrameConfig: %s", status);
476*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kErrorInInput;
477*c8dee2aaSAndroid Build Coastguard Worker     }
478*c8dee2aaSAndroid Build Coastguard Worker 
479*c8dee2aaSAndroid Build Coastguard Worker     uint32_t pixelFormat = WUFFS_BASE__PIXEL_FORMAT__INVALID;
480*c8dee2aaSAndroid Build Coastguard Worker     size_t   bytesPerPixel = 0;
481*c8dee2aaSAndroid Build Coastguard Worker 
482*c8dee2aaSAndroid Build Coastguard Worker     switch (dstInfo.colorType()) {
483*c8dee2aaSAndroid Build Coastguard Worker         case kRGB_565_SkColorType:
484*c8dee2aaSAndroid Build Coastguard Worker             pixelFormat = WUFFS_BASE__PIXEL_FORMAT__BGR_565;
485*c8dee2aaSAndroid Build Coastguard Worker             bytesPerPixel = 2;
486*c8dee2aaSAndroid Build Coastguard Worker             break;
487*c8dee2aaSAndroid Build Coastguard Worker         case kBGRA_8888_SkColorType:
488*c8dee2aaSAndroid Build Coastguard Worker             pixelFormat = WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL;
489*c8dee2aaSAndroid Build Coastguard Worker             bytesPerPixel = 4;
490*c8dee2aaSAndroid Build Coastguard Worker             break;
491*c8dee2aaSAndroid Build Coastguard Worker         case kRGBA_8888_SkColorType:
492*c8dee2aaSAndroid Build Coastguard Worker             pixelFormat = WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL;
493*c8dee2aaSAndroid Build Coastguard Worker             bytesPerPixel = 4;
494*c8dee2aaSAndroid Build Coastguard Worker             break;
495*c8dee2aaSAndroid Build Coastguard Worker         default:
496*c8dee2aaSAndroid Build Coastguard Worker             break;
497*c8dee2aaSAndroid Build Coastguard Worker     }
498*c8dee2aaSAndroid Build Coastguard Worker 
499*c8dee2aaSAndroid Build Coastguard Worker     // We can use "one pass" decoding if we have a Skia pixel format that Wuffs
500*c8dee2aaSAndroid Build Coastguard Worker     // supports...
501*c8dee2aaSAndroid Build Coastguard Worker     fIncrDecOnePass = (pixelFormat != WUFFS_BASE__PIXEL_FORMAT__INVALID) &&
502*c8dee2aaSAndroid Build Coastguard Worker                       // ...and no color profile (as Wuffs does not support them)...
503*c8dee2aaSAndroid Build Coastguard Worker                       (!getEncodedInfo().profile()) &&
504*c8dee2aaSAndroid Build Coastguard Worker                       // ...and we use the identity transform (as Wuffs does
505*c8dee2aaSAndroid Build Coastguard Worker                       // not support scaling).
506*c8dee2aaSAndroid Build Coastguard Worker                       (this->dimensions() == dstInfo.dimensions());
507*c8dee2aaSAndroid Build Coastguard Worker 
508*c8dee2aaSAndroid Build Coastguard Worker     result = fIncrDecOnePass ? this->onStartIncrementalDecodeOnePass(
509*c8dee2aaSAndroid Build Coastguard Worker                                    dstInfo, static_cast<uint8_t*>(dst), rowBytes, options,
510*c8dee2aaSAndroid Build Coastguard Worker                                    pixelFormat, bytesPerPixel)
511*c8dee2aaSAndroid Build Coastguard Worker                              : this->onStartIncrementalDecodeTwoPass();
512*c8dee2aaSAndroid Build Coastguard Worker     if (result != SkCodec::kSuccess) {
513*c8dee2aaSAndroid Build Coastguard Worker         return result;
514*c8dee2aaSAndroid Build Coastguard Worker     }
515*c8dee2aaSAndroid Build Coastguard Worker 
516*c8dee2aaSAndroid Build Coastguard Worker     fIncrDecDst = static_cast<uint8_t*>(dst);
517*c8dee2aaSAndroid Build Coastguard Worker     fIncrDecRowBytes = rowBytes;
518*c8dee2aaSAndroid Build Coastguard Worker     fFirstCallToIncrementalDecode = true;
519*c8dee2aaSAndroid Build Coastguard Worker     return SkCodec::kSuccess;
520*c8dee2aaSAndroid Build Coastguard Worker }
521*c8dee2aaSAndroid Build Coastguard Worker 
onStartIncrementalDecodeOnePass(const SkImageInfo & dstInfo,uint8_t * dst,size_t rowBytes,const SkCodec::Options & options,uint32_t pixelFormat,size_t bytesPerPixel)522*c8dee2aaSAndroid Build Coastguard Worker SkCodec::Result SkWuffsCodec::onStartIncrementalDecodeOnePass(const SkImageInfo&      dstInfo,
523*c8dee2aaSAndroid Build Coastguard Worker                                                               uint8_t*                dst,
524*c8dee2aaSAndroid Build Coastguard Worker                                                               size_t                  rowBytes,
525*c8dee2aaSAndroid Build Coastguard Worker                                                               const SkCodec::Options& options,
526*c8dee2aaSAndroid Build Coastguard Worker                                                               uint32_t                pixelFormat,
527*c8dee2aaSAndroid Build Coastguard Worker                                                               size_t bytesPerPixel) {
528*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__pixel_config pixelConfig;
529*c8dee2aaSAndroid Build Coastguard Worker     pixelConfig.set(pixelFormat, WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, dstInfo.width(),
530*c8dee2aaSAndroid Build Coastguard Worker                     dstInfo.height());
531*c8dee2aaSAndroid Build Coastguard Worker 
532*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__table_u8 table;
533*c8dee2aaSAndroid Build Coastguard Worker     table.ptr = dst;
534*c8dee2aaSAndroid Build Coastguard Worker     table.width = static_cast<size_t>(dstInfo.width()) * bytesPerPixel;
535*c8dee2aaSAndroid Build Coastguard Worker     table.height = dstInfo.height();
536*c8dee2aaSAndroid Build Coastguard Worker     table.stride = rowBytes;
537*c8dee2aaSAndroid Build Coastguard Worker 
538*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__status status = fPixelBuffer.set_from_table(&pixelConfig, table);
539*c8dee2aaSAndroid Build Coastguard Worker     if (status.repr != nullptr) {
540*c8dee2aaSAndroid Build Coastguard Worker         SkCodecPrintf("set_from_table: %s", status.message());
541*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kInternalError;
542*c8dee2aaSAndroid Build Coastguard Worker     }
543*c8dee2aaSAndroid Build Coastguard Worker 
544*c8dee2aaSAndroid Build Coastguard Worker     // SRC is usually faster than SRC_OVER, but for a dependent frame, dst is
545*c8dee2aaSAndroid Build Coastguard Worker     // assumed to hold the previous frame's pixels (after processing the
546*c8dee2aaSAndroid Build Coastguard Worker     // DisposalMethod). For one-pass decoding, we therefore use SRC_OVER.
547*c8dee2aaSAndroid Build Coastguard Worker     if ((options.fFrameIndex != 0) &&
548*c8dee2aaSAndroid Build Coastguard Worker         (this->frame(options.fFrameIndex)->getRequiredFrame() != SkCodec::kNoFrame)) {
549*c8dee2aaSAndroid Build Coastguard Worker         fIncrDecPixelBlend = WUFFS_BASE__PIXEL_BLEND__SRC_OVER;
550*c8dee2aaSAndroid Build Coastguard Worker     } else {
551*c8dee2aaSAndroid Build Coastguard Worker         SkSampler::Fill(dstInfo, dst, rowBytes, options.fZeroInitialized);
552*c8dee2aaSAndroid Build Coastguard Worker         fIncrDecPixelBlend = WUFFS_BASE__PIXEL_BLEND__SRC;
553*c8dee2aaSAndroid Build Coastguard Worker     }
554*c8dee2aaSAndroid Build Coastguard Worker 
555*c8dee2aaSAndroid Build Coastguard Worker     return SkCodec::kSuccess;
556*c8dee2aaSAndroid Build Coastguard Worker }
557*c8dee2aaSAndroid Build Coastguard Worker 
onStartIncrementalDecodeTwoPass()558*c8dee2aaSAndroid Build Coastguard Worker SkCodec::Result SkWuffsCodec::onStartIncrementalDecodeTwoPass() {
559*c8dee2aaSAndroid Build Coastguard Worker     // Either re-use the previously allocated "two pass" pixel buffer (and
560*c8dee2aaSAndroid Build Coastguard Worker     // memset to zero), or allocate (and zero initialize) a new one.
561*c8dee2aaSAndroid Build Coastguard Worker     bool already_zeroed = false;
562*c8dee2aaSAndroid Build Coastguard Worker 
563*c8dee2aaSAndroid Build Coastguard Worker     if (!fTwoPassPixbufPtr) {
564*c8dee2aaSAndroid Build Coastguard Worker         uint64_t pixbuf_len = fPixelConfig.pixbuf_len();
565*c8dee2aaSAndroid Build Coastguard Worker         void*    pixbuf_ptr_raw = (pixbuf_len <= SIZE_MAX)
566*c8dee2aaSAndroid Build Coastguard Worker                                       ? sk_malloc_flags(pixbuf_len, SK_MALLOC_ZERO_INITIALIZE)
567*c8dee2aaSAndroid Build Coastguard Worker                                       : nullptr;
568*c8dee2aaSAndroid Build Coastguard Worker         if (!pixbuf_ptr_raw) {
569*c8dee2aaSAndroid Build Coastguard Worker             return SkCodec::kInternalError;
570*c8dee2aaSAndroid Build Coastguard Worker         }
571*c8dee2aaSAndroid Build Coastguard Worker         fTwoPassPixbufPtr.reset(reinterpret_cast<uint8_t*>(pixbuf_ptr_raw));
572*c8dee2aaSAndroid Build Coastguard Worker         fTwoPassPixbufLen = SkToSizeT(pixbuf_len);
573*c8dee2aaSAndroid Build Coastguard Worker         already_zeroed = true;
574*c8dee2aaSAndroid Build Coastguard Worker     }
575*c8dee2aaSAndroid Build Coastguard Worker 
576*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__status status = fPixelBuffer.set_from_slice(
577*c8dee2aaSAndroid Build Coastguard Worker         &fPixelConfig, wuffs_base__make_slice_u8(fTwoPassPixbufPtr.get(), fTwoPassPixbufLen));
578*c8dee2aaSAndroid Build Coastguard Worker     if (status.repr != nullptr) {
579*c8dee2aaSAndroid Build Coastguard Worker         SkCodecPrintf("set_from_slice: %s", status.message());
580*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kInternalError;
581*c8dee2aaSAndroid Build Coastguard Worker     }
582*c8dee2aaSAndroid Build Coastguard Worker 
583*c8dee2aaSAndroid Build Coastguard Worker     if (!already_zeroed) {
584*c8dee2aaSAndroid Build Coastguard Worker         uint32_t src_bits_per_pixel = fPixelConfig.pixel_format().bits_per_pixel();
585*c8dee2aaSAndroid Build Coastguard Worker         if ((src_bits_per_pixel == 0) || (src_bits_per_pixel % 8 != 0)) {
586*c8dee2aaSAndroid Build Coastguard Worker             return SkCodec::kInternalError;
587*c8dee2aaSAndroid Build Coastguard Worker         }
588*c8dee2aaSAndroid Build Coastguard Worker         size_t src_bytes_per_pixel = src_bits_per_pixel / 8;
589*c8dee2aaSAndroid Build Coastguard Worker 
590*c8dee2aaSAndroid Build Coastguard Worker         wuffs_base__rect_ie_u32 frame_rect = fFrameConfig.bounds();
591*c8dee2aaSAndroid Build Coastguard Worker         wuffs_base__table_u8    pixels = fPixelBuffer.plane(0);
592*c8dee2aaSAndroid Build Coastguard Worker 
593*c8dee2aaSAndroid Build Coastguard Worker         uint8_t* ptr = pixels.ptr + (frame_rect.min_incl_y * pixels.stride) +
594*c8dee2aaSAndroid Build Coastguard Worker                        (frame_rect.min_incl_x * src_bytes_per_pixel);
595*c8dee2aaSAndroid Build Coastguard Worker         size_t len = frame_rect.width() * src_bytes_per_pixel;
596*c8dee2aaSAndroid Build Coastguard Worker 
597*c8dee2aaSAndroid Build Coastguard Worker         // As an optimization, issue a single sk_bzero call, if possible.
598*c8dee2aaSAndroid Build Coastguard Worker         // Otherwise, zero out each row separately.
599*c8dee2aaSAndroid Build Coastguard Worker         if ((len == pixels.stride) && (frame_rect.min_incl_y < frame_rect.max_excl_y)) {
600*c8dee2aaSAndroid Build Coastguard Worker             sk_bzero(ptr, len * (frame_rect.max_excl_y - frame_rect.min_incl_y));
601*c8dee2aaSAndroid Build Coastguard Worker         } else {
602*c8dee2aaSAndroid Build Coastguard Worker             for (uint32_t y = frame_rect.min_incl_y; y < frame_rect.max_excl_y; y++) {
603*c8dee2aaSAndroid Build Coastguard Worker                 sk_bzero(ptr, len);
604*c8dee2aaSAndroid Build Coastguard Worker                 ptr += pixels.stride;
605*c8dee2aaSAndroid Build Coastguard Worker             }
606*c8dee2aaSAndroid Build Coastguard Worker         }
607*c8dee2aaSAndroid Build Coastguard Worker     }
608*c8dee2aaSAndroid Build Coastguard Worker 
609*c8dee2aaSAndroid Build Coastguard Worker     fIncrDecPixelBlend = WUFFS_BASE__PIXEL_BLEND__SRC;
610*c8dee2aaSAndroid Build Coastguard Worker     return SkCodec::kSuccess;
611*c8dee2aaSAndroid Build Coastguard Worker }
612*c8dee2aaSAndroid Build Coastguard Worker 
onIncrementalDecode(int * rowsDecoded)613*c8dee2aaSAndroid Build Coastguard Worker SkCodec::Result SkWuffsCodec::onIncrementalDecode(int* rowsDecoded) {
614*c8dee2aaSAndroid Build Coastguard Worker     if (!fIncrDecDst) {
615*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kInternalError;
616*c8dee2aaSAndroid Build Coastguard Worker     }
617*c8dee2aaSAndroid Build Coastguard Worker 
618*c8dee2aaSAndroid Build Coastguard Worker     if (rowsDecoded) {
619*c8dee2aaSAndroid Build Coastguard Worker         *rowsDecoded = dstInfo().height();
620*c8dee2aaSAndroid Build Coastguard Worker     }
621*c8dee2aaSAndroid Build Coastguard Worker 
622*c8dee2aaSAndroid Build Coastguard Worker     SkCodec::Result result =
623*c8dee2aaSAndroid Build Coastguard Worker         fIncrDecOnePass ? this->onIncrementalDecodeOnePass() : this->onIncrementalDecodeTwoPass();
624*c8dee2aaSAndroid Build Coastguard Worker     if (result == SkCodec::kSuccess) {
625*c8dee2aaSAndroid Build Coastguard Worker         fIncrDecDst = nullptr;
626*c8dee2aaSAndroid Build Coastguard Worker         fIncrDecRowBytes = 0;
627*c8dee2aaSAndroid Build Coastguard Worker         fIncrDecPixelBlend = WUFFS_BASE__PIXEL_BLEND__SRC;
628*c8dee2aaSAndroid Build Coastguard Worker         fIncrDecOnePass = false;
629*c8dee2aaSAndroid Build Coastguard Worker     }
630*c8dee2aaSAndroid Build Coastguard Worker     return result;
631*c8dee2aaSAndroid Build Coastguard Worker }
632*c8dee2aaSAndroid Build Coastguard Worker 
onIncrementalDecodeOnePass()633*c8dee2aaSAndroid Build Coastguard Worker SkCodec::Result SkWuffsCodec::onIncrementalDecodeOnePass() {
634*c8dee2aaSAndroid Build Coastguard Worker     const char* status = this->decodeFrame();
635*c8dee2aaSAndroid Build Coastguard Worker     if (status != nullptr) {
636*c8dee2aaSAndroid Build Coastguard Worker         if (status == wuffs_base__suspension__short_read) {
637*c8dee2aaSAndroid Build Coastguard Worker             return SkCodec::kIncompleteInput;
638*c8dee2aaSAndroid Build Coastguard Worker         } else {
639*c8dee2aaSAndroid Build Coastguard Worker             SkCodecPrintf("decodeFrame: %s", status);
640*c8dee2aaSAndroid Build Coastguard Worker             return SkCodec::kErrorInInput;
641*c8dee2aaSAndroid Build Coastguard Worker         }
642*c8dee2aaSAndroid Build Coastguard Worker     }
643*c8dee2aaSAndroid Build Coastguard Worker     return SkCodec::kSuccess;
644*c8dee2aaSAndroid Build Coastguard Worker }
645*c8dee2aaSAndroid Build Coastguard Worker 
onIncrementalDecodeTwoPass()646*c8dee2aaSAndroid Build Coastguard Worker SkCodec::Result SkWuffsCodec::onIncrementalDecodeTwoPass() {
647*c8dee2aaSAndroid Build Coastguard Worker     SkCodec::Result result = SkCodec::kSuccess;
648*c8dee2aaSAndroid Build Coastguard Worker     const char*     status = this->decodeFrame();
649*c8dee2aaSAndroid Build Coastguard Worker     bool            independent;
650*c8dee2aaSAndroid Build Coastguard Worker     SkAlphaType     alphaType;
651*c8dee2aaSAndroid Build Coastguard Worker     const int       index = options().fFrameIndex;
652*c8dee2aaSAndroid Build Coastguard Worker     if (index == 0) {
653*c8dee2aaSAndroid Build Coastguard Worker         independent = true;
654*c8dee2aaSAndroid Build Coastguard Worker         alphaType = to_alpha_type(getEncodedInfo().opaque());
655*c8dee2aaSAndroid Build Coastguard Worker     } else {
656*c8dee2aaSAndroid Build Coastguard Worker         const SkWuffsFrame* f = this->frame(index);
657*c8dee2aaSAndroid Build Coastguard Worker         independent = f->getRequiredFrame() == SkCodec::kNoFrame;
658*c8dee2aaSAndroid Build Coastguard Worker         alphaType = to_alpha_type(f->reportedAlpha() == SkEncodedInfo::kOpaque_Alpha);
659*c8dee2aaSAndroid Build Coastguard Worker     }
660*c8dee2aaSAndroid Build Coastguard Worker     if (status != nullptr) {
661*c8dee2aaSAndroid Build Coastguard Worker         if (status == wuffs_base__suspension__short_read) {
662*c8dee2aaSAndroid Build Coastguard Worker             result = SkCodec::kIncompleteInput;
663*c8dee2aaSAndroid Build Coastguard Worker         } else {
664*c8dee2aaSAndroid Build Coastguard Worker             SkCodecPrintf("decodeFrame: %s", status);
665*c8dee2aaSAndroid Build Coastguard Worker             result = SkCodec::kErrorInInput;
666*c8dee2aaSAndroid Build Coastguard Worker         }
667*c8dee2aaSAndroid Build Coastguard Worker 
668*c8dee2aaSAndroid Build Coastguard Worker         if (!independent) {
669*c8dee2aaSAndroid Build Coastguard Worker             // For a dependent frame, we cannot blend the partial result, since
670*c8dee2aaSAndroid Build Coastguard Worker             // that will overwrite the contribution from prior frames.
671*c8dee2aaSAndroid Build Coastguard Worker             return result;
672*c8dee2aaSAndroid Build Coastguard Worker         }
673*c8dee2aaSAndroid Build Coastguard Worker     }
674*c8dee2aaSAndroid Build Coastguard Worker 
675*c8dee2aaSAndroid Build Coastguard Worker     uint32_t src_bits_per_pixel = fPixelBuffer.pixcfg.pixel_format().bits_per_pixel();
676*c8dee2aaSAndroid Build Coastguard Worker     if ((src_bits_per_pixel == 0) || (src_bits_per_pixel % 8 != 0)) {
677*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kInternalError;
678*c8dee2aaSAndroid Build Coastguard Worker     }
679*c8dee2aaSAndroid Build Coastguard Worker     size_t src_bytes_per_pixel = src_bits_per_pixel / 8;
680*c8dee2aaSAndroid Build Coastguard Worker 
681*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__rect_ie_u32 frame_rect = fFrameConfig.bounds();
682*c8dee2aaSAndroid Build Coastguard Worker     if (fFirstCallToIncrementalDecode) {
683*c8dee2aaSAndroid Build Coastguard Worker         if (frame_rect.width() > (SIZE_MAX / src_bytes_per_pixel)) {
684*c8dee2aaSAndroid Build Coastguard Worker             return SkCodec::kInternalError;
685*c8dee2aaSAndroid Build Coastguard Worker         }
686*c8dee2aaSAndroid Build Coastguard Worker 
687*c8dee2aaSAndroid Build Coastguard Worker         auto bounds = SkIRect::MakeLTRB(frame_rect.min_incl_x, frame_rect.min_incl_y,
688*c8dee2aaSAndroid Build Coastguard Worker                                         frame_rect.max_excl_x, frame_rect.max_excl_y);
689*c8dee2aaSAndroid Build Coastguard Worker 
690*c8dee2aaSAndroid Build Coastguard Worker         // If the frame rect does not fill the output, ensure that those pixels are not
691*c8dee2aaSAndroid Build Coastguard Worker         // left uninitialized.
692*c8dee2aaSAndroid Build Coastguard Worker         if (independent && (bounds != this->bounds() || result != kSuccess)) {
693*c8dee2aaSAndroid Build Coastguard Worker             SkSampler::Fill(dstInfo(), fIncrDecDst, fIncrDecRowBytes, options().fZeroInitialized);
694*c8dee2aaSAndroid Build Coastguard Worker         }
695*c8dee2aaSAndroid Build Coastguard Worker         fFirstCallToIncrementalDecode = false;
696*c8dee2aaSAndroid Build Coastguard Worker     } else {
697*c8dee2aaSAndroid Build Coastguard Worker         // Existing clients intend to only show frames beyond the first if they
698*c8dee2aaSAndroid Build Coastguard Worker         // are complete (based on FrameInfo::fFullyReceived), since it might
699*c8dee2aaSAndroid Build Coastguard Worker         // look jarring to draw a partial frame over an existing frame. If they
700*c8dee2aaSAndroid Build Coastguard Worker         // changed their behavior and expected to continue decoding a partial
701*c8dee2aaSAndroid Build Coastguard Worker         // frame after the first one, we'll need to update our blending code.
702*c8dee2aaSAndroid Build Coastguard Worker         // Otherwise, if the frame were interlaced and not independent, the
703*c8dee2aaSAndroid Build Coastguard Worker         // second pass may have an overlapping dirty_rect with the first,
704*c8dee2aaSAndroid Build Coastguard Worker         // resulting in blending with the first pass.
705*c8dee2aaSAndroid Build Coastguard Worker         SkASSERT(index == 0);
706*c8dee2aaSAndroid Build Coastguard Worker     }
707*c8dee2aaSAndroid Build Coastguard Worker 
708*c8dee2aaSAndroid Build Coastguard Worker     // If the frame's dirty rect is empty, no need to swizzle.
709*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__rect_ie_u32 dirty_rect = fDecoder->frame_dirty_rect();
710*c8dee2aaSAndroid Build Coastguard Worker     if (!dirty_rect.is_empty()) {
711*c8dee2aaSAndroid Build Coastguard Worker         wuffs_base__table_u8 pixels = fPixelBuffer.plane(0);
712*c8dee2aaSAndroid Build Coastguard Worker 
713*c8dee2aaSAndroid Build Coastguard Worker         // The Wuffs model is that the dst buffer is the image, not the frame.
714*c8dee2aaSAndroid Build Coastguard Worker         // The expectation is that you allocate the buffer once, but re-use it
715*c8dee2aaSAndroid Build Coastguard Worker         // for the N frames, regardless of each frame's top-left co-ordinate.
716*c8dee2aaSAndroid Build Coastguard Worker         //
717*c8dee2aaSAndroid Build Coastguard Worker         // To get from the start (in the X-direction) of the image to the start
718*c8dee2aaSAndroid Build Coastguard Worker         // of the dirty_rect, we adjust s by (dirty_rect.min_incl_x * src_bytes_per_pixel).
719*c8dee2aaSAndroid Build Coastguard Worker         uint8_t* s = pixels.ptr + (dirty_rect.min_incl_y * pixels.stride) +
720*c8dee2aaSAndroid Build Coastguard Worker                      (dirty_rect.min_incl_x * src_bytes_per_pixel);
721*c8dee2aaSAndroid Build Coastguard Worker 
722*c8dee2aaSAndroid Build Coastguard Worker         // Currently, this is only used for GIF, which will never have an ICC profile. When it is
723*c8dee2aaSAndroid Build Coastguard Worker         // used for other formats that might have one, we will need to transform from profiles that
724*c8dee2aaSAndroid Build Coastguard Worker         // do not have corresponding SkColorSpaces.
725*c8dee2aaSAndroid Build Coastguard Worker         SkASSERT(!getEncodedInfo().profile());
726*c8dee2aaSAndroid Build Coastguard Worker 
727*c8dee2aaSAndroid Build Coastguard Worker         auto srcInfo =
728*c8dee2aaSAndroid Build Coastguard Worker             getInfo().makeWH(dirty_rect.width(), dirty_rect.height()).makeAlphaType(alphaType);
729*c8dee2aaSAndroid Build Coastguard Worker         SkBitmap src;
730*c8dee2aaSAndroid Build Coastguard Worker         src.installPixels(srcInfo, s, pixels.stride);
731*c8dee2aaSAndroid Build Coastguard Worker         SkPaint paint;
732*c8dee2aaSAndroid Build Coastguard Worker         if (independent) {
733*c8dee2aaSAndroid Build Coastguard Worker             paint.setBlendMode(SkBlendMode::kSrc);
734*c8dee2aaSAndroid Build Coastguard Worker         }
735*c8dee2aaSAndroid Build Coastguard Worker 
736*c8dee2aaSAndroid Build Coastguard Worker         SkDraw draw;
737*c8dee2aaSAndroid Build Coastguard Worker         draw.fDst.reset(dstInfo(), fIncrDecDst, fIncrDecRowBytes);
738*c8dee2aaSAndroid Build Coastguard Worker         SkMatrix matrix = SkMatrix::RectToRect(SkRect::Make(this->dimensions()),
739*c8dee2aaSAndroid Build Coastguard Worker                                                SkRect::Make(this->dstInfo().dimensions()));
740*c8dee2aaSAndroid Build Coastguard Worker         draw.fCTM = &matrix;
741*c8dee2aaSAndroid Build Coastguard Worker         SkRasterClip rc(SkIRect::MakeSize(this->dstInfo().dimensions()));
742*c8dee2aaSAndroid Build Coastguard Worker         draw.fRC = &rc;
743*c8dee2aaSAndroid Build Coastguard Worker 
744*c8dee2aaSAndroid Build Coastguard Worker         SkMatrix translate = SkMatrix::Translate(dirty_rect.min_incl_x, dirty_rect.min_incl_y);
745*c8dee2aaSAndroid Build Coastguard Worker         draw.drawBitmap(src, translate, nullptr, SkSamplingOptions(), paint);
746*c8dee2aaSAndroid Build Coastguard Worker     }
747*c8dee2aaSAndroid Build Coastguard Worker 
748*c8dee2aaSAndroid Build Coastguard Worker     if (result == SkCodec::kSuccess) {
749*c8dee2aaSAndroid Build Coastguard Worker         // On success, we are done using the "two pass" pixel buffer for this
750*c8dee2aaSAndroid Build Coastguard Worker         // frame. We have the option of releasing its memory, but there is a
751*c8dee2aaSAndroid Build Coastguard Worker         // trade-off. If decoding a subsequent frame will also need "two pass"
752*c8dee2aaSAndroid Build Coastguard Worker         // decoding, it would have to re-allocate the buffer instead of just
753*c8dee2aaSAndroid Build Coastguard Worker         // re-using it. On the other hand, if there is no subsequent frame, and
754*c8dee2aaSAndroid Build Coastguard Worker         // the SkWuffsCodec object isn't deleted soon, then we are holding
755*c8dee2aaSAndroid Build Coastguard Worker         // megabytes of memory longer than we need to.
756*c8dee2aaSAndroid Build Coastguard Worker         //
757*c8dee2aaSAndroid Build Coastguard Worker         // For example, when the Chromium web browser decodes the <img> tags in
758*c8dee2aaSAndroid Build Coastguard Worker         // a HTML page, the SkCodec object can live until navigating away from
759*c8dee2aaSAndroid Build Coastguard Worker         // the page, which can be much longer than when the pixels are fully
760*c8dee2aaSAndroid Build Coastguard Worker         // decoded, especially for a still (non-animated) image. Even for
761*c8dee2aaSAndroid Build Coastguard Worker         // looping animations, caching the decoded frames (at the higher HTML
762*c8dee2aaSAndroid Build Coastguard Worker         // renderer layer) may mean that each frame is only decoded once (at
763*c8dee2aaSAndroid Build Coastguard Worker         // the lower SkCodec layer), in sequence.
764*c8dee2aaSAndroid Build Coastguard Worker         //
765*c8dee2aaSAndroid Build Coastguard Worker         // The heuristic we use here is to free the memory if we have decoded
766*c8dee2aaSAndroid Build Coastguard Worker         // the last frame of the animation (or, for still images, the only
767*c8dee2aaSAndroid Build Coastguard Worker         // frame). The output of the next decode request (if any) should be the
768*c8dee2aaSAndroid Build Coastguard Worker         // same either way, but the steady state memory use should hopefully be
769*c8dee2aaSAndroid Build Coastguard Worker         // lower than always keeping the fTwoPassPixbufPtr buffer up until the
770*c8dee2aaSAndroid Build Coastguard Worker         // SkWuffsCodec destructor runs.
771*c8dee2aaSAndroid Build Coastguard Worker         //
772*c8dee2aaSAndroid Build Coastguard Worker         // This only applies to "two pass" decoding. "One pass" decoding does
773*c8dee2aaSAndroid Build Coastguard Worker         // not allocate, free or otherwise use fTwoPassPixbufPtr.
774*c8dee2aaSAndroid Build Coastguard Worker         if (fFramesComplete && (static_cast<size_t>(options().fFrameIndex) == fFrames.size() - 1)) {
775*c8dee2aaSAndroid Build Coastguard Worker             fTwoPassPixbufPtr.reset(nullptr);
776*c8dee2aaSAndroid Build Coastguard Worker             fTwoPassPixbufLen = 0;
777*c8dee2aaSAndroid Build Coastguard Worker         }
778*c8dee2aaSAndroid Build Coastguard Worker     }
779*c8dee2aaSAndroid Build Coastguard Worker 
780*c8dee2aaSAndroid Build Coastguard Worker     return result;
781*c8dee2aaSAndroid Build Coastguard Worker }
782*c8dee2aaSAndroid Build Coastguard Worker 
onGetFrameCount()783*c8dee2aaSAndroid Build Coastguard Worker int SkWuffsCodec::onGetFrameCount() {
784*c8dee2aaSAndroid Build Coastguard Worker     if (!fCanSeek) {
785*c8dee2aaSAndroid Build Coastguard Worker         return 1;
786*c8dee2aaSAndroid Build Coastguard Worker     }
787*c8dee2aaSAndroid Build Coastguard Worker 
788*c8dee2aaSAndroid Build Coastguard Worker     // It is valid, in terms of the SkCodec API, to call SkCodec::getFrameCount
789*c8dee2aaSAndroid Build Coastguard Worker     // while in an incremental decode (after onStartIncrementalDecode returns
790*c8dee2aaSAndroid Build Coastguard Worker     // and before onIncrementalDecode returns kSuccess).
791*c8dee2aaSAndroid Build Coastguard Worker     //
792*c8dee2aaSAndroid Build Coastguard Worker     // We should not advance the SkWuffsCodec' stream while doing so, even
793*c8dee2aaSAndroid Build Coastguard Worker     // though other SkCodec implementations can return increasing values from
794*c8dee2aaSAndroid Build Coastguard Worker     // onGetFrameCount when given more data. If we tried to do so, the
795*c8dee2aaSAndroid Build Coastguard Worker     // subsequent resume of the incremental decode would continue reading from
796*c8dee2aaSAndroid Build Coastguard Worker     // a different position in the I/O stream, leading to an incorrect error.
797*c8dee2aaSAndroid Build Coastguard Worker     //
798*c8dee2aaSAndroid Build Coastguard Worker     // Other SkCodec implementations can move the stream forward during
799*c8dee2aaSAndroid Build Coastguard Worker     // onGetFrameCount because they assume that the stream is rewindable /
800*c8dee2aaSAndroid Build Coastguard Worker     // seekable. For example, an alternative GIF implementation may choose to
801*c8dee2aaSAndroid Build Coastguard Worker     // store, for each frame walked past when merely counting the number of
802*c8dee2aaSAndroid Build Coastguard Worker     // frames, the I/O position of each of the frame's GIF data blocks. (A GIF
803*c8dee2aaSAndroid Build Coastguard Worker     // frame's compressed data can have multiple data blocks, each at most 255
804*c8dee2aaSAndroid Build Coastguard Worker     // bytes in length). Obviously, this can require O(numberOfFrames) extra
805*c8dee2aaSAndroid Build Coastguard Worker     // memory to store these I/O positions. The constant factor is small, but
806*c8dee2aaSAndroid Build Coastguard Worker     // it's still O(N), not O(1).
807*c8dee2aaSAndroid Build Coastguard Worker     //
808*c8dee2aaSAndroid Build Coastguard Worker     // Wuffs and SkWuffsCodec try to minimize relying on the rewindable /
809*c8dee2aaSAndroid Build Coastguard Worker     // seekable assumption. By design, Wuffs per se aims for O(1) memory use
810*c8dee2aaSAndroid Build Coastguard Worker     // (after any pixel buffers are allocated) instead of O(N), and its I/O
811*c8dee2aaSAndroid Build Coastguard Worker     // type, wuffs_base__io_buffer, is not necessarily rewindable or seekable.
812*c8dee2aaSAndroid Build Coastguard Worker     //
813*c8dee2aaSAndroid Build Coastguard Worker     // The Wuffs API provides a limited, optional form of seeking, to the start
814*c8dee2aaSAndroid Build Coastguard Worker     // of an animation frame's data, but does not provide arbitrary save and
815*c8dee2aaSAndroid Build Coastguard Worker     // load of its internal state whilst in the middle of an animation frame.
816*c8dee2aaSAndroid Build Coastguard Worker     bool incrementalDecodeIsInProgress = fIncrDecDst != nullptr;
817*c8dee2aaSAndroid Build Coastguard Worker 
818*c8dee2aaSAndroid Build Coastguard Worker     if (!fFramesComplete && !incrementalDecodeIsInProgress) {
819*c8dee2aaSAndroid Build Coastguard Worker         this->onGetFrameCountInternal();
820*c8dee2aaSAndroid Build Coastguard Worker         this->updateNumFullyReceivedFrames();
821*c8dee2aaSAndroid Build Coastguard Worker     }
822*c8dee2aaSAndroid Build Coastguard Worker     return fFrames.size();
823*c8dee2aaSAndroid Build Coastguard Worker }
824*c8dee2aaSAndroid Build Coastguard Worker 
onGetFrameCountInternal()825*c8dee2aaSAndroid Build Coastguard Worker void SkWuffsCodec::onGetFrameCountInternal() {
826*c8dee2aaSAndroid Build Coastguard Worker     size_t n = fFrames.size();
827*c8dee2aaSAndroid Build Coastguard Worker     int    i = n ? n - 1 : 0;
828*c8dee2aaSAndroid Build Coastguard Worker     if (this->seekFrame(i) != SkCodec::kSuccess) {
829*c8dee2aaSAndroid Build Coastguard Worker         return;
830*c8dee2aaSAndroid Build Coastguard Worker     }
831*c8dee2aaSAndroid Build Coastguard Worker 
832*c8dee2aaSAndroid Build Coastguard Worker     // Iterate through the frames, converting from Wuffs'
833*c8dee2aaSAndroid Build Coastguard Worker     // wuffs_base__frame_config type to Skia's SkWuffsFrame type.
834*c8dee2aaSAndroid Build Coastguard Worker     for (; i < INT_MAX; i++) {
835*c8dee2aaSAndroid Build Coastguard Worker         const char* status = this->decodeFrameConfig();
836*c8dee2aaSAndroid Build Coastguard Worker         if (status == nullptr) {
837*c8dee2aaSAndroid Build Coastguard Worker             // No-op.
838*c8dee2aaSAndroid Build Coastguard Worker         } else if (status == wuffs_base__note__end_of_data) {
839*c8dee2aaSAndroid Build Coastguard Worker             break;
840*c8dee2aaSAndroid Build Coastguard Worker         } else {
841*c8dee2aaSAndroid Build Coastguard Worker             return;
842*c8dee2aaSAndroid Build Coastguard Worker         }
843*c8dee2aaSAndroid Build Coastguard Worker 
844*c8dee2aaSAndroid Build Coastguard Worker         if (static_cast<size_t>(i) < fFrames.size()) {
845*c8dee2aaSAndroid Build Coastguard Worker             continue;
846*c8dee2aaSAndroid Build Coastguard Worker         }
847*c8dee2aaSAndroid Build Coastguard Worker         fFrames.emplace_back(&fFrameConfig);
848*c8dee2aaSAndroid Build Coastguard Worker         SkWuffsFrame* f = &fFrames[fFrames.size() - 1];
849*c8dee2aaSAndroid Build Coastguard Worker         fFrameHolder.setAlphaAndRequiredFrame(f);
850*c8dee2aaSAndroid Build Coastguard Worker     }
851*c8dee2aaSAndroid Build Coastguard Worker 
852*c8dee2aaSAndroid Build Coastguard Worker     fFramesComplete = true;
853*c8dee2aaSAndroid Build Coastguard Worker }
854*c8dee2aaSAndroid Build Coastguard Worker 
onGetFrameInfo(int i,SkCodec::FrameInfo * frameInfo) const855*c8dee2aaSAndroid Build Coastguard Worker bool SkWuffsCodec::onGetFrameInfo(int i, SkCodec::FrameInfo* frameInfo) const {
856*c8dee2aaSAndroid Build Coastguard Worker     if (!fCanSeek) {
857*c8dee2aaSAndroid Build Coastguard Worker         // We haven't read forward in the stream, so this info isn't available.
858*c8dee2aaSAndroid Build Coastguard Worker         return false;
859*c8dee2aaSAndroid Build Coastguard Worker     }
860*c8dee2aaSAndroid Build Coastguard Worker 
861*c8dee2aaSAndroid Build Coastguard Worker     const SkWuffsFrame* f = this->frame(i);
862*c8dee2aaSAndroid Build Coastguard Worker     if (!f) {
863*c8dee2aaSAndroid Build Coastguard Worker         return false;
864*c8dee2aaSAndroid Build Coastguard Worker     }
865*c8dee2aaSAndroid Build Coastguard Worker     if (frameInfo) {
866*c8dee2aaSAndroid Build Coastguard Worker         f->fillIn(frameInfo, static_cast<uint64_t>(i) < this->fNumFullyReceivedFrames);
867*c8dee2aaSAndroid Build Coastguard Worker     }
868*c8dee2aaSAndroid Build Coastguard Worker     return true;
869*c8dee2aaSAndroid Build Coastguard Worker }
870*c8dee2aaSAndroid Build Coastguard Worker 
onGetRepetitionCount()871*c8dee2aaSAndroid Build Coastguard Worker int SkWuffsCodec::onGetRepetitionCount() {
872*c8dee2aaSAndroid Build Coastguard Worker     // Convert from Wuffs's loop count to Skia's repeat count. Wuffs' uint32_t
873*c8dee2aaSAndroid Build Coastguard Worker     // number is how many times to play the loop. Skia's int number is how many
874*c8dee2aaSAndroid Build Coastguard Worker     // times to play the loop *after the first play*. Wuffs and Skia use 0 and
875*c8dee2aaSAndroid Build Coastguard Worker     // kRepetitionCountInfinite respectively to mean loop forever.
876*c8dee2aaSAndroid Build Coastguard Worker     uint32_t n = fDecoder->num_animation_loops();
877*c8dee2aaSAndroid Build Coastguard Worker     if (n == 0) {
878*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kRepetitionCountInfinite;
879*c8dee2aaSAndroid Build Coastguard Worker     }
880*c8dee2aaSAndroid Build Coastguard Worker     n--;
881*c8dee2aaSAndroid Build Coastguard Worker     return n < INT_MAX ? n : INT_MAX;
882*c8dee2aaSAndroid Build Coastguard Worker }
883*c8dee2aaSAndroid Build Coastguard Worker 
seekFrame(int frameIndex)884*c8dee2aaSAndroid Build Coastguard Worker SkCodec::Result SkWuffsCodec::seekFrame(int frameIndex) {
885*c8dee2aaSAndroid Build Coastguard Worker     if (fDecoderIsSuspended) {
886*c8dee2aaSAndroid Build Coastguard Worker         SkCodec::Result res = this->resetDecoder();
887*c8dee2aaSAndroid Build Coastguard Worker         if (res != SkCodec::kSuccess) {
888*c8dee2aaSAndroid Build Coastguard Worker             return res;
889*c8dee2aaSAndroid Build Coastguard Worker         }
890*c8dee2aaSAndroid Build Coastguard Worker     }
891*c8dee2aaSAndroid Build Coastguard Worker 
892*c8dee2aaSAndroid Build Coastguard Worker     uint64_t pos = 0;
893*c8dee2aaSAndroid Build Coastguard Worker     if (frameIndex < 0) {
894*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kInternalError;
895*c8dee2aaSAndroid Build Coastguard Worker     } else if (frameIndex == 0) {
896*c8dee2aaSAndroid Build Coastguard Worker         pos = fFirstFrameIOPosition;
897*c8dee2aaSAndroid Build Coastguard Worker     } else if (static_cast<size_t>(frameIndex) < fFrames.size()) {
898*c8dee2aaSAndroid Build Coastguard Worker         pos = fFrames[frameIndex].ioPosition();
899*c8dee2aaSAndroid Build Coastguard Worker     } else {
900*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kInternalError;
901*c8dee2aaSAndroid Build Coastguard Worker     }
902*c8dee2aaSAndroid Build Coastguard Worker 
903*c8dee2aaSAndroid Build Coastguard Worker     if (!seek_buffer(&fIOBuffer, fPrivStream.get(), pos)) {
904*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kInternalError;
905*c8dee2aaSAndroid Build Coastguard Worker     }
906*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__status status =
907*c8dee2aaSAndroid Build Coastguard Worker         fDecoder->restart_frame(frameIndex, fIOBuffer.reader_io_position());
908*c8dee2aaSAndroid Build Coastguard Worker     if (status.repr != nullptr) {
909*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kInternalError;
910*c8dee2aaSAndroid Build Coastguard Worker     }
911*c8dee2aaSAndroid Build Coastguard Worker     return SkCodec::kSuccess;
912*c8dee2aaSAndroid Build Coastguard Worker }
913*c8dee2aaSAndroid Build Coastguard Worker 
resetDecoder()914*c8dee2aaSAndroid Build Coastguard Worker SkCodec::Result SkWuffsCodec::resetDecoder() {
915*c8dee2aaSAndroid Build Coastguard Worker     if (!fPrivStream->rewind()) {
916*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kInternalError;
917*c8dee2aaSAndroid Build Coastguard Worker     }
918*c8dee2aaSAndroid Build Coastguard Worker     fIOBuffer.meta = wuffs_base__empty_io_buffer_meta();
919*c8dee2aaSAndroid Build Coastguard Worker 
920*c8dee2aaSAndroid Build Coastguard Worker     SkCodec::Result result =
921*c8dee2aaSAndroid Build Coastguard Worker         reset_and_decode_image_config(fDecoder.get(), nullptr, &fIOBuffer, fPrivStream.get());
922*c8dee2aaSAndroid Build Coastguard Worker     if (result == SkCodec::kIncompleteInput) {
923*c8dee2aaSAndroid Build Coastguard Worker         return SkCodec::kInternalError;
924*c8dee2aaSAndroid Build Coastguard Worker     } else if (result != SkCodec::kSuccess) {
925*c8dee2aaSAndroid Build Coastguard Worker         return result;
926*c8dee2aaSAndroid Build Coastguard Worker     }
927*c8dee2aaSAndroid Build Coastguard Worker 
928*c8dee2aaSAndroid Build Coastguard Worker     fDecoderIsSuspended = false;
929*c8dee2aaSAndroid Build Coastguard Worker     return SkCodec::kSuccess;
930*c8dee2aaSAndroid Build Coastguard Worker }
931*c8dee2aaSAndroid Build Coastguard Worker 
decodeFrameConfig()932*c8dee2aaSAndroid Build Coastguard Worker const char* SkWuffsCodec::decodeFrameConfig() {
933*c8dee2aaSAndroid Build Coastguard Worker     while (true) {
934*c8dee2aaSAndroid Build Coastguard Worker         wuffs_base__status status =
935*c8dee2aaSAndroid Build Coastguard Worker             fDecoder->decode_frame_config(&fFrameConfig, &fIOBuffer);
936*c8dee2aaSAndroid Build Coastguard Worker         if ((status.repr == wuffs_base__suspension__short_read) &&
937*c8dee2aaSAndroid Build Coastguard Worker             fill_buffer(&fIOBuffer, fPrivStream.get())) {
938*c8dee2aaSAndroid Build Coastguard Worker             continue;
939*c8dee2aaSAndroid Build Coastguard Worker         }
940*c8dee2aaSAndroid Build Coastguard Worker         fDecoderIsSuspended = !status.is_complete();
941*c8dee2aaSAndroid Build Coastguard Worker         this->updateNumFullyReceivedFrames();
942*c8dee2aaSAndroid Build Coastguard Worker         return status.repr;
943*c8dee2aaSAndroid Build Coastguard Worker     }
944*c8dee2aaSAndroid Build Coastguard Worker }
945*c8dee2aaSAndroid Build Coastguard Worker 
decodeFrame()946*c8dee2aaSAndroid Build Coastguard Worker const char* SkWuffsCodec::decodeFrame() {
947*c8dee2aaSAndroid Build Coastguard Worker     while (true) {
948*c8dee2aaSAndroid Build Coastguard Worker         wuffs_base__status status = fDecoder->decode_frame(
949*c8dee2aaSAndroid Build Coastguard Worker             &fPixelBuffer, &fIOBuffer, fIncrDecPixelBlend,
950*c8dee2aaSAndroid Build Coastguard Worker             wuffs_base__make_slice_u8(fWorkbufPtr.get(), fWorkbufLen), nullptr);
951*c8dee2aaSAndroid Build Coastguard Worker         if ((status.repr == wuffs_base__suspension__short_read) &&
952*c8dee2aaSAndroid Build Coastguard Worker             fill_buffer(&fIOBuffer, fPrivStream.get())) {
953*c8dee2aaSAndroid Build Coastguard Worker             continue;
954*c8dee2aaSAndroid Build Coastguard Worker         }
955*c8dee2aaSAndroid Build Coastguard Worker         fDecoderIsSuspended = !status.is_complete();
956*c8dee2aaSAndroid Build Coastguard Worker         this->updateNumFullyReceivedFrames();
957*c8dee2aaSAndroid Build Coastguard Worker         return status.repr;
958*c8dee2aaSAndroid Build Coastguard Worker     }
959*c8dee2aaSAndroid Build Coastguard Worker }
960*c8dee2aaSAndroid Build Coastguard Worker 
updateNumFullyReceivedFrames()961*c8dee2aaSAndroid Build Coastguard Worker void SkWuffsCodec::updateNumFullyReceivedFrames() {
962*c8dee2aaSAndroid Build Coastguard Worker     // num_decoded_frames's return value, n, can change over time, both up and
963*c8dee2aaSAndroid Build Coastguard Worker     // down, as we seek back and forth in the underlying stream.
964*c8dee2aaSAndroid Build Coastguard Worker     // fNumFullyReceivedFrames is the highest n we've seen.
965*c8dee2aaSAndroid Build Coastguard Worker     uint64_t n = fDecoder->num_decoded_frames();
966*c8dee2aaSAndroid Build Coastguard Worker     if (fNumFullyReceivedFrames < n) {
967*c8dee2aaSAndroid Build Coastguard Worker         fNumFullyReceivedFrames = n;
968*c8dee2aaSAndroid Build Coastguard Worker     }
969*c8dee2aaSAndroid Build Coastguard Worker }
970*c8dee2aaSAndroid Build Coastguard Worker 
971*c8dee2aaSAndroid Build Coastguard Worker // We cannot use the SkCodec implementation since we pass nullptr to the superclass out of
972*c8dee2aaSAndroid Build Coastguard Worker // an abundance of caution w/r to rewinding the stream.
973*c8dee2aaSAndroid Build Coastguard Worker //
974*c8dee2aaSAndroid Build Coastguard Worker // TODO(https://crbug.com/370522089): See if `SkCodec` can be tweaked to avoid
975*c8dee2aaSAndroid Build Coastguard Worker // the need to hide the stream from it.
getEncodedData() const976*c8dee2aaSAndroid Build Coastguard Worker std::unique_ptr<SkStream> SkWuffsCodec::getEncodedData() const {
977*c8dee2aaSAndroid Build Coastguard Worker     SkASSERT(fPrivStream);
978*c8dee2aaSAndroid Build Coastguard Worker     return fPrivStream->duplicate();
979*c8dee2aaSAndroid Build Coastguard Worker }
980*c8dee2aaSAndroid Build Coastguard Worker 
981*c8dee2aaSAndroid Build Coastguard Worker namespace SkGifDecoder {
982*c8dee2aaSAndroid Build Coastguard Worker 
IsGif(const void * buf,size_t bytesRead)983*c8dee2aaSAndroid Build Coastguard Worker bool IsGif(const void* buf, size_t bytesRead) {
984*c8dee2aaSAndroid Build Coastguard Worker     constexpr const char* gif_ptr = "GIF8";
985*c8dee2aaSAndroid Build Coastguard Worker     constexpr size_t      gif_len = 4;
986*c8dee2aaSAndroid Build Coastguard Worker     return (bytesRead >= gif_len) && (memcmp(buf, gif_ptr, gif_len) == 0);
987*c8dee2aaSAndroid Build Coastguard Worker }
988*c8dee2aaSAndroid Build Coastguard Worker 
MakeFromStream(std::unique_ptr<SkStream> stream,SkCodec::SelectionPolicy selectionPolicy,SkCodec::Result * result)989*c8dee2aaSAndroid Build Coastguard Worker std::unique_ptr<SkCodec> MakeFromStream(std::unique_ptr<SkStream> stream,
990*c8dee2aaSAndroid Build Coastguard Worker                                         SkCodec::SelectionPolicy  selectionPolicy,
991*c8dee2aaSAndroid Build Coastguard Worker                                         SkCodec::Result*          result) {
992*c8dee2aaSAndroid Build Coastguard Worker     SkASSERT(result);
993*c8dee2aaSAndroid Build Coastguard Worker     if (!stream) {
994*c8dee2aaSAndroid Build Coastguard Worker         *result = SkCodec::kInvalidInput;
995*c8dee2aaSAndroid Build Coastguard Worker         return nullptr;
996*c8dee2aaSAndroid Build Coastguard Worker     }
997*c8dee2aaSAndroid Build Coastguard Worker 
998*c8dee2aaSAndroid Build Coastguard Worker     bool canSeek = stream->hasPosition() && stream->hasLength();
999*c8dee2aaSAndroid Build Coastguard Worker 
1000*c8dee2aaSAndroid Build Coastguard Worker     if (selectionPolicy != SkCodec::SelectionPolicy::kPreferStillImage) {
1001*c8dee2aaSAndroid Build Coastguard Worker         // Some clients (e.g. Android) need to be able to seek the stream, but may
1002*c8dee2aaSAndroid Build Coastguard Worker         // not provide a seekable stream. Copy the stream to one that can seek.
1003*c8dee2aaSAndroid Build Coastguard Worker         if (!canSeek) {
1004*c8dee2aaSAndroid Build Coastguard Worker             auto data = SkCopyStreamToData(stream.get());
1005*c8dee2aaSAndroid Build Coastguard Worker             stream = std::make_unique<SkMemoryStream>(std::move(data));
1006*c8dee2aaSAndroid Build Coastguard Worker             canSeek = true;
1007*c8dee2aaSAndroid Build Coastguard Worker         }
1008*c8dee2aaSAndroid Build Coastguard Worker     }
1009*c8dee2aaSAndroid Build Coastguard Worker 
1010*c8dee2aaSAndroid Build Coastguard Worker     uint8_t               buffer[SK_WUFFS_CODEC_BUFFER_SIZE];
1011*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__io_buffer iobuf =
1012*c8dee2aaSAndroid Build Coastguard Worker         wuffs_base__make_io_buffer(wuffs_base__make_slice_u8(buffer, SK_WUFFS_CODEC_BUFFER_SIZE),
1013*c8dee2aaSAndroid Build Coastguard Worker                                    wuffs_base__empty_io_buffer_meta());
1014*c8dee2aaSAndroid Build Coastguard Worker     wuffs_base__image_config imgcfg = wuffs_base__null_image_config();
1015*c8dee2aaSAndroid Build Coastguard Worker 
1016*c8dee2aaSAndroid Build Coastguard Worker     // Wuffs is primarily a C library, not a C++ one. Furthermore, outside of
1017*c8dee2aaSAndroid Build Coastguard Worker     // the wuffs_base__etc types, the sizeof a file format specific type like
1018*c8dee2aaSAndroid Build Coastguard Worker     // GIF's wuffs_gif__decoder can vary between Wuffs versions. If p is of
1019*c8dee2aaSAndroid Build Coastguard Worker     // type wuffs_gif__decoder*, then the supported API treats p as a pointer
1020*c8dee2aaSAndroid Build Coastguard Worker     // to an opaque type: a private implementation detail. The API is always
1021*c8dee2aaSAndroid Build Coastguard Worker     // "set_foo(p, etc)" and not "p->foo = etc".
1022*c8dee2aaSAndroid Build Coastguard Worker     //
1023*c8dee2aaSAndroid Build Coastguard Worker     // See https://en.wikipedia.org/wiki/Opaque_pointer#C
1024*c8dee2aaSAndroid Build Coastguard Worker     //
1025*c8dee2aaSAndroid Build Coastguard Worker     // Thus, we don't use C++'s new operator (which requires knowing the sizeof
1026*c8dee2aaSAndroid Build Coastguard Worker     // the struct at compile time). Instead, we use sk_malloc_canfail, with
1027*c8dee2aaSAndroid Build Coastguard Worker     // sizeof__wuffs_gif__decoder returning the appropriate value for the
1028*c8dee2aaSAndroid Build Coastguard Worker     // (statically or dynamically) linked version of the Wuffs library.
1029*c8dee2aaSAndroid Build Coastguard Worker     //
1030*c8dee2aaSAndroid Build Coastguard Worker     // As a C (not C++) library, none of the Wuffs types have constructors or
1031*c8dee2aaSAndroid Build Coastguard Worker     // destructors.
1032*c8dee2aaSAndroid Build Coastguard Worker     //
1033*c8dee2aaSAndroid Build Coastguard Worker     // In RAII style, we can still use std::unique_ptr with these pointers, but
1034*c8dee2aaSAndroid Build Coastguard Worker     // we pair the pointer with sk_free instead of C++'s delete.
1035*c8dee2aaSAndroid Build Coastguard Worker     void* decoder_raw = sk_malloc_canfail(sizeof__wuffs_gif__decoder());
1036*c8dee2aaSAndroid Build Coastguard Worker     if (!decoder_raw) {
1037*c8dee2aaSAndroid Build Coastguard Worker         *result = SkCodec::kInternalError;
1038*c8dee2aaSAndroid Build Coastguard Worker         return nullptr;
1039*c8dee2aaSAndroid Build Coastguard Worker     }
1040*c8dee2aaSAndroid Build Coastguard Worker     std::unique_ptr<wuffs_gif__decoder, decltype(&sk_free)> decoder(
1041*c8dee2aaSAndroid Build Coastguard Worker         reinterpret_cast<wuffs_gif__decoder*>(decoder_raw), &sk_free);
1042*c8dee2aaSAndroid Build Coastguard Worker 
1043*c8dee2aaSAndroid Build Coastguard Worker     SkCodec::Result reset_result =
1044*c8dee2aaSAndroid Build Coastguard Worker         reset_and_decode_image_config(decoder.get(), &imgcfg, &iobuf, stream.get());
1045*c8dee2aaSAndroid Build Coastguard Worker     if (reset_result != SkCodec::kSuccess) {
1046*c8dee2aaSAndroid Build Coastguard Worker         *result = reset_result;
1047*c8dee2aaSAndroid Build Coastguard Worker         return nullptr;
1048*c8dee2aaSAndroid Build Coastguard Worker     }
1049*c8dee2aaSAndroid Build Coastguard Worker 
1050*c8dee2aaSAndroid Build Coastguard Worker     uint32_t width = imgcfg.pixcfg.width();
1051*c8dee2aaSAndroid Build Coastguard Worker     uint32_t height = imgcfg.pixcfg.height();
1052*c8dee2aaSAndroid Build Coastguard Worker     if ((width == 0) || (width > INT_MAX) || (height == 0) || (height > INT_MAX)) {
1053*c8dee2aaSAndroid Build Coastguard Worker         *result = SkCodec::kInvalidInput;
1054*c8dee2aaSAndroid Build Coastguard Worker         return nullptr;
1055*c8dee2aaSAndroid Build Coastguard Worker     }
1056*c8dee2aaSAndroid Build Coastguard Worker 
1057*c8dee2aaSAndroid Build Coastguard Worker     uint64_t workbuf_len = decoder->workbuf_len().max_incl;
1058*c8dee2aaSAndroid Build Coastguard Worker     void*    workbuf_ptr_raw = nullptr;
1059*c8dee2aaSAndroid Build Coastguard Worker     if (workbuf_len) {
1060*c8dee2aaSAndroid Build Coastguard Worker         workbuf_ptr_raw = workbuf_len <= SIZE_MAX ? sk_malloc_canfail(workbuf_len) : nullptr;
1061*c8dee2aaSAndroid Build Coastguard Worker         if (!workbuf_ptr_raw) {
1062*c8dee2aaSAndroid Build Coastguard Worker             *result = SkCodec::kInternalError;
1063*c8dee2aaSAndroid Build Coastguard Worker             return nullptr;
1064*c8dee2aaSAndroid Build Coastguard Worker         }
1065*c8dee2aaSAndroid Build Coastguard Worker     }
1066*c8dee2aaSAndroid Build Coastguard Worker     std::unique_ptr<uint8_t, decltype(&sk_free)> workbuf_ptr(
1067*c8dee2aaSAndroid Build Coastguard Worker         reinterpret_cast<uint8_t*>(workbuf_ptr_raw), &sk_free);
1068*c8dee2aaSAndroid Build Coastguard Worker 
1069*c8dee2aaSAndroid Build Coastguard Worker     SkEncodedInfo::Color color =
1070*c8dee2aaSAndroid Build Coastguard Worker         (imgcfg.pixcfg.pixel_format().repr == WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL)
1071*c8dee2aaSAndroid Build Coastguard Worker             ? SkEncodedInfo::kBGRA_Color
1072*c8dee2aaSAndroid Build Coastguard Worker             : SkEncodedInfo::kRGBA_Color;
1073*c8dee2aaSAndroid Build Coastguard Worker 
1074*c8dee2aaSAndroid Build Coastguard Worker     // In Skia's API, the alpha we calculate here and return is only for the
1075*c8dee2aaSAndroid Build Coastguard Worker     // first frame.
1076*c8dee2aaSAndroid Build Coastguard Worker     SkEncodedInfo::Alpha alpha = imgcfg.first_frame_is_opaque() ? SkEncodedInfo::kOpaque_Alpha
1077*c8dee2aaSAndroid Build Coastguard Worker                                                                 : SkEncodedInfo::kBinary_Alpha;
1078*c8dee2aaSAndroid Build Coastguard Worker 
1079*c8dee2aaSAndroid Build Coastguard Worker     SkEncodedInfo encodedInfo = SkEncodedInfo::Make(width, height, color, alpha, 8);
1080*c8dee2aaSAndroid Build Coastguard Worker 
1081*c8dee2aaSAndroid Build Coastguard Worker     *result = SkCodec::kSuccess;
1082*c8dee2aaSAndroid Build Coastguard Worker     return std::unique_ptr<SkCodec>(new SkWuffsCodec(std::move(encodedInfo), std::move(stream),
1083*c8dee2aaSAndroid Build Coastguard Worker                                                      canSeek,
1084*c8dee2aaSAndroid Build Coastguard Worker                                                      std::move(decoder), std::move(workbuf_ptr),
1085*c8dee2aaSAndroid Build Coastguard Worker                                                      workbuf_len, imgcfg, iobuf));
1086*c8dee2aaSAndroid Build Coastguard Worker }
1087*c8dee2aaSAndroid Build Coastguard Worker 
Decode(std::unique_ptr<SkStream> stream,SkCodec::Result * outResult,SkCodecs::DecodeContext ctx)1088*c8dee2aaSAndroid Build Coastguard Worker std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream> stream,
1089*c8dee2aaSAndroid Build Coastguard Worker                                 SkCodec::Result* outResult,
1090*c8dee2aaSAndroid Build Coastguard Worker                                 SkCodecs::DecodeContext ctx) {
1091*c8dee2aaSAndroid Build Coastguard Worker     SkCodec::Result resultStorage;
1092*c8dee2aaSAndroid Build Coastguard Worker     if (!outResult) {
1093*c8dee2aaSAndroid Build Coastguard Worker         outResult = &resultStorage;
1094*c8dee2aaSAndroid Build Coastguard Worker     }
1095*c8dee2aaSAndroid Build Coastguard Worker     auto policy = SkCodec::SelectionPolicy::kPreferStillImage;
1096*c8dee2aaSAndroid Build Coastguard Worker     if (ctx) {
1097*c8dee2aaSAndroid Build Coastguard Worker         policy = *static_cast<SkCodec::SelectionPolicy*>(ctx);
1098*c8dee2aaSAndroid Build Coastguard Worker     }
1099*c8dee2aaSAndroid Build Coastguard Worker     return MakeFromStream(std::move(stream), policy, outResult);
1100*c8dee2aaSAndroid Build Coastguard Worker }
1101*c8dee2aaSAndroid Build Coastguard Worker 
Decode(sk_sp<SkData> data,SkCodec::Result * outResult,SkCodecs::DecodeContext ctx)1102*c8dee2aaSAndroid Build Coastguard Worker std::unique_ptr<SkCodec> Decode(sk_sp<SkData> data,
1103*c8dee2aaSAndroid Build Coastguard Worker                                 SkCodec::Result* outResult,
1104*c8dee2aaSAndroid Build Coastguard Worker                                 SkCodecs::DecodeContext ctx) {
1105*c8dee2aaSAndroid Build Coastguard Worker     if (!data) {
1106*c8dee2aaSAndroid Build Coastguard Worker         if (outResult) {
1107*c8dee2aaSAndroid Build Coastguard Worker             *outResult = SkCodec::kInvalidInput;
1108*c8dee2aaSAndroid Build Coastguard Worker         }
1109*c8dee2aaSAndroid Build Coastguard Worker         return nullptr;
1110*c8dee2aaSAndroid Build Coastguard Worker     }
1111*c8dee2aaSAndroid Build Coastguard Worker     return Decode(SkMemoryStream::Make(std::move(data)), outResult, ctx);
1112*c8dee2aaSAndroid Build Coastguard Worker }
1113*c8dee2aaSAndroid Build Coastguard Worker }  // namespace SkGifDecoder
1114*c8dee2aaSAndroid Build Coastguard Worker 
1115