mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 08:02:59 +00:00
434 lines
13 KiB
Rust
434 lines
13 KiB
Rust
//! ImageData declarations, pixel snapshots, and clone helpers.
|
|
|
|
use crate::{embedding, interfaces as web_api_interfaces};
|
|
use moli_canvas::byte_len as rgba8_byte_len;
|
|
use moli_v8_util::{
|
|
callback_data_index_value, callback_data_item, get_private_value, global_constructor_object,
|
|
throw_type_error, v8_string,
|
|
};
|
|
use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};
|
|
use moli_webidl as webidl;
|
|
use std::str::FromStr;
|
|
use webidl::{SnapshotPrototype, WebIdlDictionarySerialize};
|
|
|
|
const IMAGE_DATA_WIDTH_SLOT: &str = "__moliImageDataWidth";
|
|
const IMAGE_DATA_HEIGHT_SLOT: &str = "__moliImageDataHeight";
|
|
const IMAGE_DATA_COLOR_SPACE_SLOT: &str = "__moliImageDataColorSpace";
|
|
const IMAGE_DATA_PIXEL_FORMAT_SLOT: &str = "__moliImageDataPixelFormat";
|
|
const IMAGE_DATA_DATA_SLOT: &str = "__moliImageDataData";
|
|
|
|
#[derive(WebApiObject)]
|
|
#[webapi(interface = web_api_interfaces::ImageData)]
|
|
struct ImageDataObjectDeclaration<'s> {
|
|
#[webapi(slot = IMAGE_DATA_WIDTH_SLOT)]
|
|
width: u32,
|
|
#[webapi(slot = IMAGE_DATA_HEIGHT_SLOT)]
|
|
height: u32,
|
|
#[webapi(slot = IMAGE_DATA_PIXEL_FORMAT_SLOT)]
|
|
pixel_format: &'static str,
|
|
#[webapi(slot = IMAGE_DATA_DATA_SLOT)]
|
|
data: v8::Local<'s, v8::Uint8ClampedArray>,
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(interface = web_api_interfaces::ImageData)]
|
|
struct ImageDataPrototypeDeclaration {
|
|
#[webapi(
|
|
accessor_property,
|
|
getter = image_data_getter_callback,
|
|
data = callback_data_index_value(scope, 0),
|
|
enumerable
|
|
)]
|
|
width: (),
|
|
#[webapi(
|
|
accessor_property,
|
|
getter = image_data_getter_callback,
|
|
data = callback_data_index_value(scope, 1),
|
|
enumerable
|
|
)]
|
|
height: (),
|
|
#[webapi(
|
|
accessor_property,
|
|
getter = image_data_getter_callback,
|
|
data = callback_data_index_value(scope, 2),
|
|
enumerable
|
|
)]
|
|
data: (),
|
|
#[webapi(
|
|
accessor_property,
|
|
getter = image_data_getter_callback,
|
|
data = callback_data_index_value(scope, 3),
|
|
enumerable
|
|
)]
|
|
color_space: (),
|
|
#[webapi(
|
|
accessor_property,
|
|
getter = image_data_getter_callback,
|
|
data = callback_data_index_value(scope, 4),
|
|
enumerable
|
|
)]
|
|
pixel_format: (),
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct ImageDataClonePayload {
|
|
pub width: u32,
|
|
pub height: u32,
|
|
pub color_space: String,
|
|
pub bytes: Vec<u8>,
|
|
}
|
|
|
|
#[derive(
|
|
Clone, Copy, Debug, Eq, PartialEq, strum::EnumString, strum::IntoStaticStr, webidl::WebIdlEnum,
|
|
)]
|
|
#[webidl(name = "PredefinedColorSpace", parse_with = Self::parse)]
|
|
#[strum(serialize_all = "lowercase")]
|
|
enum ImageDataColorSpace {
|
|
Srgb,
|
|
#[strum(serialize = "display-p3")]
|
|
DisplayP3,
|
|
}
|
|
|
|
impl ImageDataColorSpace {
|
|
fn parse(value: &str) -> Option<Self> {
|
|
Self::from_str(value).ok()
|
|
}
|
|
|
|
fn label(self) -> &'static str {
|
|
self.into()
|
|
}
|
|
}
|
|
|
|
#[derive(webidl::WebIdlDictionary)]
|
|
#[webidl(prefix = "ImageDataSettings", snapshot)]
|
|
struct ImageDataSettingsMembers {
|
|
#[webidl(converter = "enum", default = ImageDataColorSpace::Srgb)]
|
|
#[webidl(snapshot_slot = IMAGE_DATA_COLOR_SPACE_SLOT, snapshot_with = color_space_snapshot)]
|
|
color_space: ImageDataColorSpace,
|
|
}
|
|
|
|
fn color_space_snapshot<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
value: &ImageDataColorSpace,
|
|
_: SnapshotPrototype,
|
|
) -> Option<v8::Local<'s, v8::Value>> {
|
|
v8_string(scope, value.label()).map(Into::into)
|
|
}
|
|
|
|
pub fn image_data_constructor_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
args: v8::FunctionCallbackArguments<'s>,
|
|
mut rv: v8::ReturnValue<'_, v8::Value>,
|
|
) {
|
|
if !args.is_construct_call() {
|
|
throw_type_error(
|
|
scope,
|
|
"Failed to construct 'ImageData': Please use the 'new' operator.",
|
|
);
|
|
return;
|
|
}
|
|
|
|
let Some((data, width, height, color_space)) = image_data_constructor_parts(scope, &args)
|
|
else {
|
|
return;
|
|
};
|
|
|
|
color_space
|
|
.initialize_snapshot(scope, args.this())
|
|
.expect("ImageData settings");
|
|
ImageDataObjectDeclaration::new(width, height, "rgba-unorm8", data)
|
|
.initialize(scope, args.this())
|
|
.expect("ImageData declaration should initialize object");
|
|
rv.set(args.this().into());
|
|
}
|
|
|
|
pub fn install_image_data_template_bindings<'s>(
|
|
scope: &mut v8::PinScope<'s, '_, ()>,
|
|
template: v8::Local<'s, v8::FunctionTemplate>,
|
|
) {
|
|
let prototype = template.prototype_template(scope);
|
|
ImageDataPrototypeDeclaration::initialize_prototype_template(scope, prototype);
|
|
}
|
|
|
|
fn image_data_getter_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
args: v8::FunctionCallbackArguments<'s>,
|
|
mut rv: v8::ReturnValue<'_, v8::Value>,
|
|
) {
|
|
let Some(slot) = callback_data_item(
|
|
scope,
|
|
&args,
|
|
IMAGE_DATA_ATTRIBUTE_SLOTS,
|
|
"ImageData attribute slots",
|
|
) else {
|
|
rv.set_undefined();
|
|
return;
|
|
};
|
|
let value =
|
|
get_private_value(scope, args.this(), slot).unwrap_or_else(|| v8::undefined(scope).into());
|
|
rv.set(value);
|
|
}
|
|
|
|
fn image_data_constructor_parts<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
args: &v8::FunctionCallbackArguments<'s>,
|
|
) -> Option<(
|
|
v8::Local<'s, v8::Uint8ClampedArray>,
|
|
u32,
|
|
u32,
|
|
ImageDataSettingsMembers,
|
|
)> {
|
|
if let Ok(data) = v8::Local::<v8::Uint8ClampedArray>::try_from(args.get(0)) {
|
|
let width = image_data_dimension_arg(scope, args.get(1))?;
|
|
let height = if args.length() > 2 && !args.get(2).is_undefined() {
|
|
image_data_dimension_arg(scope, args.get(2))?
|
|
} else {
|
|
let pixels = data.byte_length() / 4;
|
|
if width == 0 || pixels % width as usize != 0 {
|
|
throw_image_data_index_size_error(scope);
|
|
return None;
|
|
}
|
|
(pixels / width as usize) as u32
|
|
};
|
|
let expected_len = image_data_expected_len(scope, width, height)?;
|
|
if data.byte_length() != expected_len {
|
|
throw_image_data_index_size_error(scope);
|
|
return None;
|
|
}
|
|
let color_space = image_data_color_space_arg(scope, args.get(3))?;
|
|
return Some((data, width, height, color_space));
|
|
}
|
|
|
|
let width = image_data_dimension_arg(scope, args.get(0))?;
|
|
let height = image_data_dimension_arg(scope, args.get(1))?;
|
|
let color_space = image_data_color_space_arg(scope, args.get(2))?;
|
|
let len = image_data_expected_len(scope, width, height)?;
|
|
let data = new_uint8_clamped_array_from_bytes(scope, vec![0; len])?;
|
|
Some((data, width, height, color_space))
|
|
}
|
|
|
|
fn image_data_dimension_arg(
|
|
scope: &mut v8::PinScope<'_, '_>,
|
|
value: v8::Local<'_, v8::Value>,
|
|
) -> Option<u32> {
|
|
let number = value.number_value(scope)?;
|
|
if !number.is_finite() || number <= 0.0 || number > i32::MAX as f64 {
|
|
throw_image_data_index_size_error(scope);
|
|
return None;
|
|
}
|
|
Some(number as u32)
|
|
}
|
|
|
|
fn image_data_color_space_arg<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
value: v8::Local<'s, v8::Value>,
|
|
) -> Option<ImageDataSettingsMembers> {
|
|
if webidl::is_nullish(value) {
|
|
return Some(ImageDataSettingsMembers {
|
|
color_space: ImageDataColorSpace::Srgb,
|
|
});
|
|
}
|
|
let object = match v8::Local::<v8::Object>::try_from(value) {
|
|
Ok(object) => object,
|
|
Err(_) => {
|
|
throw_type_error(
|
|
scope,
|
|
"Failed to construct 'ImageData': settings must be an object",
|
|
);
|
|
return None;
|
|
}
|
|
};
|
|
let color_space =
|
|
match webidl::parse_dictionary_object::<ImageDataSettingsMembers>(scope, object) {
|
|
Ok(value) => value,
|
|
Err(error) => {
|
|
throw_type_error(scope, &error.to_string());
|
|
return None;
|
|
}
|
|
};
|
|
Some(color_space)
|
|
}
|
|
|
|
const IMAGE_DATA_ATTRIBUTE_SLOTS: &[&str] = &[
|
|
IMAGE_DATA_WIDTH_SLOT,
|
|
IMAGE_DATA_HEIGHT_SLOT,
|
|
IMAGE_DATA_DATA_SLOT,
|
|
IMAGE_DATA_COLOR_SPACE_SLOT,
|
|
IMAGE_DATA_PIXEL_FORMAT_SLOT,
|
|
];
|
|
|
|
fn image_data_expected_len(
|
|
scope: &mut v8::PinScope<'_, '_>,
|
|
width: u32,
|
|
height: u32,
|
|
) -> Option<usize> {
|
|
rgba8_byte_len(width, height).or_else(|| {
|
|
throw_image_data_index_size_error(scope);
|
|
None
|
|
})
|
|
}
|
|
|
|
pub fn new_uint8_clamped_array_from_bytes<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
bytes: Vec<u8>,
|
|
) -> Option<v8::Local<'s, v8::Uint8ClampedArray>> {
|
|
let len = bytes.len();
|
|
let backing_store = v8::ArrayBuffer::new_backing_store_from_vec(bytes).make_shared();
|
|
let buffer = v8::ArrayBuffer::with_backing_store(scope, &backing_store);
|
|
v8::Uint8ClampedArray::new(scope, buffer, 0, len)
|
|
}
|
|
|
|
pub fn build_image_data_object<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
width: u32,
|
|
height: u32,
|
|
) -> Option<v8::Local<'s, v8::Object>> {
|
|
let ctor =
|
|
v8::Local::<v8::Function>::try_from(global_constructor_object(scope, "ImageData")?).ok()?;
|
|
let object = ctor.new_instance(
|
|
scope,
|
|
&[
|
|
v8::Integer::new(scope, width as i32).into(),
|
|
v8::Integer::new(scope, height as i32).into(),
|
|
],
|
|
)?;
|
|
Some(object)
|
|
}
|
|
|
|
pub fn build_image_data_object_with_bytes<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
width: u32,
|
|
height: u32,
|
|
bytes: Vec<u8>,
|
|
) -> Option<v8::Local<'s, v8::Object>> {
|
|
let data = new_uint8_clamped_array_from_bytes(scope, bytes)?;
|
|
let ctor =
|
|
v8::Local::<v8::Function>::try_from(global_constructor_object(scope, "ImageData")?).ok()?;
|
|
let object = ctor.new_instance(
|
|
scope,
|
|
&[
|
|
data.into(),
|
|
v8::Integer::new(scope, width as i32).into(),
|
|
v8::Integer::new(scope, height as i32).into(),
|
|
],
|
|
)?;
|
|
Some(object)
|
|
}
|
|
|
|
pub fn build_image_data_object_from_clone_payload<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
payload: ImageDataClonePayload,
|
|
) -> Option<v8::Local<'s, v8::Object>> {
|
|
let data = new_uint8_clamped_array_from_bytes(scope, payload.bytes)?;
|
|
let settings = ImageDataSettingsMembers {
|
|
color_space: ImageDataColorSpace::parse(&payload.color_space)?,
|
|
}
|
|
.to_js_snapshot(scope, SnapshotPrototype::Ordinary)?;
|
|
let ctor =
|
|
v8::Local::<v8::Function>::try_from(global_constructor_object(scope, "ImageData")?).ok()?;
|
|
ctor.new_instance(
|
|
scope,
|
|
&[
|
|
data.into(),
|
|
v8::Integer::new(scope, payload.width as i32).into(),
|
|
v8::Integer::new(scope, payload.height as i32).into(),
|
|
settings.into(),
|
|
],
|
|
)
|
|
}
|
|
|
|
pub fn image_data_clone_payload_from_object<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
object: v8::Local<'s, v8::Object>,
|
|
) -> Option<ImageDataClonePayload> {
|
|
let (width, height) = image_data_dimensions_from_object(scope, object)?;
|
|
let bytes = image_data_bytes_from_object(scope, object)?;
|
|
if bytes.len() != rgba8_byte_len(width, height)? {
|
|
return None;
|
|
}
|
|
let color_space =
|
|
image_data_string_from_object_slot(scope, object, IMAGE_DATA_COLOR_SPACE_SLOT)?;
|
|
Some(ImageDataClonePayload {
|
|
width,
|
|
height,
|
|
color_space,
|
|
bytes,
|
|
})
|
|
}
|
|
|
|
pub fn image_data_dimensions_from_object<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
object: v8::Local<'s, v8::Object>,
|
|
) -> Option<(u32, u32)> {
|
|
Some((
|
|
image_data_dimension_from_object_slot(scope, object, IMAGE_DATA_WIDTH_SLOT)?,
|
|
image_data_dimension_from_object_slot(scope, object, IMAGE_DATA_HEIGHT_SLOT)?,
|
|
))
|
|
}
|
|
|
|
fn image_data_dimension_from_object_slot<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
object: v8::Local<'s, v8::Object>,
|
|
slot: &'static str,
|
|
) -> Option<u32> {
|
|
let value = get_private_value(scope, object, slot)?.number_value(scope)?;
|
|
if !value.is_finite() || value <= 0.0 || value > u32::MAX as f64 {
|
|
return None;
|
|
}
|
|
Some(value as u32)
|
|
}
|
|
|
|
fn image_data_string_from_object_slot<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
object: v8::Local<'s, v8::Object>,
|
|
slot: &'static str,
|
|
) -> Option<String> {
|
|
get_private_value(scope, object, slot)
|
|
.and_then(|value| value.to_string(scope))
|
|
.map(|value| value.to_rust_string_lossy(scope))
|
|
}
|
|
|
|
pub fn image_data_bytes_from_object<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
object: v8::Local<'s, v8::Object>,
|
|
) -> Option<Vec<u8>> {
|
|
let view = get_private_value(scope, object, IMAGE_DATA_DATA_SLOT)
|
|
.and_then(|value| v8::Local::<v8::Uint8ClampedArray>::try_from(value).ok())?;
|
|
let mut bytes = vec![0; view.byte_length()];
|
|
let written = view.copy_contents(&mut bytes);
|
|
bytes.truncate(written);
|
|
Some(bytes)
|
|
}
|
|
|
|
fn throw_image_data_index_size_error(scope: &mut v8::PinScope<'_, '_>) {
|
|
embedding::throw_dom_exception_value(
|
|
scope,
|
|
"The source width is zero or not a finite integer.",
|
|
"IndexSizeError",
|
|
);
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod image_data_color_space_tests {
|
|
use super::ImageDataColorSpace;
|
|
|
|
#[test]
|
|
fn image_data_color_space_parses_supported_settings_token() {
|
|
assert_eq!(
|
|
ImageDataColorSpace::parse("srgb"),
|
|
Some(ImageDataColorSpace::Srgb)
|
|
);
|
|
assert_eq!(ImageDataColorSpace::parse("SRGB"), None);
|
|
assert_eq!(
|
|
ImageDataColorSpace::parse("display-p3"),
|
|
Some(ImageDataColorSpace::DisplayP3)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn image_data_color_space_label_uses_web_exposed_token() {
|
|
assert_eq!(ImageDataColorSpace::Srgb.label(), "srgb");
|
|
assert_eq!(ImageDataColorSpace::DisplayP3.label(), "display-p3");
|
|
}
|
|
}
|