Enhanced Features: Snapshot Manager + MP4 Muxer

.gitignore

@@ -14,3 +14,9 @@ install_manifest.txt
 #live
 live/
 live555-latest.tar.gz
+# OS
+.DS_Store
+/tmp
+/test
+.cursor
+.ssh

inc/ALSACapture.h

@@ -51,6 +51,7 @@ class ALSACapture  : public DeviceInterface
 
 		virtual int            getSampleRate()      { return m_params.m_sampleRate; }
 		virtual int            getChannels  ()      { return m_params.m_channels;   }
+		virtual int            getFps()             { return -1;                    }  // Not applicable for audio
 		virtual int            getAudioFormat ()    { return m_fmt;                 }
 		virtual std::list<int> getAudioFormatList() { return m_fmtList;             }
 

inc/DeviceInterface.h

@@ -22,6 +22,7 @@ class DeviceInterface
 		virtual unsigned long  getBufferSize()               = 0;
 		virtual int            getWidth()                    { return -1; }	
 		virtual int            getHeight()                   { return -1; }
+		virtual int            getFps()                      { return -1; }	
 		virtual int            getVideoFormat()              { return -1; }
 		virtual std::list<int> getVideoFormatList()          { return std::list<int>(); }
 		virtual int            getSampleRate()               { return -1; }

inc/DeviceSourceFactory.h

