webrtc-streamer 0.7.0 → 0.7.1

package/libv4l2cpp/inc/V4l2Device.h

@@ -28,16 +28,22 @@
 #define V4L2_PIX_FMT_HEVC  v4l2_fourcc('H', 'E', 'V', 'C')
 #endif
 
+enum V4l2IoType
+{
+	IOTYPE_READWRITE,
+	IOTYPE_MMAP
+};
+
 // ---------------------------------
 // V4L2 Device parameters
 // ---------------------------------
 struct V4L2DeviceParameters 
 {
-	V4L2DeviceParameters(const char* devname, const std::list<unsigned int> & formatList, unsigned int width, unsigned int height, int fps, int verbose = 0, int openFlags = O_RDWR | O_NONBLOCK) : 
-		m_devName(devname), m_formatList(formatList), m_width(width), m_height(height), m_fps(fps), m_verbose(verbose), m_openFlags(openFlags) {}
+	V4L2DeviceParameters(const char* devname, const std::list<unsigned int> & formatList, unsigned int width, unsigned int height, int fps, V4l2IoType ioType = IOTYPE_MMAP, int verbose = 0, int openFlags = O_RDWR | O_NONBLOCK) : 
+		m_devName(devname), m_formatList(formatList), m_width(width), m_height(height), m_fps(fps), m_iotype(ioType), m_verbose(verbose), m_openFlags(openFlags) {}
 
-	V4L2DeviceParameters(const char* devname, unsigned int format, unsigned int width, unsigned int height, int fps, int verbose = 0, int openFlags = O_RDWR | O_NONBLOCK) : 
-		m_devName(devname), m_width(width), m_height(height), m_fps(fps), m_verbose(verbose), m_openFlags(openFlags) {
+	V4L2DeviceParameters(const char* devname, unsigned int format, unsigned int width, unsigned int height, int fps, V4l2IoType ioType = IOTYPE_MMAP, int verbose = 0, int openFlags = O_RDWR | O_NONBLOCK) : 
+		m_devName(devname), m_width(width), m_height(height), m_fps(fps), m_iotype(ioType), m_verbose(verbose), m_openFlags(openFlags) {
 			if (format) {
 				m_formatList.push_back(format);
 			}
@@ -48,6 +54,7 @@ struct V4L2DeviceParameters
 	unsigned int m_width;
 	unsigned int m_height;
 	int m_fps;			
+	V4l2IoType m_iotype;
 	int m_verbose;
 	int m_openFlags;
 };
@@ -69,12 +76,12 @@ class V4l2Device
 		int configureFormat(int fd, unsigned int format, unsigned int width, unsigned int height);
 		int configureParam(int fd, int fps);
 
-		virtual bool init(unsigned int mandatoryCapabilities);		
-		virtual size_t writeInternal(char*, size_t) { return -1; }
-		virtual bool startPartialWrite(void)        { return false; }
-		virtual size_t writePartialInternal(char*, size_t) { return -1; }
-		virtual bool endPartialWrite(void)          { return false; }
-		virtual size_t readInternal(char*, size_t)  { return -1; }
+		virtual bool   init(unsigned int mandatoryCapabilities);		
+		virtual size_t writeInternal(char*, size_t)        { return -1;    }
+		virtual bool   startPartialWrite()                 { return false; }
+		virtual size_t writePartialInternal(char*, size_t) { return -1;    }
+		virtual bool   endPartialWrite()                   { return false; }
+		virtual size_t readInternal(char*, size_t)         { return -1;    }
 	
 	public:
 		V4l2Device(const V4L2DeviceParameters&  params, v4l2_buf_type deviceType);		
@@ -88,8 +95,9 @@ class V4l2Device
 		unsigned int getFormat()     { return m_format;     }
 		unsigned int getWidth()      { return m_width;      }
 		unsigned int getHeight()     { return m_height;     }
-		int getFd()         { return m_fd;         }
-		void queryFormat();	
+		int          getFd()         { return m_fd;         }
+		void         queryFormat();
+			
 		int setFormat(unsigned int format, unsigned int width, unsigned int height) {
 			return this->configureFormat(m_fd, format, width, height);
 		}

package/libv4l2cpp/inc/V4l2MmapDevice.h

@@ -21,9 +21,9 @@ class V4l2MmapDevice : public V4l2Device
 {	
 	protected:	
 		size_t writeInternal(char* buffer, size_t bufferSize);
-		bool startPartialWrite(void);
+		bool   startPartialWrite();
 		size_t writePartialInternal(char*, size_t);
-		bool endPartialWrite(void);
+		bool   endPartialWrite();
 		size_t readInternal(char* buffer, size_t bufferSize);
 			
 	public:

package/libv4l2cpp/inc/V4l2Output.h

@@ -24,14 +24,14 @@ class V4l2Output : public V4l2Access
 		V4l2Output(V4l2Device* device);
 
 	public:
-		static V4l2Output* create(const V4L2DeviceParameters & param, IoType iotype = V4l2Access::IOTYPE_MMAP);
+		static V4l2Output* create(const V4L2DeviceParameters & param);
 		virtual ~V4l2Output();
 	
 		size_t write(char* buffer, size_t bufferSize);
-		int    isWritable(timeval* tv);
-		bool   startPartialWrite(void);
+		bool   isWritable(timeval* tv);
+		bool   startPartialWrite();
 		size_t writePartial(char* buffer, size_t bufferSize);
-		bool   endPartialWrite(void);
+		bool   endPartialWrite();
 };
 
 #endif

package/libv4l2cpp/main.cpp

@@ -0,0 +1,118 @@
+/* ---------------------------------------------------------------------------
+** 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.
+**
+** main.cpp
+** 
+** test V4L2 capture device 
+** 
+** -------------------------------------------------------------------------*/
+
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+
+#include "logger.h"
+#include "V4l2Capture.h"
+
+int stop=0;
+
+/* ---------------------------------------------------------------------------
+**  SIGINT handler
+** -------------------------------------------------------------------------*/
+void sighandler(int)
+{ 
+       printf("SIGINT\n");
+       stop =1;
+}
+
+/* ---------------------------------------------------------------------------
+**  main
+** -------------------------------------------------------------------------*/
+int main(int argc, char* argv[]) 
+{	
+	int verbose = 0;
+	const char *in_devname = "/dev/video0";	
+	V4l2IoType ioTypeIn  = IOTYPE_MMAP;
+	int format = 0;
+	int width = 0;
+	int height = 0;
+	int fps = 0;
+	
+	int c = 0;
+	while ((c = getopt (argc, argv, "hv:" "G:f:r")) != -1)
+	{
+		switch (c)
+		{
+			case 'v':	verbose   = 1; if (optarg && *optarg=='v') verbose++; break;
+			case 'r':	ioTypeIn  = IOTYPE_READWRITE                        ; break;			
+            case 'G':   sscanf(optarg,"%dx%dx%d", &width, &height, &fps)    ; break;
+			case 'f':	format    = V4l2Device::fourcc(optarg)              ; break;
+			case 'h':
+			{
+				std::cout << argv[0] << " [-v[v]] [-G <width>x<height>x<fps>] [-f format] [device] [-r]" << std::endl;
+				std::cout << "\t -v            : verbose " << std::endl;
+				std::cout << "\t -vv           : very verbose " << std::endl;
+				std::cout << "\t -r            : V4L2 capture using read interface (default use memory mapped buffers)" << std::endl;
+				std::cout << "\t device        : V4L2 capture device (default "<< in_devname << ")" << std::endl;
+				exit(0);
+			}
+		}
+	}
+	if (optind<argc)
+	{
+		in_devname = argv[optind];
+		optind++;
+	}	
+
+	// initialize log4cpp
+	initLogger(verbose);
+
+	// init V4L2 capture interface
+	V4L2DeviceParameters param(in_devname, format, width, height, fps, ioTypeIn, verbose);
+	V4l2Capture* videoCapture = V4l2Capture::create(param);
+	
+	if (videoCapture == NULL)
+	{	
+		LOG(WARN) << "Cannot reading from V4L2 capture interface for device:" << in_devname; 
+	}
+	else
+	{
+		timeval tv;
+		
+		LOG(NOTICE) << "Start reading from " << in_devname;
+		signal(SIGINT,sighandler);				
+		while (!stop) 
+		{
+			tv.tv_sec=1;
+			tv.tv_usec=0;
+			int ret = videoCapture->isReadable(&tv);
+			if (ret == 1)
+			{
+				char buffer[videoCapture->getBufferSize()];
+				int rsize = videoCapture->read(buffer, sizeof(buffer));
+				if (rsize == -1)
+				{
+					LOG(NOTICE) << "stop " << strerror(errno); 
+					stop=1;					
+				}
+				else
+				{
+					LOG(NOTICE) << "size:" << rsize;
+				}
+			}
+			else if (ret == -1)
+			{
+				LOG(NOTICE) << "stop " << strerror(errno); 
+				stop=1;
+			}
+		}
+		
+
+		delete videoCapture;
+	}
+	
+	return 0;
+}

package/libv4l2cpp/src/V4l2Capture.cpp

@@ -23,12 +23,12 @@
 // -----------------------------------------
 //    create video capture interface
 // -----------------------------------------
-V4l2Capture* V4l2Capture::create(const V4L2DeviceParameters & param, IoType iotype)
+V4l2Capture* V4l2Capture::create(const V4L2DeviceParameters & param)
 {
 	V4l2Capture* videoCapture = NULL;
 	V4l2Device* videoDevice = NULL; 
 	int caps = V4L2_CAP_VIDEO_CAPTURE;
-	switch (iotype)
+	switch (param.m_iotype)
 	{
 		case IOTYPE_MMAP: 
 			videoDevice = new V4l2MmapDevice(param, V4L2_BUF_TYPE_VIDEO_CAPTURE); 
@@ -70,13 +70,13 @@ V4l2Capture::~V4l2Capture()
 // -----------------------------------------
 //    check readability
 // -----------------------------------------
-int V4l2Capture::isReadable(timeval* tv)
+bool V4l2Capture::isReadable(timeval* tv)
 {
 	int fd = m_device->getFd();
 	fd_set fdset;
 	FD_ZERO(&fdset);	
 	FD_SET(fd, &fdset);
-	return select(fd+1, &fdset, NULL, NULL, tv);
+	return (select(fd+1, &fdset, NULL, NULL, tv) == 1);
 }
 
 // -----------------------------------------

package/libv4l2cpp/src/V4l2Device.cpp

@@ -75,9 +75,9 @@ void V4l2Device::queryFormat()
 // intialize the V4L2 connection
 bool V4l2Device::init(unsigned int mandatoryCapabilities)
 {
-        struct stat sb;
-        if ( (stat(m_params.m_devName.c_str(), &sb)==0) && ((sb.st_mode & S_IFMT) == S_IFCHR) )
-        {
+	struct stat sb;
+	if ( (stat(m_params.m_devName.c_str(), &sb)==0) && ((sb.st_mode & S_IFMT) == S_IFCHR) )
+	{
 		if (initdevice(m_params.m_devName.c_str(), mandatoryCapabilities) == -1)
 		{
 			LOG(ERROR) << "Cannot init device:" << m_params.m_devName;
@@ -85,8 +85,8 @@ bool V4l2Device::init(unsigned int mandatoryCapabilities)
 	}
 	else
 	{
-                // open a normal file
-                m_fd = open(m_params.m_devName.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
+		// open a normal file
+		m_fd = open(m_params.m_devName.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
 	}
 	return (m_fd!=-1);
 }
@@ -187,8 +187,8 @@ int V4l2Device::configureFormat(int fd, unsigned int format, unsigned int width,
 	struct v4l2_format   fmt;			
 	memset(&(fmt), 0, sizeof(fmt));
 	fmt.type                = m_deviceType;
-        if (ioctl(m_fd,VIDIOC_G_FMT,&fmt) == -1)
-        {
+	if (ioctl(m_fd,VIDIOC_G_FMT,&fmt) == -1)
+	{
 		LOG(ERROR) << m_params.m_devName << ": Cannot get format " << strerror(errno);
 		return -1;
 	}

package/libv4l2cpp/src/V4l2MmapDevice.cpp

@@ -245,7 +245,7 @@ size_t V4l2MmapDevice::writeInternal(char* buffer, size_t bufferSize)
 	return size;
 }
 
-bool V4l2MmapDevice::startPartialWrite(void)
+bool V4l2MmapDevice::startPartialWrite()
 {
 	if (n_buffers <= 0)
 		return false;
@@ -287,7 +287,7 @@ size_t V4l2MmapDevice::writePartialInternal(char* buffer, size_t bufferSize)
 	return size;
 }
 
-bool V4l2MmapDevice::endPartialWrite(void)
+bool V4l2MmapDevice::endPartialWrite()
 {
 	if (!m_partialWriteInProgress)
 		return false;

package/libv4l2cpp/src/V4l2Output.cpp

@@ -24,12 +24,12 @@
 // -----------------------------------------
 //    create video output interface
 // -----------------------------------------
-V4l2Output* V4l2Output::create(const V4L2DeviceParameters & param, IoType iotype)
+V4l2Output* V4l2Output::create(const V4L2DeviceParameters & param)
 {
 	V4l2Output* videoOutput = NULL;
 	V4l2Device* videoDevice = NULL; 
 	int caps = V4L2_CAP_VIDEO_OUTPUT;
-	switch (iotype)
+	switch (param.m_iotype)
 	{
 		case IOTYPE_MMAP: 
 			videoDevice = new V4l2MmapDevice(param, V4L2_BUF_TYPE_VIDEO_OUTPUT); 
@@ -71,13 +71,13 @@ V4l2Output::~V4l2Output()
 // -----------------------------------------
 //    check writability
 // -----------------------------------------
-int V4l2Output::isWritable(timeval* tv)
+bool V4l2Output::isWritable(timeval* tv)
 {
 	int fd = m_device->getFd();
 	fd_set fdset;
 	FD_ZERO(&fdset);	
 	FD_SET(fd, &fdset);
-	return select(fd+1, NULL, &fdset, NULL, tv);
+	return (select(fd+1, NULL, &fdset, NULL, tv) == 1);
 }
 
 // -----------------------------------------
@@ -89,7 +89,7 @@ size_t V4l2Output::write(char* buffer, size_t bufferSize)
 }
 
 
-bool V4l2Output::startPartialWrite(void)
+bool V4l2Output::startPartialWrite()
 {
 	return m_device->startPartialWrite();
 }
@@ -99,7 +99,7 @@ size_t V4l2Output::writePartial(char* buffer, size_t bufferSize)
 	return m_device->writePartialInternal(buffer, bufferSize);
 }
 
-bool V4l2Output::endPartialWrite(void)
+bool V4l2Output::endPartialWrite()
 {
 	return m_device->endPartialWrite();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webrtc-streamer",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "",
   "main": "joinjanusvideoroom.js",
   "dependencies": {