Updating the C API to match the C++ layer

diff --git a/include/c/sk_codec.h b/include/c/sk_codec.h
index fd73a2e..c34988f 100644 (file)
--- a/include/c/sk_codec.h
+++ b/include/c/sk_codec.h
@@ -26,7 +26,7 @@ SK_C_API void sk_codec_get_encodedinfo(sk_codec_t* codec, sk_encodedinfo_t* info
 SK_C_API sk_codec_origin_t sk_codec_get_origin(sk_codec_t* codec);
 SK_C_API void sk_codec_get_scaled_dimensions(sk_codec_t* codec, float desiredScale, sk_isize_t* dimensions);
 SK_C_API bool sk_codec_get_valid_subset(sk_codec_t* codec, sk_irect_t* desiredSubset);
-SK_C_API sk_encoded_format_t sk_codec_get_encoded_format(sk_codec_t* codec);
+SK_C_API sk_encoded_image_format_t sk_codec_get_encoded_format(sk_codec_t* codec);
 SK_C_API sk_codec_result_t sk_codec_get_pixels(sk_codec_t* codec, const sk_imageinfo_t* info, void* pixels, size_t rowBytes, const sk_codec_options_t* options, sk_pmcolor_t ctable[], int* ctableCount);
 SK_C_API sk_codec_result_t sk_codec_get_pixels_using_defaults(sk_codec_t* codec, const sk_imageinfo_t* info, void* pixels, size_t rowBytes);
 SK_C_API sk_codec_result_t sk_codec_start_incremental_decode(sk_codec_t* codec, const sk_imageinfo_t* info, void* pixels, size_t rowBytes, const sk_codec_options_t* options, sk_pmcolor_t ctable[], int* ctableCount);

diff --git a/include/c/sk_image.h b/include/c/sk_image.h
index a95b452..c630cf7 100644 (file)
--- a/include/c/sk_image.h
+++ b/include/c/sk_image.h
@@ -39,9 +39,8 @@ SK_C_API bool sk_image_read_pixels(const sk_image_t* image, const sk_imageinfo_t
 SK_C_API 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);
 SK_C_API 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);
 SK_C_API sk_data_t* sk_image_encode(const sk_image_t*);
-SK_C_API sk_data_t* sk_image_encode_specific(const sk_image_t* cimage, sk_image_encoder_type_t encoder, int quality);
+SK_C_API sk_data_t* sk_image_encode_specific(const sk_image_t* cimage, sk_encoded_image_format_t encoder, int quality);
 SK_C_API sk_image_t* sk_image_make_subset(const sk_image_t* cimage, const sk_irect_t* subset);
-SK_C_API sk_image_t* sk_image_make_texture_image(const sk_image_t* cimage, gr_context_t* context);
 SK_C_API sk_image_t* sk_image_make_non_texture_image(const sk_image_t* cimage);
 SK_C_API 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);
 

diff --git a/include/c/sk_maskfilter.h b/include/c/sk_maskfilter.h
index cd0ca4c..65eefec 100644 (file)
--- a/include/c/sk_maskfilter.h
+++ b/include/c/sk_maskfilter.h
@@ -36,21 +36,6 @@ SK_C_API void sk_maskfilter_unref(sk_maskfilter_t*);
 SK_C_API sk_maskfilter_t* sk_maskfilter_new_blur(sk_blurstyle_t, float sigma);
 SK_C_API sk_maskfilter_t* sk_maskfilter_new_blur_with_flags(sk_blurstyle_t, float sigma, const sk_rect_t* occluder, sk_blurmaskfilter_blurflags_t flags);
 
-
-/** Create an emboss maskfilter
-    @param blurSigma    standard deviation of the Gaussian blur to apply
-                        before applying lighting (e.g. 3)
-    @param direction    array of 3 scalars [x, y, z] specifying the direction of the light source
-    @param ambient      0...1 amount of ambient light
-    @param specular     coefficient for specular highlights (e.g. 8)
-    @return the emboss maskfilter
-*/
-SK_C_API sk_maskfilter_t* sk_maskfilter_new_emboss(
-    float blurSigma,
-    const float direction[3],
-    float ambient, 
-    float specular);
-
 SK_C_API sk_maskfilter_t* sk_maskfilter_new_table(
     const uint8_t table[256]);
 
