///|
priv enum BlendMode {
Replace
Add
Mul(Bool)
Blend(BlendAlpha)
MulAdd(BlendAlpha)
MixAlpha(clamp~ : Bool, swapped~ : Bool)
Skip
}
///|
priv struct BlendAlpha {
base : @grid.SubGrid[Float]?
new : @grid.SubGrid[Float]?
clamp : Bool
swapped : Bool
premultiplied : Bool
}
///|
priv struct BlendParams {
mode : BlendMode
mut base_topleft : (Int32, Int32)
mut new_topleft : (Int32, Int32)
mut width : Int32
mut height : Int32
}
///|
fn BlendParams::from_blending_info(
channel_idx : Int32,
color_channels : Int32,
blending_info : @frame.BlendingInfo,
base_alpha : @grid.SubGrid[Float]?,
new_alpha : @grid.SubGrid[Float]?,
premultiplied : Bool?,
) -> BlendParams {
let is_alpha = channel_idx == blending_info.alpha_channel + color_channels
let mode : BlendMode = match blending_info.mode {
Replace => Replace
Add => Add
Blend =>
if is_alpha {
MixAlpha(clamp=blending_info.clamp, swapped=false)
} else {
Blend({
base: base_alpha,
new: new_alpha,
clamp: blending_info.clamp,
swapped: false,
premultiplied: premultiplied.unwrap_or(false),
})
}
MulAdd =>
if is_alpha {
Skip
} else {
MulAdd({
base: base_alpha,
new: new_alpha,
clamp: blending_info.clamp,
swapped: false,
premultiplied: premultiplied.unwrap_or(false),
})
}
Mul => Mul(blending_info.clamp)
}
{ mode, base_topleft: (0, 0), new_topleft: (0, 0), width: 0, height: 0, }
}
///|
fn BlendParams::from_patch_blending_info(
channel_idx : Int32,
color_channels : Int32,
blending_info : @frame.BlendingModeInformation,
base_alpha : @grid.SubGrid[Float]?,
new_alpha : @grid.SubGrid[Float]?,
premultiplied : Bool?,
) -> BlendParams? {
let is_alpha = channel_idx == blending_info.alpha_channel + color_channels
let mode : BlendMode = match blending_info.mode {
@frame.PatchBlendMode::None => return None
@frame.PatchBlendMode::Replace => Replace
@frame.PatchBlendMode::Add => Add
@frame.PatchBlendMode::Mul => Mul(blending_info.clamp)
@frame.PatchBlendMode::BlendAbove | @frame.PatchBlendMode::BlendBelow => {
let swapped = blending_info.mode is @frame.PatchBlendMode::BlendBelow
if is_alpha {
MixAlpha(clamp=blending_info.clamp, swapped~)
} else {
Blend({
base: base_alpha,
new: new_alpha,
clamp: blending_info.clamp,
swapped,
premultiplied: premultiplied.unwrap_or(false),
})
}
}
@frame.PatchBlendMode::MulAddAbove | @frame.PatchBlendMode::MulAddBelow => {
let swapped = blending_info.mode is @frame.PatchBlendMode::MulAddBelow
if is_alpha {
if swapped {
Replace
} else {
Skip
}
} else {
MulAdd({
base: base_alpha,
new: new_alpha,
clamp: blending_info.clamp,
swapped,
premultiplied: premultiplied.unwrap_or(false),
})
}
}
}
Some({ mode, base_topleft: (0, 0), new_topleft: (0, 0), width: 0, height: 0, })
}
///|
fn source_and_alpha_from_blending_info(
blending_info : @frame.BlendingInfo,
has_extra : Bool,
) -> (Int32, Int32?) {
let source = blending_info.source
let alpha = if (blending_info.mode is Blend || blending_info.mode is MulAdd) &&
has_extra {
Some(blending_info.alpha_channel)
} else {
None
}
(source, alpha)
}
///|
/// Blends `new_grid` of `new_frame` onto its reference frames, producing the
/// composited image covering `output_frame_region` (in frame coordinates).
fn blend(
image_header : @image.ImageHeader,
reference_grids : FixedArray[Reference?],
new_frame : IndexedFrame,
new_grid : ImageWithRegion,
output_frame_region : Region,
) -> ImageWithRegion raise @bitstream.JxlError {
let header = new_frame.header()
let tracker = new_frame.alloc_tracker()
let full_frame_region = Region::with_size(header.width, header.height)
let output_image_region = output_frame_region.translate(header.x0, header.y0)
let used_refs = FixedArray::make(4, false)
used_refs[header.blending_info.source] = true
for bi in header.ec_blending_info {
used_refs[bi.source] = true
}
let ref_list : Array[Reference] = []
for ref_idx in 0..<4 {
if !used_refs[ref_idx] {
continue
}
if reference_grids[ref_idx] is Some(grid) {
ref_list.push(grid)
}
}
ref_list.sort_by_key(grid => grid.frame.idx)
for grid in ref_list {
ignore(grid.image.run_with_image().blend(Some(output_image_region)))
}
let color_channels = new_grid.color_channels()
let output_grid = ImageWithRegion::new(color_channels, tracker)
output_grid.set_ct_done(new_grid.ct_done())
let has_extra = !header.ec_blending_info.is_empty()
let num_channels = color_channels + header.ec_blending_info.length()
for idx in 0..= color_channels {
image_header.metadata.ec_info[idx - color_channels].bit_depth
} else {
image_header.metadata.bit_depth
}
let (ref_idx, alpha_idx) = source_and_alpha_from_blending_info(
blending_info, has_extra,
)
let ref_grid = reference_grids[ref_idx]
let original_frame_region = new_grid.regions_and_shifts()[idx].0.intersection(
full_frame_region,
)
let clipped_original_frame_region = original_frame_region.intersection(
output_frame_region,
)
let (target_grid, target_region, target_subgrid, base_alpha, clone_empty) : (
ImageBuffer,
Region,
@grid.SubGrid[Float],
@grid.SubGrid[Float]?,
Bool,
) = match ref_grid {
Some(grid) => {
// Upstream allows taking the reference buffer instead of cloning it
// (`can_overwrite`), but `try_take_blended` can never succeed there
// since another strong reference is alive; the clone path is taken.
let base_grid_render = grid.image.run_with_image()
let base_grid = base_grid_render.blend(Some(output_image_region))
guard base_grid.color_channels() == color_channels else {
abort("blend: color channel count mismatch")
}
if base_grid.regions_and_shifts()[idx].0.is_empty() {
let g = @grid.Grid::with_alloc_tracker(
output_frame_region.width,
output_frame_region.height,
(0.0 : Float),
tracker,
)
(F32(g), output_frame_region, g.as_subgrid(), None, true)
} else {
let base_frame_header = grid.frame.header()
let base_frame_region = output_image_region.translate(
-base_frame_header.x0,
-base_frame_header.y0,
)
let cloned = base_grid.buffer()[idx].try_clone()
let target_region = base_grid.regions_and_shifts()[idx].0.translate(
base_frame_header.x0 - header.x0,
base_frame_header.y0 - header.y0,
)
let tg = cloned.convert_to_float_modular(bit_depth)
let grid_region = base_grid.regions_and_shifts()[idx].0
let region = base_frame_region.translate(
-grid_region.left,
-grid_region.top,
)
let target_subgrid = tg
.as_subgrid()
.subgrid(region.left, region.top, region.width, region.height)
let mut base_alpha = None
if alpha_idx is Some(alpha_idx) && alpha_idx + color_channels != idx {
let alpha_bit_depth = image_header.metadata.ec_info[alpha_idx].bit_depth
let base_alpha_grid = base_grid.buffer()[alpha_idx + color_channels]
.try_clone()
.convert_to_float_modular(alpha_bit_depth)
let grid_region = base_grid.regions_and_shifts()[alpha_idx +
color_channels].0
let region = base_frame_region.translate(
-grid_region.left,
-grid_region.top,
)
base_alpha = Some(
base_alpha_grid
.as_subgrid()
.subgrid(region.left, region.top, region.width, region.height),
)
}
(F32(tg), target_region, target_subgrid, base_alpha, false)
}
}
None => {
let g = @grid.Grid::with_alloc_tracker(
output_frame_region.width,
output_frame_region.height,
(0.0 : Float),
tracker,
)
(F32(g), output_frame_region, g.as_subgrid(), None, true)
}
}
if alpha_idx is Some(aidx) {
let bit_depth = image_header.metadata.ec_info[aidx].bit_depth
ignore(
new_grid.convert_channel_to_float_modular(
aidx + color_channels,
bit_depth,
),
)
}
ignore(new_grid.convert_channel_to_float_modular(idx, bit_depth))
let new_alpha = match alpha_idx {
Some(aidx) =>
Some(new_grid.buffer()[aidx + color_channels].float().as_subgrid())
None => None
}
let premultiplied = match alpha_idx {
Some(aidx) => image_header.metadata.ec_info[aidx].alpha_associated()
None => None
}
let blend_params = BlendParams::from_blending_info(
idx,
color_channels,
blending_info,
if clone_empty {
None
} else {
base_alpha
},
new_alpha,
premultiplied,
)
blend_params.base_topleft = (
abs_diff(clipped_original_frame_region.left, output_frame_region.left),
abs_diff(clipped_original_frame_region.top, output_frame_region.top),
)
blend_params.new_topleft = (
abs_diff(clipped_original_frame_region.left, original_frame_region.left),
abs_diff(clipped_original_frame_region.top, original_frame_region.top),
)
blend_params.width = clipped_original_frame_region.width
blend_params.height = clipped_original_frame_region.height
let new_g = new_grid.buffer()[idx].float()
blend_single(target_subgrid, new_g.as_subgrid(), blend_params)
output_grid.append_channel(target_grid, target_region)
}
if header.can_reference() {
let ref_idx = header.save_as_reference
if reference_grids[ref_idx] is Some(grid) &&
!grid.frame.header().is_keyframe() {
ignore(grid.image.reset())
}
}
output_grid.set_blend_done(true)
output_grid
}
///|
/// Renders a patch onto `base_grid`.
pub fn patch(
image_header : @image.ImageHeader,
base_grid : ImageWithRegion,
patch_ref_grid : ImageWithRegion,
patch_ref : @frame.PatchRef,
) -> Unit raise @bitstream.JxlError {
let color_channels = base_grid.color_channels()
guard patch_ref_grid.color_channels() == color_channels else {
abort("patch: color channel count mismatch")
}
for target in patch_ref.patch_targets {
let num_channels = color_channels + target.blending.length() - 1
for idx in 0..= color_channels {
image_header.metadata.ec_info[idx - color_channels].bit_depth
} else {
image_header.metadata.bit_depth
}
let alpha_idx = match blending_info.mode {
@frame.PatchBlendMode::BlendAbove
| @frame.PatchBlendMode::BlendBelow
| @frame.PatchBlendMode::MulAddAbove
| @frame.PatchBlendMode::MulAddBelow =>
Some(blending_info.alpha_channel)
_ => None
}
let mut base_alpha = None
let mut new_alpha = None
let mut premultiplied = None
if alpha_idx is Some(alpha_idx) && alpha_idx + color_channels != idx {
let alpha_bit_depth = image_header.metadata.ec_info[alpha_idx].bit_depth
let alpha = base_grid.convert_channel_to_float_modular(
alpha_idx + color_channels,
alpha_bit_depth,
)
base_alpha = Some(alpha.as_subgrid())
new_alpha = Some(
patch_ref_grid.buffer()[alpha_idx + color_channels]
.float()
.as_subgrid(),
)
premultiplied = image_header.metadata.ec_info[alpha_idx].alpha_associated()
}
let base = base_grid
.convert_channel_to_float_modular(idx, bit_depth)
.as_subgrid()
guard BlendParams::from_patch_blending_info(
idx, color_channels, blending_info, base_alpha, new_alpha, premultiplied,
)
is Some(blend_params) else {
continue
}
blend_params.base_topleft = (base_left, base_top)
blend_params.new_topleft = (patch_left, patch_top)
blend_params.width = width
blend_params.height = height
blend_single(
base,
patch_ref_grid.buffer()[idx].float().as_subgrid(),
blend_params,
)
}
}
}
///|
const ONE : Float = 1.0
///|
fn clamp01(v : Float) -> Float {
if v < 0.0 {
0.0
} else if v > 1.0 {
1.0
} else {
v
}
}
///|
fn blend_single(
base : @grid.SubGrid[Float],
new_grid : @grid.SubGrid[Float],
blend_params : BlendParams,
) -> Unit {
let (base_x, base_y) = blend_params.base_topleft
let (new_x, new_y) = blend_params.new_topleft
let width = blend_params.width
let height = blend_params.height
let bbuf = base.buf
let nbuf = new_grid.buf
match blend_params.mode {
Replace | Blend({ new: None, .. }) =>
for dy in 0..
for dy in 0..
for dy in 0..
for dy in 0.. a.buf[a.row_offset(base_buf_y) + base_x + dx]
None => 0.0
}
let (base_sample, new_sample, ba, na0) = if swapped {
(
nbuf[nrow + dx],
bbuf[brow + dx],
new_alpha.buf[narow + dx],
base_alpha_sample,
)
} else {
(
bbuf[brow + dx],
nbuf[nrow + dx],
base_alpha_sample,
new_alpha.buf[narow + dx],
)
}
let mut na = na0
if clamp {
na = clamp01(na)
}
bbuf[brow + dx] = if premultiplied {
new_sample + base_sample * (ONE - na)
} else {
let base_alpha_rev = ONE - ba
let new_alpha_rev = ONE - na
let mixed_alpha = ONE - new_alpha_rev * base_alpha_rev
let mixed_alpha_recip : Float = if mixed_alpha > 0.0 {
ONE / mixed_alpha
} else {
0.0
}
(na * new_sample + ba * base_sample * new_alpha_rev) *
mixed_alpha_recip
}
}
}
MulAdd({ base: base_alpha, new: Some(new_alpha), clamp, swapped, .. }) =>
for dy in 0.. a.buf[a.row_offset(base_buf_y) + base_x + dx]
None => 0.0
},
)
} else {
(bbuf[brow + dx], nbuf[nrow + dx], new_alpha.buf[narow + dx])
}
let mut na = na0
if clamp {
na = clamp01(na)
}
bbuf[brow + dx] = base_sample + na * new_sample
}
}
MixAlpha(clamp~, swapped~) =>
for dy in 0.. ()
}
}