Replace VideoCaptureDataCallback by VideoSinkInterface.

webrtc/modules/video_capture/linux/device_info_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 10 matching lines @@
 #include <linux/videodev2.h>
 
 #include "webrtc/system_wrappers/include/trace.h"
 
 
 namespace webrtc
 {
 namespace videocapturemodule
 {
 VideoCaptureModule::DeviceInfo*
-VideoCaptureImpl::CreateDeviceInfo(const int32_t id)
+VideoCaptureImpl::CreateDeviceInfo()
 {
-    return new videocapturemodule::DeviceInfoLinux(id);
+    return new videocapturemodule::DeviceInfoLinux();
 }
 
-DeviceInfoLinux::DeviceInfoLinux(const int32_t id)
-    : DeviceInfoImpl(id)
+DeviceInfoLinux::DeviceInfoLinux()
+    : DeviceInfoImpl()
 {
 }
 
 int32_t DeviceInfoLinux::Init()
 {
     return 0;
 }
 
 DeviceInfoLinux::~DeviceInfoLinux()
 {
 }
 
 uint32_t DeviceInfoLinux::NumberOfDevices()
 {
-    WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideoCapture, _id, "%s", __FUNCTION__);
+    WEBRTC_TRACE(webrtc::kTraceApiCall,
+                 webrtc::kTraceVideoCapture, 0, "%s", __FUNCTION__);
 
     uint32_t count = 0;
     char device[20];
     int fd = -1;
 
     /* detect /dev/video [0-63]VideoCaptureModule entries */
     for (int n = 0; n < 64; n++)
     {
         sprintf(device, "/dev/video%d", n);
         if ((fd = open(device, O_RDONLY)) != -1)
         {
             close(fd);
             count++;
         }
     }
 
     return count;
 }
 
 int32_t DeviceInfoLinux::GetDeviceName(
                                          uint32_t deviceNumber,
                                          char* deviceNameUTF8,
                                          uint32_t deviceNameLength,
                                          char* deviceUniqueIdUTF8,
                                          uint32_t deviceUniqueIdUTF8Length,
                                          char* /*productUniqueIdUTF8*/,
                                          uint32_t /*productUniqueIdUTF8Length*/)
 {
-    WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideoCapture, _id, "%s", __FUNCTION__);
+    WEBRTC_TRACE(webrtc::kTraceApiCall,
+                 webrtc::kTraceVideoCapture, 0, "%s", __FUNCTION__);
 
     // Travel through /dev/video [0-63]
     uint32_t count = 0;
     char device[20];
     int fd = -1;
     bool found = false;
     for (int n = 0; n < 64; n++)
     {
         sprintf(device, "/dev/video%d", n);
         if ((fd = open(device, O_RDONLY)) != -1)
         {
             if (count == deviceNumber) {
                 // Found the device
                 found = true;
                 break;
             } else {
                 close(fd);
                 count++;
             }
         }
     }
 
     if (!found)
         return -1;
 
     // query device capabilities
     struct v4l2_capability cap;
     if (ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                    "error in querying the device capability for device %s. errno = %d",
                    device, errno);
         close(fd);
         return -1;
     }
 
     close(fd);
 
     char cameraName[64];
     memset(deviceNameUTF8, 0, deviceNameLength);
     memcpy(cameraName, cap.card, sizeof(cap.card));
 
     if (deviceNameLength >= strlen(cameraName))
     {
         memcpy(deviceNameUTF8, cameraName, strlen(cameraName));
     }
     else
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id, "buffer passed is too small");
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
+                     "buffer passed is too small");
         return -1;
     }
 
     if (cap.bus_info[0] != 0) // may not available in all drivers
     {
         // copy device id
         if (deviceUniqueIdUTF8Length >= strlen((const char*) cap.bus_info))
         {
             memset(deviceUniqueIdUTF8, 0, deviceUniqueIdUTF8Length);
             memcpy(deviceUniqueIdUTF8, cap.bus_info,
                    strlen((const char*) cap.bus_info));
         }
         else
         {
-            WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+            WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                        "buffer passed is too small");
             return -1;
         }
     }
 
     return 0;
 }
 
 int32_t DeviceInfoLinux::CreateCapabilityMap(
                                         const char* deviceUniqueIdUTF8)
 {
     int fd;
     char device[32];
     bool found = false;
 
     const int32_t deviceUniqueIdUTF8Length =
                             (int32_t) strlen((char*) deviceUniqueIdUTF8);
     if (deviceUniqueIdUTF8Length > kVideoCaptureUniqueNameLength)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id, "Device name too long");
+        WEBRTC_TRACE(webrtc::kTraceError,
+                     webrtc::kTraceVideoCapture, 0, "Device name too long");
         return -1;
     }
-    WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, _id,
+    WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, 0,
                "CreateCapabilityMap called for device %s", deviceUniqueIdUTF8);
 
     /* detect /dev/video [0-63] entries */
     for (int n = 0; n < 64; ++n)
     {
         sprintf(device, "/dev/video%d", n);
         fd = open(device, O_RDONLY);
         if (fd == -1)
           continue;
 
@@ skipping 19 matching lines @@
                     found = true;
                     break;
                 }
             }
         }
         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;
     }
 
     // now fd will point to the matching device
     // reset old capability list.
     _captureCapabilities.clear();
 
     int size = FillCapabilities(fd);
     close(fd);
 
     // Store the new used device name
     _lastUsedDeviceNameLength = deviceUniqueIdUTF8Length;
     _lastUsedDeviceName = (char*) realloc(_lastUsedDeviceName,
                                                    _lastUsedDeviceNameLength + 1);
     memcpy(_lastUsedDeviceName, deviceUniqueIdUTF8, _lastUsedDeviceNameLength + 1);
 
     WEBRTC_TRACE(webrtc::kTraceInfo,
                  webrtc::kTraceVideoCapture,
-                 _id,
+                 0,
                  "CreateCapabilityMap %u",
                  static_cast<unsigned int>(_captureCapabilities.size()));
 
     return size;
 }
 
 bool DeviceInfoLinux::IsDeviceNameMatches(const char* name,
                                           const char* deviceUniqueIdUTF8)
 {
     if (strncmp(deviceUniqueIdUTF8, name, strlen(name)) == 0)
@@ skipping 66 matching lines @@
                     {
                         cap.maxFPS = 15;
                     }
                     else
                     {
                         cap.maxFPS = 30;
                     }
 
                     _captureCapabilities.push_back(cap);
                     index++;
-                    WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, _id,
-                               "Camera capability, width:%d height:%d type:%d fps:%d",
-                               cap.width, cap.height, cap.rawType, cap.maxFPS);
+                    WEBRTC_TRACE(
+                        webrtc::kTraceInfo, webrtc::kTraceVideoCapture, 0,
+                        "Camera capability, width:%d height:%d type:%d fps:%d",
+                        cap.width, cap.height, cap.rawType, cap.maxFPS);
                 }
             }
         }
     }
 
     WEBRTC_TRACE(webrtc::kTraceInfo,
                  webrtc::kTraceVideoCapture,
-                 _id,
+                 0,
                  "CreateCapabilityMap %u",
                  static_cast<unsigned int>(_captureCapabilities.size()));
     return _captureCapabilities.size();
 }
 
 }  // namespace videocapturemodule
 }  // namespace webrtc