Replace VideoCaptureDataCallback by VideoSinkInterface.

webrtc/modules/video_capture/windows/device_info_ds.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 24 matching lines @@
     {176,144,101},
     {160,120,109},
     {1280,720,166},
     {960,544,126},
     {800,448,120},
     {800,600,127}
   },
 };
 
 // static
-DeviceInfoDS* DeviceInfoDS::Create(const int32_t id)
+DeviceInfoDS* DeviceInfoDS::Create()
 {
-    DeviceInfoDS* dsInfo = new DeviceInfoDS(id);
+    DeviceInfoDS* dsInfo = new DeviceInfoDS();
     if (!dsInfo || dsInfo->Init() != 0)
     {
         delete dsInfo;
         dsInfo = NULL;
     }
     return dsInfo;
 }
 
-DeviceInfoDS::DeviceInfoDS(const int32_t id)
-    : DeviceInfoImpl(id), _dsDevEnum(NULL), _dsMonikerDevEnum(NULL),
+DeviceInfoDS::DeviceInfoDS()
+    : _dsDevEnum(NULL), _dsMonikerDevEnum(NULL),
       _CoUninitializeIsRequired(true)
 {
     // 1) Initialize the COM library (make Windows load the DLLs).
     //
     // CoInitializeEx must be called at least once, and is usually called only once,
     // for each thread that uses the COM library. Multiple calls to CoInitializeEx
     // by the same thread are allowed as long as they pass the same concurrency flag,
     // but subsequent valid calls return S_FALSE.
     // To close the COM library gracefully on a thread, each successful call to
     // CoInitializeEx, including any call that returns S_FALSE, must be balanced
@@ skipping 13 matching lines @@
     {
         // Avoid calling CoUninitialize() since CoInitializeEx() failed.
         _CoUninitializeIsRequired = FALSE;
 
         if (hr == RPC_E_CHANGED_MODE)
         {
             // Calling thread has already initialized COM to be used in a single-threaded
             // apartment (STA). We are then prevented from using STA.
             // Details: hr = 0x80010106 <=> "Cannot change thread mode after it is set".
             //
-            WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideoCapture, _id,
+            WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideoCapture, 0,
                          "VideoCaptureWindowsDSInfo::VideoCaptureWindowsDSInfo "
                          "CoInitializeEx(NULL, COINIT_APARTMENTTHREADED) => "
                          "RPC_E_CHANGED_MODE, error 0x%x",
                          hr);
         }
     }
 }
 
 DeviceInfoDS::~DeviceInfoDS()
 {
     RELEASE_AND_CLEAR(_dsMonikerDevEnum);
     RELEASE_AND_CLEAR(_dsDevEnum);
     if (_CoUninitializeIsRequired)
     {
         CoUninitialize();
     }
 }
 
 int32_t DeviceInfoDS::Init()
 {
     HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
                                   IID_ICreateDevEnum, (void **) &_dsDevEnum);
     if (hr != NOERROR)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                      "Failed to create CLSID_SystemDeviceEnum, error 0x%x", hr);
         return -1;
     }
     return 0;
 }
 uint32_t DeviceInfoDS::NumberOfDevices()
 {
     ReadLockScoped cs(_apiLock);
     return GetDeviceInfo(0, 0, 0, 0, 0, 0, 0);
 }
@@ skipping 28 matching lines @@
 
 {
 
     // enumerate all video capture devices
     RELEASE_AND_CLEAR(_dsMonikerDevEnum);
     HRESULT hr =
         _dsDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
                                           &_dsMonikerDevEnum, 0);
     if (hr != NOERROR)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                      "Failed to enumerate CLSID_SystemDeviceEnum, error 0x%x."
                      " No webcam exist?", hr);
         return 0;
     }
 
     _dsMonikerDevEnum->Reset();
     ULONG cFetched;
     IMoniker *pM;
     int index = 0;
     while (S_OK == _dsMonikerDevEnum->Next(1, &pM, &cFetched))
