rngine 0.8.0 → 0.8.2

package/shared/skia/include/android/SkAndroidFrameworkUtils.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAndroidFrameworkUtils_DEFINED
+#define SkAndroidFrameworkUtils_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTileMode.h"
+
+class SkCanvas;
+struct SkIRect;
+struct SkRect;
+class SkSurface;
+class SkShader;
+
+/**
+ *  SkAndroidFrameworkUtils expose private APIs used only by Android framework.
+ */
+class SkAndroidFrameworkUtils {
+public:
+
+#if defined(SK_GANESH)
+    /**
+     *  clipWithStencil draws the current clip into a stencil buffer with reference value and mask
+     *  set to 0x1. This function works only on a GPU canvas.
+     *
+     *  @param  canvas A GPU canvas that has a non-empty clip.
+     *
+     *  @return true on success or false if clip is empty or not a GPU canvas.
+     */
+    static bool clipWithStencil(SkCanvas* canvas);
+#endif //defined(SK_GANESH)
+
+    static void SafetyNetLog(const char*);
+
+    static int SaveBehind(SkCanvas* canvas, const SkRect* subset);
+
+    // Operating within the canvas' clip stack, this resets the geometry of the clip to be wide
+    // open modula any device clip restriction that was set outside of the clip stack.
+    static void ResetClip(SkCanvas* canvas);
+
+    /**
+     * Unrolls a chain of nested SkPaintFilterCanvas to return the base wrapped canvas.
+     *
+     *  @param  canvas A SkPaintFilterCanvas or any other SkCanvas subclass.
+     *
+     *  @return SkCanvas that was found in the innermost SkPaintFilterCanvas.
+     */
+    static SkCanvas* getBaseWrappedCanvas(SkCanvas* canvas);
+
+    /**
+     *  If the shader represents a linear gradient ShaderAsALinearGradient
+     *  returns true and if info is not null, ShaderAsALinearGradient populates
+     *  info with the parameters for the gradient. fColorCount is both an input
+     *  and output parameter. On input, it indicates how many entries in
+     *  fColors and fColorOffsets can be used, if they are not nullptr. After
+     *  asAGradient has run, fColorCount indicates how many color-offset pairs
+     *  there are in the gradient. fColorOffsets specifies where on the range of
+     *  0 to 1 to transition to the given color. fPoints represent the endpoints
+     *  of the gradient.
+     */
+    struct LinearGradientInfo {
+        int         fColorCount    = 0;        //!< In-out parameter, specifies passed size
+                                               //   of fColors/fColorOffsets on input, and
+                                               //   actual number of colors/offsets on
+                                               //   output.
+        SkColor4f*  fColors        = nullptr;  //!< The colors in the gradient.
+        SkScalar*   fColorOffsets  = nullptr;  //!< The unit offset for color transitions.
+        SkPoint     fPoints[2];                //!< Type specific, see above.
+        SkTileMode  fTileMode;
+        uint32_t    fGradientFlags = 0;        //!< see SkGradientShader::Flags
+    };
+
+    static bool ShaderAsALinearGradient(SkShader* shader, LinearGradientInfo*);
+};
+
+#endif // SkAndroidFrameworkUtils_DEFINED

package/shared/skia/include/android/SkAnimatedImage.h

