///|
/// Render cache of a frame being rendered (jxl-render `RenderCache`):
/// parsed LfGlobal, HfGlobal and LF groups, kept so that progressive
/// rendering does not reparse them.
pub struct RenderCache {
mut lf_global : @frame.LfGlobal?
mut hf_global : @frame.HfGlobal?
lf_groups : Map[Int32, @frame.LfGroup]
}
///|
pub fn RenderCache::new(_frame : IndexedFrame) -> RenderCache {
// Upstream also computes (and discards) the LF channel sizes here.
{ lf_global: None, hf_global: None, lf_groups: {}, }
}
///|
/// Render state of a frame (jxl-render `FrameRender`).
///
/// Upstream variant names, except `None` → `Empty` and `Err` → `Failed`
/// (to not shadow `Option::None`/`Result::Err`).
pub enum FrameRender {
Empty
Rendering
InProgress(RenderCache)
Done(ImageWithRegion)
Blended(ImageWithRegion)
Failed(@bitstream.JxlError)
ErrTaken
}
///|
/// `RenderOp`: renders a frame from the given state.
pub type RenderOp = (FrameRender, Region) -> FrameRender
///|
/// A handle to the render state of a frame (jxl-render `FrameRenderHandle`).
///
/// Upstream protects `render` with a mutex and a condvar for multithreaded
/// rendering; rendering is sequential here.
pub struct FrameRenderHandle {
frame : IndexedFrame
image_region : Region
mut render : FrameRender
render_op : RenderOp
refs : FixedArray[Reference?]
}
///|
pub fn FrameRenderHandle::new(
frame : IndexedFrame,
image_region : Region,
render_op : RenderOp,
refs : FixedArray[Reference?],
) -> FrameRenderHandle {
{ frame, image_region, render: Empty, render_op, refs, }
}
///|
pub fn FrameRenderHandle::from_cache(
frame : IndexedFrame,
image_region : Region,
cache : RenderCache,
render_op : RenderOp,
refs : FixedArray[Reference?],
) -> FrameRenderHandle {
{ frame, image_region, render: InProgress(cache), render_op, refs, }
}
///|
/// Renders the frame if not rendered yet, and returns a handle to the
/// rendered image.
pub fn FrameRenderHandle::run_with_image(
self : FrameRenderHandle,
) -> RenderedImage raise @bitstream.JxlError {
match self.start_render() {
Some(state) => {
let render_result = (self.render_op)(state, self.image_region)
match render_result {
InProgress(_) => {
self.done_render(render_result)
raise incomplete_frame()
}
Failed(e) => {
self.done_render(ErrTaken)
raise e
}
_ => ()
}
self.done_render(render_result)
}
None => self.wait_until_render()
}
RenderedImage::new(self)
}
///|
/// Renders the frame if not rendered yet, ignoring errors.
pub fn FrameRenderHandle::run(
self : FrameRenderHandle,
image_region : Region,
) -> Unit {
if self.start_render_silent() is Some(state) {
let render_result = (self.render_op)(state, image_region)
self.done_render(render_result)
}
}
///|
/// Resets the render state, returning the previous state.
pub fn FrameRenderHandle::reset(self : FrameRenderHandle) -> FrameRender {
let r = self.render
self.render = Empty
r
}
///|
fn FrameRenderHandle::start_render(
self : FrameRenderHandle,
) -> FrameRender? raise @bitstream.JxlError {
let render = self.render
self.render = Rendering
match render {
Empty | InProgress(_) => Some(render)
Failed(e) => {
self.render = ErrTaken
raise e
}
ErrTaken => {
self.render = ErrTaken
raise failed_reference()
}
render => {
self.render = render
None
}
}
}
///|
fn FrameRenderHandle::start_render_silent(
self : FrameRenderHandle,
) -> FrameRender? {
let render = self.render
self.render = Rendering
match render {
Empty | InProgress(_) => Some(render)
render => {
self.render = render
None
}
}
}
///|
/// Checks that the frame is rendered (upstream waits on a condvar while
/// another thread renders; rendering is sequential here, so `Rendering`
/// would mean a dependency cycle).
fn FrameRenderHandle::wait_until_render(
self : FrameRenderHandle,
) -> Unit raise @bitstream.JxlError {
match self.render {
Rendering => abort("frame render is reentrant")
Done(_) | Blended(_) => ()
Empty | InProgress(_) => {
self.render = Empty
raise incomplete_frame()
}
Failed(e) => {
self.render = Empty
raise e
}
ErrTaken => {
self.render = Empty
raise failed_reference()
}
}
}
///|
fn FrameRenderHandle::done_render(
self : FrameRenderHandle,
render : FrameRender,
) -> Unit {
guard !(render is Rendering) else { abort("done_render with Rendering") }
self.render = render
}