Improved recording experience

- Added setup command to build a videos directory at ~/Videos/spur
- Added filename support
- Still need to add randomly generated filenames based on timestamps

Author: nsrCodes

Cargo.toml

@@ -10,4 +10,7 @@ scrap = "0.5.0"
 v4l = {version = "0.12.1", features = ["v4l2-sys"] }
 gstreamer = "0.17.4"
 gstreamer-video = "0.17.2"
-num-rational = "0.4.0"
+num-rational = "0.4.0"
+
+home = "0.5.3"
+chrono = "0.4"

src/constants.rs

@@ -1,4 +1,10 @@
 pub const AUTHOR: &str = "nsrCodes";
 pub const DESCRIPTION: &str = "Make easily sharable recordings with ease";
 pub const CMD: &str = "spur";
-pub const VERSION: &str = "0.1.0";
+pub const VERSION: &str = "0.1.1";
+
+/* App constants */
+pub const CONFIG_FILE_NAME: &str = "spur_config.txt";
+pub const VIDEOS_FOLDER_FROM_HOME: &str = "Videos/spur";
+pub const STREAM_API: &str = "rtmp://someendpoint:1935"; // todo : get from env
+pub const STREAM_API_PATH: &str = "live"; // todo : get from env

src/lib.rs

@@ -4,13 +4,15 @@ pub mod constants;
 pub mod options;
 pub mod overlay;
 pub mod parser;
+pub mod paths;
 pub mod recorder;
 pub mod session;
 pub mod streamer;
 
 #[derive(Debug)]
 pub enum CustomError {
     InvalidAnswer,
+    CouldNotFindHome,
 }
 
 #[derive(Debug)]