@@ -0,0 +1,193 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAnimatedImage_DEFINED
+#define SkAnimatedImage_DEFINED
+
+#include "include/codec/SkCodecAnimation.h"
+#include "include/core/SkBitmap.h"
+#include "include/core/SkDrawable.h"
+#include "include/core/SkMatrix.h"
+#include "include/core/SkRect.h"
+
+class SkAndroidCodec;
+class SkImage;
+class SkPicture;
+
+/**
+ *  Thread unsafe drawable for drawing animated images (e.g. GIF).
+ */
+class SK_API SkAnimatedImage : public SkDrawable {
+public:
+    /**
+     *  Create an SkAnimatedImage from the SkAndroidCodec.
+     *
+     *  Returns null on failure to allocate pixels. On success, this will
+     *  decode the first frame.
+     *
+     *  @param info Width and height may require scaling.
+     *  @param cropRect Rectangle to crop to after scaling.
+     *  @param postProcess Picture to apply after scaling and cropping.
+     */
+    static sk_sp<SkAnimatedImage> Make(std::unique_ptr<SkAndroidCodec>,
+            const SkImageInfo& info, SkIRect cropRect, sk_sp<SkPicture> postProcess);
+
+    /**
+     *  Simpler version that uses the default size, no cropping, and no postProcess.
+     */
+    static sk_sp<SkAnimatedImage> Make(std::unique_ptr<SkAndroidCodec>);
+
+    ~SkAnimatedImage() override;
+
+    /**
+     *  Reset the animation to the beginning.
+     */
+    void reset();
+
+    /**
+     *  Whether the animation completed.
+     *
+     *  Returns true after all repetitions are complete, or an error stops the
+     *  animation. Gets reset to false if the animation is restarted.
+     */
+    bool isFinished() const { return fFinished; }
+
+    /**
+     * Returned by decodeNextFrame and currentFrameDuration if the animation
+     * is not running.
+     */
+    static constexpr int kFinished = -1;
+
+    /**
+     *  Decode the next frame.
+     *
+     *  If the animation is on the last frame or has hit an error, returns
+     *  kFinished.
+     */
+    int decodeNextFrame();
+
+    /**
+     *  Returns the current frame as an SkImage. The SkImage will not change
+     *  after it has been returned.
+     *  If there is no current frame, nullptr will be returned.
+     */
+    sk_sp<SkImage> getCurrentFrame();
+
+    /**
+     *  How long to display the current frame.
+     *
+     *  Useful for the first frame, for which decodeNextFrame is called
+     *  internally.
+     */
+    int currentFrameDuration() {
+        return fCurrentFrameDuration;
+    }
+
+    /**
+     *  Change the repetition count.
+     *
+     *  By default, the image will repeat the number of times indicated in the
+     *  encoded data.
+     *
+     *  Use SkCodec::kRepetitionCountInfinite for infinite, and 0 to show all
+     *  frames once and then stop.
+     */
+    void setRepetitionCount(int count);
+
+    /**
+     *  Return the currently set repetition count.
+     */
+    int getRepetitionCount() const {
+        return fRepetitionCount;
+    }
+
+    /**
+     *  Return the total number of frames in the animation.
+     */
+    int getFrameCount() const { return fFrameCount; }
+
+    /**
+     *  Change the filter mode.
+     *
+     *  By default, the image will apply bilinear filtering when drawing in the
+     *  OnDraw method.
+     */
+    void setFilterMode(SkFilterMode filterMode);
+
+    /**
+     *  Return the filter mode used for sampling when drawing.
+     */
+    SkFilterMode getFilterMode() const { return fFilterMode; }
+
+protected:
+    SkRect onGetBounds() override;
+    void onDraw(SkCanvas*) override;
+
+private:
+    struct Frame {
+        SkBitmap fBitmap;
+        int      fIndex;
+        SkCodecAnimation::DisposalMethod fDisposalMethod;
+
+        // init() may have to create a new SkPixelRef, if the
+        // current one is already in use by another owner (e.g.
+        // an SkPicture). This determines whether to copy the
+        // existing one to the new one.
+        enum class OnInit {
+            // Restore the image from the old SkPixelRef to the
+            // new one.
+            kRestoreIfNecessary,
+            // No need to restore.
+            kNoRestore,
+        };
+
+        Frame();
+        bool init(const SkImageInfo& info, OnInit);
+        bool copyTo(Frame*) const;
+    };
+
+    std::unique_ptr<SkAndroidCodec> fCodec;
+          SkImageInfo               fDecodeInfo;
+    const SkIRect                   fCropRect;
+    const sk_sp<SkPicture>          fPostProcess;
+    const int                       fFrameCount;
+    SkMatrix                        fMatrix;
+    int                             fSampleSize;
+
+    bool                            fFinished;
+    int                             fCurrentFrameDuration;
+    Frame                           fDisplayFrame;
+    Frame                           fDecodingFrame;
+    Frame                           fRestoreFrame;
+    int                             fRepetitionCount;
+    int                             fRepetitionsCompleted;
+    SkFilterMode                    fFilterMode = SkFilterMode::kLinear;
+
+    SkAnimatedImage(std::unique_ptr<SkAndroidCodec>, const SkImageInfo& requestedInfo,
+            SkIRect cropRect, sk_sp<SkPicture> postProcess);
+
+    int computeNextFrame(int current, bool* animationEnded);
+    double finish();
+
+    /**
+     *  True if there is no crop, orientation, or post decoding scaling.
+     */
+    bool simple() const { return fMatrix.isIdentity() && !fPostProcess
+                                 && fCropRect == fDecodeInfo.bounds(); }
+
+    /**
+     *  Returns the current frame as an SkImage.
+     *
+     *  Like getCurrentFrame, but only returns the raw data from the internal SkBitmap. (i.e. no
+     *  scaling, orientation-correction or cropping.) If simple(), this is the final output.
+     */
+    sk_sp<SkImage> getCurrentFrameSimple();
+
+    using INHERITED = SkDrawable;
+};
+
+#endif // SkAnimatedImage_DEFINED

