src/c/sk_image.cpp

   1 /*
   2  * Copyright 2014 Google Inc.
   3  * Copyright 2015 Xamarin Inc.
   4  * Copyright 2017 Microsoft Corporation. All rights reserved.
   5  *
   6  * Use of this source code is governed by a BSD-style license that can be
   7  * found in the LICENSE file.
   8  */
   9
  10 #include "SkImage.h"
  11 #include "SkImageEncoder.h"
  12
  13 #include "sk_image.h"
  14
  15 #include "sk_types_priv.h"
  16
  17 void sk_image_ref(const sk_image_t* cimage) {
  18     AsImage(cimage)->ref();
  19 }
  20
  21 void sk_image_unref(const sk_image_t* cimage) {
  22     SkSafeUnref(AsImage(cimage));
  23 }
  24
  25 sk_image_t* sk_image_new_raster_copy(const sk_imageinfo_t* cinfo, const void* pixels, size_t rowBytes) {
  26     return sk_image_new_raster_copy_with_colortable(cinfo, pixels, rowBytes, nullptr);
  27 }
  28
  29 sk_image_t* sk_image_new_raster_copy_with_pixmap(const sk_pixmap_t* pixmap) {
  30     auto image = SkImage::MakeRasterCopy(AsPixmap(*pixmap));
  31     return ToImage(image.release());
  32 }
  33
  34 sk_image_t* sk_image_new_raster_copy_with_colortable(const sk_imageinfo_t* cinfo, const void* pixels, size_t rowBytes, sk_colortable_t* ctable) {
  35     SkImageInfo info;
  36     from_c(*cinfo, &info);
  37     auto image = SkImage::MakeRasterCopy(SkPixmap(info, pixels, rowBytes, AsColorTable(ctable)));
  38     return ToImage(image.release());
  39 }
  40
  41 sk_image_t* sk_image_new_raster_data(const sk_imageinfo_t* cinfo, sk_data_t* pixels, size_t rowBytes) {
  42     SkImageInfo info;
  43     from_c(*cinfo, &info);
  44     return ToImage(SkImage::MakeRasterData(info, sk_ref_sp(AsData(pixels)), rowBytes).release());
  45 }
  46
  47 sk_image_t* sk_image_new_raster(const sk_pixmap_t* pixmap, sk_image_raster_release_proc releaseProc, void* context) {
  48     auto image = SkImage::MakeFromRaster(AsPixmap(*pixmap), releaseProc, context);
  49     return ToImage(image.release());
  50 }
  51
  52 sk_image_t* sk_image_new_from_bitmap(const sk_bitmap_t* cbitmap) {
  53     return ToImage(SkImage::MakeFromBitmap(*AsBitmap(cbitmap)).release());
  54 }
  55
  56 sk_image_t* sk_image_new_from_encoded(sk_data_t* cdata, const sk_irect_t* subset) {
  57     return ToImage(SkImage::MakeFromEncoded(sk_ref_sp(AsData(cdata)), AsIRect(subset)).release());
  58 }
  59
  60 sk_image_t* sk_image_new_from_texture(gr_context_t* context, const gr_backend_texture_desc_t* desc, sk_alphatype_t alpha, sk_colorspace_t* colorSpace, sk_image_texture_release_proc releaseProc, void* releaseContext) {
  61     return ToImage(SkImage::MakeFromTexture(AsGrContext(context), AsGrBackendTextureDesc(*desc), (SkAlphaType)alpha, sk_ref_sp(AsColorSpace(colorSpace)), releaseProc, releaseContext).release());
  62 }
  63
  64 sk_image_t* sk_image_new_from_adopted_texture(gr_context_t* context, const gr_backend_texture_desc_t* desc, sk_alphatype_t alpha, sk_colorspace_t* colorSpace) {
  65     return ToImage(SkImage::MakeFromAdoptedTexture(AsGrContext(context), AsGrBackendTextureDesc(*desc), (SkAlphaType)alpha, sk_ref_sp(AsColorSpace(colorSpace))).release());
  66 }
  67
  68 sk_image_t* sk_image_new_from_picture(sk_picture_t* picture, const sk_isize_t* dimensions, const sk_matrix_t* cmatrix, const sk_paint_t* paint) {
  69     SkMatrix matrix;
  70     if (cmatrix) {
  71         from_c(cmatrix, &matrix);
  72     }
  73     return ToImage(SkImage::MakeFromPicture(sk_ref_sp(AsPicture(picture)), AsISize(*dimensions), &matrix, AsPaint(paint), SkImage::BitDepth::kU8, SkColorSpace::MakeSRGB()).release());
  74 }
  75
  76 int sk_image_get_width(const sk_image_t* cimage) {
  77     return AsImage(cimage)->width();
  78 }
  79
  80 int sk_image_get_height(const sk_image_t* cimage) {
  81     return AsImage(cimage)->height();
  82 }
  83
  84 uint32_t sk_image_get_unique_id(const sk_image_t* cimage) {
  85     return AsImage(cimage)->uniqueID();
  86 }
  87
  88 sk_alphatype_t sk_image_get_alpha_type(const sk_image_t* image) {
  89     return (sk_alphatype_t) AsImage(image)->alphaType();
  90 }
  91
  92 bool sk_image_is_alpha_only(const sk_image_t* image) {
  93     return AsImage(image)->isAlphaOnly();
  94 }
  95
  96 sk_shader_t* sk_image_make_shader(const sk_image_t* image, sk_shader_tilemode_t tileX, sk_shader_tilemode_t tileY, const sk_matrix_t* cmatrix) {
  97     sk_sp<SkShader> shader;
  98     if (cmatrix) {
  99         SkMatrix matrix;
 100         from_c(cmatrix, &matrix);
 101         shader = AsImage(image)->makeShader((SkShader::TileMode)tileX, (SkShader::TileMode)tileY, &matrix);
 102     } else {
 103         shader = AsImage(image)->makeShader((SkShader::TileMode)tileX, (SkShader::TileMode)tileY, nullptr);
 104     }
 105     return ToShader(shader.release());
 106 }
 107
 108 bool sk_image_peek_pixels(const sk_image_t* image, sk_pixmap_t* pixmap) {
 109     return AsImage(image)->peekPixels(AsPixmap(pixmap));
 110 }
 111
 112 bool sk_image_is_texture_backed(const sk_image_t* image) {
 113     return AsImage(image)->isTextureBacked();
 114 }
 115
 116 bool sk_image_is_lazy_generated(const sk_image_t* image) {
 117     return AsImage(image)->isLazyGenerated();
 118 }
 119
 120 bool sk_image_read_pixels(const sk_image_t* image, const sk_imageinfo_t* dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY, sk_image_caching_hint_t cachingHint) {
 121     SkImageInfo info;
 122     from_c(*dstInfo, &info);
 123     return AsImage(image)->readPixels(info, dstPixels, dstRowBytes, srcX, srcY, (SkImage::CachingHint)cachingHint);
 124 }
 125
 126 bool sk_image_read_pixels_into_pixmap(const sk_image_t* image, const sk_pixmap_t* dst, int srcX, int srcY, sk_image_caching_hint_t cachingHint) {
 127     return AsImage(image)->readPixels(AsPixmap(*dst), srcX, srcY, (SkImage::CachingHint)cachingHint);
 128 }
 129
 130 bool sk_image_scale_pixels(const sk_image_t* image, const sk_pixmap_t* dst, sk_filter_quality_t quality, sk_image_caching_hint_t cachingHint) {
 131     return AsImage(image)->scalePixels(AsPixmap(*dst), (SkFilterQuality)quality, (SkImage::CachingHint)cachingHint);
 132 }
 133
 134 sk_data_t* sk_image_encode(const sk_image_t* cimage) {
 135     return ToData(AsImage(cimage)->encode());
 136 }
 137
 138 sk_data_t* sk_image_encode_with_serializer(const sk_image_t* cimage, sk_pixelserializer_t* serializer) {
 139     return ToData(AsImage(cimage)->encode(AsPixelSerializer(serializer)));
 140 }
 141
 142 sk_data_t* sk_image_encode_specific(const sk_image_t* cimage, sk_encoded_image_format_t encoder, int quality) {
 143     return ToData(AsImage(cimage)->encode((SkEncodedImageFormat)encoder, quality));
 144 }
 145
 146 sk_image_t* sk_image_make_subset(const sk_image_t* cimage, const sk_irect_t* subset) {
 147     return ToImage(AsImage(cimage)->makeSubset(AsIRect(*subset)).release());
 148 }
 149
 150 sk_image_t* sk_image_make_non_texture_image(const sk_image_t* cimage) {
 151     return ToImage(AsImage(cimage)->makeNonTextureImage().release());
 152 }
 153
 154 sk_image_t* sk_image_make_with_filter(const sk_image_t* cimage, const sk_imagefilter_t* filter, const sk_irect_t* subset, const sk_irect_t* clipBounds, sk_irect_t* outSubset, sk_ipoint_t* outOffset) {
 155     return ToImage(AsImage(cimage)->makeWithFilter(AsImageFilter(filter), AsIRect(*subset), AsIRect(*clipBounds), AsIRect(outSubset), AsIPoint(outOffset)).release());
 156 }