@@ -61,8 +46,6 @@ SK_C_API sk_maskfilter_t* sk_maskfilter_new_clip(
     uint8_t min,
     uint8_t max);
 
-SK_C_API sk_maskfilter_t* sk_maskfilter_new_shadow(float occluderHeight, const sk_point3_t* lightPos, float lightRadius, float ambientAlpha, float spotAlpha, sk_shadowmaskfilter_shadowflags_t flags);
-
 SK_C_PLUS_PLUS_END_GUARD
 
 #endif

diff --git a/include/c/sk_stream.h b/include/c/sk_stream.h
index 82e58bd..ac43f49 100644 (file)
--- a/include/c/sk_stream.h
+++ b/include/c/sk_stream.h
@@ -57,14 +57,13 @@ SK_C_API sk_wstream_filestream_t* sk_filewstream_new(const char* path);
 SK_C_API void sk_filewstream_destroy(sk_wstream_filestream_t* cstream);
 
 SK_C_API sk_wstream_dynamicmemorystream_t* sk_dynamicmemorywstream_new(void);
-SK_C_API sk_data_t* sk_dynamicmemorywstream_copy_to_data(sk_wstream_dynamicmemorystream_t* cstream);
 SK_C_API sk_stream_asset_t* sk_dynamicmemorywstream_detach_as_stream(sk_wstream_dynamicmemorystream_t* cstream);
 SK_C_API void sk_dynamicmemorywstream_destroy(sk_wstream_dynamicmemorystream_t* cstream);
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SK_C_API bool sk_wstream_write(sk_wstream_t* cstream, const void* buffer, size_t size);
-SK_C_API void sk_wstream_newline(sk_wstream_t* cstream);
+SK_C_API bool sk_wstream_newline(sk_wstream_t* cstream);
 SK_C_API void sk_wstream_flush(sk_wstream_t* cstream);
 SK_C_API size_t sk_wstream_bytes_written(sk_wstream_t* cstream);
 SK_C_API bool sk_wstream_write_8(sk_wstream_t* cstream, uint8_t value);

