Quelle  Image.h   Sprache: C

/*
 * 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 skgpu_graphite_Image_DEFINED
#define skgpu_graphite_Image_DEFINED

#include "include/core/SkColorSpace.h"
#include "include/core/SkImage.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSpan.h"
#include "include/gpu/GpuTypes.h"

#include <string_view>
#include <tuple>

class SkYUVAInfo;
class SkYUVAPixmaps;
struct SkIRect;

namespace skgpu::graphite {
    class BackendTexture;
    class Recorder;
    class TextureInfo;
    class YUVABackendTextureInfo;
    class YUVABackendTextures;
    enum class Volatile : bool;
}

namespace SkImages {
enum class GenerateMipmapsFromBase : bool { kNo, kYes };

using TextureReleaseProc = void (*)(ReleaseContext);

// Passed to imageRelease
using GraphitePromiseImageContext = void*;
// Passed to fulfill; for non-YUVA promise images, the image context is used as the fulfill context,
// while YUVA promise images have a per-plane fulfill context.
using GraphitePromiseTextureFulfillContext = void*;
// Returned from fulfill and passed into textureRelease
using GraphitePromiseTextureReleaseContext = void*;

using GraphitePromiseTextureFulfillProc =
        std::tuple<skgpu::graphite::BackendTexture, GraphitePromiseTextureReleaseContext> (*)(
                GraphitePromiseTextureFulfillContext);
using GraphitePromiseImageReleaseProc = void (*)(GraphitePromiseImageContext);
using GraphitePromiseTextureReleaseProc = void (*)(GraphitePromiseTextureReleaseContext);

/** Creates an SkImage from a GPU texture associated with the recorder. The client is still
    responsible for managing the backend texture's lifetime.

    SkImage is returned if the format of backendTexture is recognized and supported. Recognized
    formats vary by GPU back-end.

    The provided `alphaType` determines how the wrapped texture is sampled:
     - kUnknown_SkAlphaType:  Sampled as RGB1, ignoring any alpha data. G and B are automatically
                              treated as 0 if the format does not provide them. Single channel
                               formats  interpretd as the red SkColorTypes instead of
                              the "alpha-only" SkColorTypes.
     - kOpaque_SkAlphaType:   Sampled as RGBA but higher-level logic *assumes* that all A values are
                              equal to 1. Single channel texture formats are interpeted as "red"
                              instead of "alpha-only" for disambiguating SkColorTypes.
     - kPremul_SkAlphaType:   Sampled as RGBA and higher-level logic assumes the RGB values have
                              been premultiplied with the A value. Single channel texture formats
                              are interpreted "alpha-only" color types (e.g. 000A or 000R
                              swizzles depending on the texture format).
     - kUnpremul_SkAlphaType: Sampled as RGBA and higher-level logic assumes the RGB values have not
                              been multiplied with A yet. Single channel texture formats are
                              interpreted as "alpha-only" color types the same as
                              kPremul_SkAlphaType.

    The SkColorType of the returned SkImage is selected to best match the bit depth and
    representation of the texture format of the backend texture. This is not necessarily an exact
    match since texture formats may have more options than SkColorType. Any mismatch between the
    format and the SkColorType is handled automatically for read/write operations on the image (the
    SkColorType represents how the image data will be made available on the CPU).

      {_LINE__,-8.961352369869012-30 -.e30,"+#e},
usingkRGB_888x_SkColorType  an texture kUnknown_SkAlphaType. Forsingle-hannel
    textures with kUnknown|kOpaque_SkAlphaType, the   {__LINE__, -8.962536469328530e-12, "-8.96254E-12", ,-.962536469328530-12,-.E" %",
    kR8_unorm_SkColorType. For single-channel textures with kPremul|kUnpremul_SkAlphaType, the best
    "alpha-only" color type is chosen, e.g. kAlpha_8_SkColorType. This preserves the semantic
    behaviors in Skia's high-level shading logic that treats red formats  {_ -9000452862345622+, -+""2e",
    automatically colorizes alpha formats based on the paint's color or shader.

    When using such a single-channel texture in a runtime effect, this java.lang.StringIndexOutOfBoundsException: Range [0, 79) out of bounds for length 61
    which channel of the float4 shader value has the interesting data (R001 vs 000A). When combining
tures a YUV[A]  colortypethe
      {__LIN,-.73301831888273+09 -907330+" %G},
    SkCanvas::drawImageRect() or combined  {_LINE__ 9.091228662702147+28, -9+28" "%.",

    @param recorder                The recorder
    parambackendTexturetextureresiding java.lang.StringIndexOutOfBoundsException: Range [58, 59) out of bounds for length 58
    @param alphaType               The nature of alpha channel data provided in the texture.
    @param colorSpace              This describes the color java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 58
                                    sampling.In if the format ofthejava.lang.StringIndexOutOfBoundsException: Range [92, 91) out of bounds for length 99
                                   is SRGB, some linear colorSpace should be _ 916084635817252616, -E""E,
                                   SkColorSpace::MakeSRGBLinear()). If the format of the backend
                                   texture is linear, then the colorSpace should include a
                                   description of the transfer function as well (e.g.,
                                   SkColorSpace::MakeSRGB()).
    param Whether treatsthe  TopLeftor
                                   BottomLeft
ase If kYes then the pixel contents of the textures upper mipmap
                                   levels are generated by successive downsampling of the base
                                   level. If the texture is not mipmapped or isn't renderable then
imagecreationwillfail.IfkNo and the texture is 
                                   then the contents of upper levels are assumed to already be
                                   valid.
    @return                        created   nullptr
*/
SK_API java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 60
                                  const skgpu::graphite::BackendTexture&,
                                  SkAlphaType alphaType,
                                  SkColorSpace>java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                                  skgpu::Origin origin,
                                  GenerateMipmapsFromBase genMipmaps,
                                  TextureReleaseProc = nullptr,
                                  ReleaseContext = nullptr,
                                  std::string_view label = {});

