Replace VideoCaptureDataCallback by VideoSinkInterface.

webrtc/modules/video_capture/linux/video_capture_linux.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 12 matching lines @@
 
 #include "webrtc/base/refcount.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/modules/video_capture/linux/video_capture_linux.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 
 namespace webrtc {
 namespace videocapturemodule {
 rtc::scoped_refptr<VideoCaptureModule> VideoCaptureImpl::Create(
-    const int32_t id,
     const char* deviceUniqueId) {
     rtc::scoped_refptr<VideoCaptureModuleV4L2> implementation(
-        new rtc::RefCountedObject<VideoCaptureModuleV4L2>(id));
+        new rtc::RefCountedObject<VideoCaptureModuleV4L2>());
 
     if (implementation->Init(deviceUniqueId) != 0)
         return nullptr;
 
     return implementation;
 }
 
-VideoCaptureModuleV4L2::VideoCaptureModuleV4L2(const int32_t id)
-    : VideoCaptureImpl(id),
+VideoCaptureModuleV4L2::VideoCaptureModuleV4L2()
+    : VideoCaptureImpl(),
       _captureCritSect(CriticalSectionWrapper::CreateCriticalSection()),
       _deviceId(-1),
       _deviceFd(-1),
       _buffersAllocatedByDevice(-1),
       _currentWidth(-1),
       _currentHeight(-1),
       _currentFrameRate(-1),
       _captureStarted(false),
       _captureVideoType(kVideoI420),
       _pool(NULL)
@@ skipping 34 matching lines @@
                         found = true;
                         break; // fd matches with device unique id supplied
                     }
                 }
             }
             close(fd); // close since this is not the matching device
         }
     }
     if (!found)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id, "no matching device found");
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture,
+                     0, "no matching device found");
         return -1;
     }
     _deviceId = n; //store the device id
     return 0;
 }
 
 VideoCaptureModuleV4L2::~VideoCaptureModuleV4L2()
 {
     StopCapture();
     if (_captureCritSect)
@@ skipping 21 matching lines @@
         }
     }
 
     CriticalSectionScoped cs(_captureCritSect);
     //first open /dev/video device
     char device[20];
     sprintf(device, "/dev/video%d", (int) _deviceId);
 
     if ((_deviceFd = open(device, O_RDWR | O_NONBLOCK, 0)) < 0)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                    "error in opening %s errono = %d", device, errno);
         return -1;
     }
 
     // Supported video formats in preferred order.
     // If the requested resolution is larger than VGA, we prefer MJPEG. Go for
     // I420 otherwise.
     const int nFormats = 5;
     unsigned int fmts[nFormats];
     if (capability.width > 640 || capability.height > 480) {
         fmts[0] = V4L2_PIX_FMT_MJPEG;
         fmts[1] = V4L2_PIX_FMT_YUV420;
         fmts[2] = V4L2_PIX_FMT_YUYV;
         fmts[3] = V4L2_PIX_FMT_UYVY;
         fmts[4] = V4L2_PIX_FMT_JPEG;
     } else {
         fmts[0] = V4L2_PIX_FMT_YUV420;
         fmts[1] = V4L2_PIX_FMT_YUYV;
         fmts[2] = V4L2_PIX_FMT_UYVY;
         fmts[3] = V4L2_PIX_FMT_MJPEG;
         fmts[4] = V4L2_PIX_FMT_JPEG;
     }
 
     // Enumerate image formats.
     struct v4l2_fmtdesc fmt;
     int fmtsIdx = nFormats;
     memset(&fmt, 0, sizeof(fmt));
     fmt.index = 0;
     fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, _id,