package/shared/skia/include/android/SkCanvasAndroid.h

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkCanvasAndroid_DEFINED
+#define SkCanvasAndroid_DEFINED
+
+class SkCanvas;
+struct SkIRect;
+class GrBackendRenderTarget;
+
+namespace skgpu::ganesh {
+SkIRect TopLayerBounds(const SkCanvas*);
+GrBackendRenderTarget TopLayerBackendRenderTarget(const SkCanvas*);
+}
+
+#endif

package/shared/skia/include/android/SkImageAndroid.h

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkImageAndroid_DEFINED
+#define SkImageAndroid_DEFINED
+
+#include "include/core/SkImage.h"
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/ganesh/GrTypes.h"
+
+class SkColorSpace;
+class GrDirectContext;
+class GrRecordingContext;
+class SkPixmap;
+struct AHardwareBuffer;
+
+namespace SkImages {
+
+/** (See skbug.com/40038695)
+    Creates SkImage from Android hardware buffer.
+    Returned SkImage takes a reference on the buffer.
+    Only available on Android, when __ANDROID_API__ is defined to be 26 or greater.
+    @param hardwareBuffer  AHardwareBuffer Android hardware buffer
+    @param colorSpace      range of colors; may be nullptr
+    @return                created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> DeferredFromAHardwareBuffer(AHardwareBuffer* hardwareBuffer,
+                                                  SkAlphaType alphaType = kPremul_SkAlphaType);
+SK_API sk_sp<SkImage> DeferredFromAHardwareBuffer(
+        AHardwareBuffer* hardwareBuffer,
+        SkAlphaType alphaType,
+        sk_sp<SkColorSpace> colorSpace,
+        GrSurfaceOrigin surfaceOrigin = kTopLeft_GrSurfaceOrigin);
+
+/** Creates SkImage from Android hardware buffer and uploads the data from the SkPixmap to it.
+    Returned SkImage takes a reference on the buffer.
+    Only available on Android, when __ANDROID_API__ is defined to be 26 or greater.
+    @param context         GPU context
+    @param pixmap          SkPixmap that contains data to be uploaded to the AHardwareBuffer
+    @param hardwareBuffer  AHardwareBuffer Android hardware buffer
+    @param surfaceOrigin   surface origin for resulting image
+    @return                created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> TextureFromAHardwareBufferWithData(
+        GrDirectContext* context,
+        const SkPixmap& pixmap,
+        AHardwareBuffer* hardwareBuffer,
+        GrSurfaceOrigin surfaceOrigin = kTopLeft_GrSurfaceOrigin);
+
+/**
+ *  Like SkImage::MakeFromBitmap, except this can be pinned using
+ *  skgpu::ganesh::PinAsTexture and Skia will *not* copy the bitmap.
+ */
+SK_API sk_sp<SkImage> PinnableRasterFromBitmap(const SkBitmap&);
+
+/**
+ * Like SkImage::MakeFromBitmap, except and Skia will *not* copy the bitmap.
+ */
+SK_API sk_sp<SkImage> RasterFromBitmapNoCopy(const SkBitmap&);
+
+}  // namespace SkImages
+
+namespace skgpu::ganesh {
+/**
+ *  Will attempt to upload and lock the contents of the image as a texture, so that subsequent
+ *  draws to a gpu-target will come from that texture (and not by looking at the original image
+ *  src). In particular this is intended to use the texture even if the image's original content
+ *  changes subsequent to this call (i.e. the src is mutable!).
+ *
+ *  Only compatible with SkImages created from SkImages::PinnableRasterFromBitmap.
+ *
+ *  All successful calls must be balanced by an equal number of calls to UnpinTexture().
+ *
+ *  Once in this "pinned" state, the image has all of the same thread restrictions that exist
+ *  for a natively created gpu image (e.g. SkImage::MakeFromTexture)
+ *  - all drawing, pinning, unpinning must happen in the same thread as the GrContext.
+ *
+ *  @return true if the image was successfully uploaded and locked into a texture
+ */
+bool PinAsTexture(GrRecordingContext*, SkImage*);
+
+/**
+ *  The balancing call to a successful invocation of PinAsTexture. When a balanced
+ *  number of calls have been made, then the "pinned" texture is free to be purged, etc. This
+ *  also means that a subsequent "pin" call will look at the original content again, and if
+ *  its uniqueID/generationID has changed, then a newer texture will be uploaded/pinned.
+ *
+ *  Only compatible with SkImages created from SkImages::PinnableRasterFromBitmap.
+ *
+ *  The context passed to unpin must match the one passed to pin.
+ */
+void UnpinTexture(GrRecordingContext*, SkImage*);
+
+} // namespace skgpu::ganesh
+
+#endif

