Add Support for Linux

.gitignore

@@ -8,7 +8,10 @@
 /[Bb]uild/
 /[Ll]ogs/
 /[Uu]ser[Ss]ettings/
-
+**/AssetBundles
+ig/
+.vscode
+*.blob
 # MemoryCaptures can get excessive in size.
 # They also could contain extremely sensitive data
 /[Mm]emoryCaptures/

.gitlab-ci.yml

@@ -0,0 +1,9 @@
+image: ${NEXUS_IMAGES_PRIVATE_URL}/devops-tools-base:latest
+
+stages:
+  - success
+
+substitute:
+  stage: success
+  script:
+    - echo "dummy pipeline only needed for repos that have no pipeline configured. this is used to trigger a successful pipeline and meet the requirements to merge"

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "Packages/com.cesium.unity"]
+	path = Packages/com.cesium.unity
+	url = ../cesium-unity.git

Assets/FFmpegOut/Runtime/CameraCapture.cs

@@ -3,6 +3,7 @@
 
 using UnityEngine;
 using System.Collections;
+using System.Threading.Tasks;
 
 namespace FFmpegOut
 {
@@ -61,7 +62,7 @@ int GetAntiAliasingLevel(Camera camera)
 
         #region Public members
 
-        protected virtual FFmpegSession GetSession( int texWidth, int texHeight )
+        protected virtual FFmpegSession GetSession(int texWidth, int texHeight)
         {
             return FFmpegSession.Create(
                 gameObject.name,
@@ -88,7 +89,7 @@ void WarnFrameDrop()
             if (++_frameDropCount != 10) return;
 
             Debug.LogWarning(
-                "Significant frame droppping was detected. This may introduce " +
+                "Significant frame dropping was detected. This may introduce " +
                 "time instability into output video. Decreasing the recording " +
                 "frame rate is recommended."
             );
@@ -133,10 +134,35 @@ void OnDisable()
         IEnumerator Start()
         {
             // Sync with FFmpeg pipe thread at the end of every frame.
-            for (var eof = new WaitForEndOfFrame();;)
+            for (var eof = new WaitForEndOfFrame(); ;)
             {
                 yield return eof;
-                _session?.CompletePushFrames();
+                if (_session != null)
+                {
+                    // Asynchronously complete push frames
+                    yield return CompletePushFramesCoroutine();
+                }
+            }
+        }
+
+        IEnumerator CompletePushFramesCoroutine()
+        {
+            var task = CompletePushFramesAsync();
+            while (!task.IsCompleted)
+            {
+                yield return null;
+            }
+            if (task.Exception != null)
+            {
+                Debug.LogError(task.Exception);
+            }
+        }
+
+        async Task CompletePushFramesAsync()
+        {
+            if (_session != null)
+            {
+                await _session.CompletePushFramesAsync();
             }
         }
 
@@ -190,12 +216,14 @@ void Update()
                 // Push the current frame twice to FFmpeg. Actually this is not
                 // an efficient way to catch up. We should think about
                 // implementing frame duplication in a more proper way. #fixme
+                // TODO: clean this up
+                // _session.PushFrame(camera.targetTexture); removing I would rather drop a frame than have the same frame show twice
                 _session.PushFrame(camera.targetTexture);
-                _session.PushFrame(camera.targetTexture);
-                _frameCount += 2;
+                _frameCount++;
             }
             else
             {
+                Debug.Log("Dropping Frame");
                 // Show a warning message about the situation.
                 WarnFrameDrop();
 

Assets/FFmpegOut/Runtime/FFmpegPreset.cs

@@ -5,6 +5,7 @@ namespace FFmpegOut
 {
     public enum FFmpegPreset
     {
+        MJPEG,
         H264Default,
         H264Nvidia,
         H264Lossless420,
@@ -26,6 +27,7 @@ public static string GetDisplayName(this FFmpegPreset preset)
         {
             switch (preset)
             {
+                case FFmpegPreset.MJPEG:           return "MJPEG";
                 case FFmpegPreset.H264Default:     return "H.264 Default (MP4)";
                 case FFmpegPreset.H264Nvidia:      return "H.264 NVIDIA (MP4)";
                 case FFmpegPreset.H264Lossless420: return "H.264 Lossless 420 (MP4)";
@@ -47,6 +49,7 @@ public static string GetSuffix(this FFmpegPreset preset)
         {
             switch (preset)
             {
+                case FFmpegPreset.MJPEG:
                 case FFmpegPreset.H264Default:
                 case FFmpegPreset.H264Nvidia:
                 case FFmpegPreset.H264Lossless420:
@@ -69,8 +72,9 @@ public static string GetOptions(this FFmpegPreset preset)
             switch (preset)
             {
                 // case FFmpegPreset.H264Default:     return "-pix_fmt yuv420p";
-                case FFmpegPreset.H264Default:     return "-c:v libx264 -preset fast -tune zerolatency -b:v 10M";
-                case FFmpegPreset.H264Nvidia:      return "-c:v h264_nvenc -preset fast  -b:v 10M";
+                case FFmpegPreset.MJPEG:           return "-flush_packets 0 -max_delay 100000";
+                case FFmpegPreset.H264Default:     return "-c:v libx264 -preset fast -b:v 10M";
+                case FFmpegPreset.H264Nvidia:      return "-c:v h264_nvenc -preset fast -b:v 10M";
                 case FFmpegPreset.H264Lossless420: return "-pix_fmt yuv420p -preset ultrafast -crf 0";
                 case FFmpegPreset.H264Lossless444: return "-pix_fmt yuv444p -preset ultrafast -crf 0";
                 case FFmpegPreset.HevcDefault:     return "-c:v libx265 -pix_fmt yuv420p";

Assets/FFmpegOut/Runtime/FFmpegSession.cs

@@ -4,6 +4,7 @@
 using UnityEngine;
 using UnityEngine.Rendering;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace FFmpegOut
 {
@@ -39,7 +40,6 @@ FFmpegPreset preset
                 + " -b:v 2M" // Bitrate
                 + " " + outputPath
             );
-
         }
 
         public static FFmpegSession CreateWithArguments(string arguments)
@@ -65,6 +65,11 @@ public void CompletePushFrames()
             _pipe?.SyncFrameData();
         }
 
+        public async Task CompletePushFramesAsync()
+        {
+            await Task.Run(() => CompletePushFrames());
+        }
+
         public void Close()
         {
             if (_pipe != null)

Assets/FFmpegOut/Runtime/LiveStream/StreamCameraCapture.cs

@@ -4,8 +4,9 @@ namespace FFmpegOut.LiveStream
 {
     public class StreamCameraCapture : CameraCapture
     {
-        [SerializeField] protected StreamPreset _streamPreset;
+        [SerializeField] public StreamPreset _streamPreset;
         [SerializeField] public string streamAddress;
+        [SerializeField] public bool isGreyScale;
 
         protected override FFmpegSession GetSession(int texWidth, int texHeight)
         {
@@ -15,7 +16,7 @@ protected override FFmpegSession GetSession(int texWidth, int texHeight)
                 frameRate,
                 preset,
                 _streamPreset,
-                streamAddress);
+                streamAddress, isGreyScale);
         }
     }
 }

Assets/FFmpegOut/Runtime/LiveStream/StreamFFmpegSession.cs

@@ -1,51 +1,92 @@
-using System;
+using System;
+using System.Threading;
+using System.Diagnostics;
 using UnityEngine;
 
 namespace FFmpegOut.LiveStream
 {
-    /// <summary>
-    /// Represents a session for streaming video from Unity to an RTP endpoint using FFmpeg.
-    /// </summary>
     public sealed class StreamFFmpegSession : FFmpegSession
     {
-        // Defines the format and codec for the raw video data from Unity.
+        private Thread ffmpegThread;
+        private Process ffmpegProcess;
+        private string ffmpegArguments;
+
         private const string UNITY_CAM_TEX_BYTE_FORMAT =
             "-pixel_format rgba -colorspace bt709 -f rawvideo -vcodec rawvideo";
-        // private const string UNITY_CAM_TEX_BYTE_FORMAT =
-        //     "-pixel_format rgba";
-
-        // Sets the FFmpeg logging level to warning.
         private const string FFMPEG_LOGLEVEL = "-loglevel warning";
 
-        // Private constructor to enforce the use of the static Create method.
-        private StreamFFmpegSession(string arguments) : base(arguments) { }
-
-        /// <summary>
-        /// Creates a new FFmpeg session for streaming.
-        /// </summary>
-        /// <param name="width">The width of the video.</param>
-        /// <param name="height">The height of the video.</param>
-        /// <param name="frameRate">The frame rate of the video.</param>
-        /// <param name="encodingPreset">The encoding preset to use.</param>
-        /// <param name="streamPreset">The streaming preset to use.</param>
-        /// <param name="address">The address to stream to.</param>
-        /// <returns>A new instance of StreamFFmpegSession.</returns>
+        private StreamFFmpegSession(string arguments) : base(arguments)
+        {
+            this.ffmpegArguments = arguments;
+        }
+
         public static StreamFFmpegSession Create(
             int width, int height, float frameRate,
             FFmpegPreset encodingPreset, StreamPreset streamPreset,
-            string address)
+            string address, bool isGreyScale)
         {
-            // Constructs the FFmpeg command-line arguments for streaming.
+            string colorConversion = "";
+            if (isGreyScale)
+            {
+                colorConversion = "-vf format=gray -pix_fmt gray ";
+            }
+
             string ffmpegArguments =
                 $"{UNITY_CAM_TEX_BYTE_FORMAT} {FFMPEG_LOGLEVEL} -framerate {frameRate} -video_size {width}x{height} "
-                + $"-re -i pipe:0 {encodingPreset.GetOptions()} "
+                + $"-re -i pipe:0 {encodingPreset.GetOptions()} {colorConversion}"
                 + $"{streamPreset.GetOptions()} {address}";
+            UnityEngine.Debug.Log($"FFmpeg Arguments: {ffmpegArguments}");
+            return new StreamFFmpegSession(ffmpegArguments);
+        }
 
-            // Logs the constructed FFmpeg arguments for debugging purposes.
-            Debug.Log($"FFmpeg Arguments: {ffmpegArguments}");
+        public void Start()
+        {
+            if (ffmpegThread == null || !ffmpegThread.IsAlive)
+            {
+                ffmpegThread = new Thread(ExecuteFFmpeg);
+                ffmpegThread.IsBackground = true;
+                ffmpegThread.Start();
+            }
+        }
 
-            // Returns a new FFmpeg session with the constructed arguments.
-            return new StreamFFmpegSession(ffmpegArguments);
+        private void ExecuteFFmpeg()
+        {
+            ProcessStartInfo startInfo = new ProcessStartInfo("ffmpeg", ffmpegArguments)
+            {
+                UseShellExecute = false,
+                RedirectStandardInput = true,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                CreateNoWindow = true
+            };
+
+            ffmpegProcess = new Process { StartInfo = startInfo };
+            ffmpegProcess.Start();
+
+            ffmpegProcess.BeginOutputReadLine();
+            ffmpegProcess.BeginErrorReadLine();
+            ffmpegProcess.OutputDataReceived += (sender, args) => UnityEngine.Debug.Log("FFmpeg output: " + args.Data);
+            ffmpegProcess.ErrorDataReceived += (sender, args) => UnityEngine.Debug.Log("FFmpeg error: " + args.Data);
+        }
+
+        public void Stop()
+        {
+            if (ffmpegProcess != null)
+            {
+                if (!ffmpegProcess.HasExited)
+                {
+                    ffmpegProcess.Kill();
+                }
+                ffmpegProcess.Dispose();
+            }
+            if (ffmpegThread != null)
+            {
+                if (ffmpegThread.IsAlive)
+                {
+                    ffmpegThread.Join();  // Wait for the thread to finish
+                }
+                ffmpegThread = null;
+            }
         }
     }
-}
+}

Assets/FFmpegOut/Runtime/LiveStream/StreamPreset.cs

@@ -3,6 +3,7 @@
     public enum StreamPreset
     {
         Udp,
+        UdpMJPEG,
         Rtp,
         Rtsp,
         Hls,
@@ -18,6 +19,8 @@ public static string GetOptions(this StreamPreset preset)
             {
                 case StreamPreset.Udp:
                     return "-f rtp";
+                case StreamPreset.UdpMJPEG:
+                    return "-vcodec mjpeg -q:v 2 -f mjpeg";
                 case StreamPreset.Rtp:
                     return "-f rtp_mpegts";
                 case StreamPreset.Rtsp: