Merge upstream/master: resolve snapshot endpoint conflict

350d · 350d · commit ab6feb64edb8 · 2025-10-03T17:45:07.000+03:00
Merged latest changes from upstream (mpromonet/v4l2rtspserver).

Conflict resolution in src/HTTPServer.cpp:
- Kept my SnapshotManager implementation for snapshot endpoint
- Upstream had BaseServerMediaSubsession::getLastFrame() approach
- My implementation is more flexible and handles both MJPEG and H264 MP4 snapshots

Other upstream changes merged:
- Updated CI workflows (.github/workflows/*.yml)
- CMakeLists.txt updates
- BaseServerMediaSubsession improvements
- V4L2DeviceSource enhancements
- H264/H265 device source updates

All tests passing, snapshot functionality preserved.
diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml
@@ -23,7 +23,7 @@ jobs:
           cpack
           echo "artifactPath=$(ls *.deb)" >> $GITHUB_ENV
 
-    - uses: actions/upload-artifact@v3
+    - uses: actions/upload-artifact@v4
       with:
         name: ${{ env.artifactPath }}
         path: ${{ env.artifactPath }}    
diff --git a/.github/workflows/cross.yml b/.github/workflows/cross.yml
@@ -62,7 +62,7 @@ jobs:
           cpack
           echo "artifactPath=$(ls *.deb)" >> $GITHUB_ENV
 
-    - uses: actions/upload-artifact@v3
+    - uses: actions/upload-artifact@v4
       with:
         name: ${{ env.artifactPath }}
         path: ${{ env.artifactPath }}   
diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml
@@ -59,7 +59,7 @@ jobs:
       # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
       # format to the repository Actions tab.
       - name: "Upload artifact"
-        uses: actions/upload-artifact@3cea5372237819ed00197afe530f5a7ea3e805c8 # v3.1.0
+        uses: actions/upload-artifact@v4
         with:
           name: SARIF file
           path: results.sarif
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.12)
 
 project(v4l2rtspserver)
 
@@ -10,24 +10,26 @@ set(STATICSTDCPP ON CACHE BOOL "use gcc static lib if available")
 set(LOG4CPP OFF CACHE BOOL "use log4cpp if available")
 set(LIVE555URL http://www.live555.com/liveMedia/public/live555-latest.tar.gz CACHE STRING "live555 url")
 set(LIVE555CFLAGS -DBSD=1 -DSOCKLEN_T=socklen_t -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE=1 -DALLOW_RTSP_SERVER_PORT_REUSE=1 -DNO_STD_LIB=1 CACHE STRING "live555 CFGLAGS")
-
-if(NOT CMAKE_BUILD_TYPE)
-     set (CMAKE_BUILD_TYPE "Release")
-endif()
+set(SYSTEMD ON CACHE BOOL "install SystemD service")
 
 set(CMAKE_CXX_STANDARD 20)
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake/")
 
-# set version based on git
 find_package(Git)
-if(GIT_FOUND)
+if(DEFINED ENV{V4L2RTSPSERVER_VERSION})
+    # set version from V4L2RTSPSERVER_VERSION env variable
+    add_compile_definitions("VERSION=\"$ENV{V4L2RTSPSERVER_VERSION}\"")
+elseif(GIT_FOUND)
+    # set version based on git
     EXECUTE_PROCESS(COMMAND ${GIT_EXECUTABLE} -C ${CMAKE_CURRENT_SOURCE_DIR} describe --tags --always --dirty OUTPUT_VARIABLE VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
     STRING(REGEX REPLACE "^v(.*)" "\\1" VERSION "${VERSION}")
-    add_definitions("-DVERSION=\"${VERSION}\"")
+    add_compile_definitions("VERSION=\"${VERSION}\"")
+else()
+    message(WARNING "VERSION is undefined")
+    add_compile_definitions("VERSION=\"undefined\"")
 endif()
 
-
 # define executable to build
 include_directories("inc")
 add_executable(${PROJECT_NAME} main.cpp)
@@ -84,7 +86,7 @@ target_compile_definitions(libv4l2rtspserver PUBLIC ${LIVE555CFLAGS})
 target_link_libraries (${PROJECT_NAME} libv4l2rtspserver ${LIVE_LIBRARIES}) 
 set (LIBRARIES "")
 if (OpenSSL_FOUND)
-    set(LIBRARIES ${LIBRARIES} ${OPENSSL_LIBRARIES})
+    set(LIBRARIES ${LIBRARIES} OpenSSL::SSL)
 endif ()
 
 #pthread
@@ -108,15 +110,17 @@ if (ALSA)
     find_package(ALSA QUIET)
     MESSAGE("ALSA_FOUND = ${ALSA_FOUND}")
     if (ALSA_LIBRARY)
-	    target_compile_definitions(libv4l2rtspserver PUBLIC HAVE_ALSA)
-        set(LIBRARIES ${LIBRARIES} ${ALSA_LIBRARY})
-        
+        target_compile_definitions(libv4l2rtspserver PUBLIC HAVE_ALSA)
+        set(LIBRARIES ${LIBRARIES} ALSA::ALSA)
+
         SET(CPACK_DEBIAN_PACKAGE_DEPENDS ${CPACK_DEBIAN_PACKAGE_DEPENDS}libasound2,)	
     endif ()
 endif()
 
 # libv4l2cpp
-execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init)
+if (GIT_FOUND)
+    execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init)
+endif()
 add_subdirectory(libv4l2cpp EXCLUDE_FROM_ALL)
 target_include_directories(libv4l2rtspserver PUBLIC libv4l2cpp/inc)
 target_link_libraries (libv4l2rtspserver PUBLIC libv4l2cpp ${LIBRARIES}) 
@@ -139,17 +143,19 @@ enable_testing()
 add_test(help ./${PROJECT_NAME} -h)
 
 #systemd
-find_package(PkgConfig)
-pkg_check_modules(SYSTEMD systemd QUIET)
-if (SYSTEMD_FOUND)
-	message(STATUS "SystemD available")
-	execute_process(COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=systemdsystemunitdir systemd OUTPUT_VARIABLE SYSTEMD_SERVICES_INSTALL_DIR)
-	string(REGEX REPLACE "[ \t\n]+" "" SYSTEMD_SERVICES_INSTALL_DIR "${SYSTEMD_SERVICES_INSTALL_DIR}")
-	message(STATUS "SystemD directory '${SYSTEMD_SERVICES_INSTALL_DIR}'")
-	
-	configure_file(v4l2rtspserver.service.in ${CMAKE_CURRENT_BINARY_DIR}/v4l2rtspserver.service @ONLY)
+if (SYSTEMD)
+    find_package(PkgConfig)
+    pkg_check_modules(SYSTEMD systemd QUIET)
+    if (SYSTEMD_FOUND)
+        message(STATUS "SystemD available")
+        execute_process(COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=systemdsystemunitdir systemd OUTPUT_VARIABLE SYSTEMD_SERVICES_INSTALL_DIR)
+        string(REGEX REPLACE "[ \t\n]+" "" SYSTEMD_SERVICES_INSTALL_DIR "${SYSTEMD_SERVICES_INSTALL_DIR}")
+        message(STATUS "SystemD directory '${SYSTEMD_SERVICES_INSTALL_DIR}'")
+        
+        configure_file(v4l2rtspserver.service.in ${CMAKE_CURRENT_BINARY_DIR}/v4l2rtspserver.service @ONLY)
         install(FILES ${CMAKE_CURRENT_BINARY_DIR}/v4l2rtspserver.service DESTINATION ${SYSTEMD_SERVICES_INSTALL_DIR})
-endif (SYSTEMD_FOUND)
+    endif (SYSTEMD_FOUND)
+endif (SYSTEMD)
 
 # package
 install (TARGETS ${PROJECT_NAME} RUNTIME DESTINATION bin)
diff --git a/inc/BaseServerMediaSubsession.h b/inc/BaseServerMediaSubsession.h
@@ -67,6 +67,7 @@ class BaseServerMediaSubsession
                 case V4L2_PIX_FMT_YUV444: rtpFormat = "video/RAW" ; break;
                 case V4L2_PIX_FMT_UYVY  : rtpFormat = "video/RAW" ; break;
                 case V4L2_PIX_FMT_NV12  : rtpFormat = "video/RAW" ; break;
+                case V4L2_PIX_FMT_Y41P  : rtpFormat = "video/RAW" ; break;
                 case V4L2_PIX_FMT_BGR24 : rtpFormat = "video/RAW" ; break;
                 case V4L2_PIX_FMT_BGR32 : rtpFormat = "video/RAW" ; break;
                 case V4L2_PIX_FMT_RGB24 : rtpFormat = "video/RAW" ; break;
@@ -116,6 +117,17 @@ class BaseServerMediaSubsession
 		static RTPSink* createSink(UsageEnvironment& env, Groupsock * rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, const std::string& format, V4L2DeviceSource* source);
 		char const* getAuxLine(V4L2DeviceSource* source, RTPSink* rtpSink);
 		
+        std::string getLastFrame() const { 
+            V4L2DeviceSource* deviceSource = dynamic_cast<V4L2DeviceSource*>(m_replicator->inputSource());
+            if (deviceSource) {
+                return deviceSource->getLastFrame(); 
+            } else {
+                return "";
+            }
+        }
+
+        std::string getFormat() const { return m_format; }
+
 	protected:
 		StreamReplicator* m_replicator;
 		std::string m_format;        
diff --git a/inc/V4L2DeviceSource.h b/inc/V4L2DeviceSource.h
@@ -16,8 +16,8 @@
 #include <list> 
 #include <iostream>
 #include <iomanip>
-
-#include <pthread.h>
+#include <mutex>
+#include <thread>
 
 // live555
 #include <liveMedia.hh>
@@ -77,6 +77,11 @@ class V4L2DeviceSource: public FramedSource
 	public:
 		static V4L2DeviceSource* createNew(UsageEnvironment& env, DeviceInterface * device, int outputFd, unsigned int queueSize, CaptureMode captureMode) ;
 		std::string getAuxLine()                   { return m_auxLine;    }
+		std::string getLastFrame() 	{ 
+			std::lock_guard<std::mutex> lock(m_lastFrameMutex);
+			std::string frame(m_lastFrame);
+			return frame; 
+		}
 		DeviceInterface* getDevice()               { return m_device;     }	
 		void postFrame(char * frame, int frameSize, const timeval &ref);
 		virtual std::list< std::string > getInitFrames() { return std::list< std::string >(); }
@@ -87,8 +92,7 @@ class V4L2DeviceSource: public FramedSource
 		V4L2DeviceSource(UsageEnvironment& env, DeviceInterface * device, int outputFd, unsigned int queueSize, CaptureMode captureMode);
 		virtual ~V4L2DeviceSource();
 
-	protected:	
-		static void* threadStub(void* clientData) { return ((V4L2DeviceSource*) clientData)->thread();};
+	protected:
 		virtual void* thread();
 		static void deliverFrameStub(void* clientData) {((V4L2DeviceSource*) clientData)->deliverFrame();};
 		void deliverFrame();
@@ -112,8 +116,10 @@ class V4L2DeviceSource: public FramedSource
 		int m_outfd;
 		DeviceInterface * m_device;
 		unsigned int m_queueSize;
-		pthread_t m_thid;
-		pthread_mutex_t m_mutex;
+		std::thread m_thread;
+		std::mutex  m_mutex;
 		std::string m_auxLine;
+		std::mutex  m_lastFrameMutex;
+		std::string m_lastFrame;
 };
 
diff --git a/src/H264_V4l2DeviceSource.cpp b/src/H264_V4l2DeviceSource.cpp
@@ -89,7 +89,7 @@ std::list< std::pair<unsigned char*,size_t> > H264_V4L2DeviceSource::splitFrames
 	{	
 		switch (frameType&0x1F)					
 		{
-			case 7: LOG(INFO) << "SPS size:" << size << " bufSize:" << bufSize; m_sps.assign((char*)buffer,size); break;
+			case 7: LOG(INFO) << "SPS size:" << size << " bufSize:" << bufSize; m_sps.assign((char*)buffer,size); m_pps.clear(); break;
 			case 8: LOG(INFO) << "PPS size:" << size << " bufSize:" << bufSize; m_pps.assign((char*)buffer,size); break;
 			case 5: 
 				LOG(INFO) << "IDR size:" << size << " bufSize:" << bufSize; 
@@ -123,6 +123,15 @@ std::list< std::pair<unsigned char*,size_t> > H264_V4L2DeviceSource::splitFrames
 						outputBuffer.insert(outputBuffer.end(), m_pps.begin(), m_pps.end());
 					}
 				}
+				if (!m_sps.empty() && !m_pps.empty()) {
+					std::lock_guard<std::mutex> lock(m_lastFrameMutex);					
+					m_lastFrame.assign(H264marker, sizeof(H264marker));
+					m_lastFrame.append(m_sps.c_str(), m_sps.size());
+					m_lastFrame.append(H264marker, sizeof(H264marker));
+					m_lastFrame.append(m_pps.c_str(), m_pps.size());
+					m_lastFrame.append(H264marker, sizeof(H264marker));
+					m_lastFrame.append((char*)buffer, size);
+				}
 			break;
 			default: 
 				break;
diff --git a/src/H265_V4l2DeviceSource.cpp b/src/H265_V4l2DeviceSource.cpp
@@ -31,7 +31,7 @@ std::list< std::pair<unsigned char*,size_t> > H265_V4L2DeviceSource::splitFrames
 	{
 		switch ((frameType&0x7E)>>1)					
 		{
-			case 32: LOG(INFO) << "VPS size:" << size << " bufSize:" << bufSize; m_vps.assign((char*)buffer,size); break;
+			case 32: LOG(INFO) << "VPS size:" << size << " bufSize:" << bufSize; m_vps.assign((char*)buffer,size); m_sps.clear(); m_pps.clear(); break;
 			case 33: LOG(INFO) << "SPS size:" << size << " bufSize:" << bufSize; m_sps.assign((char*)buffer,size); break;
 			case 34: LOG(INFO) << "PPS size:" << size << " bufSize:" << bufSize; m_pps.assign((char*)buffer,size); break;
 			case 19: 
@@ -42,6 +42,17 @@ std::list< std::pair<unsigned char*,size_t> > H265_V4L2DeviceSource::splitFrames
 					frameList.push_back(std::pair<unsigned char*,size_t>((unsigned char*)m_sps.c_str(), m_sps.size()));
 					frameList.push_back(std::pair<unsigned char*,size_t>((unsigned char*)m_pps.c_str(), m_pps.size()));
 				}
+				if (!m_vps.empty() && !m_sps.empty() && !m_pps.empty()) {
+					std::lock_guard<std::mutex> lock(m_lastFrameMutex);					
+					m_lastFrame.assign(H264marker, sizeof(H264marker));
+					m_lastFrame.append(m_vps.c_str(), m_vps.size());
+					m_lastFrame.append(H264marker, sizeof(H264marker));
+					m_lastFrame.append(m_sps.c_str(), m_sps.size());
+					m_lastFrame.append(H264marker, sizeof(H264marker));
+					m_lastFrame.append(m_pps.c_str(), m_pps.size());
+					m_lastFrame.append(H264marker, sizeof(H264marker));
+					m_lastFrame.append((char*)buffer, size);
+				}				
 			break;
 			default: break;
 		}
diff --git a/src/HTTPServer.cpp b/src/HTTPServer.cpp
@@ -18,10 +18,11 @@
 #include <cstring>
 #include <time.h>
 #include "ByteStreamMemoryBufferSource.hh"
-
 #include "HTTPServer.h"
 #include "SnapshotManager.h"
 
+#include "BaseServerMediaSubsession.h"
+
 u_int32_t HTTPServer::HTTPClientConnection::m_ClientSessionId = 0;
 
 void HTTPServer::HTTPClientConnection::sendHeader(const char* contentType, unsigned int contentLength)
diff --git a/src/ServerMediaSubsession.cpp b/src/ServerMediaSubsession.cpp
@@ -86,6 +86,7 @@ RTPSink*  BaseServerMediaSubsession::createSink(UsageEnvironment& env, Groupsock
 			case V4L2_PIX_FMT_YUV444: sampling = "YCbCr-4:4:4"; break;
 			case V4L2_PIX_FMT_UYVY  : sampling = "YCbCr-4:2:2"; break;
 			case V4L2_PIX_FMT_NV12  : sampling = "YCbCr-4:2:0"; break;
+			case V4L2_PIX_FMT_Y41P  : sampling = "YCbCr-4:1:1"; break;
 			case V4L2_PIX_FMT_RGB24 : sampling = "RGB"        ; break;
 			case V4L2_PIX_FMT_RGB32 : sampling = "RGBA"       ; break;
 			case V4L2_PIX_FMT_BGR24 : sampling = "BGR"        ; break;
diff --git a/src/V4L2DeviceSource.cpp b/src/V4L2DeviceSource.cpp
@@ -62,14 +62,11 @@ V4L2DeviceSource::V4L2DeviceSource(UsageEnvironment& env, DeviceInterface * devi
 	m_queueSize(queueSize)
 {
 	m_eventTriggerId = envir().taskScheduler().createEventTrigger(V4L2DeviceSource::deliverFrameStub);
-	memset(&m_thid, 0, sizeof(m_thid));
-	memset(&m_mutex, 0, sizeof(m_mutex));
-	pthread_mutex_init(&m_mutex, NULL);
 	if (m_device)
 	{
 		switch (captureMode) {
 			case CAPTURE_INTERNAL_THREAD:
-				pthread_create(&m_thid, NULL, threadStub, this);		
+				m_thread = std::thread(&V4L2DeviceSource::thread, this);	
 			break;
 			case CAPTURE_LIVE555_THREAD:
 				envir().taskScheduler().turnOnBackgroundReadHandling( m_device->getFd(), V4L2DeviceSource::incomingPacketHandlerStub, this);
@@ -85,8 +82,9 @@ V4L2DeviceSource::V4L2DeviceSource(UsageEnvironment& env, DeviceInterface * devi
 V4L2DeviceSource::~V4L2DeviceSource()
 {	
 	envir().taskScheduler().deleteEventTrigger(m_eventTriggerId);
-	pthread_join(m_thid, NULL);	
-	pthread_mutex_destroy(&m_mutex);
+    if (m_thread.joinable()) {
+        m_thread.join();
+    }
 	delete m_device;
 }
 
@@ -141,7 +139,7 @@ void V4L2DeviceSource::deliverFrame()
 		fDurationInMicroseconds = 0;
 		fFrameSize = 0;
 		
-		pthread_mutex_lock (&m_mutex);
+		m_mutex.lock();
 		if (m_captureQueue.empty())
 		{
 			LOG(DEBUG) << "Queue is empty";		
@@ -176,7 +174,7 @@ void V4L2DeviceSource::deliverFrame()
 				envir().taskScheduler().triggerEvent(m_eventTriggerId, this);
 			}
 		}
-		pthread_mutex_unlock (&m_mutex);
+		m_mutex.unlock();
 		
 		if (fFrameSize > 0)
 		{
@@ -284,15 +282,15 @@ void V4L2DeviceSource::processFrame(char * frame, int frameSize, const timeval &
 // post a frame to fifo
 void V4L2DeviceSource::queueFrame(char * frame, int frameSize, const timeval &tv, char * allocatedBuffer) 
 {
-	pthread_mutex_lock (&m_mutex);
+	m_mutex.lock();
 	while (m_captureQueue.size() >= m_queueSize)
 	{
 		LOG(DEBUG) << "Queue full size drop frame size:"  << (int)m_captureQueue.size() ;		
 		delete m_captureQueue.front();
 		m_captureQueue.pop_front();
 	}
 	m_captureQueue.push_back(new Frame(frame, frameSize, tv, allocatedBuffer));	
-	pthread_mutex_unlock (&m_mutex);
+	m_mutex.unlock();
 	
 	// post an event to ask to deliver the frame
 	envir().taskScheduler().triggerEvent(m_eventTriggerId, this);
@@ -305,6 +303,9 @@ std::list< std::pair<unsigned char*,size_t> > V4L2DeviceSource::splitFrames(unsi
 	if (frame != NULL)
 	{
 		frameList.push_back(std::pair<unsigned char*,size_t>(frame, frameSize));
+
+		std::lock_guard<std::mutex> lock(m_lastFrameMutex);
+		m_lastFrame.assign((char*)frame, frameSize);
 	}
 	return frameList;
 }

Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ std::list< std::pair<unsigned char*,size_t> > H264_V4L2DeviceSource::splitFrames`
`89`	`89`	`{`
`90`	`90`	`switch (frameType&0x1F)`
`91`	`91`	`{`
`92`		`- case 7: LOG(INFO) << "SPS size:" << size << " bufSize:" << bufSize; m_sps.assign((char*)buffer,size); break;`
	`92`	`+ case 7: LOG(INFO) << "SPS size:" << size << " bufSize:" << bufSize; m_sps.assign((char*)buffer,size); m_pps.clear(); break;`
`93`	`93`	`case 8: LOG(INFO) << "PPS size:" << size << " bufSize:" << bufSize; m_pps.assign((char*)buffer,size); break;`
`94`	`94`	`case 5:`
`95`	`95`	`LOG(INFO) << "IDR size:" << size << " bufSize:" << bufSize;`
`@@ -123,6 +123,15 @@ std::list< std::pair<unsigned char*,size_t> > H264_V4L2DeviceSource::splitFrames`
`123`	`123`	`outputBuffer.insert(outputBuffer.end(), m_pps.begin(), m_pps.end());`
`124`	`124`	`}`
`125`	`125`	`}`
	`126`	`+ if (!m_sps.empty() && !m_pps.empty()) {`
	`127`	`+ std::lock_guard<std::mutex> lock(m_lastFrameMutex);`
	`128`	`+ m_lastFrame.assign(H264marker, sizeof(H264marker));`
	`129`	`+ m_lastFrame.append(m_sps.c_str(), m_sps.size());`
	`130`	`+ m_lastFrame.append(H264marker, sizeof(H264marker));`
	`131`	`+ m_lastFrame.append(m_pps.c_str(), m_pps.size());`
	`132`	`+ m_lastFrame.append(H264marker, sizeof(H264marker));`
	`133`	`+ m_lastFrame.append((char*)buffer, size);`
	`134`	`+ }`
`126`	`135`	`break;`
`127`	`136`	`default:`
`128`	`137`	`break;`