Skip to content

Commit 0539c4d

Browse files
richiemcilroyrichiemcilroy
authored
Merge pull request #1578 from CapSoftware/copilot/fix-continue-in-closure-error
Fix continue-in-closure compile errors in Windows encoder paths
2 parents 7f8a638 + 743e39a commit 0539c4d

1 file changed

Lines changed: 100 additions & 86 deletions

File tree

  • crates/recording/src/output_pipeline

‎crates/recording/src/output_pipeline/win.rs‎

Lines changed: 100 additions & 86 deletions
Original file line numberDiff line numberDiff line change
@@ -314,55 +314,58 @@ impl Muxer for WindowsMuxer {
314314
let result = encoder.run(
315315
Arc::new(AtomicBool::default()),
316316
|| {
317-
match video_rx.recv_timeout(frame_interval) {
318-
Ok(Some((frame, timestamp))) => {
319-
last_texture = Some(frame.texture().clone());
320-
last_timestamp = Some(timestamp);
321-
}
322-
Ok(None) => {
323-
trace!("End of stream signal received");
324-
return Ok(None);
325-
}
326-
Err(RecvTimeoutError::Timeout) => {
327-
if pause_flag.load(Ordering::Acquire) {
328-
last_timestamp = None;
329-
continue;
330-
} else if let Some(last_ts) = last_timestamp {
331-
let new_ts = last_ts.saturating_add(frame_interval);
332-
last_timestamp = Some(new_ts);
333-
frames_reused += 1;
334-
if frames_reused.is_multiple_of(30) {
335-
debug!(
336-
frames_reused = frames_reused,
337-
frame_count = frame_count,
338-
"Frame pacing: reusing frames due to slow capture"
339-
);
317+
loop {
318+
match video_rx.recv_timeout(frame_interval) {
319+
Ok(Some((frame, timestamp))) => {
320+
last_texture = Some(frame.texture().clone());
321+
last_timestamp = Some(timestamp);
322+
}
323+
Ok(None) => {
324+
trace!("End of stream signal received");
325+
return Ok(None);
326+
}
327+
Err(RecvTimeoutError::Timeout) => {
328+
if pause_flag.load(Ordering::Acquire) {
329+
last_timestamp = None;
330+
continue;
331+
} else if let Some(last_ts) = last_timestamp {
332+
let new_ts = last_ts.saturating_add(frame_interval);
333+
last_timestamp = Some(new_ts);
334+
frames_reused += 1;
335+
if frames_reused.is_multiple_of(30) {
336+
debug!(
337+
frames_reused = frames_reused,
338+
frame_count = frame_count,
339+
"Frame pacing: reusing frames due to slow capture"
340+
);
341+
}
340342
}
341343
}
344+
Err(RecvTimeoutError::Disconnected) => {
345+
trace!("Channel disconnected");
346+
return Ok(None);
347+
}
342348
}
343-
Err(RecvTimeoutError::Disconnected) => {
344-
trace!("Channel disconnected");
345-
return Ok(None);
346-
}
347-
}
348349

349-
if let (Some(texture), Some(ts)) = (&last_texture, last_timestamp) {
350-
let normalized_ts = normalize_timestamp(ts, &mut first_timestamp);
351-
frame_count += 1;
352-
let frame_time = duration_to_timespan(normalized_ts);
353-
Ok(Some((texture.clone(), frame_time)))
354-
} else {
355-
match video_rx.recv() {
356-
Ok(Some((frame, timestamp))) => {
357-
let texture = frame.texture().clone();
358-
last_texture = Some(texture.clone());
359-
last_timestamp = Some(timestamp);
360-
let normalized_ts = normalize_timestamp(timestamp, &mut first_timestamp);
361-
frame_count = 1;
362-
let frame_time = duration_to_timespan(normalized_ts);
363-
Ok(Some((texture, frame_time)))
350+
if let (Some(texture), Some(ts)) = (&last_texture, last_timestamp) {
351+
let normalized_ts = normalize_timestamp(ts, &mut first_timestamp);
352+
frame_count += 1;
353+
let frame_time = duration_to_timespan(normalized_ts);
354+
return Ok(Some((texture.clone(), frame_time)));
355+
} else {
356+
match video_rx.recv() {
357+
Ok(Some((frame, timestamp))) => {
358+
let texture = frame.texture().clone();
359+
last_texture = Some(texture.clone());
360+
last_timestamp = Some(timestamp);
361+
let normalized_ts =
362+
normalize_timestamp(timestamp, &mut first_timestamp);
363+
frame_count = 1;
364+
let frame_time = duration_to_timespan(normalized_ts);
365+
return Ok(Some((texture, frame_time)));
366+
}
367+
Ok(None) | Err(_) => return Ok(None),
364368
}
365-
Ok(None) | Err(_) => Ok(None),
366369
}
367370
}
368371
},
@@ -836,52 +839,63 @@ impl Muxer for WindowsCameraMuxer {
836839
let result = encoder.run(
837840
Arc::new(AtomicBool::default()),
838841
|| {
839-
match video_rx.recv_timeout(frame_interval) {
840-
Ok(Some((frame, timestamp))) => {
841-
last_frame = Some(frame);
842-
last_timestamp = Some(timestamp);
843-
}
844-
Ok(None) => {
845-
trace!("End of camera stream signal received");
846-
return Ok(None);
847-
}
848-
Err(RecvTimeoutError::Timeout) => {
849-
if pause_flag.load(Ordering::Acquire) {
850-
last_timestamp = None;
851-
continue;
852-
} else if let Some(last_ts) = last_timestamp {
853-
let new_ts = last_ts.saturating_add(frame_interval);
854-
last_timestamp = Some(new_ts);
842+
loop {
843+
match video_rx.recv_timeout(frame_interval) {
844+
Ok(Some((frame, timestamp))) => {
845+
last_frame = Some(frame);
846+
last_timestamp = Some(timestamp);
847+
}
848+
Ok(None) => {
849+
trace!("End of camera stream signal received");
850+
return Ok(None);
851+
}
852+
Err(RecvTimeoutError::Timeout) => {
853+
if pause_flag.load(Ordering::Acquire) {
854+
last_timestamp = None;
855+
continue;
856+
} else if let Some(last_ts) = last_timestamp {
857+
let new_ts = last_ts.saturating_add(frame_interval);
858+
last_timestamp = Some(new_ts);
859+
}
860+
}
861+
Err(RecvTimeoutError::Disconnected) => {
862+
trace!("Camera channel disconnected");
863+
return Ok(None);
855864
}
856865
}
857-
Err(RecvTimeoutError::Disconnected) => {
858-
trace!("Camera channel disconnected");
859-
return Ok(None);
860-
}
861-
}
862866

863-
if let (Some(frame), Some(ts)) = (&last_frame, last_timestamp) {
864-
let normalized_ts = normalize_camera_timestamp(ts, &mut first_timestamp);
865-
frame_count += 1;
866-
if frame_count.is_multiple_of(30) {
867-
debug!(
868-
"Windows camera encoder: processed {} frames",
869-
frame_count
870-
);
871-
}
872-
let texture = upload_mf_buffer_to_texture(&d3d_device, frame, &mut camera_buffers)?;
873-
Ok(Some((texture, duration_to_timespan(normalized_ts))))
874-
} else {
875-
match video_rx.recv() {
876-
Ok(Some((frame, timestamp))) => {
877-
last_frame = Some(frame.clone());
878-
last_timestamp = Some(timestamp);
879-
let normalized_ts = normalize_camera_timestamp(timestamp, &mut first_timestamp);
880-
frame_count = 1;
881-
let texture = upload_mf_buffer_to_texture(&d3d_device, &frame, &mut camera_buffers)?;
882-
Ok(Some((texture, duration_to_timespan(normalized_ts))))
867+
if let (Some(frame), Some(ts)) = (&last_frame, last_timestamp) {
868+
let normalized_ts =
869+
normalize_camera_timestamp(ts, &mut first_timestamp);
870+
frame_count += 1;
871+
if frame_count.is_multiple_of(30) {
872+
debug!(
873+
"Windows camera encoder: processed {} frames",
874+
frame_count
875+
);
876+
}
877+
let texture =
878+
upload_mf_buffer_to_texture(&d3d_device, frame, &mut camera_buffers)?;
879+
return Ok(Some((texture, duration_to_timespan(normalized_ts))));
880+
} else {
881+
match video_rx.recv() {
882+
Ok(Some((frame, timestamp))) => {
883+
last_frame = Some(frame.clone());
884+
last_timestamp = Some(timestamp);
885+
let normalized_ts = normalize_camera_timestamp(
886+
timestamp,
887+
&mut first_timestamp,
888+
);
889+
frame_count = 1;
890+
let texture = upload_mf_buffer_to_texture(
891+
&d3d_device,
892+
&frame,
893+
&mut camera_buffers,
894+
)?;
895+
return Ok(Some((texture, duration_to_timespan(normalized_ts))));
896+
}
897+
Ok(None) | Err(_) => return Ok(None),
883898
}
884-
Ok(None) | Err(_) => Ok(None),
885899
}
886900
}
887901
},

0 commit comments

Comments
 (0)