feat: support raw pixels output

.github/workflows/CI.yaml

@@ -350,7 +350,7 @@ jobs:
               apt-get install -y nodejs && \
               npm install -g pnpm && \
               pnpm install --ignore-scripts && \
-              pnpm test && \
+              npm test && \
               ls -la
             "
 
@@ -391,7 +391,7 @@ jobs:
               apk add nodejs npm && \
               npm install -g pnpm && \
               pnpm install --ignore-scripts && \
-              pnpm test
+              npm test
             "
 
       - name: Test failed
@@ -437,7 +437,7 @@ jobs:
               apt-get install -y nodejs && \
               npm install -g pnpm && \
               pnpm install --ignore-scripts && \
-              pnpm test && \
+              npm test && \
               ls -la
             "
 

__test__/draw.spec.ts

@@ -804,3 +804,23 @@ test('webp-output', async (t) => {
   ctx.fillRect(0, 0, 80, 80)
   await snapshotImage(t, t.context, 'webp')
 })
+
+test('raw output', async (t) => {
+  const { ctx, canvas } = t.context
+  // Moved square
+  ctx.translate(110, 30)
+  ctx.fillStyle = 'red'
+  ctx.fillRect(0, 0, 80, 80)
+
+  // Reset current transformation matrix to the identity matrix
+  ctx.setTransform(1, 0, 0, 1, 0, 0)
+
+  // Unmoved square
+  ctx.fillStyle = 'gray'
+  ctx.fillRect(0, 0, 80, 80)
+
+  const output = canvas.data()
+  const pngFromCanvas = await canvas.encode('png')
+  const pngOutput = png.decoders['image/png'](pngFromCanvas)
+  t.deepEqual(output, pngOutput.data)
+})

__test__/image-snapshot.ts

@@ -11,7 +11,7 @@ const jpeg = JPEG()
 export async function snapshotImage<C>(
   t: ExecutionContext<C>,
   context = t.context,
-  type: 'png' | 'jpeg' | 'avif' | 'webp' | 'heif' = 'png',
+  type: 'png' | 'jpeg' | 'webp' = 'png',
   differentRatio = 0.01,
 ) {
   // @ts-expect-error

index.d.ts

@@ -277,7 +277,11 @@ export interface Canvas {
   width: number
   height: number
   getContext(contextType: '2d', contextAttributes?: { alpha: boolean }): SKRSContext2D
-  toBuffer(): Buffer
+  encodeSync(format: 'webp' | 'jpeg', quality: number): Buffer
+  encodeSync(format: 'png'): Buffer
+  toBuffer(mime: 'image/png' | 'image/jpeg' | 'image/webp'): Buffer
+  // raw pixels
+  data(): Buffer
   encode(format: 'webp' | 'jpeg', quality: number): Promise<Buffer>
   encode(format: 'png'): Promise<Buffer>
 }

src/ctx.rs

@@ -1938,7 +1938,7 @@ impl Task for ContextData {
           output.0.ptr,
           output.0.size,
           output,
-          |data_ref: Self::Output, _| data_ref.unref(),
+          |data_ref: Self::Output, _| mem::drop(data_ref),
         )
         .map(|value| value.into_raw())
     }

src/lib.rs

@@ -5,8 +5,10 @@
 #[macro_use]
 extern crate napi_derive;
 
-use napi::*;
 use std::convert::TryInto;
+use std::mem;
+
+use napi::*;
 
 use ctx::{Context, ContextData};
 use font::{init_font_regexp, FONT_REGEXP};
@@ -41,8 +43,10 @@ fn init(mut exports: JsObject, env: Env) -> Result<()> {
     &[
       Property::new(&env, "getContext")?.with_method(get_context),
       Property::new(&env, "encode")?.with_method(encode),
+      Property::new(&env, "encodeSync")?.with_method(encode_sync),
       Property::new(&env, "toBuffer")?.with_method(to_buffer),
       Property::new(&env, "savePNG")?.with_method(save_png),
+      Property::new(&env, "data")?.with_method(data),
     ],
   )?;
 
@@ -153,15 +157,101 @@ fn encode(ctx: CallContext) -> Result<JsObject> {
   ctx.env.spawn(task).map(|p| p.promise_object())
 }
 
