dymokomi/luce-browser-render
Source of release 0.6.2
0.6.2 / src / gfx / bitmap.lucb
#==============================================================================================
#
# bitmap - Bitmap: a 32-bit pixel buffer in one of four channel orders
#
# DESCRIPTION:
# Port of Libraries/LibGfx/Bitmap.cpp (lines 1-370) with the inline members of
# Libraries/LibGfx/Bitmap.h (lines 1-270). The struct is in types_bitmap.
#
# Memory (DESIGN.md §3.3): a Bitmap is a managed allocation and its pixels are atomic
# storage (ak.kmalloc_atomic), so no destructor frees them: the C++ destructor's
# kfree(data) callback and ~Bitmap are not ported, and `m_destruction_callback` is only
# kept for wrappers, where the C++ destructor would run it (the port never does).
#
# Core::AnonymousBuffer is region r08's (anonymous_buffer.lucb: zeroed managed memory,
# no file descriptor). PAGE_SIZE is 4096 here (sysconf(_SC_PAGESIZE) in the donor on
# POSIX); it only rounds the size of a shareable bitmap's buffer.
#
# Replaced: Skia. scaled() draws through the raster module (raster_utils), and
# set_alpha_type_destructive (un)premultiplies as Skia's SkConvertPixels does, the
# donor's non-macOS path (the macOS build uses vImage instead).
#
#==============================================================================================
# AK/Platform.h PAGE_SIZE (see the header).
let page_size: usize = 4096
# mark: BitmapFormat ===========================================================================
## Ported from Libraries/LibGfx/Bitmap.cpp:34 Gfx::bitmap_format_name.
pub func bitmap_format_name(format_: BitmapFormat) -> ak.StringView:
match format_:
.invalid: return ak.sv("Invalid")
.bg_rx8888: return ak.sv("BGRx8888")
.bgra8888: return ak.sv("BGRA8888")
.rg_bx8888: return ak.sv("RGBx8888")
.rgba8888: return ak.sv("RGBA8888")
_: trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibGfx/Bitmap.h:38 Gfx::is_valid_bitmap_format.
pub func is_valid_bitmap_format(format_: u32) -> bool:
match format_:
0, 1, 2, 3, 4: return true # Invalid, BGRx8888, BGRA8888, RGBx8888, RGBA8888
_: return false
## Ported from Libraries/LibGfx/Bitmap.cpp:46 Gfx::Bitmap::minimum_pitch.
pub func bitmap_minimum_pitch(width: usize, format_: BitmapFormat) -> usize:
var element_size: usize
match format_:
.bg_rx8888, .bgra8888, .rg_bx8888, .rgba8888:
element_size = 4
_: trap("VERIFY_NOT_REACHED")
return width * element_size
## Ported from Libraries/LibGfx/Bitmap.cpp:63 Gfx::size_would_overflow.
func size_would_overflow(format_: BitmapFormat, size: IntSize) -> bool:
if int_size_width(&size) < 0 or int_size_height(&size) < 0:
return true
# This check is a bit arbitrary, but should protect us from most shenanigans:
if int_size_width(&size) >= 32767 or int_size_height(&size) >= 32767: # INT16_MAX
return true
# In contrast, this check is absolutely necessary:
let pitch = bitmap_minimum_pitch((usize)int_size_width(&size), format_)
return (pitch *? (usize)int_size_height(&size)) == none # Checked<size_t>::multiplication_would_overflow
# mark: Creation ===============================================================================
## Ported from Libraries/LibGfx/Bitmap.cpp:75 Gfx::Bitmap::create.
pub func bitmap_create_int_size(format_: BitmapFormat, size: IntSize) -> Bitmap*!:
# For backwards compatibility, premultiplied alpha is assumed
return try bitmap_create_alpha_type(format_, AlphaType.premultiplied, size)
## Ported from Libraries/LibGfx/Bitmap.cpp:81 Gfx::Bitmap::create.
pub func bitmap_create_alpha_type(format_: BitmapFormat, alpha_type: AlphaType, size: IntSize) -> Bitmap*!:
let backing_store = try bitmap_allocate_backing_store(format_, size)
let this = try new Bitmap
bitmap_construct_int_size_backing_store(this, format_, alpha_type, size, backing_store)
return this
## Ported from Libraries/LibGfx/Bitmap.cpp:87 Gfx::Bitmap::create_shareable.
pub func bitmap_create_shareable(format_: BitmapFormat, alpha_type: AlphaType, size: IntSize) -> Bitmap*!:
if size_would_overflow(format_, size):
error(ak.ak_error, "Gfx::Bitmap::create_shareable size overflow")
let pitch = bitmap_minimum_pitch((usize)int_size_width(&size), format_)
let data_size = bitmap_size_in_bytes_usize(pitch, int_size_height(&size))
let buffer = try core_anonymous_buffer_create_with_size(ak.round_up_to_power_of_two_usize(data_size, page_size))
let bitmap = try bitmap_create_with_anonymous_buffer(format_, alpha_type, buffer, size)
return bitmap
## Ported from Libraries/LibGfx/Bitmap.cpp:100 Gfx::Bitmap::Bitmap.
pub func bitmap_construct_int_size_backing_store(this: Bitmap*, format_: BitmapFormat, alpha_type: AlphaType, size: IntSize, backing_store: BackingStore):
this.m_size = size
this.m_data = backing_store.data
this.m_pitch = backing_store.pitch
this.m_format = format_
this.m_alpha_type = alpha_type
assert(not int_size_is_empty(&this.m_size))
assert(not size_would_overflow(format_, size))
assert(this.m_data != none)
assert(backing_store.size_in_bytes == bitmap_size_in_bytes(this))
# m_destruction_callback = [data] { kfree(data); }: the pixels are managed (see the header).
## Ported from Libraries/LibGfx/Bitmap.cpp:116 Gfx::Bitmap::create_wrapper.
pub func bitmap_create_wrapper(format_: BitmapFormat, alpha_type: AlphaType, size: IntSize, pitch: usize, data: void*?, destruction_callback: ak.Function0[unit]) -> Bitmap*!:
if size_would_overflow(format_, size):
error(ak.ak_error, "Gfx::Bitmap::create_wrapper size overflow")
let this = new Bitmap else trap("out of memory")
bitmap_construct_int_size_usize(this, format_, alpha_type, size, pitch, data, destruction_callback)
return this
## Ported from Libraries/LibGfx/Bitmap.cpp:123 Gfx::Bitmap::Bitmap.
pub func bitmap_construct_int_size_usize(this: Bitmap*, format_: BitmapFormat, alpha_type: AlphaType, size: IntSize, pitch: usize, data: void*?, destruction_callback: ak.Function0[unit]):
this.m_size = size
this.m_data = data
this.m_pitch = pitch
this.m_format = format_
this.m_alpha_type = alpha_type
this.m_destruction_callback = destruction_callback
assert(pitch >= bitmap_minimum_pitch((usize)int_size_width(&size), format_))
assert(not size_would_overflow(format_, size))
# FIXME: assert that `data` is actually long enough!
## Ported from Libraries/LibGfx/Bitmap.cpp:136 Gfx::Bitmap::create_with_anonymous_buffer.
pub func bitmap_create_with_anonymous_buffer(format_: BitmapFormat, alpha_type: AlphaType, buffer: CoreAnonymousBuffer, size: IntSize) -> Bitmap*!:
if size_would_overflow(format_, size):
error(ak.ak_error, "Gfx::Bitmap::create_with_anonymous_buffer size overflow")
let this = try new Bitmap
bitmap_construct_core_anonymous_buffer(this, format_, alpha_type, buffer, size)
return this
## Ported from Libraries/LibGfx/Bitmap.cpp:144 Gfx::Bitmap::create_with_raw_data.
pub func bitmap_create_with_raw_data(format_: BitmapFormat, alpha_type: AlphaType, raw_data: const u8[], size: IntSize) -> Bitmap*!:
if size_would_overflow(format_, size):
error(ak.ak_error, "Gfx::Bitmap::create_with_raw_data size overflow")
let backing_store = try bitmap_allocate_backing_store(format_, size, BitmapInitializeBackingStore.no)
# raw_data.copy_to(Bytes { backing_store.data, backing_store.size_in_bytes })
let target = u8[]((u8*)(backing_store.data else trap("VERIFY: backing store")), backing_store.size_in_bytes)
assert(target.length >= raw_data.length)
memory.copy(target, raw_data, raw_data.length)
let this = try new Bitmap
bitmap_construct_int_size_backing_store(this, format_, alpha_type, size, backing_store)
return this
## Ported from Libraries/LibGfx/Bitmap.cpp:154 Gfx::Bitmap::Bitmap.
pub func bitmap_construct_core_anonymous_buffer(this: Bitmap*, format_: BitmapFormat, alpha_type: AlphaType, buffer: CoreAnonymousBuffer, size: IntSize):
this.m_size = size
this.m_data = core_anonymous_buffer_data(&buffer)
this.m_pitch = bitmap_minimum_pitch((usize)int_size_width(&size), format_)
this.m_format = format_
this.m_alpha_type = alpha_type
this.m_buffer = buffer
assert(not size_would_overflow(format_, size))
# mark: Copies =================================================================================
## Ported from Libraries/LibGfx/Bitmap.cpp:165 Gfx::Bitmap::clone.
pub func bitmap_clone(this: const Bitmap*) -> Bitmap*!:
let new_bitmap = try bitmap_create_alpha_type(bitmap_format(this), bitmap_alpha_type(this), bitmap_size(this))
assert(bitmap_size_in_bytes(this) == bitmap_size_in_bytes(new_bitmap))
let count = bitmap_size_in_bytes(this)
memory.copy(u8[]((u8*)(bitmap_scanline(new_bitmap, 0) else trap("VERIFY")), count), u8[]((u8*)(bitmap_scanline_const(this, 0) else trap("VERIFY")), count), count)
return new_bitmap
## Ported from Libraries/LibGfx/Bitmap.cpp:175 Gfx::Bitmap::cropped.
pub func bitmap_cropped(this: const Bitmap*, crop: DevicePixelRect, outside_color: Color) -> Bitmap*!:
# OPTIMIZATION: Skip slow manual copying for NO-OP crops
if crop == bitmap_rect(this):
return try bitmap_clone(this)
let crop_width = device_pixel_rect_width(&crop)
let crop_height = device_pixel_rect_height(&crop)
let new_bitmap = try bitmap_create_alpha_type(bitmap_format(this), bitmap_alpha_type(this), IntSize(m_width = crop_width, m_height = crop_height))
for y in 0..<crop_height:
for x in 0..<crop_width:
let global_x = x + device_pixel_rect_left(&crop)
let global_y = y + device_pixel_rect_top(&crop)
if global_x >= bitmap_width(this) or global_y >= bitmap_height(this) or global_x < 0 or global_y < 0:
bitmap_set_pixel(new_bitmap, x, y, outside_color)
else:
bitmap_set_pixel(new_bitmap, x, y, bitmap_get_pixel(this, global_x, global_y))
return new_bitmap
## Ported from Libraries/LibGfx/Bitmap.cpp:197 Gfx::Bitmap::scaled.
## Replaced: SkImage::scalePixels becomes a raster draw of the pixels (raster_utils).
pub func bitmap_scaled(this: const Bitmap*, width: i32, height: i32, scaling_mode: ScalingMode) -> Bitmap*!:
let scaled_bitmap = try bitmap_create_alpha_type(bitmap_format(this), bitmap_alpha_type(this), IntSize(m_width = width, m_height = height))
if not raster_scale_pixels(this, scaled_bitmap, scaling_mode):
error(ak.ak_error, "Unable to scale pixels for bitmap")
return scaled_bitmap
## Ported from Libraries/LibGfx/Bitmap.cpp:215 Gfx::Bitmap::to_bitmap_backed_by_anonymous_buffer.
pub func bitmap_to_bitmap_backed_by_anonymous_buffer(this: const Bitmap*) -> Bitmap*!:
if core_anonymous_buffer_is_valid(&this.m_buffer):
# FIXME: The const_cast here is awkward.
return (Bitmap*)this
let buffer = try core_anonymous_buffer_create_with_size(ak.round_up_to_power_of_two_usize(bitmap_size_in_bytes(this), page_size))
let bitmap = try bitmap_create_with_anonymous_buffer(bitmap_format(this), bitmap_alpha_type(this), buffer, bitmap_size(this))
let count = bitmap_size_in_bytes(this)
memory.copy(u8[]((u8*)(bitmap_scanline(bitmap, 0) else trap("VERIFY")), count), u8[]((u8*)(bitmap_scanline_const(this, 0) else trap("VERIFY")), count), count)
return bitmap
## Ported from Libraries/LibGfx/Bitmap.cpp:234 Gfx::Bitmap::strip_alpha_channel.
pub func bitmap_strip_alpha_channel(this: Bitmap*):
assert(this.m_format == BitmapFormat.bgra8888 or this.m_format == BitmapFormat.bg_rx8888)
let pixels = bitmap_pixels(this)
for i in 0..<pixels.length:
pixels[i] = 0xff000000 | (pixels[i] & 0xffffff)
this.m_format = BitmapFormat.bg_rx8888
## Ported from Libraries/LibGfx/Bitmap.cpp:242 Gfx::Bitmap::to_shareable_bitmap.
pub func bitmap_to_shareable_bitmap(this: const Bitmap*) -> ShareableBitmap:
let bitmap = bitmap_to_bitmap_backed_by_anonymous_buffer(this) catch:
var invalid: ShareableBitmap
shareable_bitmap_construct(&invalid)
return invalid
var shareable: ShareableBitmap
shareable_bitmap_construct_bitmap(&shareable, bitmap, ShareableBitmapTag.construct_with_known_good_bitmap)
return shareable
## Ported from Libraries/LibGfx/Bitmap.cpp:250 Gfx::Bitmap::allocate_backing_store.
pub func bitmap_allocate_backing_store(format_: BitmapFormat, size: IntSize, initialize_backing_store: BitmapInitializeBackingStore = BitmapInitializeBackingStore.yes) -> BackingStore!:
if int_size_is_empty(&size):
error(ak.ak_error, "Gfx::Bitmap backing store size is empty")
if size_would_overflow(format_, size):
error(ak.ak_error, "Gfx::Bitmap backing store size overflow")
let pitch = bitmap_minimum_pitch((usize)int_size_width(&size), format_)
let data_size_in_bytes = bitmap_size_in_bytes_usize(pitch, int_size_height(&size))
# kcalloc / kmalloc: pixels are atomic storage (DESIGN.md §3.3 rule 5).
let data = ak.kmalloc_atomic(data_size_in_bytes) else error(ak.ak_errno_error, "ENOMEM")
if initialize_backing_store == BitmapInitializeBackingStore.yes:
memory.set(u8[]((u8*)data, data_size_in_bytes), 0)
return BackingStore(data = data, pitch = pitch, size_in_bytes = data_size_in_bytes)
# mark: Scanlines ==============================================================================
## Ported from Libraries/LibGfx/Bitmap.h:160 Gfx::Bitmap::unchecked_scanline_u8.
pub func bitmap_unchecked_scanline_u8(this: Bitmap*, y: i32) -> u8*?:
let data = this.m_data else return none
return (u8*)data + (usize)y * this.m_pitch
## Ported from Libraries/LibGfx/Bitmap.h:165 Gfx::Bitmap::unchecked_scanline_u8.
pub func bitmap_unchecked_scanline_u8_const(this: const Bitmap*, y: i32) -> const u8*?:
let data = this.m_data else return none
return (const u8*)data + (usize)y * this.m_pitch
## Ported from Libraries/LibGfx/Bitmap.h:170 Gfx::Bitmap::unchecked_scanline.
pub func bitmap_unchecked_scanline(this: Bitmap*, y: i32) -> u32*?:
return (u32*?)bitmap_unchecked_scanline_u8(this, y)
## Ported from Libraries/LibGfx/Bitmap.h:175 Gfx::Bitmap::unchecked_scanline.
pub func bitmap_unchecked_scanline_const(this: const Bitmap*, y: i32) -> const u32*?:
return (const u32*?)bitmap_unchecked_scanline_u8_const(this, y)
## Ported from Libraries/LibGfx/Bitmap.h:180 Gfx::Bitmap::scanline_u8.
pub func bitmap_scanline_u8(this: Bitmap*, y: i32) -> u8*?:
assert(y >= 0)
assert(y < bitmap_height(this))
return bitmap_unchecked_scanline_u8(this, y)
## Ported from Libraries/LibGfx/Bitmap.h:187 Gfx::Bitmap::scanline_u8.
pub func bitmap_scanline_u8_const(this: const Bitmap*, y: i32) -> const u8*?:
assert(y >= 0)
assert(y < bitmap_height(this))
return bitmap_unchecked_scanline_u8_const(this, y)
## Ported from Libraries/LibGfx/Bitmap.h:194 Gfx::Bitmap::scanline.
pub func bitmap_scanline(this: Bitmap*, y: i32) -> u32*?:
return (u32*?)bitmap_scanline_u8(this, y)
## Ported from Libraries/LibGfx/Bitmap.h:199 Gfx::Bitmap::scanline.
pub func bitmap_scanline_const(this: const Bitmap*, y: i32) -> const u32*?:
return (const u32*?)bitmap_scanline_u8_const(this, y)
## Ported from Libraries/LibGfx/Bitmap.h:204 Gfx::Bitmap::begin.
pub func bitmap_begin(this: Bitmap*) -> u32*?:
return bitmap_scanline(this, 0)
## Ported from Libraries/LibGfx/Bitmap.h:209 Gfx::Bitmap::begin.
pub func bitmap_begin_const(this: const Bitmap*) -> const u32*?:
return bitmap_scanline_const(this, 0)
## Ported from Libraries/LibGfx/Bitmap.h:214 Gfx::Bitmap::end.
pub func bitmap_end(this: Bitmap*) -> u32*?:
let data = this.m_data else return none
return (u32*)((u8*)data + bitmap_data_size(this))
## Ported from Libraries/LibGfx/Bitmap.h:219 Gfx::Bitmap::end.
pub func bitmap_end_const(this: const Bitmap*) -> const u32*?:
let data = this.m_data else return none
return (const u32*)((const u8*)data + bitmap_data_size(this))
## Ported from Libraries/LibGfx/Bitmap.h:224 Gfx::Bitmap::data_size.
pub func bitmap_data_size(this: const Bitmap*) -> usize:
return (usize)int_size_height(&this.m_size) * this.m_pitch
## The pixels from begin() to end() as a span: the range C++'s `for (auto& pixel : *this)` walks.
pub func bitmap_pixels(this: Bitmap*) -> u32[]:
let begin = bitmap_begin(this) else trap("VERIFY: bitmap data")
return u32[](begin, bitmap_data_size(this) // 4)
## The pixels from begin() to end() as a read-only span.
pub func bitmap_pixels_const(this: const Bitmap*) -> const u32[]:
let begin = bitmap_begin_const(this) else trap("VERIFY: bitmap data")
return u32[]((u32*)begin, bitmap_data_size(this) // 4)
# mark: Accessors ==============================================================================
## Ported from Libraries/LibGfx/Bitmap.h:90 Gfx::Bitmap::rect.
pub func bitmap_rect(this: const Bitmap*) -> DevicePixelRect:
return DevicePixelRect(m_location = IntPoint(m_x = 0, m_y = 0), m_size = this.m_size)
## Ported from Libraries/LibGfx/Bitmap.h:91 Gfx::Bitmap::size.
pub func bitmap_size(this: const Bitmap*) -> IntSize:
return this.m_size
## Ported from Libraries/LibGfx/Bitmap.h:92 Gfx::Bitmap::width.
pub func bitmap_width(this: const Bitmap*) -> i32:
return int_size_width(&this.m_size)
## Ported from Libraries/LibGfx/Bitmap.h:93 Gfx::Bitmap::height.
pub func bitmap_height(this: const Bitmap*) -> i32:
return int_size_height(&this.m_size)
## Ported from Libraries/LibGfx/Bitmap.h:95 Gfx::Bitmap::pitch.
pub func bitmap_pitch(this: const Bitmap*) -> usize:
return this.m_pitch
## Ported from Libraries/LibGfx/Bitmap.h:99 Gfx::Bitmap::has_alpha_channel.
pub func bitmap_has_alpha_channel(this: const Bitmap*) -> bool:
return this.m_format == BitmapFormat.bgra8888 or this.m_format == BitmapFormat.rgba8888
## Ported from Libraries/LibGfx/Bitmap.h:100 Gfx::Bitmap::format.
pub func bitmap_format(this: const Bitmap*) -> BitmapFormat:
return this.m_format
## Ported from Libraries/LibGfx/Bitmap.h:105 Gfx::Bitmap::size_in_bytes.
pub func bitmap_size_in_bytes_usize(pitch: usize, height: i32) -> usize:
return pitch * (usize)height
## Ported from Libraries/LibGfx/Bitmap.h:106 Gfx::Bitmap::size_in_bytes.
pub func bitmap_size_in_bytes(this: const Bitmap*) -> usize:
return bitmap_size_in_bytes_usize(this.m_pitch, bitmap_height(this))
## Ported from Libraries/LibGfx/Bitmap.h:111 Gfx::Bitmap::anonymous_buffer.
pub func bitmap_anonymous_buffer(this: Bitmap*) -> CoreAnonymousBuffer*:
return &this.m_buffer
## Ported from Libraries/LibGfx/Bitmap.h:112 Gfx::Bitmap::anonymous_buffer.
pub func bitmap_anonymous_buffer_const(this: const Bitmap*) -> CoreAnonymousBuffer:
return this.m_buffer
## Ported from Libraries/LibGfx/Bitmap.h:137 Gfx::Bitmap::alpha_type.
pub func bitmap_alpha_type(this: const Bitmap*) -> AlphaType:
return this.m_alpha_type
# mark: Pixels =================================================================================
## Ported from Libraries/LibGfx/Bitmap.h:229 Gfx::Bitmap::get_pixel.
pub func bitmap_get_pixel(this: const Bitmap*, x: i32, y: i32) -> Color:
assert(x >= 0)
assert(x < bitmap_width(this))
let row = bitmap_scanline_const(this, y) else trap("VERIFY: bitmap data")
let pixel = row[(usize)x]
match this.m_format:
.bg_rx8888: return color_from_bgrx(pixel)
.bgra8888: return color_from_bgra(pixel)
.rgba8888: return color_from_rgba(pixel)
.rg_bx8888: return color_from_rgbx(pixel)
.invalid: trap("VERIFY_NOT_REACHED")
_: trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibGfx/Bitmap.h:249 Gfx::Bitmap::set_pixel.
pub func bitmap_set_pixel(this: Bitmap*, x: i32, y: i32, color: Color):
let row = bitmap_scanline(this, y) else trap("VERIFY: bitmap data")
match this.m_format:
.bgra8888:
row[(usize)x] = color_value(&color)
.bg_rx8888:
row[(usize)x] = color_value(&color) | ((u32)0xFF << 24)
.rgba8888:
row[(usize)x] = ((u32)color_alpha(&color) << 24) | ((u32)color_blue(&color) << 16) | ((u32)color_green(&color) << 8) | (u32)color_red(&color)
.rg_bx8888:
row[(usize)x] = ((u32)0xFF << 24) | ((u32)color_blue(&color) << 16) | ((u32)color_green(&color) << 8) | (u32)color_red(&color)
.invalid: trap("VERIFY_NOT_REACHED")
_: trap("VERIFY_NOT_REACHED")
# The absolute difference of two channel values, as `abs(static_cast<int>(a) - b)`.
func bitmap_channel_error(a: u8, b: u8) -> u8:
return a - b if a > b else b - a
## Ported from Libraries/LibGfx/Bitmap.cpp:271 Gfx::Bitmap::diff.
pub func bitmap_diff(this: const Bitmap*, other: const Bitmap*) -> BitmapDiffResult:
let own_width = bitmap_width(this)
let own_height = bitmap_height(this)
assert(own_width == bitmap_width(other) and own_height == bitmap_height(other))
var result: BitmapDiffResult
for y in 0..<own_height:
for x in 0..<own_width:
let own_pixel = bitmap_get_pixel(this, x, y)
let other_pixel = bitmap_get_pixel(other, x, y)
if color_eq(&own_pixel, other_pixel):
continue
result.pixel_error_count += 1
let red_error = bitmap_channel_error(color_red(&own_pixel), color_red(&other_pixel))
let green_error = bitmap_channel_error(color_green(&own_pixel), color_green(&other_pixel))
let blue_error = bitmap_channel_error(color_blue(&own_pixel), color_blue(&other_pixel))
let alpha_error = bitmap_channel_error(color_alpha(&own_pixel), color_alpha(&other_pixel))
result.total_red_error += red_error
result.total_green_error += green_error
result.total_blue_error += blue_error
result.total_alpha_error += alpha_error
if red_error > result.maximum_red_error: result.maximum_red_error = red_error
if green_error > result.maximum_green_error: result.maximum_green_error = green_error
if blue_error > result.maximum_blue_error: result.maximum_blue_error = blue_error
if alpha_error > result.maximum_alpha_error: result.maximum_alpha_error = alpha_error
result.identical = result.pixel_error_count == 0
result.total_error = result.total_red_error + result.total_green_error + result.total_blue_error + result.total_alpha_error
let maximum_red_green_error = result.maximum_green_error if result.maximum_red_error < result.maximum_green_error else result.maximum_red_error
let maximum_blue_alpha_error = result.maximum_alpha_error if result.maximum_blue_error < result.maximum_alpha_error else result.maximum_blue_error
result.maximum_error = maximum_blue_alpha_error if maximum_red_green_error < maximum_blue_alpha_error else maximum_red_green_error
return result
## Ported from Libraries/LibGfx/Bitmap.cpp:314 Gfx::Bitmap::set_alpha_type_destructive (the
## non-macOS branch: Skia's SkPixmap::readPixels between the two alpha types, which is
## SkOpts::RGBA_to_rgbA / rgbA_to_RGBA on 8888 pixels).
pub func bitmap_set_alpha_type_destructive(this: Bitmap*, alpha_type: AlphaType):
if alpha_type == this.m_alpha_type:
return
if this.m_format == BitmapFormat.bg_rx8888 or this.m_format == BitmapFormat.rg_bx8888:
this.m_alpha_type = alpha_type
return
# The channel order does not matter: alpha is the top byte of both BGRA8888 and RGBA8888.
assert(this.m_format == BitmapFormat.bgra8888 or this.m_format == BitmapFormat.rgba8888)
for y in 0..<bitmap_height(this):
let row = u32[](bitmap_scanline(this, y) else trap("VERIFY"), (usize)bitmap_width(this))
if this.m_alpha_type == AlphaType.unpremultiplied:
raster_premultiply_row(row)
else:
raster_unpremultiply_row(row)
this.m_alpha_type = alpha_type