package/shared/skia/include/android/SkSurfaceAndroid.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSurfaceAndroid_DEFINED
+#define SkSurfaceAndroid_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSurface.h"
+#include "include/gpu/ganesh/GrTypes.h"
+
+class SkColorSpace;
+class GrDirectContext;
+class SkPixmap;
+struct AHardwareBuffer;
+
+namespace SkSurfaces {
+
+/** Private; only to be used by Android Framework.
+    Creates SkSurface from Android hardware buffer.
+    Returned SkSurface takes a reference on the buffer. The ref on the buffer will be released
+    when the SkSurface is destroyed and there is no pending work on the GPU involving the
+    buffer.
+
+    Currently this is only supported for buffers that can be textured as well as rendered to.
+    In other words that must have both AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT and
+    AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE usage bits.
+
+    @param context         GPU context
+    @param hardwareBuffer  AHardwareBuffer Android hardware buffer
+    @param colorSpace      range of colors; may be nullptr
+    @param surfaceProps    LCD striping orientation and setting for device independent
+                           fonts; may be nullptr
+    @param fromWindow      Whether or not the AHardwareBuffer is part of an Android Window.
+                           Currently only used with Vulkan backend.
+    @return                created SkSurface, or nullptr
+*/
+SK_API sk_sp<SkSurface> WrapAndroidHardwareBuffer(GrDirectContext* context,
+                                                  AHardwareBuffer* hardwareBuffer,
+                                                  GrSurfaceOrigin origin,
+                                                  sk_sp<SkColorSpace> colorSpace,
+                                                  const SkSurfaceProps* surfaceProps,
+                                                  bool fromWindow = false);
+
+}  // namespace SkSurfaces
+
+#endif

package/shared/skia/include/android/graphite/SurfaceAndroid.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SurfaceAndroid_DEFINED
+#define SurfaceAndroid_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+struct AHardwareBuffer;
+class SkColorSpace;
+class SkSurface;
+class SkSurfaceProps;
+
+namespace skgpu::graphite {
+    class Recorder;
+}
+
+namespace SkSurfaces {
+
+using ReleaseContext = void*;
+using BufferReleaseProc = void (*)(ReleaseContext);
+
+/** Private; only to be used by Android Framework.
+    Creates an SkSurface from an Android hardware buffer.
+
+    Upon success bufferReleaseProc is called when it is safe to delete the buffer in the
+    backend API (accounting only for use of the buffer by this surface). If SkSurface creation
+    fails bufferReleaseProc is called before this function returns.
+
+    Currently this is only supported for buffers that can be textured as well as rendered to.
+    In other words the buffer must have both AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT and
+    AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE usage bits.
+
+    @param recorder          the applicable Graphite recorder
+    @param hardwareBuffer    an Android hardware buffer
+    @param colorSpace        range of colors; may be nullptr
+    @param surfaceProps      LCD striping orientation and setting for device independent
+                             fonts; may be nullptr
+    @param bufferReleaseProc function called when the buffer can be released
+    @param ReleaseContext    state passed to bufferReleaseProc
+    @param fromWindow        Whether or not the AHardwareBuffer is part of an Android Window.
+                             Currently only used with Vulkan backend.
+    @return                  created SkSurface, or nullptr
+*/
+SK_API sk_sp<SkSurface> WrapAndroidHardwareBuffer(skgpu::graphite::Recorder* recorder,
+                                                  AHardwareBuffer* hardwareBuffer,
+                                                  sk_sp<SkColorSpace> colorSpace,
+                                                  const SkSurfaceProps* surfaceProps,
+                                                  BufferReleaseProc = nullptr,
+                                                  ReleaseContext = nullptr,
+                                                  bool fromWindow = false);
+
+}  // namespace SkSurfaces
+
+#endif // SurfaceAndroid_DEFINED

package/shared/skia/include/android/vk/AndroidVulkanMemoryAllocator.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef AndroidVulkanMemoryAllocator_DEFINED
+#define AndroidVulkanMemoryAllocator_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+namespace skgpu {
+struct VulkanBackendContext;
+class VulkanMemoryAllocator;
+}
+
+namespace SkiaVMA {
+
+struct Options {
+    bool fThreadSafe = true;
+};
+
+// Returns a concrete implementation of a memory allocator using some hard-coded settings.
+// If Android Framework ever wants to make their own, they can stop using this.
+sk_sp<skgpu::VulkanMemoryAllocator> Make(const skgpu::VulkanBackendContext&, Options);
+
+}  // namespace SkiaVMA
+
+#endif