-#[js_function]
+#[js_function(2)]
+fn encode_sync(ctx: CallContext) -> Result<JsBuffer> {
+  let format = ctx.get::<JsString>(0)?.into_utf8()?;
+  let quality = if ctx.length == 1 {
+    100
+  } else {
+    ctx.get::<JsNumber>(1)?.get_uint32()? as u8
+  };
+  let this = ctx.this_unchecked::<JsObject>();
+  let ctx_js = this.get_named_property::<JsObject>("ctx")?;
+  let ctx2d = ctx.env.unwrap::<Context>(&ctx_js)?;
+  let surface_ref = ctx2d.surface.reference();
+
+  if let Some(data_ref) = match format.as_str()? {
+    "webp" => surface_ref.encode_data(sk::SkEncodedImageFormat::Webp, quality),
+    "jpeg" => surface_ref.encode_data(sk::SkEncodedImageFormat::Jpeg, quality),
+    "png" => surface_ref.png_data(),
+    _ => {
+      return Err(Error::new(
+        Status::InvalidArg,
+        format!("{} is not valid format", format.as_str()?),
+      ))
+    }
+  } {
+    unsafe {
+      ctx
+        .env
+        .create_buffer_with_borrowed_data(
+          data_ref.0.ptr,
+          data_ref.0.size,
+          data_ref,
+          |data: SurfaceDataRef, _| mem::drop(data),
+        )
+        .map(|b| b.into_raw())
+    }
+  } else {
+    Err(Error::new(
+      Status::InvalidArg,
+      format!("encode {} output failed", format.as_str()?),
+    ))
+  }
+}
+
+#[js_function(2)]
 fn to_buffer(ctx: CallContext) -> Result<JsBuffer> {
+  let mime = ctx.get::<JsString>(0)?.into_utf8()?;
+  let quality = if ctx.length == 1 {
+    100
+  } else {
+    ctx.get::<JsNumber>(1)?.get_uint32()? as u8
+  };
+  let this = ctx.this_unchecked::<JsObject>();
+  let ctx_js = this.get_named_property::<JsObject>("ctx")?;
+  let ctx2d = ctx.env.unwrap::<Context>(&ctx_js)?;
+  let surface_ref = ctx2d.surface.reference();
+
+  if let Some(data_ref) = match mime.as_str()? {
+    "image/webp" => surface_ref.encode_data(sk::SkEncodedImageFormat::Webp, quality),
+    "image/jpeg" => surface_ref.encode_data(sk::SkEncodedImageFormat::Jpeg, quality),
+    "image/png" => surface_ref.png_data(),
+    _ => {
+      return Err(Error::new(
+        Status::InvalidArg,
+        format!("{} is not valid mime", mime.as_str()?),
+      ))
+    }
+  } {
+    unsafe {
+      ctx
+        .env
+        .create_buffer_with_borrowed_data(
+          data_ref.0.ptr,
+          data_ref.0.size,
+          data_ref,
+          |data: SurfaceDataRef, _| mem::drop(data),
+        )
+        .map(|b| b.into_raw())
+    }
+  } else {
+    Err(Error::new(
+      Status::InvalidArg,
+      format!("encode {} output failed", mime.as_str()?),
+    ))
+  }
+}
+
+#[js_function]
+fn data(ctx: CallContext) -> Result<JsBuffer> {
   let this = ctx.this_unchecked::<JsObject>();
   let ctx_js = this.get_named_property::<JsObject>("ctx")?;
   let ctx2d = ctx.env.unwrap::<Context>(&ctx_js)?;
 
   let surface_ref = ctx2d.surface.reference();
 
-  let data_ref = surface_ref.png_data().ok_or_else(|| {
+  let (ptr, size) = surface_ref.data().ok_or_else(|| {
     Error::new(
       Status::GenericFailure,
       "Get png data from surface failed".to_string(),
@@ -170,12 +260,7 @@ fn to_buffer(ctx: CallContext) -> Result<JsBuffer> {
   unsafe {
     ctx
       .env
-      .create_buffer_with_borrowed_data(
-        data_ref.0.ptr,
-        data_ref.0.size,
-        data_ref,
-        |data: SurfaceDataRef, _| data.unref(),
-      )
+      .create_buffer_with_borrowed_data(ptr, size, 0, noop_finalize)
       .map(|value| value.into_raw())
   }
 }

src/sk.rs

@@ -1263,6 +1263,7 @@ impl Surface {
     }
   }
 
+  #[inline]
   pub fn save_png(&self, path: &str) -> bool {
     let c_path = std::ffi::CString::new(path).unwrap();
     unsafe { ffi::skiac_surface_save(self.ptr, c_path.as_ptr()) }
@@ -1400,6 +1401,20 @@ impl SurfaceRef {
     }
   }
 
+  #[inline]
+  pub fn data(&self) -> Option<(*const u8, usize)> {
+    let mut data = ffi::skiac_surface_data {
+      ptr: ptr::null_mut(),
+      size: 0,
+    };
+    unsafe { ffi::skiac_surface_read_pixels(self.0, &mut data) };
+    if data.ptr.is_null() {
+      None
+    } else {
+      Some((data.ptr, data.size))
+    }
+  }
+
   #[inline]
   pub fn encode_data(&self, format: SkEncodedImageFormat, quality: u8) -> Option<SurfaceDataRef> {
     unsafe {
@@ -1455,8 +1470,10 @@ impl SurfaceDataRef {
   pub fn slice(&self) -> &'static [u8] {
     unsafe { slice::from_raw_parts(self.0.ptr, self.0.size) }
   }
+}
 
-  pub fn unref(self) {
+impl Drop for SurfaceDataRef {
+  fn drop(&mut self) {
     unsafe { ffi::skiac_sk_data_destroy(self.0.data) }
   }
 }