Move out ordqueue impl

Cargo.toml

@@ -39,6 +39,7 @@ loop9 = "0.1.5"
 # noisy-float 0.2 bug
 num-traits = { version = "0.2.17", features = ["i128", "std"] }
 crossbeam-utils = "0.8.19"
+ordered-channel = { version = "1.0.0", features = ["crossbeam-channel"] }
 
 [dependencies.ffmpeg]
 package = "ffmpeg-next"

src/error.rs

@@ -59,16 +59,16 @@ impl From<gif::EncodingError> for Error {
     }
 }
 
-impl<T> From<crossbeam_channel::SendError<T>> for Error {
+impl<T> From<ordered_channel::SendError<T>> for Error {
     #[cold]
-    fn from(_: crossbeam_channel::SendError<T>) -> Self {
+    fn from(_: ordered_channel::SendError<T>) -> Self {
         Self::ThreadSend
     }
 }
 
-impl From<crossbeam_channel::RecvError> for Error {
+impl From<ordered_channel::RecvError> for Error {
     #[cold]
-    fn from(_: crossbeam_channel::RecvError) -> Self {
+    fn from(_: ordered_channel::RecvError) -> Self {
         Self::Aborted
     }
 }

src/lib.rs

@@ -36,8 +36,9 @@ use rgb::*;
 
 mod error;
 pub use crate::error::*;
-mod ordqueue;
-use crate::ordqueue::{OrdQueue, OrdQueueIter};
+use ordered_channel::Sender as OrdQueue;
+use ordered_channel::Receiver as OrdQueueIter;
+use ordered_channel::bounded as ordqueue_new;
 pub mod progress;
 use crate::progress::*;
 pub mod c_api;
@@ -480,15 +481,15 @@ impl Writer {
 
     #[inline(never)]
     fn write_frames(&self, write_queue: Receiver<FrameMessage>, writer: &mut dyn Write, reporter: &mut dyn ProgressReporter) -> CatResult<()> {
-        let (send, recv) = ordqueue::new(2);
+        let (lzw_queue, lzw_recv) = ordqueue_new(2);
         minipool::new_scope((if self.settings.s.fast || self.settings.gifsicle_loss() > 0 { 3 } else { 1 }).try_into().unwrap(), "lzw", move || {
             let mut pts_in_delay_units = 0_u64;
 
             let written = Rc::new(Cell::new(0));
             let mut enc = RustEncoder::new(writer, written.clone());
 
             let mut n_done = 0;
-            for tmp in recv {
+            for tmp in lzw_recv {
                 let (end_pts, ordinal_frame_number, frame, screen_width, screen_height): (f64, _, _, _, _) = tmp;
                 // delay=1 doesn't work, and it's too late to drop frames now
                 let delay = ((end_pts * 100_f64).round() as u64)
@@ -520,7 +521,7 @@ impl Writer {
                 }
 
                 let frame = RustEncoder::<&mut dyn std::io::Write>::compress_frame(frame, &self.settings)?;
-                send.push(frame_index, (end_pts, ordinal_frame_number, frame, screen_width, screen_height))?;
+                lzw_queue.send(frame_index, (end_pts, ordinal_frame_number, frame, screen_width, screen_height))?;
             }
             Ok(())
         })
@@ -540,15 +541,15 @@ impl Writer {
     #[inline(never)]
     fn write_inner(&self, decode_queue_recv: Receiver<InputFrame>, writer: &mut dyn Write, reporter: &mut dyn ProgressReporter) -> CatResult<()> {
         thread::scope(|s| {
-            let (diff_queue, diff_queue_recv) = ordqueue::new(0);
+            let (diff_queue, diff_queue_recv) = ordqueue_new(0);
             let resize_thread = thread::Builder::new().name("resize".into()).spawn_scoped(s, move || {
                 self.make_resize(decode_queue_recv, diff_queue)
             })?;
             let (quant_queue, quant_queue_recv) = crossbeam_channel::bounded(0);
             let diff_thread = thread::Builder::new().name("diff".into()).spawn_scoped(s, move || {
                 self.make_diffs(diff_queue_recv, quant_queue)
             })?;
-            let (remap_queue, remap_queue_recv) = ordqueue::new(0);
+            let (remap_queue, remap_queue_recv) = ordqueue_new(0);
             let quant_thread = thread::Builder::new().name("quant".into()).spawn_scoped(s, move || {
                 self.quantize_frames(quant_queue_recv, remap_queue)
             })?;
@@ -591,7 +592,7 @@ impl Writer {
                 };
                 let resized = resized_binary_alpha(image, self.settings.s.width, self.settings.s.height, self.settings.matte)?;
                 let frame_blurred = if self.settings.extra_effort { smart_blur(resized.as_ref()) } else { less_smart_blur(resized.as_ref()) };
-                diff_queue.push(frame.frame_index, InputFrameResized {
+                diff_queue.send(frame.frame_index, InputFrameResized {
                     frame: resized,
                     frame_blurred,
                     presentation_timestamp: frame.presentation_timestamp,
@@ -745,15 +746,15 @@ impl Writer {
             let needs_transparency = frame_index > 0 || (frame_index == 0 && first_frame_has_transparency);
             let (liq, remap, liq_image, out_buf) = self.quantize(image, &importance_map, frame_index == 0, needs_transparency, prev_frame_keeps)?;
 
-            remap_queue.push(frame_index as usize, RemapMessage {
+            Ok(remap_queue.send(frame_index as usize, RemapMessage {
                 ordinal_frame_number,
                 end_pts,
                 dispose,
                 liq, remap,
                 liq_image,
                 out_buf,
                 has_next_frame,
-            })
+            })?)
         })
     }