Merge branch 'release/0.2.0'

Author: c-x-berger

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rusty-engine"
-version = "0.1.0"
+version = "0.2.0"
 description = "Rust reimagining of potential-engine"
 readme = "README.md"
 license = "MIT"
@@ -13,6 +13,8 @@ travis-ci = { repository = "opensight-cv/rusty-engine" }
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0.44"
 structopt = "0.3.7"
 glib = "0.9.0"
 gstreamer = "0.15.0"

Cargo.toml

@@ -9,7 +9,7 @@ use gstreamer_rtsp_server::{
 };
 use structopt::StructOpt;
 
-use pipe_builder::{Encoder, Input, VideoSize};
+use pipe_builder::{Encoder, Input, Pipe, VideoSize};
 
 #[derive(Debug, StructOpt)]
 #[structopt(
@@ -34,9 +34,10 @@ struct Opt {
         long,
         help = "Input mode to use",
         required_unless = "list",
+        required_unless = "pipes-as-json",
         possible_values(&["v4l2", "shmem", "rpi"])
     )]
-    input: Input,
+    input: Option<Input>, // this looks stupid, but some library freaks out without it. we get the desired effect at run anyway
     #[structopt(
         short,
         long,
@@ -54,6 +55,8 @@ struct Opt {
         default_value_if("input", Some("rpi"), "camera")
     )]
     encoder: Encoder,
+    #[structopt(long, help = "Pipelines to run as JSON.")]
+    pipes_as_json: Option<String>,
     #[structopt(long, help = "List all input modes and exit.", group = "list")]
     list_in: bool,
     #[structopt(long, help = "List all encoders and exit.", group = "list")]
@@ -79,30 +82,46 @@ fn main() {
         }
         return;
     }
-    // try to set up video size
-    let size = VideoSize::new(opt.width, opt.height, opt.framerate);
-    let device = opt.device.unwrap_or("".to_string());
-    let mut input = opt.input;
-    input = match input {
-        Input::Video4Linux(_) => Input::Video4Linux(device),
-        Input::SharedMemory(_) => Input::SharedMemory(device),
-        _ => input,
-    };
-    let encoder = opt.encoder;
-    let pipe = pipe_builder::create_pipe(input, encoder, size);
-    println!("Pipeline constructed: {}", pipe);
+    // set up basic Gst stuff
     gstreamer::init().expect("GStreamer could not init!");
     let loop_ = MainLoop::new(Option::None, false);
     let server = RTSPServer::new();
     server.set_service(&opt.net_opt.get_port().to_string());
-    let factory = RTSPMediaFactory::new();
-    factory.set_launch(&pipe);
-    factory.set_shared(true);
     let mounts = server
         .get_mount_points()
         .expect("Failed to get mount points");
-    // set up mounts
-    mounts.add_factory(opt.net_opt.get_url(), &factory);
+    if opt.pipes_as_json.is_some() {
+        let config = opt.pipes_as_json.unwrap();
+        let pipes: Vec<Pipe> = serde_json::from_str(&config).expect("JSON could not parse!");
+        println!("{:#?}", pipes);
+        for pipe in pipes.iter() {
+            let factory = RTSPMediaFactory::new();
+            let pipe_str = pipe_builder::create_pipe(pipe);
+            println!("Pipeline constructed: {}", pipe_str);
+            factory.set_launch(&pipe_str);
+            factory.set_shared(true);
+            mounts.add_factory(pipe.url(), &factory);
+        }
+    } else {
+        // try to set up video size
+        let size = VideoSize::new(opt.width, opt.height, opt.framerate);
+        let device = opt.device.unwrap_or("".to_string());
+        let mut input = opt.input.unwrap();
+        input = match input {
+            Input::Video4Linux(_) => Input::Video4Linux(device),
+            Input::SharedMemory(_) => Input::SharedMemory(device),
+            _ => input,
+        };
+        let encoder = opt.encoder;
+        let pipe = Pipe::new(input, encoder, size, String::from(opt.net_opt.get_url()));
+        let pipe_str = pipe_builder::create_pipe(&pipe);
+        println!("Pipeline constructed: {}", pipe_str);
+        let factory = RTSPMediaFactory::new();
+        factory.set_launch(&pipe_str);
+        factory.set_shared(true);
+        // set up mounts
+        mounts.add_factory(pipe.url(), &factory);
+    }
     server.attach(Option::None);
     println!("Starting loop...");
     loop_.run();

src/main.rs