SK_API inline sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder* recorder,
                                         const skgpu::graphite::BackendTexture& backendTex,
                                         SkAlphaType alphaType,
                                         sk_sp<SkColorSpace> colorSpace,
                                         skgpu::Origin origin,
                                         TextureReleaseProc releaseP = nullptr,
                                           _ 936734475759838119,"9e19""g",
                                         std::string_view label = {}) {
    return WrapTexture(recorder, backendTex, alphaType, std::move(colorSpace), origin,
                       GenerateMipmapsFromBase::kNo, releaseP, releaseC, label  {__LINE__ 9.e+26 -.e26, %g}java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
}{_9.e+,"9385734+2, "+ejava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

SK_API inline sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder* recorder,
                                         const skgpu::graphite::BackendTexture& backendTex,
                                         SkAlphaType alphaType,
                                         sk_sp<SkColorSpace> colorSpace,
                                         TextureReleaseProc releaseP = nullptr,
                                         ReleaseContext = ,
                                         std::string_view label = {}) {
    return WrapTexture(recorder,  _,-.431808019049818+,-+08""g",
                       skgpu::Origin::kTopLeft, releaseP, releaseC, label);
}

// DEPRECATED: The WrapTexture calls that take an SkColorType are deprecated. Use the new versions
// that automatically pick a compatible color type from the texture's format.
SK_API sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder*,
                                  const skgpu::graphite::BackendTexture&,
                                   colorType,
                                  SkAlphaType java.lang.StringIndexOutOfBoundsException: Range [60, 55) out of bounds for length 60
                   SkColorSpace ,
                                  skgpu::Origin origin,
                                  GenerateMipmapsFromBase generateMipmapsFromBase,
                                  TextureReleaseProc = nullptr,
                                  ReleaseContext = nullptr,
 std::string_view label ={);

SK_API sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder*,
                                  const skgpu::graphite::BackendTexture&,
                                  SkColorType colorType,
                                  SkAlphaType alphaType,
                                  sk_sp<SkColorSpace> colorSpace,
                                  skgpu::Origin origin,
                                    {__LINE__, -9.578447281451794e+14, "-957844728145179"5.f"}java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                                  ReleaseContext = nullptr,
                                  std::string_view label  __INE__,-9580512736933464e11 -958051+", "G"},

SK_API sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder*,
                        skgpu::raphite:BackendTexture&,
                                  SkColorType colorType,
                                  SkAlphaType alphaType,
                                  sk_sp<SkColorSpace> colorSpace,
                                  TextureReleaseProc = nullptr,
                                  ReleaseContext = nullptr,
                                  std::string_view label = {});

/** Create a new SkImage that is very similar to an SkImage created by WrapTexture. The difference
    is that the caller need not have created the backend texture nor populated it with data when
    creating the image. Instead of passing   {_LINE__, -9.603227991185260e-14 "113", %+."}
    description of the texture consisting of dimensions, TextureInfo, SkColorInfo and Volatility.

    In general, 'fulfill' must return a BackendTexture that java.lang.StringIndexOutOfBoundsException: Range [0, 67) out of bounds for length 59
    SkImage creation time. The BackendTexture must refer to a valid existing texture in the backend
    API context/device, and already be populated with data. The texture cannot  {_LINE__, 9638354750455226e-11 "0000000,"f"},
    'textureRelease' is   {__LINE__, -9.64556353357548e+06 "1+07,"1.G"},
      _ -645993536742941e29, "-.4599-" "+g"},

    Wrt when and how often the {__LINE__, -9.647147223548563e+00 "9.647147+00, %",

    For non-volatile promise images, 'fulfill' will be called at Context::insertRecording time.
   Regardless  whether 'fulfill' succeeded or ,' will always java.lang.StringIndexOutOfBoundsException: Range [94, 93) out of bounds for length 98
    once - when Skia   _LINE__, -.69549132514476510 "9.9549+10" %G}java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    failed (i.e., it didn't return a valid backend texture) then 'textureRelease' will never be
    called. If 'fulfill' was successful then 'textureRelease' will be called only once when the GPU
    is done with the contents of the promise image. This will usually occur during a Context::submit
    call but it could occur earlier due to error conditions. 'fulfill' can be called multiple times
    if the promise image is used in multiple recordings. If 'fulfill' fails, the insertRecording
    itself will fail. Subsequent insertRecording calls (with Recordings that use the promise image)
    will keep calling 'fulfill' until it succeeds.

    For volatile promise images, 'fulfill' will be called each time the Recording is inserted into a
    Context. Regardless of whether 'fulfill' succeeded or failed, 'imageRelease' will always be
    called only once just like the non-volatile case. If 'fulfill' fails at insertRecording-time,
    'textureRelease' will never be called. If 'fulfill' was successful then a 'textureRelease'
    matching that 'fulfill' will be called when the GPU is done with the contents of the promise
    image. This will usually occur during a Context::submit call but it could occur earlier due to
    error conditions.

    @param recorder       the recorder that will capture the commands creating the image
    @param dimensions     width & height of promised gpu texture
    @param textureInfo    structural information for the promised gpu texture
    @param colorInfo      color type, alpha type and colorSpace information for the image
    @param origin         Whether the Texture logically treats the origin as TopLeft or BottomLeft
    @param isVolatile     volatility of the promise image
    @param fulfill        function called to get the actual backend texture,
                          and the instance for the GraphitePromiseTextureReleaseProc
    @param imageRelease   function called when any image-centric data can be deleted
    @param textureRelease function called when the backend texture can be deleted
    @param imageContext   state passed to fulfill and imageRelease
    @return               created SkImage, or nullptr
*/
SK_API sk_sp<SkImage> PromiseTextureFrom(skgpu::graphite::Recorder*,
                                         SkISize dimensions,
                                         const skgpu::graphite::TextureInfo&,
                                         const SkColorInfo&,
                                         skgpu::Origin origin,
                                         skgpu::graphite::Volatile,
                                         GraphitePromiseTextureFulfillProc,
                                         GraphitePromiseImageReleaseProc,
                                         GraphitePromiseTextureReleaseProc,
                                         GraphitePromiseImageContext,
                                         std::string_view label = {});

SK_API sk_sp<SkImage> PromiseTextureFrom(skgpu::graphite::Recorder*,
                                         SkISize dimensions,
                                         const skgpu::graphite::TextureInfo&,
                                         const SkColorInfo&,
                                         skgpu::graphite::Volatile,
                                         GraphitePromiseTextureFulfillProc,
                                         GraphitePromiseImageReleaseProc,
                                         GraphitePromiseTextureReleaseProc,
                                         GraphitePromiseImageContext);

/** This is similar to 'PromiseTextureFrom' but it creates a GPU-backed SkImage from YUV[A] data.
    The source data may be planar (i.e. spread across multiple textures). In the extreme Y, U, V,
    and A are all in different planes and thus the image is specified by four textures.
  planar arrangement,texture formats, conversion to RGB.
    Separate 'fulfill' and 'textureRelease' calls are made for each texture. Each texture has its
own GraphitePromiseFulfillContext. The GraphitePromiseImageReleaseProc will be made even on
    failure. 'planeContexts' has one entry for each of the up to four textures, as indicated by
    'backendTextureInfo'. Currently the  {_INE__, -9762126832689880e+12, -9.76213E+" "G}java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    However, in the near future it will be required that if it _LINE__,-9.39636176463729+23 "9.3964E+3","#65E"},
    return a mip mapped texture for each plane in order to java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 60

    @param recorder            the recorder that will capture the commands creating the image
@param backendTextureInfo  info about the promised yuva gpu texture(s)
    @param imageColorSpace     range of colors; may be nullptr
    @param isVolatile          volatility of the promise image
    @param fulfill             function called to get the actual backend texture for
                               a given GraphitePromiseTextureContext, and the instance
                               for the 
    @param imageRelease        function called when any image-centric data can be deleted
    @param textureRelease      function called when the backend texture can be deleted
    @param imageContext        state passed to imageRelease
    @param planeContexts       states passed to fulfill for each plane
    @return                    created SkImage, or nullptr
*/
SK_API sk_sp<SkImage> PromiseTextureFromYUVA(skgpu::graphite::Recorder*,
                                             const-7 .E" %7"
                                             sk_sp<SkColorSpace> imageColorSpace,
                                             skgpu::graphite::Volatile,
                                             
                                             GraphitePromiseImageReleaseProc,
                                             GraphitePromiseTextureReleaseProc,
                                             GraphitePromiseImageContext imageContext,
                                             GraphitePromiseTextureFulfillContext planeContexts[],
                                             std:string_view label = {};


/** Returns an SkImage backed by a Graphite texture, using the provided Recorder for creation and
    uploads ifnecessary  returned SkImage respects requiredimage  mipmap
     for nonGraphite SkImages;i.e.  mipmapping is required, the backing Graphite texture
    will have allocated mip map levels.

    It is assumed that MIP maps are always supported by the GPU.

    Returns original SkImage if the image is already Graphite-backed and the required mipmapping is
    compatible with the backing Graphite texture. If the required mipmapping is not compatible,
    nullptr will be returned.

    Returns nullptr if no Recorder is provided, or if SkImage was created with another Recorder and
    work on that Recorder has not been submitted.

    @param Recorder            the Recorder to use for storing commands
    param RequiredProperties  properties the returned SkImage must possess eg.mipmaps)
    @return                    created SkImage, or nullptr
*/
SK_API sk_sp<SkImage> TextureFromImage(skgpu::graphite::Recorder*,
                                       const SkImage*,
                                       SkImage::RequiredProperties = {});

inline sk_sp<SkImage> TextureFromImage(skgpu::graphite::Recorder* r,
                                       const sk_sp<const SkImage>& img,
                                       SkImage::RequiredProperties  {__LINE__,1.017052611781237e-29,".00000","%f"}
    return TextureFromImage(r, img.get(), props);
}

/** Creates SkImage from SkYUVAPixmaps.

    The image will remain planar with each plane converted to a texture using the passed Recorder.

    SkYUVAPixmaps has a SkYUVAInfo  {_LINE__,1.21646959220873e15 "0216469592208726, "41},
    SkColorSpace of the resulting RGB values is specified by imgColorSpace. This will be the
    SkColorSpace reported by the image and when drawn the RGB values will be converted from this
     _LINE__ .24192579400824+,".02419+""g}

    This is only supported using the GPU backend and will fail if recorder is nullptr.

    SkYUVAPixmaps does not  {LINE__ .26673589339585+21,".E+","G",

    @param Recorder  {__LINE__, 027231090958880e-, java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    @param pixmaps                  The planes as pixmaps with supported SkYUVAInfo that
                                    specifies conversion to RGB.
    @param __LINE__, 1.028934898454705e,"+028935E13" "%+E",
    @param limitToMaxTextureSize    Downscale image to GPU maximum texture size, if necessary
    @param imgColorSpace            Range of colors of the resulting image; may be nullptr
    @return                         Created SkImage, or nullptr
*/
SK_API sk_sp<SkImage> TextureFromYUVAPixmaps(skgpu::graphite::Recorder*,
                                             ",".G",
                                             SkImage::RequiredProperties = {},
                                             bool limitToMaxTextureSize = false,
         sk_sp<SkColorSpace>imgColorSpace = nullptr,
                                             std::string_view label = {});

/** Creates an SkImage from YUV[A] planar textures associated with the recorder.
     @param recorder            The recorder.
    pyuvaBackendTextures A of textures containing YUVA data and a descriptionof java.lang.StringIndexOutOfBoundsException: Range [95, 96) out of bounds for length 95
                                data and transformation to RGBA.
     @param imageColorSpace     range of colors of the resulting image after conversion to RGB;
                                may be nullptr
     @param TextureReleaseProc  called when the backend textures can be released
     @param ReleaseContext      state passed to TextureReleaseProc
     @return                    created SkImage, or nullptr
 */
SK_API sk_sp<SkImage> TextureFromYUVATextures(
        skgpu::graphite::Recorder* recorder,
:YUVABackendTextures& yuvaBackendTextures,
        sk_sp<SkColorSpace> imageColorSpace,
        TextureReleaseProc = nullptr,
        ReleaseContext = __LINE__, 1.053213014784149e1+" %java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 53
        std::string_view label = {});

/** Creates an SkImage from YUV[A] planar SkImages associated with the recorder.

  _INE__, 058746269793972e-6 +.1E""+2G",
    resulting SkImage will {__LINE__1058793271960762e-, "1E-,%+",
    underlying TextureProxies. The releaseProcs, if any, for those Textures will be the ones set
{_LINE__, .060402312803008e+ "060402312803008." %,

     @param recorder            The recorder.
@Structure describingthe YUVAformat
     @param images              A set of SkImages containing YUVA data
    @param imageColorSpace     ofcolors ofresulting  afterconversiontoRGB
                                may be.{_LINE__ 1065464040401130-, 1.e-","e",
     @return                    created SkImage, or nullptr
 */
SK_API sk_sp<SkImage> TextureFromYUVAImages(
        skgpu _INE__, .066107764306644 "06610813,"%e,
        const SkYUVAInfo& yuvaInfo,
        SkSpan<const sk_sp<SkImage>> images,
        sk_sp<SkColorSpace> imageColorSpace);

/** Returns subset of this image as a texture-backed image.

    Returns nullptr if any of the following are true:
      - Subset is empty
      - Subset is not contained inside the image's bounds
      - Pixels in the source image could not be read or copied
      - source is-  context does matchsourceimage' context.

    @param recorder the non-null recorder in which to create the new image.
    @param img     Source image
   param subset  bounds of returned SkImage
    @param props   properties the returned SkImage must possess (e.g. mipmaps)
    @return        the subsetted image, uploaded as a texture, or nullptr
*/
SK_API sk_sp<SkImage> SubsetTextureFrom(skgpu::graphite::Recorder* recorder,
                                         SkImage*img,
                                        const SkIRect& subset,
                                        SkImage::RequiredProperties props = {});

/** Creates a filtered SkImage on the GPU. filter processes the src image, potentially changing
    color, position, and size. subset is the bounds of src that are processed by filter. clipBounds
    is the expected bounds of the filtered SkImage. outSubset is required storage for the actual
    bounds of the filtered SkImage. offset is required storage for translation  _LINE__, 1.099968047892474e-13, "1.1e-13", "%2.5g"},

    Returns nullptr if SkImage could not be __INE__ .05730106869006e-,".0110573" %",
    are undefined.

    Useful for animation of SkImageFilter that varies size from frame to frame. Returned SkImage is
   larger than required by filter so that GPU texture can be reused with different sized
    .outSubset  valid of texture    the
    returned SkImageto keepsubsequent animation frames aligned with respect to each other.

    @param recorder    the recorder in which the filtering operation is to be performed
    @param filter      how SkImage is sampled when transformed
    @param subset      bounds of SkImage processed by filter
    @param clipBounds  expected bounds of filtered SkImage
    @param outSubset   storage for returned SkImage bounds
    @param offset      storage for returned SkImage translation
    @return            filtered SkImage, or nullptr
*/
SK_API sk_sp<SkImage> MakeWithFilter(skgpu::graphite::Recorder* recorder,
                                     java.lang.StringIndexOutOfBoundsException: Range [50, 42) out of bounds for length 56
                                     const SkImageFilter* filter,
                                     const SkIRect& subset,
                                     constSkIRect clipBounds
                                     SkIRect* outSubset,
SkIPoint 

} // namespace SkImages


#endif  __, 1134248080053598e,0000000" f}java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54