diff --git a/include/c/sk_types.h b/include/c/sk_types.h
index 840a98a..6616e0b 100644 (file)
--- a/include/c/sk_types.h
+++ b/include/c/sk_types.h
@@ -393,18 +393,6 @@ typedef enum {
 } sk_displacement_map_effect_channel_selector_type_t;
 
 typedef enum {
-    UNKNOWN_SK_IMAGE_ENCODER_TYPE,
-    BMP_SK_IMAGE_ENCODER_TYPE,
-    GIF_SK_IMAGE_ENCODER_TYPE,
-    ICO_SK_IMAGE_ENCODER_TYPE,
-    JPEG_SK_IMAGE_ENCODER_TYPE,
-    PNG_SK_IMAGE_ENCODER_TYPE,
-    WBMP_SK_IMAGE_ENCODER_TYPE,
-    WEBP_SK_IMAGE_ENCODER_TYPE,
-    KTX_SK_IMAGE_ENCODER_TYPE,
-} sk_image_encoder_type_t;
-
-typedef enum {
     CLAMP_SK_MATRIX_CONVOLUTION_TILEMODE,
     REPEAT_SK_MATRIX_CONVOLUTION_TILEMODE,
     CLAMP_TO_BLACK_SK_MATRIX_CONVOLUTION_TILEMODE,
@@ -431,7 +419,6 @@ typedef enum {
  *  Enum describing format of encoded data.
  */
 typedef enum {
-    UNKNOWN_SK_ENCODED_FORMAT,
     BMP_SK_ENCODED_FORMAT,
     GIF_SK_ENCODED_FORMAT,
     ICO_SK_ENCODED_FORMAT,
@@ -443,7 +430,7 @@ typedef enum {
     KTX_SK_ENCODED_FORMAT,
     ASTC_SK_ENCODED_FORMAT,
     DNG_SK_ENCODED_FORMAT
-} sk_encoded_format_t;
+} sk_encoded_image_format_t;
 
 typedef enum {
     TOP_LEFT_SK_CODEC_ORIGIN     = 1, // Default
@@ -593,7 +580,7 @@ typedef enum {
 typedef enum {
     UNKNOWN_GR_PIXEL_CONFIG,
     ALPHA_8_GR_PIXEL_CONFIG,
-    INDEX_8_GR_PIXEL_CONFIG,
+    GRAY_8_GR_PIXEL_CONFIG,
     RGB_565_GR_PIXEL_CONFIG,
     RGBA_4444_GR_PIXEL_CONFIG,
     RGBA_8888_GR_PIXEL_CONFIG,
@@ -760,14 +747,6 @@ typedef struct {
 } sk_document_pdf_metadata_t;
 
 typedef enum {
-    NONE_SK_SHADOWMASKFILTER_SHADOWFLAGS = 0x00,
-    TRANSPARENT_OCCLUDER_SK_SHADOWMASKFILTER_SHADOWFLAGS = 0x01,
-    LARGER_UMBRA_SK_SHADOWMASKFILTER_SHADOWFLAGS = 0x02,
-    GAUSSIAN_EDGE_SK_SHADOWMASKFILTER_SHADOWFLAGS = 0x04,
-    ALL_SK_SHADOWMASKFILTER_SHADOWFLAGS = 0x07
-} sk_shadowmaskfilter_shadowflags_t;
-
-typedef enum {
     OPAQUE_SK_ENCODEDINFO_ALPHA,
     UNPREMUL_SK_ENCODEDINFO_ALPHA,
     BINARY_SK_ENCODEDINFO_ALPHA,
@@ -797,6 +776,7 @@ typedef struct {
 typedef struct {
     size_t fRequiredFrame;
     size_t fDuration;
+    bool fullyRecieved;
 } sk_codec_frameinfo_t;
 
 typedef struct sk_xmlstreamwriter_t sk_xmlstreamwriter_t;

diff --git a/src/c/sk_codec.cpp b/src/c/sk_codec.cpp
index c01dbb5..a9382f2 100644 (file)
--- a/src/c/sk_codec.cpp
+++ b/src/c/sk_codec.cpp
@@ -56,9 +56,9 @@ bool sk_codec_get_valid_subset(sk_codec_t* codec, sk_irect_t* desiredSubset)
     return AsCodec(codec)->getValidSubset(AsIRect(desiredSubset));
 }
 
-sk_encoded_format_t sk_codec_get_encoded_format(sk_codec_t* codec)
+sk_encoded_image_format_t sk_codec_get_encoded_format(sk_codec_t* codec)
 {
-    return (sk_encoded_format_t)AsCodec(codec)->getEncodedFormat();
+    return (sk_encoded_image_format_t)AsCodec(codec)->getEncodedFormat();
 }
 
 sk_codec_result_t sk_codec_get_pixels(sk_codec_t* codec, const sk_imageinfo_t* cinfo, void* pixels, size_t rowBytes, const sk_codec_options_t* coptions, sk_pmcolor_t ctable[], int* ctableCount)

diff --git a/src/c/sk_enums.cpp b/src/c/sk_enums.cpp
index 102087b..db7bda2 100644 (file)
--- a/src/c/sk_enums.cpp
+++ b/src/c/sk_enums.cpp
@@ -7,7 +7,6 @@
 
 #include "sk_types_priv.h"
 #include "SkMatrix44.h"
-#include "SkShadowMaskFilter.h"
 #include "SkBitmapScaler.h"
 #include "SkBlurMaskFilter.h"
 
@@ -106,17 +105,6 @@ static_assert ((int)SkMatrixConvolutionImageFilter::TileMode::kClamp_TileMode
 static_assert ((int)SkMatrixConvolutionImageFilter::TileMode::kRepeat_TileMode         == (int)REPEAT_SK_MATRIX_CONVOLUTION_TILEMODE,           ASSERT_MSG(SkMatrixConvolutionImageFilter::TileMode, sk_matrix_convolution_tilemode_t));
 static_assert ((int)SkMatrixConvolutionImageFilter::TileMode::kClampToBlack_TileMode   == (int)CLAMP_TO_BLACK_SK_MATRIX_CONVOLUTION_TILEMODE,   ASSERT_MSG(SkMatrixConvolutionImageFilter::TileMode, sk_matrix_convolution_tilemode_t));
 
-// sk_image_encoder_type_t
-static_assert ((int)SkImageEncoder::Type::kUnknown_Type   == (int)UNKNOWN_SK_IMAGE_ENCODER_TYPE,   ASSERT_MSG(SkImageEncoder::Type, sk_image_encoder_type_t));
-static_assert ((int)SkImageEncoder::Type::kBMP_Type       == (int)BMP_SK_IMAGE_ENCODER_TYPE,       ASSERT_MSG(SkImageEncoder::Type, sk_image_encoder_type_t));
-static_assert ((int)SkImageEncoder::Type::kGIF_Type       == (int)GIF_SK_IMAGE_ENCODER_TYPE,       ASSERT_MSG(SkImageEncoder::Type, sk_image_encoder_type_t));
-static_assert ((int)SkImageEncoder::Type::kICO_Type       == (int)ICO_SK_IMAGE_ENCODER_TYPE,       ASSERT_MSG(SkImageEncoder::Type, sk_image_encoder_type_t));
-static_assert ((int)SkImageEncoder::Type::kJPEG_Type      == (int)JPEG_SK_IMAGE_ENCODER_TYPE,      ASSERT_MSG(SkImageEncoder::Type, sk_image_encoder_type_t));
-static_assert ((int)SkImageEncoder::Type::kPNG_Type       == (int)PNG_SK_IMAGE_ENCODER_TYPE,       ASSERT_MSG(SkImageEncoder::Type, sk_image_encoder_type_t));
-static_assert ((int)SkImageEncoder::Type::kWBMP_Type      == (int)WBMP_SK_IMAGE_ENCODER_TYPE,      ASSERT_MSG(SkImageEncoder::Type, sk_image_encoder_type_t));
-static_assert ((int)SkImageEncoder::Type::kWEBP_Type      == (int)WEBP_SK_IMAGE_ENCODER_TYPE,      ASSERT_MSG(SkImageEncoder::Type, sk_image_encoder_type_t));
-static_assert ((int)SkImageEncoder::Type::kKTX_Type       == (int)KTX_SK_IMAGE_ENCODER_TYPE,       ASSERT_MSG(SkImageEncoder::Type, sk_image_encoder_type_t));
-
 // sk_blendmode_t
 static_assert ((int)SkBlendMode::kClear        == (int)CLEAR_SK_BLENDMODE,        ASSERT_MSG(SkBlendMode, sk_blendmode_t));
 static_assert ((int)SkBlendMode::kSrc          == (int)SRC_SK_BLENDMODE,          ASSERT_MSG(SkBlendMode, sk_blendmode_t));
@@ -208,22 +196,21 @@ static_assert ((int)SkRegion::Op::kReverseDifference_Op   == (int)REVERSE_DIFFER
 static_assert ((int)SkRegion::Op::kReplace_Op             == (int)REPLACE_SK_REGION_OP,              ASSERT_MSG(SkRegion::Op, sk_region_op_t));
 
 // sk_clipop_t
-static_assert ((int)SkClipOp::kDifference_SkClipOp   == (int)DIFFERENCE_SK_CLIPOP,           ASSERT_MSG(SkClipOp, sk_clipop_t));
-static_assert ((int)SkClipOp::kIntersect_SkClipOp    == (int)INTERSECT_SK_CLIPOP,            ASSERT_MSG(SkClipOp, sk_clipop_t));
-
-// sk_encoded_format_t
-static_assert ((int)SkEncodedFormat::kUnknown_SkEncodedFormat   == (int)UNKNOWN_SK_ENCODED_FORMAT,   ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t));
-static_assert ((int)SkEncodedFormat::kBMP_SkEncodedFormat       == (int)BMP_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t));
-static_assert ((int)SkEncodedFormat::kGIF_SkEncodedFormat       == (int)GIF_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t));
-static_assert ((int)SkEncodedFormat::kICO_SkEncodedFormat       == (int)ICO_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t));
-static_assert ((int)SkEncodedFormat::kJPEG_SkEncodedFormat      == (int)JPEG_SK_ENCODED_FORMAT,      ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t));
-static_assert ((int)SkEncodedFormat::kPNG_SkEncodedFormat       == (int)PNG_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t));
-static_assert ((int)SkEncodedFormat::kWBMP_SkEncodedFormat      == (int)WBMP_SK_ENCODED_FORMAT,      ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t));
-static_assert ((int)SkEncodedFormat::kWEBP_SkEncodedFormat      == (int)WEBP_SK_ENCODED_FORMAT,      ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t));
-static_assert ((int)SkEncodedFormat::kPKM_SkEncodedFormat       == (int)PKM_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t));
-static_assert ((int)SkEncodedFormat::kKTX_SkEncodedFormat       == (int)KTX_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t));
-static_assert ((int)SkEncodedFormat::kASTC_SkEncodedFormat      == (int)ASTC_SK_ENCODED_FORMAT,      ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t));
-static_assert ((int)SkEncodedFormat::kDNG_SkEncodedFormat       == (int)DNG_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedFormat, sk_encoded_format_t));
+static_assert ((int)SkClipOp::kDifference   == (int)DIFFERENCE_SK_CLIPOP,           ASSERT_MSG(SkClipOp, sk_clipop_t));
+static_assert ((int)SkClipOp::kIntersect    == (int)INTERSECT_SK_CLIPOP,            ASSERT_MSG(SkClipOp, sk_clipop_t));
+
+// sk_encoded_image_format_t
+static_assert ((int)SkEncodedImageFormat::kBMP       == (int)BMP_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedImageFormat, sk_encoded_image_format_t));
+static_assert ((int)SkEncodedImageFormat::kGIF       == (int)GIF_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedImageFormat, sk_encoded_image_format_t));
+static_assert ((int)SkEncodedImageFormat::kICO       == (int)ICO_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedImageFormat, sk_encoded_image_format_t));
+static_assert ((int)SkEncodedImageFormat::kJPEG      == (int)JPEG_SK_ENCODED_FORMAT,      ASSERT_MSG(SkEncodedImageFormat, sk_encoded_image_format_t));
+static_assert ((int)SkEncodedImageFormat::kPNG       == (int)PNG_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedImageFormat, sk_encoded_image_format_t));
+static_assert ((int)SkEncodedImageFormat::kWBMP      == (int)WBMP_SK_ENCODED_FORMAT,      ASSERT_MSG(SkEncodedImageFormat, sk_encoded_image_format_t));
+static_assert ((int)SkEncodedImageFormat::kWEBP      == (int)WEBP_SK_ENCODED_FORMAT,      ASSERT_MSG(SkEncodedImageFormat, sk_encoded_image_format_t));
+static_assert ((int)SkEncodedImageFormat::kPKM       == (int)PKM_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedImageFormat, sk_encoded_image_format_t));
+static_assert ((int)SkEncodedImageFormat::kKTX       == (int)KTX_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedImageFormat, sk_encoded_image_format_t));
+static_assert ((int)SkEncodedImageFormat::kASTC      == (int)ASTC_SK_ENCODED_FORMAT,      ASSERT_MSG(SkEncodedImageFormat, sk_encoded_image_format_t));
+static_assert ((int)SkEncodedImageFormat::kDNG       == (int)DNG_SK_ENCODED_FORMAT,       ASSERT_MSG(SkEncodedImageFormat, sk_encoded_image_format_t));
 
 // sk_codec_origin_t
 static_assert ((int)SkCodec::Origin::kTopLeft_Origin       == (int)TOP_LEFT_SK_CODEC_ORIGIN,       ASSERT_MSG(SkCodec::Origin, sk_codec_origin_t));