@@ -1,6 +1,7 @@
+use serde::Deserialize;
 use std::{convert, fmt, str::FromStr};
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Deserialize)]
 pub enum Encoder {
     Software,
     OpenMAX,

src/pipe_builder/encoder.rs

@@ -1,6 +1,7 @@
+use serde::Deserialize;
 use std::{convert, fmt, str::FromStr};
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Deserialize)]
 pub enum Input {
     Video4Linux(String),
     SharedMemory(String),

src/pipe_builder/input.rs

@@ -1,7 +1,11 @@
 mod encoder;
 mod input;
-pub use self::{encoder::Encoder, input::Input};
+mod pipe;
+pub use self::{encoder::Encoder, input::Input, pipe::Pipe};
 
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
 pub struct VideoSize {
     width: u32,
     height: u32,
@@ -18,32 +22,34 @@ impl VideoSize {
     }
 }
 
-pub fn create_pipe(inp: Input, enc: Encoder, dim: VideoSize) -> String {
-    if inp == Input::Raspberry && enc != Encoder::Camera {
+pub fn create_pipe(pipe: &Pipe) -> String {
+    if *pipe.input() == Input::Raspberry && *pipe.encoder() != Encoder::Camera {
         println!("using a raspberry pi camera with any encoder besides the one provided by the driver is a Bad Idea");
     }
-    let inp_str = match inp {
+    let inp_str = match pipe.input() {
         Input::Video4Linux(device) => format!("v4l2src device={}", device),
         Input::Raspberry => String::from("rpicamsrc"),
         Input::SharedMemory(socket) => format!(
             "shmsrc socket-path={} ! capsfilter caps=video/x-raw,format=I420",
             socket
         ),
     };
-    let enc_str = match enc {
+    let enc_str = match pipe.encoder() {
         Encoder::Software => format!(
-            "video/x-raw,width={w},height={h},framerate={f}/1 ! videoconvert ! x264enc",
-            w = dim.width,
-            h = dim.height,
-            f = dim.framerate
+            "video/x-raw,width={w},height={h},framerate={f}/1 ! videoconvert ! x264enc tune=zerolatency",
+            w = pipe.size().width,
+            h = pipe.size().height,
+            f = pipe.size().framerate
         ),
         Encoder::Camera => format!(
             "video/x-h264,width={w},height={h},framerate={f}/1",
-            w = dim.width,
-            h = dim.height,
-            f = dim.framerate
+            w = pipe.size().width,
+            h = pipe.size().height,
+            f = pipe.size().framerate
         ),
-        Encoder::OpenMAX => format!("videoconvert ! video/x-raw,format=I420,width={w},height={h},framerate={f}/1 ! omxh264enc ! video/x-h264", w = dim.width, h = dim.height, f = dim.framerate)
+        Encoder::OpenMAX => format!(
+            "video/x-raw,width={w},height={h},framerate={f}/1 ! videoconvert ! video/x-raw,format=I420 ! omxh264enc ! video/x-h264,profile=baseline",
+            w = pipe.size().width, h = pipe.size().height, f = pipe.size().framerate)
     };
     vec![inp_str, enc_str, String::from("rtph264pay name=pay0")].join(" ! ")
 }
@@ -60,26 +66,37 @@ mod tests {
     fn test_raspberry_pipe() {
         assert_eq!(
             "rpicamsrc ! video/x-h264,width=320,height=240,framerate=30/1 ! rtph264pay name=pay0",
-            create_pipe(Input::Raspberry, Encoder::Camera, test_size())
+            create_pipe(&Pipe::new(
+                Input::Raspberry,
+                Encoder::Camera,
+                test_size(),
+                String::new()
+            ))
         );
     }
 
     #[test]
     fn test_v4l2_pipes() {
         assert_eq!(
-            "v4l2src device=/dev/video0 ! video/x-raw,width=320,height=240,framerate=30/1 ! videoconvert ! x264enc ! rtph264pay name=pay0",
+            "v4l2src device=/dev/video0 ! video/x-raw,width=320,height=240,framerate=30/1 ! videoconvert ! x264enc tune=zerolatency ! rtph264pay name=pay0",
             create_pipe(
-                Input::Video4Linux("/dev/video0".to_string()),
-                Encoder::Software,
-                test_size(),
+                &Pipe::new(
+                    Input::Video4Linux("/dev/video0".to_string()),
+                    Encoder::Software,
+                    test_size(),
+                    String::new()
+                )
             )
         );
         assert_eq!(
-            "v4l2src device=/dev/video0 ! videoconvert ! video/x-raw,format=I420,width=320,height=240,framerate=30/1 ! omxh264enc ! video/x-h264 ! rtph264pay name=pay0",
+            "v4l2src device=/dev/video0 ! video/x-raw,width=320,height=240,framerate=30/1 ! videoconvert ! video/x-raw,format=I420 ! omxh264enc ! video/x-h264,profile=baseline ! rtph264pay name=pay0",
             create_pipe(
-                Input::Video4Linux("/dev/video0".to_string()),
-                Encoder::OpenMAX,
-                test_size(),
+                &Pipe::new(
+                    Input::Video4Linux("/dev/video0".to_string()),
+                    Encoder::OpenMAX,
+                    test_size(),
+                    String::new()
+                )
             )
         );
     }

src/pipe_builder/mod.rs

@@ -0,0 +1,41 @@
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+pub struct Pipe {
+    input: super::Input,
+    encoder: super::Encoder,
+    size: super::VideoSize,
+    url: String,
+}
+
+impl Pipe {
+    pub fn new(
+        input: super::Input,
+        encoder: super::Encoder,
+        size: super::VideoSize,
+        url: String,
+    ) -> Pipe {
+        Pipe {
+            input,
+            encoder,
+            size,
+            url,
+        }
+    }
+
+    pub fn input(&self) -> &super::Input {
+        &self.input
+    }
+
+    pub fn encoder(&self) -> &super::Encoder {
+        &self.encoder
+    }
+
+    pub fn size(&self) -> &super::VideoSize {
+        &self.size
+    }
+
+    pub fn url(&self) -> &String {
+        &self.url
+    }
+}