Add additional APIs

include/c/gr_context.h

@@ -14,6 +14,9 @@
 
 SK_C_PLUS_PLUS_BEGIN_GUARD
 
+SK_C_API void gr_recording_context_unref(gr_recording_context_t* context);
+SK_C_API int gr_recording_context_get_max_surface_sample_count_for_color_type(gr_recording_context_t* context, sk_colortype_t colorType);
+SK_C_API gr_backend_t gr_recording_context_get_backend(gr_recording_context_t* context);
 
 // GrDirectContext
 
@@ -26,17 +29,16 @@ SK_C_API gr_direct_context_t* gr_direct_context_make_metal_with_options(void* de
 
 // TODO: the overloads with GrContextOptions
 
-SK_C_API void gr_direct_context_unref(gr_direct_context_t* context);
 SK_C_API bool gr_direct_context_is_abandoned(gr_direct_context_t* context);
 SK_C_API void gr_direct_context_abandon_context(gr_direct_context_t* context);
 SK_C_API void gr_direct_context_release_resources_and_abandon_context(gr_direct_context_t* context);
 SK_C_API size_t gr_direct_context_get_resource_cache_limit(gr_direct_context_t* context);
 SK_C_API void gr_direct_context_set_resource_cache_limit(gr_direct_context_t* context, size_t maxResourceBytes);
 SK_C_API void gr_direct_context_get_resource_cache_usage(gr_direct_context_t* context, int* maxResources, size_t* maxResourceBytes);
-SK_C_API int gr_direct_context_get_max_surface_sample_count_for_color_type(gr_direct_context_t* context, sk_colortype_t colorType);
 SK_C_API void gr_direct_context_flush(gr_direct_context_t* context);
+SK_C_API bool gr_direct_context_submit(gr_direct_context_t* context, bool syncCpu);
+SK_C_API void gr_direct_context_flush_and_submit(gr_direct_context_t* context, bool syncCpu);
 SK_C_API void gr_direct_context_reset_context(gr_direct_context_t* context, uint32_t state);
-SK_C_API gr_backend_t gr_direct_context_get_backend(gr_direct_context_t* context);
 SK_C_API void gr_direct_context_dump_memory_statistics(const gr_direct_context_t* context, sk_tracememorydump_t* dump);
 SK_C_API void gr_direct_context_free_gpu_resources(gr_direct_context_t* context);
 SK_C_API void gr_direct_context_perform_deferred_cleanup(gr_direct_context_t* context, long long ms);

include/c/sk_canvas.h

@@ -38,10 +38,12 @@ SK_C_API void sk_canvas_draw_image_rect(sk_canvas_t*, const sk_image_t*, const s
 SK_C_API void sk_canvas_draw_picture(sk_canvas_t*, const sk_picture_t*, const sk_matrix_t*, const sk_paint_t*);
 SK_C_API void sk_canvas_draw_drawable(sk_canvas_t*, sk_drawable_t*, const sk_matrix_t*);
 SK_C_API void sk_canvas_clear(sk_canvas_t*, sk_color_t);
+SK_C_API void sk_canvas_clear_color4f(sk_canvas_t*, sk_color4f_t);
 SK_C_API void sk_canvas_discard(sk_canvas_t*);
 SK_C_API int sk_canvas_get_save_count(sk_canvas_t*);
 SK_C_API void sk_canvas_restore_to_count(sk_canvas_t*, int saveCount);
 SK_C_API void sk_canvas_draw_color(sk_canvas_t* ccanvas, sk_color_t color, sk_blendmode_t mode);
+SK_C_API void sk_canvas_draw_color4f(sk_canvas_t* ccanvas, sk_color4f_t color, sk_blendmode_t mode);
 SK_C_API void sk_canvas_draw_points(sk_canvas_t*, sk_point_mode_t, size_t, const sk_point_t[], const sk_paint_t*);
 SK_C_API void sk_canvas_draw_point(sk_canvas_t*, float, float, const sk_paint_t*);
 SK_C_API void sk_canvas_draw_line(sk_canvas_t* ccanvas, float x0, float y0, float x1, float y1, sk_paint_t* cpaint);

include/c/sk_imagefilter.h

@@ -49,8 +49,8 @@ SK_C_API sk_imagefilter_t* sk_imagefilter_new_picture_with_croprect(sk_picture_t
 SK_C_API sk_imagefilter_t* sk_imagefilter_new_tile(const sk_rect_t* src, const sk_rect_t* dst, sk_imagefilter_t* input);
 SK_C_API sk_imagefilter_t* sk_imagefilter_new_xfermode(sk_blendmode_t mode, sk_imagefilter_t* background, sk_imagefilter_t* foreground, const sk_imagefilter_croprect_t* cropRect);
 
-SK_C_API sk_imagefilter_t* sk_imagefilter_new_dilate(int radiusX, int radiusY, sk_imagefilter_t* input, const sk_imagefilter_croprect_t* cropRect);
-SK_C_API sk_imagefilter_t* sk_imagefilter_new_erode(int radiusX, int radiusY, sk_imagefilter_t* input, const sk_imagefilter_croprect_t* cropRect);
+SK_C_API sk_imagefilter_t* sk_imagefilter_new_dilate(float radiusX, float radiusY, sk_imagefilter_t* input, const sk_imagefilter_croprect_t* cropRect);
+SK_C_API sk_imagefilter_t* sk_imagefilter_new_erode(float radiusX, float radiusY, sk_imagefilter_t* input, const sk_imagefilter_croprect_t* cropRect);
 
 SK_C_API sk_imagefilter_t* sk_imagefilter_new_distant_lit_diffuse(const sk_point3_t* direction, sk_color_t lightColor, float surfaceScale, float kd, sk_imagefilter_t* input, const sk_imagefilter_croprect_t* cropRect);
 SK_C_API sk_imagefilter_t* sk_imagefilter_new_point_lit_diffuse(const sk_point3_t* location, sk_color_t lightColor, float surfaceScale, float kd, sk_imagefilter_t* input, const sk_imagefilter_croprect_t* cropRect);

include/c/sk_pixmap.h

@@ -30,7 +30,7 @@ SK_C_API bool sk_pixmap_read_pixels(const sk_pixmap_t* cpixmap, const sk_imagein
 SK_C_API bool sk_pixmap_scale_pixels(const sk_pixmap_t* cpixmap, const sk_pixmap_t* dst, sk_filter_quality_t quality);
 SK_C_API bool sk_pixmap_extract_subset(const sk_pixmap_t* cpixmap, sk_pixmap_t* result, const sk_irect_t* subset);
 SK_C_API bool sk_pixmap_erase_color(const sk_pixmap_t* cpixmap, sk_color_t color, const sk_irect_t* subset);
-SK_C_API bool sk_pixmap_erase_color4f(const sk_pixmap_t* cpixmap, const sk_color4f_t* color, const sk_irect_t* subset);
+SK_C_API bool sk_pixmap_erase_color4f(const sk_pixmap_t* cpixmap, const sk_color4f_t* color, sk_colorspace_t* colorspace, const sk_irect_t* subset);
 
 SK_C_API sk_color_t sk_color_unpremultiply(const sk_pmcolor_t pmcolor);
 SK_C_API sk_pmcolor_t sk_color_premultiply(const sk_color_t color);

include/c/sk_surface.h

@@ -36,6 +36,8 @@ SK_C_API bool sk_surface_peek_pixels(sk_surface_t* surface, sk_pixmap_t* pixmap)
 SK_C_API bool sk_surface_read_pixels(sk_surface_t* surface, sk_imageinfo_t* dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY);
 SK_C_API const sk_surfaceprops_t* sk_surface_get_props(sk_surface_t* surface);
 SK_C_API void sk_surface_flush(sk_surface_t* surface);
+SK_C_API void sk_surface_flush_and_submit(sk_surface_t* surface, bool syncCpu);
+SK_C_API gr_recording_context_t* sk_surface_get_recording_context(sk_surface_t* surface);
 
 // surface props
 

src/c/gr_context.cpp

@@ -11,6 +11,21 @@
 
 #include "src/c/sk_types_priv.h"
 
+// GrRecordingContext
+
+void gr_recording_context_unref(gr_recording_context_t* context) {
+    SK_ONLY_GPU(SkSafeUnref(AsGrRecordingContext(context)));
+}
+
+int gr_recording_context_get_max_surface_sample_count_for_color_type(gr_recording_context_t* context, sk_colortype_t colorType) {
+    return SK_ONLY_GPU(AsGrRecordingContext(context)->maxSurfaceSampleCountForColorType((SkColorType)colorType), 0);
+}
+
+gr_backend_t gr_recording_context_get_backend(gr_recording_context_t* context) {
+    return SK_ONLY_GPU((gr_backend_t)AsGrRecordingContext(context)->backend(), (gr_backend_t)0);
+}
+
+
 // GrDirectContext
 
 gr_direct_context_t* gr_direct_context_make_gl(const gr_glinterface_t* glInterface) {
@@ -52,10 +67,6 @@ gr_direct_context_t* gr_direct_context_make_metal_with_options(void* device, voi
     return SK_ONLY_METAL(ToGrDirectContext(GrDirectContext::MakeMetal(device, queue, opts).release()), nullptr);
 }
 
-void gr_direct_context_unref(gr_direct_context_t* context) {
-    SK_ONLY_GPU(SkSafeUnref(AsGrDirectContext(context)));
-}
-
 bool gr_direct_context_is_abandoned(gr_direct_context_t* context) {
     return SK_ONLY_GPU(AsGrDirectContext(context)->abandoned(), true);
 }
@@ -80,20 +91,20 @@ void gr_direct_context_get_resource_cache_usage(gr_direct_context_t* context, in
     SK_ONLY_GPU(AsGrDirectContext(context)->getResourceCacheUsage(maxResources, maxResourceBytes));
 }
 
-int gr_direct_context_get_max_surface_sample_count_for_color_type(gr_direct_context_t* context, sk_colortype_t colorType) {
-    return SK_ONLY_GPU(AsGrDirectContext(context)->maxSurfaceSampleCountForColorType((SkColorType)colorType), 0);
-}
-
 void gr_direct_context_flush(gr_direct_context_t* context) {
     SK_ONLY_GPU(AsGrDirectContext(context)->flush());
 }
 
-void gr_direct_context_reset_context(gr_direct_context_t* context, uint32_t state) {
-    SK_ONLY_GPU(AsGrDirectContext(context)->resetContext(state));
+bool gr_direct_context_submit(gr_direct_context_t* context, bool syncCpu) {
+    return SK_ONLY_GPU(AsGrDirectContext(context)->submit(syncCpu), false);
 }
 
-gr_backend_t gr_direct_context_get_backend(gr_direct_context_t* context) {
-    return SK_ONLY_GPU((gr_backend_t)AsGrDirectContext(context)->backend(), (gr_backend_t)0);
+void gr_direct_context_flush_and_submit(gr_direct_context_t* context, bool syncCpu) {
+    SK_ONLY_GPU(AsGrDirectContext(context)->flushAndSubmit(syncCpu));
+}
+
+void gr_direct_context_reset_context(gr_direct_context_t* context, uint32_t state) {
+    SK_ONLY_GPU(AsGrDirectContext(context)->resetContext(state));
 }
 
 void gr_direct_context_dump_memory_statistics(const gr_direct_context_t* context, sk_tracememorydump_t* dump) {

src/c/sk_canvas.cpp

@@ -25,6 +25,10 @@ void sk_canvas_clear(sk_canvas_t* ccanvas, sk_color_t color) {
     AsCanvas(ccanvas)->clear(color);
 }
 
+void sk_canvas_clear_color4f(sk_canvas_t* ccanvas, sk_color4f_t color) {
+    AsCanvas(ccanvas)->clear(AsColor4f(color));
+}
+
 void sk_canvas_discard(sk_canvas_t* ccanvas) {
     AsCanvas(ccanvas)->discard();
 }
@@ -41,6 +45,10 @@ void sk_canvas_draw_color(sk_canvas_t* ccanvas, sk_color_t color, sk_blendmode_t
     AsCanvas(ccanvas)->drawColor(color, (SkBlendMode)cmode);
 }
 
+void sk_canvas_draw_color4f(sk_canvas_t* ccanvas, sk_color4f_t color, sk_blendmode_t cmode) {
+    AsCanvas(ccanvas)->drawColor(AsColor4f(color), (SkBlendMode)cmode);
+}
+
 void sk_canvas_draw_points(sk_canvas_t* ccanvas, sk_point_mode_t pointMode, size_t count, const sk_point_t points [], const sk_paint_t* cpaint) {
     AsCanvas(ccanvas)->drawPoints ((SkCanvas::PointMode)pointMode, count, AsPoint(points), *AsPaint(cpaint));
 }

src/c/sk_enums.cpp

@@ -15,6 +15,7 @@
 #include "include/core/SkPathMeasure.h"
 #include "include/core/SkRegion.h"
 #include "include/core/SkShader.h"
+#include "include/core/SkSurface.h"
 #include "include/core/SkTypeface.h"
 #include "include/core/SkVertices.h"
 #include "include/effects/Sk1DPathEffect.h"

src/c/sk_imagefilter.cpp

@@ -151,11 +151,11 @@ sk_imagefilter_t* sk_imagefilter_new_xfermode(sk_blendmode_t cmode, sk_imagefilt
 }
 
 
-sk_imagefilter_t* sk_imagefilter_new_dilate(int radiusX, int radiusY, sk_imagefilter_t* input, const sk_imagefilter_croprect_t* cropRect) {
+sk_imagefilter_t* sk_imagefilter_new_dilate(float radiusX, float radiusY, sk_imagefilter_t* input, const sk_imagefilter_croprect_t* cropRect) {
     return ToImageFilter(SkDilateImageFilter::Make(radiusX, radiusY, sk_ref_sp(AsImageFilter(input)), AsImageFilterCropRect(cropRect)).release());
 }
 
-sk_imagefilter_t* sk_imagefilter_new_erode(int radiusX, int radiusY, sk_imagefilter_t* input, const sk_imagefilter_croprect_t* cropRect) {
+sk_imagefilter_t* sk_imagefilter_new_erode(float radiusX, float radiusY, sk_imagefilter_t* input, const sk_imagefilter_croprect_t* cropRect) {
     return ToImageFilter(SkErodeImageFilter::Make(radiusX, radiusY, sk_ref_sp(AsImageFilter(input)), AsImageFilterCropRect(cropRect)).release());
 }
 

src/c/sk_pixmap.cpp

@@ -72,8 +72,8 @@ bool sk_pixmap_erase_color(const sk_pixmap_t* cpixmap, sk_color_t color, const s
     return AsPixmap(cpixmap)->erase((SkColor)color, *AsIRect(subset));
 }
 
-bool sk_pixmap_erase_color4f(const sk_pixmap_t* cpixmap, const sk_color4f_t* color, const sk_irect_t* subset) {
-    return AsPixmap(cpixmap)->erase(*AsColor4f(color), AsIRect(subset));
+bool sk_pixmap_erase_color4f(const sk_pixmap_t* cpixmap, const sk_color4f_t* color, sk_colorspace_t* colorspace, const sk_irect_t* subset) {
+    return AsPixmap(cpixmap)->erase(*AsColor4f(color), AsColorSpace(colorspace), AsIRect(subset));
 }
 
 sk_color_t sk_color_unpremultiply(const sk_pmcolor_t pmcolor) {

src/c/sk_surface.cpp

@@ -97,6 +97,14 @@ void sk_surface_flush(sk_surface_t* surface) {
     AsSurface(surface)->flush();
 }
 
+void sk_surface_flush_and_submit(sk_surface_t* surface, bool syncCpu) {
+    AsSurface(surface)->flushAndSubmit(syncCpu);
+}
+
+gr_recording_context_t* sk_surface_get_recording_context(sk_surface_t* surface) {
+    return ToGrRecordingContext(AsSurface(surface)->recordingContext());
+}
+
 // surface props
 
 sk_surfaceprops_t* sk_surfaceprops_new(uint32_t flags, sk_pixelgeometry_t geometry) {

src/xamarin/SkiaKeeper.c

@@ -58,7 +58,7 @@ void** KeepSkiaCSymbols (void)
     static void* ret[] = {
         // Skia
         (void*)sk_colortype_get_default_8888,
-        (void*)gr_direct_context_unref,
+        (void*)gr_recording_context_unref,
         (void*)gr_glinterface_create_native_interface,
         (void*)sk_bitmap_new,
         (void*)sk_canvas_destroy,