@@ skipping 24 matching lines @@
                         if (deviceNameLength > 0)
                         {
                             convResult = WideCharToMultiByte(CP_UTF8, 0,
                                                              varName.bstrVal, -1,
                                                              (char*) deviceNameUTF8,
                                                              deviceNameLength, NULL,
                                                              NULL);
                             if (convResult == 0)
                             {
                                 WEBRTC_TRACE(webrtc::kTraceError,
-                                             webrtc::kTraceVideoCapture, _id,
+                                             webrtc::kTraceVideoCapture, 0,
                                              "Failed to convert device name to UTF8. %d",
                                              GetLastError());
                                 return -1;
                             }
                         }
                         if (deviceUniqueIdUTF8Length > 0)
                         {
                             hr = pBag->Read(L"DevicePath", &varName, 0);
                             if (FAILED(hr))
                             {
                                 strncpy_s((char *) deviceUniqueIdUTF8,
                                           deviceUniqueIdUTF8Length,
                                           (char *) deviceNameUTF8, convResult);
                                 WEBRTC_TRACE(webrtc::kTraceError,
-                                             webrtc::kTraceVideoCapture, _id,
+                                             webrtc::kTraceVideoCapture, 0,
                                              "Failed to get deviceUniqueIdUTF8 using deviceNameUTF8");
                             }
                             else
                             {
                                 convResult = WideCharToMultiByte(
                                                           CP_UTF8,
                                                           0,
                                                           varName.bstrVal,
                                                           -1,
                                                           (char*) deviceUniqueIdUTF8,
                                                           deviceUniqueIdUTF8Length,
                                                           NULL, NULL);
                                 if (convResult == 0)
                                 {
                                     WEBRTC_TRACE(webrtc::kTraceError,
-                                                 webrtc::kTraceVideoCapture, _id,
+                                                 webrtc::kTraceVideoCapture, 0,
                                                  "Failed to convert device name to UTF8. %d",
                                                  GetLastError());
                                     return -1;
                                 }
                                 if (productUniqueIdUTF8
                                     && productUniqueIdUTF8Length > 0)
                                 {
                                     GetProductId(deviceUniqueIdUTF8,
                                                  productUniqueIdUTF8,
                                                  productUniqueIdUTF8Length);
                                 }
                             }
                         }
 
                     }
                     ++index; // increase the number of valid devices
                 }
             }
             VariantClear(&varName);
             pBag->Release();
             pM->Release();
         }
 
     }
     if (deviceNameLength)
     {
-        WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCapture, _id, "%s %s",
+        WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCapture, 0, "%s %s",
                      __FUNCTION__, deviceNameUTF8);
     }
     return index;
 }
 
 IBaseFilter * DeviceInfoDS::GetDeviceFilter(
                                      const char* deviceUniqueIdUTF8,
                                      char* productUniqueIdUTF8,
                                      uint32_t productUniqueIdUTF8Length)
 {
 
     const int32_t deviceUniqueIdUTF8Length =
         (int32_t) strlen((char*) deviceUniqueIdUTF8); // UTF8 is also NULL terminated
     if (deviceUniqueIdUTF8Length > kVideoCaptureUniqueNameLength)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                      "Device name too long");
         return NULL;
     }
 
     // enumerate all video capture devices
     RELEASE_AND_CLEAR(_dsMonikerDevEnum);
     HRESULT hr = _dsDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
                                                    &_dsMonikerDevEnum, 0);
     if (hr != NOERROR)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                      "Failed to enumerate CLSID_SystemDeviceEnum, error 0x%x."
                      " No webcam exist?", hr);
         return 0;
     }
     _dsMonikerDevEnum->Reset();
     ULONG cFetched;
     IMoniker *pM;
 
     IBaseFilter *captureFilter = NULL;
     bool deviceFound = false;
@@ skipping 29 matching lines @@
                                 (const char*) deviceUniqueIdUTF8,
                                 deviceUniqueIdUTF8Length) == 0)
                     {
                         // We have found the requested device
                         deviceFound = true;
                         hr = pM->BindToObject(0, 0, IID_IBaseFilter,
                                               (void**) &captureFilter);
                         if FAILED(hr)
                         {
                             WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture,
-                                         _id, "Failed to bind to the selected capture device %d",hr);
+                                         0, "Failed to bind to the selected capture device %d",hr);
                         }
 
                         if (productUniqueIdUTF8
                             && productUniqueIdUTF8Length > 0) // Get the device name
                         {
 
                             GetProductId(deviceUniqueIdUTF8,
                                          productUniqueIdUTF8,
                                          productUniqueIdUTF8Length);
                         }
