Add ability to copy frame to clipboard

Author: valadaptive

Cargo.lock

@@ -10,6 +10,7 @@ repository = "https://github.com/valadaptive/ntsc-rs/tree/main/crates/gui"
 
 [dependencies]
 ntscrs = { path = "../ntscrs" }
+arboard = "3.3.2"
 eframe = { version = "0.27", features=["persistence"] }
 env_logger = "0.10.0"
 image = "0.24.7"

crates/gui/Cargo.toml

@@ -18,18 +18,22 @@ use std::{
     thread,
 };
 
-use eframe::egui::{self, pos2, vec2, Rect, util::undoer::Undoer, Response};
+use eframe::egui::{self, pos2, util::undoer::Undoer, vec2, ColorImage, Rect, Response};
 use futures_lite::{Future, FutureExt};
 use glib::clone::Downgrade;
-use gstreamer::{glib, prelude::*, ClockTime};
+use gstreamer::{
+    glib::{self, subclass::types::ObjectSubclassExt},
+    prelude::*,
+    ClockTime,
+};
 use gstreamer_video::{VideoCapsBuilder, VideoFormat, VideoInterlaceMode};
 
 use gui::{
     expression_parser::eval_expression_string,
     gst_utils::{
         clock_format::{clock_time_format, clock_time_parser},
-        egui_sink::{EffectPreviewSetting, EguiCtx, SinkTexture},
-        elements::{EguiSink, NtscFilter, VideoPadFilter},
+        egui_sink::{EffectPreviewSetting, EguiCtx, EguiSink, SinkTexture},
+        elements,
         gstreamer_error::GstreamerError,
         ntscrs_filter::NtscFilterSettings,
         pipeline_utils::{create_pipeline, PipelineError},
@@ -44,7 +48,7 @@ use ntscrs::settings::{
     NtscEffect, NtscEffectFullSettings, ParseSettingsError, SettingDescriptor, SettingID,
     SettingKind, SettingsList, UseField,
 };
-use snafu::prelude::*;
+use snafu::{prelude::*, ResultExt};
 
 use log::debug;
 
@@ -76,21 +80,21 @@ fn initialize_gstreamer() -> Result<(), GstreamerError> {
         None,
         "eguisink",
         gstreamer::Rank::None,
-        EguiSink::static_type(),
+        elements::EguiSink::static_type(),
     )?;
 
     gstreamer::Element::register(
         None,
         "ntscfilter",
         gstreamer::Rank::None,
-        NtscFilter::static_type(),
+        elements::NtscFilter::static_type(),
     )?;
 
     gstreamer::Element::register(
         None,
         "videopadfilter",
         gstreamer::Rank::None,
-        VideoPadFilter::static_type(),
+        elements::VideoPadFilter::static_type(),
     )?;
 
     // PulseAudio has a severe bug that will greatly delay initial playback to the point of unusability:
@@ -2218,8 +2222,9 @@ impl NtscApp {
         egui::TopBottomPanel::top("video_info").show_inside(ui, |ui| {
             ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                 let mut remove_pipeline = false;
-                let mut res = None;
+                let mut change_framerate_res = None;
                 let mut save_image_to: Option<(PathBuf, PathBuf)> = None;
+                let mut copy_image_res: Option<Result<ColorImage, GstreamerError>> = None;
                 if let Some(info) = &mut self.pipeline {
                     let mut metadata = info.metadata.lock().unwrap();
                     if ui.button("🗙").clicked() {
@@ -2228,13 +2233,21 @@ impl NtscApp {
 
                     ui.separator();
 
-                    if ui.button("Save image").clicked() {
+                    if ui.button("Save frame").clicked() {
                         let src_path = info.path.clone();
 
                         let dst_path = src_path.with_extension("");
                         save_image_to = Some((src_path, dst_path));
                     }
 
+                    if ui.button("Copy frame").clicked() {
+                        let egui_sink =
+                            info.egui_sink.downcast_ref::<elements::EguiSink>().unwrap();
+
+                        let egui_sink = EguiSink::from_obj(egui_sink);
+                        copy_image_res = Some(egui_sink.get_image().map_err(|e| e.into()));
+                    }
+
                     if let Some(current_framerate) = metadata.framerate {
                         ui.separator();
                         match metadata.is_still_image {
@@ -2258,7 +2271,7 @@ impl NtscApp {
                                             metadata.framerate = Some(new_framerate);
                                         }
 
-                                        res = Some(changed_framerate);
+                                        change_framerate_res = Some(changed_framerate);
                                     }
                                 }
                             }
@@ -2292,10 +2305,30 @@ impl NtscApp {
                     });
                 }
 
-                if let Some(res) = res {
+                if let Some(res) = change_framerate_res {
                     self.handle_result(res);
                 }
 
+                if let Some(res) = copy_image_res {
+                    match res {
+                        Ok(image) => {
+                            let res = arboard::Clipboard::new().and_then(|mut cb| {
+                                let data = arboard::ImageData {
+                                    width: image.width(),
+                                    height: image.height(),
+                                    bytes: Cow::from(image.as_raw()),
+                                };
+                                cb.set_image(data)?;
+                                Ok(())
+                            });
+                            self.handle_result(res);
+                        }
+                        Err(e) => {
+                            self.handle_error(&e);
+                        }
+                    }
+                }
+
                 if remove_pipeline {
                     self.handle_result_with(|app| app.remove_pipeline());
                 }

crates/gui/src/bin/ntsc-rs-standalone.rs

@@ -97,6 +97,17 @@ impl EguiSink {
         Ok(())
     }
 
+    pub fn get_image(&self) -> Result<ColorImage, gstreamer::FlowError> {
+        let vframe = self.last_frame.lock().unwrap();
+        let (vframe, ..) = vframe.as_ref().ok_or(gstreamer::FlowError::Error)?;
+
+        let width = vframe.width() as usize;
+        let height = vframe.height() as usize;
+        let mut image = ColorImage::new([width, height], Color32::BLACK);
+        self.apply_effect(vframe, &mut image, None)?;
+        Ok(image)
+    }
+
     pub fn update_texture(&self) -> Result<(), gstreamer::FlowError> {
         let mut tex = self.texture.lock().unwrap();
         let vframe = self.last_frame.lock().unwrap();

crates/gui/src/gst_utils/egui_sink.rs

@@ -8,6 +8,7 @@ pub enum GstreamerError {
     BoolError(glib::BoolError),
     PadLinkError(gstreamer::PadLinkError),
     StateChangeError(gstreamer::StateChangeError),
+    FlowError(gstreamer::FlowError),
 }
 
 impl From<glib::Error> for GstreamerError {
@@ -34,13 +35,20 @@ impl From<gstreamer::StateChangeError> for GstreamerError {
     }
 }
 
+impl From<gstreamer::FlowError> for GstreamerError {
+    fn from(value: gstreamer::FlowError) -> Self {
+        GstreamerError::FlowError(value)
+    }
+}
+
 impl Display for GstreamerError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             GstreamerError::GlibError(e) => e.fmt(f),
             GstreamerError::BoolError(e) => e.fmt(f),
             GstreamerError::PadLinkError(e) => e.fmt(f),
             GstreamerError::StateChangeError(e) => e.fmt(f),
+            GstreamerError::FlowError(e) => e.fmt(f),
         }
     }
 }
@@ -52,6 +60,7 @@ impl Error for GstreamerError {
             GstreamerError::BoolError(e) => Some(e),
             GstreamerError::PadLinkError(e) => Some(e),
             GstreamerError::StateChangeError(e) => Some(e),
+            GstreamerError::FlowError(e) => Some(e),
         }
     }
 }