@@ -283,8 +270,8 @@ static_assert ((int)GrSurfaceOrigin::kTopLeft_GrSurfaceOrigin      == (int)TOP_L
 
 // gr_pixelconfig_t
 static_assert ((int)GrPixelConfig::kUnknown_GrPixelConfig          == (int)UNKNOWN_GR_PIXEL_CONFIG,          ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
-static_assert ((int)GrPixelConfig::kIndex_8_GrPixelConfig          == (int)INDEX_8_GR_PIXEL_CONFIG,          ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
 static_assert ((int)GrPixelConfig::kAlpha_8_GrPixelConfig          == (int)ALPHA_8_GR_PIXEL_CONFIG,          ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
+static_assert ((int)GrPixelConfig::kGray_8_GrPixelConfig           == (int)GRAY_8_GR_PIXEL_CONFIG,           ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
 static_assert ((int)GrPixelConfig::kRGB_565_GrPixelConfig          == (int)RGB_565_GR_PIXEL_CONFIG,          ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
 static_assert ((int)GrPixelConfig::kRGBA_4444_GrPixelConfig        == (int)RGBA_4444_GR_PIXEL_CONFIG,        ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
 static_assert ((int)GrPixelConfig::kRGBA_8888_GrPixelConfig        == (int)RGBA_8888_GR_PIXEL_CONFIG,        ASSERT_MSG(GrPixelConfig, gr_pixelconfig_t));
@@ -340,13 +327,6 @@ static_assert ((int)SkPathMeasure::MatrixFlags::kGetPosition_MatrixFlag    == (i
 static_assert ((int)SkPathMeasure::MatrixFlags::kGetTangent_MatrixFlag     == (int)GET_TANGENT_SK_PATHMEASURE_MATRIXFLAGS,       ASSERT_MSG(SkPathMeasure::MatrixFlags, sk_pathmeasure_matrixflags_t));
 static_assert ((int)SkPathMeasure::MatrixFlags::kGetPosAndTan_MatrixFlag   == (int)GET_POS_AND_TAN_SK_PATHMEASURE_MATRIXFLAGS,   ASSERT_MSG(SkPathMeasure::MatrixFlags, sk_pathmeasure_matrixflags_t));
 
-// sk_shadowmaskfilter_shadowflags_t
-static_assert ((int)SkShadowMaskFilter::ShadowFlags::kNone_ShadowFlag                  == (int)NONE_SK_SHADOWMASKFILTER_SHADOWFLAGS,                   ASSERT_MSG(SkShadowMaskFilter::ShadowFlags, sk_shadowmaskfilter_shadowflags_t));
-static_assert ((int)SkShadowMaskFilter::ShadowFlags::kTransparentOccluder_ShadowFlag   == (int)TRANSPARENT_OCCLUDER_SK_SHADOWMASKFILTER_SHADOWFLAGS,   ASSERT_MSG(SkShadowMaskFilter::ShadowFlags, sk_shadowmaskfilter_shadowflags_t));
-static_assert ((int)SkShadowMaskFilter::ShadowFlags::kLargerUmbra_ShadowFlag           == (int)LARGER_UMBRA_SK_SHADOWMASKFILTER_SHADOWFLAGS,           ASSERT_MSG(SkShadowMaskFilter::ShadowFlags, sk_shadowmaskfilter_shadowflags_t));
-static_assert ((int)SkShadowMaskFilter::ShadowFlags::kGaussianEdge_ShadowFlag          == (int)GAUSSIAN_EDGE_SK_SHADOWMASKFILTER_SHADOWFLAGS,          ASSERT_MSG(SkShadowMaskFilter::ShadowFlags, sk_shadowmaskfilter_shadowflags_t));
-static_assert ((int)SkShadowMaskFilter::ShadowFlags::kAll_ShadowFlag                   == (int)ALL_SK_SHADOWMASKFILTER_SHADOWFLAGS,                    ASSERT_MSG(SkShadowMaskFilter::ShadowFlags, sk_shadowmaskfilter_shadowflags_t));
-
 // sk_encodedinfo_alpha_t
 static_assert ((int)SkEncodedInfo::Alpha::kOpaque_Alpha     == (int)OPAQUE_SK_ENCODEDINFO_ALPHA,     ASSERT_MSG(SkEncodedInfo::Alpha, sk_encodedinfo_alpha_t));
 static_assert ((int)SkEncodedInfo::Alpha::kUnpremul_Alpha   == (int)UNPREMUL_SK_ENCODEDINFO_ALPHA,   ASSERT_MSG(SkEncodedInfo::Alpha, sk_encodedinfo_alpha_t));

diff --git a/src/c/sk_image.cpp b/src/c/sk_image.cpp
index 5781acb..18a7af8 100644 (file)
--- a/src/c/sk_image.cpp
+++ b/src/c/sk_image.cpp
@@ -128,18 +128,14 @@ sk_data_t* sk_image_encode(const sk_image_t* cimage) {
     return ToData(AsImage(cimage)->encode());
 }
 
-sk_data_t* sk_image_encode_specific(const sk_image_t* cimage, sk_image_encoder_type_t encoder, int quality) {
-    return ToData(AsImage(cimage)->encode((SkImageEncoder::Type)encoder, quality));
+sk_data_t* sk_image_encode_specific(const sk_image_t* cimage, sk_encoded_image_format_t encoder, int quality) {
+    return ToData(AsImage(cimage)->encode((SkEncodedImageFormat)encoder, quality));
 }
 
 sk_image_t* sk_image_make_subset(const sk_image_t* cimage, const sk_irect_t* subset) {
     return ToImage(AsImage(cimage)->makeSubset(AsIRect(*subset)).release());
 }
 
-sk_image_t* sk_image_make_texture_image(const sk_image_t* cimage, gr_context_t* context) {
-    return ToImage(AsImage(cimage)->makeTextureImage(AsGrContext(context)).release());
-}
-
 sk_image_t* sk_image_make_non_texture_image(const sk_image_t* cimage) {
     return ToImage(AsImage(cimage)->makeNonTextureImage().release());
 }

diff --git a/src/c/sk_maskfilter.cpp b/src/c/sk_maskfilter.cpp
index 4b9b714..dfc0de8 100644 (file)
--- a/src/c/sk_maskfilter.cpp
+++ b/src/c/sk_maskfilter.cpp
@@ -7,20 +7,11 @@
 
 #include "SkBlurMaskFilter.h"
 #include "SkTableMaskFilter.h"
-#include "SkShadowMaskFilter.h"
 
 #include "sk_maskfilter.h"
 
 #include "sk_types_priv.h"
 
-sk_maskfilter_t* sk_maskfilter_new_emboss(
-    float blurSigma, 
-    const float direction[3],
-    float ambient, 
-    float specular) {
-    return ToMaskFilter(SkBlurMaskFilter::MakeEmboss(blurSigma, direction, ambient, specular).release());
-}
-
 sk_maskfilter_t* sk_maskfilter_new_table(const uint8_t table[256]) {
     return ToMaskFilter(SkTableMaskFilter::Create(table));
 }
@@ -48,7 +39,3 @@ sk_maskfilter_t* sk_maskfilter_new_blur(sk_blurstyle_t cstyle, float sigma) {
 sk_maskfilter_t* sk_maskfilter_new_blur_with_flags(sk_blurstyle_t cstyle, float sigma, const sk_rect_t* occluder, sk_blurmaskfilter_blurflags_t flags) {
     return ToMaskFilter(SkBlurMaskFilter::Make((SkBlurStyle)cstyle, sigma, AsRect(*occluder), (SkBlurMaskFilter::BlurFlags)flags).release());
 }
-
-sk_maskfilter_t* sk_maskfilter_new_shadow(float occluderHeight, const sk_point3_t* lightPos, float lightRadius, float ambientAlpha, float spotAlpha, sk_shadowmaskfilter_shadowflags_t flags) {
-    return ToMaskFilter(SkShadowMaskFilter::Make(occluderHeight, AsPoint3(*lightPos), lightRadius, ambientAlpha, spotAlpha, (SkShadowMaskFilter::ShadowFlags)flags).release());
-}

diff --git a/src/c/sk_stream.cpp b/src/c/sk_stream.cpp
index aff6385..a76d177 100644 (file)
--- a/src/c/sk_stream.cpp
+++ b/src/c/sk_stream.cpp
@@ -150,11 +150,6 @@ sk_wstream_dynamicmemorystream_t* sk_dynamicmemorywstream_new()
     return ToDynamicMemoryWStream(new SkDynamicMemoryWStream());
 }
 
-sk_data_t* sk_dynamicmemorywstream_copy_to_data(sk_wstream_dynamicmemorystream_t* cstream)
-{
-    return ToData(AsDynamicMemoryWStream(cstream)->snapshotAsData().release());
-}
-
 sk_stream_asset_t* sk_dynamicmemorywstream_detach_as_stream(sk_wstream_dynamicmemorystream_t* cstream)
 {
     return ToStreamAsset(AsDynamicMemoryWStream(cstream)->detachAsStream());
@@ -165,7 +160,7 @@ bool sk_wstream_write(sk_wstream_t* cstream, const void* buffer, size_t size)
     return AsWStream(cstream)->write(buffer, size);
 }
 
-void sk_wstream_newline(sk_wstream_t* cstream)
+bool sk_wstream_newline(sk_wstream_t* cstream)
 {
     return AsWStream(cstream)->newline();
 }

diff --git a/src/c/sk_typeface.cpp b/src/c/sk_typeface.cpp
index 035ef05..680dadb 100644 (file)
--- a/src/c/sk_typeface.cpp
+++ b/src/c/sk_typeface.cpp
@@ -102,7 +102,7 @@ size_t sk_typeface_get_table_data(sk_typeface_t* typeface, sk_font_table_tag_t t
 
 sk_fontmgr_t* sk_fontmgr_ref_default()
 {
-    return ToFontMgr(SkFontMgr::RefDefault());
+    return ToFontMgr(SkFontMgr::RefDefault().release());
 }
 
 void sk_fontmgr_unref(sk_fontmgr_t* fontmgr)