@@ skipping 27 matching lines @@
                                          const char* deviceUniqueIdUTF8)
 
 {
     // Reset old capability list
     _captureCapabilities.clear();
 
     const int32_t deviceUniqueIdUTF8Length =
         (int32_t) strlen((char*) deviceUniqueIdUTF8);
     if (deviceUniqueIdUTF8Length > kVideoCaptureUniqueNameLength)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        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);
 
 
     char productId[kVideoCaptureProductIdLength];
     IBaseFilter* captureDevice = DeviceInfoDS::GetDeviceFilter(
                                                deviceUniqueIdUTF8,
                                                productId,
                                                kVideoCaptureProductIdLength);
     if (!captureDevice)
         return -1;
     IPin* outputCapturePin = GetOutputPin(captureDevice, GUID_NULL);
     if (!outputCapturePin)
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                      "Failed to get capture device output pin");
         RELEASE_AND_CLEAR(captureDevice);
         return -1;
     }
     IAMExtDevice* extDevice = NULL;
     HRESULT hr = captureDevice->QueryInterface(IID_IAMExtDevice,
                                                (void **) &extDevice);
     if (SUCCEEDED(hr) && extDevice)
     {
-        WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, 0,
                      "This is an external device");
         extDevice->Release();
     }
 
     IAMStreamConfig* streamConfig = NULL;
     hr = outputCapturePin->QueryInterface(IID_IAMStreamConfig,
                                           (void**) &streamConfig);
     if (FAILED(hr))
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                      "Failed to get IID_IAMStreamConfig interface from capture device");
         return -1;
     }
 
     // this  gets the FPS
     IAMVideoControl* videoControlConfig = NULL;
     HRESULT hrVC = captureDevice->QueryInterface(IID_IAMVideoControl,
                                       (void**) &videoControlConfig);
     if (FAILED(hrVC))
     {
-        WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideoCapture, 0,
                      "IID_IAMVideoControl Interface NOT SUPPORTED");
     }
 
     AM_MEDIA_TYPE *pmt = NULL;
     VIDEO_STREAM_CONFIG_CAPS caps;
     int count, size;
 
     hr = streamConfig->GetNumberOfCapabilities(&count, &size);
     if (FAILED(hr))
     {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                      "Failed to GetNumberOfCapabilities");
         RELEASE_AND_CLEAR(videoControlConfig);
         RELEASE_AND_CLEAR(streamConfig);
         RELEASE_AND_CLEAR(outputCapturePin);
         RELEASE_AND_CLEAR(captureDevice);
         return -1;
     }
 
     // Check if the device support formattype == FORMAT_VideoInfo2 and FORMAT_VideoInfo.
     // Prefer FORMAT_VideoInfo since some cameras (ZureCam) has been seen having problem with MJPEG and FORMAT_VideoInfo2
     // Interlace flag is only supported in FORMAT_VideoInfo2
     bool supportFORMAT_VideoInfo2 = false;
     bool supportFORMAT_VideoInfo = false;
     bool foundInterlacedFormat = false;
     GUID preferedVideoFormat = FORMAT_VideoInfo;
     for (int32_t tmp = 0; tmp < count; ++tmp)
     {
         hr = streamConfig->GetStreamCaps(tmp, &pmt,
                                          reinterpret_cast<BYTE*> (&caps));
         if (!FAILED(hr))
         {
             if (pmt->majortype == MEDIATYPE_Video
                 && pmt->formattype == FORMAT_VideoInfo2)
             {
-                WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCapture, _id,
+                WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCapture, 0,
                              " Device support FORMAT_VideoInfo2");
                 supportFORMAT_VideoInfo2 = true;
                 VIDEOINFOHEADER2* h =
                     reinterpret_cast<VIDEOINFOHEADER2*> (pmt->pbFormat);
                 assert(h);
                 foundInterlacedFormat |= h->dwInterlaceFlags
                                         & (AMINTERLACE_IsInterlaced
                                            | AMINTERLACE_DisplayModeBobOnly);
             }
             if (pmt->majortype == MEDIATYPE_Video
                 && pmt->formattype == FORMAT_VideoInfo)
             {
-                WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCapture, _id,
+                WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCapture, 0,
                              " Device support FORMAT_VideoInfo2");
                 supportFORMAT_VideoInfo = true;
             }
         }
     }
     if (supportFORMAT_VideoInfo2)
     {
         if (supportFORMAT_VideoInfo && !foundInterlacedFormat)
         {
             preferedVideoFormat = FORMAT_VideoInfo;
         }
         else
         {
             preferedVideoFormat = FORMAT_VideoInfo2;
         }
     }
 
     for (int32_t tmp = 0; tmp < count; ++tmp)
     {
         hr = streamConfig->GetStreamCaps(tmp, &pmt,
                                          reinterpret_cast<BYTE*> (&caps));
         if (FAILED(hr))
         {
-            WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, _id,
+            WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                          "Failed to GetStreamCaps");
             RELEASE_AND_CLEAR(videoControlConfig);
             RELEASE_AND_CLEAR(streamConfig);
             RELEASE_AND_CLEAR(outputCapturePin);
             RELEASE_AND_CLEAR(captureDevice);
             return -1;
         }
 
         if (pmt->majortype == MEDIATYPE_Video
             && pmt->formattype == preferedVideoFormat)