@@ -19,11 +19,11 @@
 
 class DeviceSourceFactory {
     public:
-		static FramedSource* createFramedSource(UsageEnvironment* env, int format, DeviceInterface* devCapture, int queueSize = 5, V4L2DeviceSource::CaptureMode captureMode = V4L2DeviceSource::CAPTURE_INTERNAL_THREAD, int outfd = -1, bool repeatConfig = true) {
+		static FramedSource* createFramedSource(UsageEnvironment* env, int format, DeviceInterface* devCapture, int queueSize = 5, V4L2DeviceSource::CaptureMode captureMode = V4L2DeviceSource::CAPTURE_INTERNAL_THREAD, int outfd = -1, bool repeatConfig = true, bool isMP4 = false) {
             FramedSource* source = NULL;
             if (format == V4L2_PIX_FMT_H264)
             {
-                source = H264_V4L2DeviceSource::createNew(*env, devCapture, outfd, queueSize, captureMode, repeatConfig, false);
+                source = H264_V4L2DeviceSource::createNew(*env, devCapture, outfd, queueSize, captureMode, repeatConfig, false, isMP4);
             }
             else if (format == V4L2_PIX_FMT_HEVC)
             {
@@ -36,9 +36,9 @@ class DeviceSourceFactory {
             return source;
         }
 
-        static StreamReplicator* createStreamReplicator(UsageEnvironment* env, int format, DeviceInterface* devCapture, int queueSize = 5, V4L2DeviceSource::CaptureMode captureMode = V4L2DeviceSource::CAPTURE_INTERNAL_THREAD, int outfd = -1, bool repeatConfig = true) {
+        static StreamReplicator* createStreamReplicator(UsageEnvironment* env, int format, DeviceInterface* devCapture, int queueSize = 5, V4L2DeviceSource::CaptureMode captureMode = V4L2DeviceSource::CAPTURE_INTERNAL_THREAD, int outfd = -1, bool repeatConfig = true, bool isMP4 = false) {
             StreamReplicator* replicator = NULL;
-            FramedSource* framedSource = DeviceSourceFactory::createFramedSource(env, format, devCapture, queueSize, captureMode, outfd, repeatConfig);
+            FramedSource* framedSource = DeviceSourceFactory::createFramedSource(env, format, devCapture, queueSize, captureMode, outfd, repeatConfig, isMP4);
             if (framedSource != NULL) 
             {						
                 // extend buffer size if needed

inc/H264_V4l2DeviceSource.h

@@ -9,25 +9,46 @@
 **
 ** -------------------------------------------------------------------------*/
 
-
 #pragma once
 
+#include <vector>
+
 // project
 #include "H26x_V4l2DeviceSource.h"
+#include "SnapshotManager.h"
+
+class QuickTimeMuxer; // Forward declaration
+
+// ---------------------------------
+// H264 V4L2 FramedSource
+// ---------------------------------
+// Note: H264marker and H264shortmarker are defined in H26x_V4l2DeviceSource.h
 
 class H264_V4L2DeviceSource : public H26X_V4L2DeviceSource
 {
 	public:				
-		static H264_V4L2DeviceSource* createNew(UsageEnvironment& env, DeviceInterface * device, int outputFd, unsigned int queueSize, CaptureMode captureMode, bool repeatConfig, bool keepMarker) {
-			return new H264_V4L2DeviceSource(env, device, outputFd, queueSize, captureMode, repeatConfig, keepMarker);
+		static H264_V4L2DeviceSource* createNew(UsageEnvironment& env, DeviceInterface * device, int outputFd, unsigned int queueSize, CaptureMode captureMode, bool repeatConfig, bool keepMarker, bool isMP4 = false) {
+			return new H264_V4L2DeviceSource(env, device, outputFd, queueSize, captureMode, repeatConfig, keepMarker, isMP4);
 		}
 
 	protected:
-		H264_V4L2DeviceSource(UsageEnvironment& env, DeviceInterface * device, int outputFd, unsigned int queueSize, CaptureMode captureMode, bool repeatConfig, bool keepMarker) 
-			: H26X_V4L2DeviceSource(env, device, outputFd, queueSize, captureMode, repeatConfig, keepMarker) {} 
+		H264_V4L2DeviceSource(UsageEnvironment& env, DeviceInterface * device, int outputFd, unsigned int queueSize, CaptureMode captureMode, bool repeatConfig, bool keepMarker, bool isMP4 = false) 
+			: H26X_V4L2DeviceSource(env, device, outputFd, queueSize, captureMode, repeatConfig, keepMarker), m_quickTimeMuxer(nullptr), m_isMP4(isMP4), m_currentFrameData(), m_currentFrameIsKeyframe(false) {
+			// Check if output file is MP4 based on file descriptor (simple heuristic)
+			// This could be improved by passing a flag from the caller
+		}
+
+		virtual ~H264_V4L2DeviceSource();
 
 		// overide V4L2DeviceSource
 		virtual std::list< std::pair<unsigned char*,size_t> > splitFrames(unsigned char* frame, unsigned frameSize);
 		virtual std::list< std::string > getInitFrames();
 		virtual bool isKeyFrame(const char*, int);
+
+	private:
+		QuickTimeMuxer* m_quickTimeMuxer;
+		bool m_isMP4;
+		std::vector<unsigned char> m_currentFrameData;
+		bool m_currentFrameIsKeyframe;
+		void initQuickTimeMuxerIfNeeded();
 };

inc/HTTPServer.h

@@ -14,6 +14,7 @@
 #pragma once
 
 #include <list>
+#include <vector>
 
 // hacking private members RTSPServer::fWeServeSRTP & RTSPServer::fWeEncryptSRTP
 #define private protected
@@ -144,6 +145,7 @@ class HTTPServer : public RTSPServer
 			void sendHeader(const char* contentType, unsigned int contentLength);		
 			void streamSource(FramedSource* source);	
 			void streamSource(const std::string & content);
+			void streamSource(const std::vector<unsigned char>& binaryData);
 			ServerMediaSubsession* getSubsesion(const char* urlSuffix);
 			bool sendFile(char const* urlSuffix);
 			bool sendM3u8PlayList(char const* urlSuffix);
@@ -232,10 +234,10 @@ class HTTPServer : public RTSPServer
 
 #if LIVEMEDIA_LIBRARY_VERSION_INT	<	1611187200
 		HTTPServer(UsageEnvironment& env, int ourSocketIPv4, int ourSocketIPv6, Port rtspPort, MyUserAuthenticationDatabase* authDatabase, unsigned reclamationTestSeconds, unsigned int hlsSegment, const std::string & webroot, const std::string & sslCert, bool enableRTSPS)
-		  : RTSPServer(env, ourSocketIPv4, rtspPort, authDatabase, reclamationTestSeconds), m_hlsSegment(hlsSegment), m_webroot(webroot)
+		  : RTSPServer(env, ourSocketIPv4, rtspPort, authDatabase, reclamationTestSeconds), m_hlsSegment(hlsSegment), m_webroot(webroot), m_enableRTSPS(false), m_enableSRTP(false)
 #else
 		HTTPServer(UsageEnvironment& env, int ourSocketIPv4, int ourSocketIPv6, Port rtspPort, MyUserAuthenticationDatabase* authDatabase, unsigned reclamationTestSeconds, unsigned int hlsSegment, const std::string & webroot, const std::string & sslCert, bool enableRTSPS)
-		  : RTSPServer(env, ourSocketIPv4, ourSocketIPv6, rtspPort, authDatabase, reclamationTestSeconds), m_hlsSegment(hlsSegment), m_webroot(webroot)
+		  : RTSPServer(env, ourSocketIPv4, ourSocketIPv6, rtspPort, authDatabase, reclamationTestSeconds), m_hlsSegment(hlsSegment), m_webroot(webroot), m_enableRTSPS(false), m_enableSRTP(false)
 #endif			
 		{
 				if ( (!m_webroot.empty()) && (*m_webroot.rend() != '/') ) {
@@ -257,40 +259,35 @@ class HTTPServer : public RTSPServer
 #if LIVEMEDIA_LIBRARY_VERSION_INT >= 1642723200      
                 if (!sslCert.empty()) {
 					this->setTLSFileNames(sslCert.c_str(), sslCert.c_str());
-					fWeServeSRTP = true;
-					fWeEncryptSRTP = encryptSRTP;
-					if (enableRTSPS) {
-						fOurConnectionsUseTLS = true;
-					} else {
-						fOurConnectionsUseTLS = false;
-					}
+					m_enableRTSPS = enableRTSPS;
+					m_enableSRTP = encryptSRTP;
                 } else {
-					fOurConnectionsUseTLS = false;
-					fWeServeSRTP = false;
-					fWeEncryptSRTP = false;
+					// Reset TLS configuration
+					m_enableRTSPS = false;
+					m_enableSRTP = false;
 				}
 #endif  			
 		}
 
 		bool isRTSPS() { 
 #if LIVEMEDIA_LIBRARY_VERSION_INT >= 1642723200
-			return fOurConnectionsUseTLS; 
+			return m_enableRTSPS;
 #else
 			return false;
 #endif			
 		}
 
 		bool isSRTP() { 
 #if LIVEMEDIA_LIBRARY_VERSION_INT >= 1642723200
-			return fWeServeSRTP; 
+			return m_enableSRTP;
 #else
 			return false;
 #endif			
 		}
 
 		bool isSRTPEncrypted() {
 #if LIVEMEDIA_LIBRARY_VERSION_INT >= 1642723200
-			return fWeEncryptSRTP; 
+			return m_enableSRTP;
 #else
 			return false;
 #endif			
@@ -323,5 +320,7 @@ class HTTPServer : public RTSPServer
     private:
 			const unsigned int m_hlsSegment;
 			std::string  m_webroot;
+			bool m_enableRTSPS;
+			bool m_enableSRTP;
 };
 

inc/MJPEGVideoSource.h

@@ -15,6 +15,8 @@
 
 #include "logger.h"
 #include "JPEGVideoSource.hh"
+#include "V4L2DeviceSource.h"
+#include "SnapshotManager.h"
 
 class MJPEGVideoSource : public JPEGVideoSource
 {

inc/QuickTimeMuxer.h

@@ -0,0 +1,121 @@
+/* ---------------------------------------------------------------------------
+** This software is in the public domain, furnished "as is", without technical
+** support, and with no warranty, express or implied, as to its usefulness for
+** any purpose.
+**
+** QuickTimeMuxer.h
+** 
+** Wrapper for live555 QuickTimeFileSink for MP4 recording
+**
+** -------------------------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include <memory>
+#include <vector>
+#include <cstdint>
+#include <chrono>
+
+class QuickTimeMuxer {
+public:
+    QuickTimeMuxer();
+    ~QuickTimeMuxer() noexcept;
+
+    // Initialize MP4 file with parameters
+    bool initialize(int fd, const std::string& sps, const std::string& pps, int width, int height, int fps = 30);
+
+    // Add H264 frame data
+    bool addFrame(const unsigned char* h264Data, size_t dataSize, bool isKeyFrame);
+
+    // Finalize MP4 file
+    bool finalize();
+
+    // Check if muxer is initialized
+    bool isInitialized() const { return m_initialized; }
+
+    // Get file descriptor for sync operations
+    int getFileDescriptor() const { return m_fd; }
+
+    // Static method for creating MP4 snapshot in memory (for SnapshotManager)
+    static std::vector<uint8_t> createMP4Snapshot(const unsigned char* h264Data, size_t dataSize,
+                                                   const std::string& sps, const std::string& pps,
+                                                   int width, int height, int fps = 30);
+
+    // Helper static methods for NAL analysis
+    static std::string getNALTypeName(uint8_t nalType);
+    static std::string getCurrentTimestamp();
+
+private:
+    bool m_initialized;
+    int m_fd;
+    std::string m_sps;
+    std::string m_pps;
+    int m_width;
+    int m_height;
+    int m_fps;
+
+    // File position tracking
+    size_t m_mdatStartPos;
+    size_t m_currentPos;
+
+    // Frame counting
+    uint32_t m_frameCount;
+    uint32_t m_keyFrameCount;
+
+    // Frame metadata for streaming
+    struct FrameInfo {
+        size_t offset;
+        size_t size;
+        bool isKeyFrame;
+    };
+    std::vector<FrameInfo> m_frames;
+
+    // Write buffer for performance (like old MP4Muxer)
+    std::vector<uint8_t> m_writeBuffer;
+    size_t m_bufferMaxSize;
+    int m_flushIntervalMs;
+    std::chrono::steady_clock::time_point m_lastFlushTime;
+
+    // Helper methods
+    void writeToFile(const void* data, size_t size);
+    bool writeMP4Header();
+    bool writeMoovBox();
+    void flushBufferToDisk(bool force);
+    bool shouldFlushBuffer(bool isKeyFrame);
+
+    // Static helper methods - based on live555 QuickTimeFileSink structure
+    static std::vector<uint8_t> createFtypBox();
+    static std::vector<uint8_t> createVideoTrackMoovBox(const std::vector<uint8_t>& sps, 
+                                                       const std::vector<uint8_t>& pps, 
+                                                       int width, int height, int fps, 
+                                                       uint32_t frameCount);
+    static std::vector<uint8_t> createTrakBox(const std::vector<uint8_t>& sps,
+                                             const std::vector<uint8_t>& pps,
+                                             int width, int height,
+                                             uint32_t timescale, uint32_t duration,
+                                             uint32_t frameCount);
+    static std::vector<uint8_t> createMdiaBox(const std::vector<uint8_t>& sps,
+                                             const std::vector<uint8_t>& pps,
+                                             int width, int height,
+                                             uint32_t timescale, uint32_t duration,
+                                             uint32_t frameCount);
+    static std::vector<uint8_t> createMinfBox(const std::vector<uint8_t>& sps,
+                                             const std::vector<uint8_t>& pps,
+                                             int width, int height,
+                                             uint32_t frameCount);
+    static std::vector<uint8_t> createStblBox(const std::vector<uint8_t>& sps,
+                                             const std::vector<uint8_t>& pps,
+                                             int width, int height,
+                                             uint32_t frameCount);
+    static std::vector<uint8_t> createMdatBox(const std::vector<uint8_t>& frameData);
+
+    // Helper methods for writeMoovBox (Step 19)
+    bool updateMdatSize(size_t mdatTotalSize);
+    void updateFrameSizes(std::vector<uint8_t>& moovBox);
+    void updateKeyframes(std::vector<uint8_t>& moovBox);
+
+    // Universal static helpers (Step B) - used by both recordings and snapshots
+    static void updateChunkOffset(std::vector<uint8_t>& moovBox, uint32_t actualChunkOffset);
+    static void updateFrameSize(std::vector<uint8_t>& moovBox, uint32_t frameSize, size_t frameIndex = 0);
+};