+    WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, 0,
                  "Video Capture enumerats supported image formats:");
     while (ioctl(_deviceFd, VIDIOC_ENUM_FMT, &fmt) == 0) {
-        WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, 0,
                      "  { pixelformat = %c%c%c%c, description = '%s' }",
                      fmt.pixelformat & 0xFF, (fmt.pixelformat>>8) & 0xFF,
                      (fmt.pixelformat>>16) & 0xFF, (fmt.pixelformat>>24) & 0xFF,
                      fmt.description);
         // Match the preferred order.
         for (int i = 0; i < nFormats; i++) {
             if (fmt.pixelformat == fmts[i] && i < fmtsIdx)
                 fmtsIdx = i;
         }
         // Keep enumerating.
         fmt.index++;
     }
 
     if (fmtsIdx == nFormats)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                      "no supporting video formats found");
         return -1;
     } else {
-        WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, 0,
                      "We prefer format %c%c%c%c",
                      fmts[fmtsIdx] & 0xFF, (fmts[fmtsIdx]>>8) & 0xFF,
                      (fmts[fmtsIdx]>>16) & 0xFF, (fmts[fmtsIdx]>>24) & 0xFF);
     }
 
     struct v4l2_format video_fmt;
     memset(&video_fmt, 0, sizeof(struct v4l2_format));
     video_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     video_fmt.fmt.pix.sizeimage = 0;
     video_fmt.fmt.pix.width = capability.width;
     video_fmt.fmt.pix.height = capability.height;
     video_fmt.fmt.pix.pixelformat = fmts[fmtsIdx];
 
     if (video_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV)
         _captureVideoType = kVideoYUY2;
     else if (video_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV420)
         _captureVideoType = kVideoI420;
     else if (video_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_UYVY)
         _captureVideoType = kVideoUYVY;
     else if (video_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG ||
              video_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_JPEG)
         _captureVideoType = kVideoMJPEG;
 
     //set format and frame size now
     if (ioctl(_deviceFd, VIDIOC_S_FMT, &video_fmt) < 0)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                    "error in VIDIOC_S_FMT, errno = %d", errno);
         return -1;
     }
 
     // initialize current width and height
     _currentWidth = video_fmt.fmt.pix.width;
     _currentHeight = video_fmt.fmt.pix.height;
     _captureDelay = 120;
 
     // Trying to set frame rate, before check driver capability.
     bool driver_framerate_support = true;
     struct v4l2_streamparm streamparms;
     memset(&streamparms, 0, sizeof(streamparms));
     streamparms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     if (ioctl(_deviceFd, VIDIOC_G_PARM, &streamparms) < 0) {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                    "error in VIDIOC_G_PARM errno = %d", errno);
         driver_framerate_support = false;
       // continue
     } else {
       // check the capability flag is set to V4L2_CAP_TIMEPERFRAME.
       if (streamparms.parm.capture.capability & V4L2_CAP_TIMEPERFRAME) {
         // driver supports the feature. Set required framerate.
         memset(&streamparms, 0, sizeof(streamparms));
         streamparms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         streamparms.parm.capture.timeperframe.numerator = 1;
         streamparms.parm.capture.timeperframe.denominator = capability.maxFPS;
         if (ioctl(_deviceFd, VIDIOC_S_PARM, &streamparms) < 0) {
-          WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+          WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                    "Failed to set the framerate. errno=%d", errno);
           driver_framerate_support = false;
         } else {
           _currentFrameRate = capability.maxFPS;
         }
       }
     }
     // If driver doesn't support framerate control, need to hardcode.
     // Hardcoding the value based on the frame size.
     if (!driver_framerate_support) {
       if(_currentWidth >= 800 && _captureVideoType != kVideoMJPEG) {
         _currentFrameRate = 15;
       } else {
         _currentFrameRate = 30;
       }
     }
 
     if (!AllocateVideoBuffers())
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                    "failed to allocate video capture buffers");
         return -1;
     }
 
     //start capture thread;
     if (!_captureThread)
     {
         _captureThread.reset(new rtc::PlatformThread(
             VideoCaptureModuleV4L2::CaptureThread, this, "CaptureThread"));
         _captureThread->Start();
         _captureThread->SetPriority(rtc::kHighPriority);
     }
 
     // Needed to start UVC camera - from the uvcview application
     enum v4l2_buf_type type;
     type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     if (ioctl(_deviceFd, VIDIOC_STREAMON, &type) == -1)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                      "Failed to turn on stream");
         return -1;
     }
 
     _captureStarted = true;
     return 0;
 }
 
 int32_t VideoCaptureModuleV4L2::StopCapture()
 {
@@ skipping 22 matching lines @@
 {
     struct v4l2_requestbuffers rbuffer;
     memset(&rbuffer, 0, sizeof(v4l2_requestbuffers));
 
     rbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     rbuffer.memory = V4L2_MEMORY_MMAP;
     rbuffer.count = kNoOfV4L2Bufffers;
 
     if (ioctl(_deviceFd, VIDIOC_REQBUFS, &rbuffer) < 0)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                    "Could not get buffers from device. errno = %d", errno);
         return false;
     }
 
     if (rbuffer.count > kNoOfV4L2Bufffers)
         rbuffer.count = kNoOfV4L2Bufffers;
 
     _buffersAllocatedByDevice = rbuffer.count;
 
     //Map the buffers
@@ skipping 38 matching lines @@
     for (int i = 0; i < _buffersAllocatedByDevice; i++)
         munmap(_pool[i].start, _pool[i].length);
 
     delete[] _pool;
 
     // turn off stream
     enum v4l2_buf_type type;
     type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     if (ioctl(_deviceFd, VIDIOC_STREAMOFF, &type) < 0)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                    "VIDIOC_STREAMOFF error. errno: %d", errno);
     }
 
     return true;
 }
 
 bool VideoCaptureModuleV4L2::CaptureStarted()
 {
     return _captureStarted;
 }
@@ skipping 39 matching lines @@
     {
         struct v4l2_buffer buf;
         memset(&buf, 0, sizeof(struct v4l2_buffer));
         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         buf.memory = V4L2_MEMORY_MMAP;
         // dequeue a buffer - repeat until dequeued properly!
         while (ioctl(_deviceFd, VIDIOC_DQBUF, &buf) < 0)
         {
             if (errno != EINTR)
             {
-                WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+                WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                            "could not sync on a buffer on device %s", strerror(errno));
                 _captureCritSect->Leave();
                 return true;
             }
         }
         VideoCaptureCapability frameInfo;
         frameInfo.width = _currentWidth;
         frameInfo.height = _currentHeight;
         frameInfo.rawType = _captureVideoType;
 
         // convert to to I420 if needed
         IncomingFrame((unsigned char*) _pool[buf.index].start,
                       buf.bytesused, frameInfo);
         // enqueue the buffer again
         if (ioctl(_deviceFd, VIDIOC_QBUF, &buf) == -1)
         {
-            WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideoCapture, _id,
+            WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideoCapture, 0,
                        "Failed to enqueue capture buffer");
         }
     }
     _captureCritSect->Leave();
     usleep(0);
     return true;
 }
 
 int32_t VideoCaptureModuleV4L2::CaptureSettings(VideoCaptureCapability& settings)
 {
     settings.width = _currentWidth;
     settings.height = _currentHeight;
     settings.maxFPS = _currentFrameRate;
     settings.rawType=_captureVideoType;
 
     return 0;
 }
 }  // namespace videocapturemodule
 }  // namespace webrtc