use super::{
super::{
Output, StreamOutcome, StreamSpec, downsample::downsample_preview, tracer::SharedState,
},
accum::EmitterAccum,
display::{DisplayDenoiser, DisplayUpdate},
};
use glam::Vec3;
use indicatrix_net::{
messages::{
Done, ErrorMsg, FrameHeader, NetError, PreviewConfig, PreviewHeader, Progress,
RenderRequest, Stats, StreamEvent, TransferMode, error_codes,
},
radiance::EncodedPayload,
};
use std::{
io::Write,
sync::{Arc, Mutex},
time::{Duration, Instant},
};
pub(in crate::stream_emit) fn effective_cadence_ms(elapsed: Duration, emission_count: u32) -> u32 {
if emission_count < 2 {
0
} else {
(elapsed.as_millis() / u128::from(emission_count - 1)) as u32
}
}
pub(super) fn emit_tick_or_heartbeat<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
emitter_accum: &mut EmitterAccum,
cadence: Duration,
last_emit: &mut Instant,
emission_count: &mut u32,
) -> Result<(), NetError> {
if last_emit.elapsed() >= cadence {
emit_tick(stream, request, state, emitter_accum, emission_count)?;
*last_emit = Instant::now();
return Ok(());
}
maybe_emit_heartbeat_backstop(
stream,
request,
state,
super::super::HEARTBEAT_INTERVAL,
last_emit,
emission_count,
)
}
fn maybe_emit_heartbeat_backstop<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
heartbeat_interval: Duration,
last_emit: &mut Instant,
emission_count: &mut u32,
) -> Result<(), NetError> {
if last_emit.elapsed() < heartbeat_interval {
return Ok(());
}
emit_progress_heartbeat(stream, request, state, emission_count)?;
*last_emit = Instant::now();
Ok(())
}
pub(super) fn emit_progress_heartbeat<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
emission_count: &mut u32,
) -> Result<(), NetError> {
let samples_done = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.samples_done;
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Progress(Progress {
request_id: request.request_id,
samples_done,
}),
None,
)?;
*emission_count += 1;
Ok(())
}
pub(in crate::stream_emit) fn emit_tick<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
emitter: &mut EmitterAccum,
emission_count: &mut u32,
) -> Result<(), NetError> {
let (range, samples_done) = emitter.swap_and_fold(state);
if request.stream.transfer_mode == TransferMode::DisplayOnly {
if emit_display_tick(stream, request, emitter, range.is_some(), samples_done)? {
*emission_count += 1;
}
return write_progress(stream, request.request_id, samples_done, emission_count);
}
let frame_sent_this_tick =
range.is_some() && matches!(request.stream.transfer_mode, TransferMode::LiveProgressive);
if let Some((first_sample, samples)) = range
&& frame_sent_this_tick
{
emitter.send_delta(|encoded| {
let header =
FrameHeader::for_encoded(request.request_id, first_sample, samples, encoded);
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Frame(header),
Some(encoded.bytes),
)
})?;
*emission_count += 1;
}
if let Some(cfg) = request.stream.preview
&& samples_done > 0
{
let full_scale_and_redundant = frame_sent_this_tick
&& cfg.width == request.scene.width
&& cfg.height == request.scene.height;
if !full_scale_and_redundant && emitter.preview_due(samples_done, request.samples) {
write_preview(stream, request, cfg, emitter, samples_done)?;
emitter.record_preview_sent(samples_done);
}
}
write_progress(stream, request.request_id, samples_done, emission_count)
}
fn write_progress<S: Write>(
stream: &mut S,
request_id: u32,
samples_done: u32,
emission_count: &mut u32,
) -> Result<(), NetError> {
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Progress(Progress {
request_id,
samples_done,
}),
None,
)?;
*emission_count += 1;
Ok(())
}
pub(super) fn emit_final<S: Write>(
stream: &mut S,
spec: &StreamSpec<'_>,
state: &Arc<Mutex<SharedState>>,
emitter: &mut EmitterAccum,
streaming_start: Instant,
emission_count: &mut u32,
) -> Result<StreamOutcome, NetError> {
let request = spec.request;
let (range, samples_done) = emitter.swap_and_fold(state);
let (final_total, reclaimed_samples) = {
let mut guard = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
(guard.final_total.take(), guard.reclaimed_samples)
};
let dims = (request.scene.width, request.scene.height);
if let Output::FinalImage(color_space) = spec.output {
let total = final_total
.as_deref()
.unwrap_or_else(|| emitter.running_total());
let written = super::picture::write_final_image(
stream,
request.request_id,
dims,
request.samples,
total,
color_space,
emitter.link(),
)?;
if let Err(message) = written {
return Ok(StreamOutcome::Failed(ErrorMsg {
code: error_codes::TRACE_PANIC,
message,
request_id: None,
}));
}
*emission_count += 1;
write_done(
stream,
request,
streaming_start,
*emission_count,
reclaimed_samples,
)?;
return Ok(StreamOutcome::Completed);
}
if request.stream.transfer_mode != TransferMode::DisplayOnly
&& let Some(cfg) = request.stream.preview
&& samples_done > 0
&& !(cfg.width == request.scene.width && cfg.height == request.scene.height)
&& emitter.preview_due(samples_done, request.samples)
{
write_preview(stream, request, cfg, emitter, samples_done)?;
emitter.record_preview_sent(samples_done);
}
emit_final_payload(
stream,
request,
state,
emitter,
range,
final_total.as_deref(),
emission_count,
)?;
write_done(
stream,
request,
streaming_start,
*emission_count,
reclaimed_samples,
)?;
Ok(StreamOutcome::Completed)
}
fn emit_display_tick<S: Write>(
stream: &mut S,
request: &RenderRequest,
emitter: &mut EmitterAccum,
fresh: bool,
samples_done: u32,
) -> Result<bool, NetError> {
let dims = (request.scene.width, request.scene.height);
match emitter.display_tick(&request.scene, fresh, samples_done) {
DisplayUpdate::Picture(picture) => super::picture::write_display_rgba(
stream,
request.request_id,
dims,
picture.samples,
&picture.rgba,
emitter.link(),
),
DisplayUpdate::Plain => super::picture::write_display_frame(
stream,
request.request_id,
dims,
samples_done,
emitter.running_total(),
emitter.link(),
),
DisplayUpdate::Nothing => Ok(false),
}
}
fn emit_final_payload<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
emitter: &mut EmitterAccum,
range: Option<(u32, u32)>,
final_total: Option<&[Vec3]>,
emission_count: &mut u32,
) -> Result<(), NetError> {
match request.stream.transfer_mode {
TransferMode::FinalOnly => {
let write = |encoded: &EncodedPayload<'_>| {
let header = FrameHeader::for_encoded(
request.request_id,
request.first_sample,
request.samples,
encoded,
);
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Frame(header),
Some(encoded.bytes),
)
};
match final_total {
Some(total) => emitter.send_other(total, write)?,
None => emitter.send_running_total(write)?,
}
*emission_count += 1;
}
TransferMode::LiveProgressive => {
if let Some((first_sample, samples)) = range {
emitter.send_delta(|encoded| {
let header = FrameHeader::for_encoded(
request.request_id,
first_sample,
samples,
encoded,
);
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Frame(header),
Some(encoded.bytes),
)
})?;
*emission_count += 1;
}
}
TransferMode::DisplayOnly => {
emit_final_display(stream, request, state, emitter, final_total, emission_count)?;
}
}
Ok(())
}
fn emit_final_display<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
emitter: &mut EmitterAccum,
final_total: Option<&[Vec3]>,
emission_count: &mut u32,
) -> Result<(), NetError> {
let mut denoiser = emitter
.take_display()
.unwrap_or_else(|| DisplayDenoiser::spawn(&request.scene));
let dims = (request.scene.width, request.scene.height);
let total = final_total.unwrap_or_else(|| emitter.running_total());
let denoised = denoiser.finish(
request.samples,
total,
super::super::HEARTBEAT_INTERVAL,
|| emit_progress_heartbeat(stream, request, state, emission_count),
)?;
let written = match denoised {
Some(rgba) => super::picture::write_display_rgba(
stream,
request.request_id,
dims,
request.samples,
&rgba,
emitter.link(),
)?,
None => super::picture::write_display_frame(
stream,
request.request_id,
dims,
request.samples,
total,
emitter.link(),
)?,
};
*emission_count += u32::from(written);
Ok(())
}
fn write_done<S: Write>(
stream: &mut S,
request: &RenderRequest,
streaming_start: Instant,
emission_count: u32,
reclaimed_samples: u32,
) -> Result<(), NetError> {
let stats = Stats {
samples_done: request.samples,
requested_cadence_ms: request.stream.cadence_ms,
effective_cadence_ms: effective_cadence_ms(streaming_start.elapsed(), emission_count),
reclaimed_samples,
};
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Done(Done {
request_id: request.request_id,
cancelled: false,
stats,
}),
None,
)
}
fn write_preview<S: Write>(
stream: &mut S,
request: &RenderRequest,
cfg: PreviewConfig,
emitter: &EmitterAccum,
samples_done: u32,
) -> Result<(), NetError> {
let preview_buffer = downsample_preview(
emitter.running_total(),
request.scene.width,
request.scene.height,
cfg.width,
cfg.height,
);
emitter.send_other(&preview_buffer, |encoded| {
let header = PreviewHeader::for_encoded(
request.request_id,
cfg.width,
cfg.height,
samples_done,
encoded,
);
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Preview(header),
Some(encoded.bytes),
)
})
}