@@ skipping 51 matching lines @@
                     0 != (maxFPS = GetMaxOfFrameArray(frameDurationList,
                                                       listSize)))
                 {
                     capability.maxFPS = static_cast<int> (10000000
                                                            / maxFPS);
                     capability.supportFrameRateControl = true;
                 }
                 else // use existing method
                 {
                     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture,
-                                 _id,
+                                 0,
                                  "GetMaxAvailableFrameRate NOT SUPPORTED");
                     if (avgTimePerFrame > 0)
                         capability.maxFPS = static_cast<int> (10000000
                                                                / avgTimePerFrame);
                     else
                         capability.maxFPS = 0;
                 }
             }
             else // use existing method in case IAMVideoControl is not supported
             {
@@ skipping 34 matching lines @@
                     || pmt->subtype == MEDIASUBTYPE_dvhd) // If this is an external DV camera
             {
                 capability.rawType = kVideoYUY2;// MS DV filter seems to create this type
             }
             else if (pmt->subtype == MEDIASUBTYPE_UYVY) // Seen used by Declink capture cards
             {
                 capability.rawType = kVideoUYVY;
             }
             else if (pmt->subtype == MEDIASUBTYPE_HDYC) // Seen used by Declink capture cards. Uses BT. 709 color. Not entiry correct to use UYVY. http://en.wikipedia.org/wiki/YCbCr
             {
-                WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideoCapture, _id,
+                WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideoCapture, 0,
                              "Device support HDYC.");
                 capability.rawType = kVideoUYVY;
             }
             else
             {
                 WCHAR strGuid[39];
                 StringFromGUID2(pmt->subtype, strGuid, 39);
                 WEBRTC_TRACE( webrtc::kTraceWarning,
-                             webrtc::kTraceVideoCapture, _id,
+                             webrtc::kTraceVideoCapture, 0,
                              "Device support unknown media type %ls, width %d, height %d",
                              strGuid);
                 continue;
             }
 
             // Get the expected capture delay from the static list
             capability.expectedCaptureDelay
                             = GetExpectedCaptureDelay(WindowsCaptureDelays,
                                                       NoWindowsCaptureDelays,
                                                       productId,
                                                       capability.width,
                                                       capability.height);
             _captureCapabilities.push_back(capability);
             _captureCapabilitiesWindows.push_back(capability);
-            WEBRTC_TRACE( webrtc::kTraceInfo, webrtc::kTraceVideoCapture, _id,
+            WEBRTC_TRACE( webrtc::kTraceInfo, webrtc::kTraceVideoCapture, 0,
                          "Camera capability, width:%d height:%d type:%d fps:%d",
                          capability.width, capability.height,
                          capability.rawType, capability.maxFPS);
         }
         DeleteMediaType(pmt);
         pmt = NULL;
     }
     RELEASE_AND_CLEAR(streamConfig);
     RELEASE_AND_CLEAR(videoControlConfig);
     RELEASE_AND_CLEAR(outputCapturePin);
     RELEASE_AND_CLEAR(captureDevice); // Release the capture device
 
     // 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,
+    WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideoCapture, 0,
                  "CreateCapabilityMap %d", _captureCapabilities.size());
 
     return static_cast<int32_t>(_captureCapabilities.size());
 }
 
 /* Constructs a product ID from the Windows DevicePath. on a USB device the devicePath contains product id and vendor id.
  This seems to work for firewire as well
  /* Example of device path
  "\\?\usb#vid_0408&pid_2010&mi_00#7&258e7aaf&0&0000#{65e8773d-8f56-11d0-a3b9-00a0c9223196}\global"
  "\\?\avc#sony&dv-vcr&camcorder&dv#65b2d50301460008#{65e8773d-8f56-11d0-a3b9-00a0c9223196}\global"
@@ skipping 92 matching lines @@
     // Release memory.
     if (uuid.pElems)
     {
         CoTaskMemFree(uuid.pElems);
     }
     filter->Release();
     return 0;
 }
 }  // namespace videocapturemodule
 }  // namespace webrtc