@@ -25,45 +27,37 @@ pub enum ThreadMessages {
 #[derive(Debug, Clone)]
 pub struct Config {
     pub s_type: SType,
-    pub name: String,
-    pub cmd: &'static str,
-    pub path: &'static str,
+    pub filename: String,
+    pub path: String,
     pub quality: Quality,
     pub framerate: FrameRate,
     pub overlay: bool,
 }
 
 impl Config {
-    pub fn new(st: SType) -> Self {
-        let (name, path) = match st {
-            // Make tis a function
-            SType::Record => (SType::to_string(&SType::Record), "rtmp://someendpoint:1935"),
-            SType::Stream => (SType::to_string(&SType::Stream), "my-demo.mkv"),
-        };
+    pub fn new(st: SType, filename: String) -> Self {
+        let path = st.get_target_path(&filename);
+
         Config {
-            cmd: constants::CMD,
-            name,
+            filename: String::from(filename),
             path,
             framerate: FrameRate::default(),
             quality: Quality::default(),
             overlay: overlay::default(),
             s_type: st,
         }
     }
+
+    // CURRENTLY, NOT USED
     pub fn update_session_type(&mut self, st: SType) {
         self.s_type = st;
-        let (name, path) = match st {
-            SType::Record => (SType::to_string(&SType::Record), "rtmp://someendpoint:1935"),
-            SType::Stream => (SType::to_string(&SType::Stream), "my-demo.mkv"),
-        };
-        self.name = name;
-        self.path = path;
+        self.path = st.get_target_path(&self.filename);
     }
-    pub fn create_path_arg<'a>(&self) -> Arg<'a> {
+    pub fn create_path_arg(&self) -> Arg {
         Arg::new("path")
             .long("path")
             .takes_value(self.s_type == SType::Record)
-            .default_value(self.path)
+            .default_value(self.path.as_str())
             .help("Set path of recording")
     }
 
@@ -82,6 +76,14 @@ impl Config {
             .help("Show current config settings")
     }
 }
+
+impl Default for Config {
+    fn default() -> Self {
+        let default_st = SType::default();
+        Config::new(default_st, parser::get_filename_from_arg(default_st, None))
+    }
+}
+
 /*Media*/
 pub trait Media {
     fn new(config: Config) -> Self
@@ -92,9 +94,3 @@ pub trait Media {
     fn cancel_stream(&self);
     fn create_pipeline(&mut self);
 }
-
-impl Default for Config {
-    fn default() -> Self {
-        Config::new(SType::default())
-    }
-}

src/options.rs

@@ -1,12 +1,80 @@
-use crate::CustomError;
+use crate::{paths, CustomError};
 use clap::Arg;
 use std::str::FromStr;
+
 pub trait MetaOption {
     const COMMAND_NAME: &'static str;
     fn values() -> [&'static str; 2];
     fn create_arg<'a>() -> Arg<'a>;
 }
 
+/** Type */
+#[derive(PartialEq, Debug, Clone, Copy)]
+pub enum SType {
+    Record = 0,
+    Stream = 1,
+}
+
+impl SType {
+    pub fn get_name(&self) -> String {
+        SType::to_string(self)
+    }
+
+    pub fn get_target_path(&self, filename: &String) -> String {
+        match self {
+            // todo: convert this into a function
+            SType::Record => paths::get_video_path(filename)
+                .as_path()
+                .display()
+                .to_string(),
+            SType::Stream => paths::get_stream_path(filename),
+        }
+    }
+}
+
+impl Default for SType {
+    fn default() -> Self {
+        SType::Stream
+    }
+}
+
+impl FromStr for SType {
+    type Err = CustomError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "record" => Ok(SType::Record),
+            "stream" => Ok(SType::Stream),
+            _ => Err(CustomError::InvalidAnswer),
+        }
+    }
+}
+
+impl ToString for SType {
+    fn to_string(&self) -> String {
+        match self {
+            &Self::Record => String::from("record"),
+            &Self::Stream => String::from("stream"),
+        }
+    }
+}
+impl MetaOption for SType {
+    const COMMAND_NAME: &'static str = "session";
+    fn values() -> [&'static str; 2] {
+        const SUB_COMMANDS: [&'static str; 2] = ["record", "stream"];
+        SUB_COMMANDS
+    }
+
+    fn create_arg<'a>() -> Arg<'a> {
+        Arg::new(Self::COMMAND_NAME)
+            .long(Self::COMMAND_NAME)
+            .takes_value(true)
+            .default_value("record")
+            .required(false)
+            .help("Wether to stream to server or store to storage")
+    }
+}
+
 /** Quality */
 #[derive(Debug, Clone, Copy)]
 pub enum Quality {
@@ -104,53 +172,3 @@ impl MetaOption for FrameRate {
             .help("Framerate of recording")
     }
 }
-
-/** Type */
-#[derive(PartialEq, Debug, Clone, Copy)]
-pub enum SType {
-    Record = 0,
-    Stream = 1,
-}
-
-impl Default for SType {
-    fn default() -> Self {
-        SType::Stream
-    }
-}
-
-impl FromStr for SType {
-    type Err = CustomError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "record" => Ok(SType::Record),
-            "stream" => Ok(SType::Stream),
-            _ => Err(CustomError::InvalidAnswer),
-        }
-    }
-}
-
-impl ToString for SType {
-    fn to_string(&self) -> String {
-        match self {
-            &Self::Record => String::from("record"),
-            &Self::Stream => String::from("stream"),
-        }
-    }
-}
-impl MetaOption for SType {
-    const COMMAND_NAME: &'static str = "session";
-    fn values() -> [&'static str; 2] {
-        const SUB_COMMANDS: [&'static str; 2] = ["record", "stream"];
-        SUB_COMMANDS
-    }
-
-    fn create_arg<'a>() -> Arg<'a> {
-        Arg::new(Self::COMMAND_NAME)
-            .long(Self::COMMAND_NAME)
-            .takes_value(true)
-            .default_value("record")
-            .required(false)
-            .help("Wether to stream to server or store to storage")
-    }
-}

src/overlay.rs

@@ -76,7 +76,6 @@ impl Media for CameraPreview {
 
     fn cancel_stream(&self) {}
     fn create_pipeline(&mut self) {
-        println!("Handling stream");
         let rate = Ratio::new(self.config.framerate as i32, 1);
         const WIDTH: i32 = 400;
         // const WIDTH: i32 = 800;
@@ -177,8 +176,8 @@ impl Media for CameraPreview {
             caps.set_data("caps", capsfilter);
 
             match caps.data::<Caps>("caps") {
-                Some(data) => {
-                    println!("{:?}", data.as_ref());
+                Some(_data) => {
+                    // println!("{:?}", data.as_ref());
                 }
                 None => println!("No data"),
             }

src/parser.rs

@@ -1,25 +1,42 @@
 use crate::{
     constants,
     options::{FrameRate, MetaOption, Quality, SType},
-    overlay, parser,
+    overlay, parser, paths,
     session::Session,
     Config,
 };
-use clap::{ArgMatches, Command};
-use std::str::FromStr;
+use clap::{Arg, ArgMatches, Command};
+use std::{fs, io::Write, process, str::FromStr};
 
-fn create_sub_command<'a>(st: SType) -> Command<'a> {
-    let conf = Config::new(st);
-    let path = conf.create_path_arg();
+/* Utils */
+// use chrono;
 
-    Command::new(conf.name).args([
+fn create_sub_command(st: SType) -> Command<'static> {
+    Command::new(st.get_name()).args([
         overlay::create_arg(),
         Quality::create_arg(),
         FrameRate::create_arg(),
-        path,
+        Arg::new("name")
+            .long("filename")
+            .short('n')
+            .takes_value(true)
+            .help("Name of recorded video"),
     ])
 }
 
+pub fn get_filename_from_arg(st: SType, arg_filename: Option<&str>) -> String {
+    let name = match arg_filename {
+        Some(fname) => fname,
+        // None => format!("{:?}", chrono::offset::Utc::now()).as_str(), // todo : generate from datetime
+        None => "123", // todo : generate from datetime
+    };
+    match st {
+        SType::Record => format!("{}.mkv", name),
+        SType::Stream => format!("/{}/{}", constants::STREAM_API_PATH, name),
+    }
+}
+
+/* Parser */
 pub fn parse_args() -> ArgMatches {
     return Command::new("spur")
         .version(constants::VERSION)
@@ -29,16 +46,50 @@ pub fn parse_args() -> ArgMatches {
         .subcommands([
             create_sub_command(SType::Record),
             create_sub_command(SType::Stream),
+            Command::new("setup").about("setting up spur on your machine"),
         ])
         .get_matches();
 }
 
 pub fn create_session_from_args() -> Session {
-    let mut conf = Config::default();
     let matches = parser::parse_args();
     match matches.subcommand() {
+        Some(("setup", _)) => {
+            // todo : abstract to function
+            // Creating a Videos directory
+            let videos_path = paths::get_video_directory_path();
+
+            fs::DirBuilder::new()
+                .recursive(true)
+                .create(&videos_path)
+                .unwrap_or_else(|err| {
+                    println!("Couldn't create directory - {}", videos_path.display());
+                    println!("Error - {:?}", err);
+                    process::exit(1);
+                });
+
+            // CURRENTLY, NOT USED
+            // Saving conf to text file
+            let home_path = paths::get_home_path().expect("Couldn't find your Home directory");
+            let mut conf_file = fs::File::create(format!(
+                "{}/{}",
+                home_path.display(),
+                constants::CONFIG_FILE_NAME
+            ))
+            .expect("Could not create conf file");
+            conf_file
+                .write_all(format!("{}", videos_path.display()).as_bytes()) // hacky
+                .expect("Could not write to conf file");
+            println!("-------------- Setup is complete ------------------------");
+            process::exit(0);
+        }
         Some((cmd_str, sub_match)) => {
-            conf.s_type = SType::from_str(cmd_str).unwrap();
+            // Creating config for new session
+            let st = SType::from_str(cmd_str).unwrap();
+            let arg_filename = sub_match.value_of("name");
+            let mut conf = Config::new(st, get_filename_from_arg(st, arg_filename));
+
+            // Updating config with parsed parameters
             let arg_quality = sub_match
                 .value_of(Quality::COMMAND_NAME)
                 .unwrap_or_default();