Video Capture Device Win: cleanup error logging

media/capture/video/win/video_capture_device_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/capture/video/win/video_capture_device_win.h"
 
 #include <ks.h>
 #include <ksmedia.h>
 
 #include <algorithm>
 #include <list>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_variant.h"
 #include "media/base/timestamp_constants.h"
 #include "media/capture/video/blob_utils.h"
 
 using base::win::ScopedCoMem;
 using base::win::ScopedComPtr;
 using base::win::ScopedVariant;
 
 namespace media {
 
+#if DCHECK_IS_ON()
+#define DLOG_IF_WITH_HRESULT(message, hr)                               \

[xianglu, 2016/09/22 20:55:14]

Would it be better if named DLOG_IF_FAILED_WITH_HRESULT? Because you are only
checking this specific condition.

+  {                                                                     \
+    DLOG_IF(ERROR, FAILED(hr)) << (message) << ": "                     \
+                               << logging::SystemErrorCodeToString(hr); \
+  }
+#else
+#define DLOG_IF_WITH_HRESULT(message, hr) \
+  {}
+#endif
+
 // Check if a Pin matches a category.
 bool PinMatchesCategory(IPin* pin, REFGUID category) {
   DCHECK(pin);
   bool found = false;
   ScopedComPtr<IKsPropertySet> ks_property;
   HRESULT hr = ks_property.QueryFrom(pin);
   if (SUCCEEDED(hr)) {
     GUID pin_category;
     DWORD return_value;
     hr = ks_property->Get(AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY, NULL, 0,
@@ skipping 198 matching lines @@
 
   if (capture_graph_builder_.get())
     capture_graph_builder_.Release();
 }
 
 bool VideoCaptureDeviceWin::Init() {
   DCHECK(thread_checker_.CalledOnValidThread());
   HRESULT hr;
 
   hr = GetDeviceFilter(device_descriptor_.device_id, capture_filter_.Receive());
-
-  if (!capture_filter_.get()) {
-    DLOG(ERROR) << "Failed to create capture filter: "
-                << logging::SystemErrorCodeToString(hr);
+  DLOG_IF_WITH_HRESULT("Failed to create capture filter", hr);
+  if (!capture_filter_.get())
     return false;
-  }
 
   output_capture_pin_ = GetPin(capture_filter_.get(), PINDIR_OUTPUT,
                                PIN_CATEGORY_CAPTURE, GUID_NULL);
   if (!output_capture_pin_.get()) {
     DLOG(ERROR) << "Failed to get capture output pin";
     return false;
   }
 
   // Create the sink filter used for receiving Captured frames.
   sink_filter_ = new SinkFilter(this);
   if (sink_filter_.get() == NULL) {
     DLOG(ERROR) << "Failed to create sink filter";
     return false;
   }
 
   input_sink_pin_ = sink_filter_->GetPin(0);
 
   hr = graph_builder_.CreateInstance(CLSID_FilterGraph, NULL,
                                      CLSCTX_INPROC_SERVER);
-  if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to create graph builder: "
-                << logging::SystemErrorCodeToString(hr);
+  DLOG_IF_WITH_HRESULT("Failed to create capture filter", hr);
+  if (FAILED(hr))
     return false;
-  }
 
   hr = capture_graph_builder_.CreateInstance(CLSID_CaptureGraphBuilder2, NULL,
                                              CLSCTX_INPROC);
-  if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to create the Capture Graph Builder: "
-                << logging::SystemErrorCodeToString(hr);
+  DLOG_IF_WITH_HRESULT("Failed to create the Capture Graph Builder", hr);
+  if (FAILED(hr))
     return false;
-  }
 
   hr = capture_graph_builder_->SetFiltergraph(graph_builder_.get());
-  if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to give graph to capture graph builder: "
-                << logging::SystemErrorCodeToString(hr);
+  DLOG_IF_WITH_HRESULT("Failed to give graph to capture graph builder", hr);
+  if (FAILED(hr))
     return false;
-  }
 
   hr = graph_builder_.QueryInterface(media_control_.Receive());
-  if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to create media control builder: "
-                << logging::SystemErrorCodeToString(hr);
+  DLOG_IF_WITH_HRESULT("Failed to create media control builder", hr);
+  if (FAILED(hr))
     return false;
-  }
 
   hr = graph_builder_->AddFilter(capture_filter_.get(), NULL);
-  if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to add the capture device to the graph: "
-                << logging::SystemErrorCodeToString(hr);
+  DLOG_IF_WITH_HRESULT("Failed to add the capture device to the graph", hr);
+  if (FAILED(hr))
     return false;
-  }
 
   hr = graph_builder_->AddFilter(sink_filter_.get(), NULL);
-  if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to add the sink filter to the graph: "
-                << logging::SystemErrorCodeToString(hr);
+  DLOG_IF_WITH_HRESULT("Failed to add the sink filter to the graph", hr);
+  if (FAILED(hr))
     return false;
-  }
 
-  // The following code builds the upstream portions of the graph,
-  // for example if a capture device uses a Windows Driver Model (WDM)
-  // driver, the graph may require certain filters upstream from the
-  // WDM Video Capture filter, such as a TV Tuner filter or an Analog
-  // Video Crossbar filter. We try using the more prevalent
-  // MEDIATYPE_Interleaved first.
+  // The following code builds the upstream portions of the graph, for example
+  // if a capture device uses a Windows Driver Model (WDM) driver, the graph may
+  // require certain filters upstream from the WDM Video Capture filter, such as
+  // a TV Tuner filter or an Analog Video Crossbar filter. We try using the more
+  // prevalent MEDIATYPE_Interleaved first.
   base::win::ScopedComPtr<IAMStreamConfig> stream_config;
 
   hr = capture_graph_builder_->FindInterface(
       &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Interleaved, capture_filter_.get(),
       IID_IAMStreamConfig, (void**)stream_config.Receive());
   if (FAILED(hr)) {
     hr = capture_graph_builder_->FindInterface(
         &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, capture_filter_.get(),
         IID_IAMStreamConfig, (void**)stream_config.Receive());
-    DLOG_IF(ERROR, FAILED(hr)) << "Failed to find CapFilter:IAMStreamConfig: "
-                               << logging::SystemErrorCodeToString(hr);
+    DLOG_IF_WITH_HRESULT("Failed to find CapFilter:IAMStreamConfig", hr);
   }
 
   return CreateCapabilityMap();
 }
 
 void VideoCaptureDeviceWin::AllocateAndStart(
     const VideoCaptureParams& params,
     std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ != kIdle)
     return;
 
   client_ = std::move(client);
 
   // Get the camera capability that best match the requested format.
   const CapabilityWin found_capability =
       GetBestMatchedCapability(params.requested_format, capabilities_);
 
   // Reduce the frame rate if the requested frame rate is lower
   // than the capability.
   const float frame_rate =
       std::min(params.requested_format.frame_rate,
                found_capability.supported_format.frame_rate);
 
   ScopedComPtr<IAMStreamConfig> stream_config;
   HRESULT hr = output_capture_pin_.QueryInterface(stream_config.Receive());
   if (FAILED(hr)) {
-    SetErrorState(FROM_HERE, "Can't get the Capture format settings");
+    SetErrorState(FROM_HERE, "Can't get the Capture format settings", hr);
     return;
   }
 
   int count = 0, size = 0;
   hr = stream_config->GetNumberOfCapabilities(&count, &size);
   if (FAILED(hr)) {
-    SetErrorState(FROM_HERE, "Failed to GetNumberOfCapabilities");
+    SetErrorState(FROM_HERE, "Failed to GetNumberOfCapabilities", hr);
     return;
   }
 
   std::unique_ptr<BYTE[]> caps(new BYTE[size]);
   ScopedMediaType media_type;
 
   // Get the windows capability from the capture device.
   // GetStreamCaps can return S_FALSE which we consider an error. Therefore the
   // FAILED macro can't be used.
   hr = stream_config->GetStreamCaps(found_capability.stream_index,
                                     media_type.Receive(), caps.get());
   if (hr != S_OK) {
-    SetErrorState(FROM_HERE, "Failed to get capture device capabilities");
+    SetErrorState(FROM_HERE, "Failed to get capture device capabilities", hr);
     return;
   }
   if (media_type->formattype == FORMAT_VideoInfo) {
     VIDEOINFOHEADER* h =
         reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
     if (frame_rate > 0)
       h->AvgTimePerFrame = kSecondsToReferenceTime / frame_rate;
   }
   // Set the sink filter to request this format.
   sink_filter_->SetRequestedMediaFormat(
       found_capability.supported_format.pixel_format, frame_rate,
       found_capability.info_header);
   // Order the capture device to use this format.
   hr = stream_config->SetFormat(media_type.get());
   if (FAILED(hr)) {
-    // TODO(grunell): Log the error. http://crbug.com/405016.
-    SetErrorState(FROM_HERE, "Failed to set capture device output format");
+    SetErrorState(FROM_HERE, "Failed to set capture device output format", hr);
     return;
   }
 
   SetAntiFlickerInCaptureFilter(params);
 
   if (media_type->subtype == kMediaSubTypeHDYC) {
     // HDYC pixel format, used by the DeckLink capture card, needs an AVI
     // decompressor filter after source, let |graph_builder_| add it.
     hr = graph_builder_->Connect(output_capture_pin_.get(),
                                  input_sink_pin_.get());
   } else {
     hr = graph_builder_->ConnectDirect(output_capture_pin_.get(),
                                        input_sink_pin_.get(), NULL);
   }
 
   if (FAILED(hr)) {
-    SetErrorState(FROM_HERE, "Failed to connect the Capture graph.");
+    SetErrorState(FROM_HERE, "Failed to connect the Capture graph.", hr);
     return;
   }
 
   hr = media_control_->Pause();
   if (FAILED(hr)) {
-    SetErrorState(
-        FROM_HERE,
-        "Failed to pause the Capture device, is it already occupied?");
+    SetErrorState(FROM_HERE, "Failed to pause the Capture device", hr);
     return;
   }
 
   // Get the format back from the sink filter after the filter have been
   // connected.
   capture_format_ = sink_filter_->ResultingFormat();
 
   // Start capturing.
   hr = media_control_->Run();
   if (FAILED(hr)) {
-    SetErrorState(FROM_HERE, "Failed to start the Capture device.");
+    SetErrorState(FROM_HERE, "Failed to start the Capture device.", hr);
     return;
   }
 
   state_ = kCapturing;
 }
 
 void VideoCaptureDeviceWin::StopAndDeAllocate() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ != kCapturing)
     return;
 
   HRESULT hr = media_control_->Stop();
   if (FAILED(hr)) {
-    SetErrorState(FROM_HERE, "Failed to stop the capture graph.");
+    SetErrorState(FROM_HERE, "Failed to stop the capture graph.", hr);
     return;
   }
 
   graph_builder_->Disconnect(output_capture_pin_.get());
   graph_builder_->Disconnect(input_sink_pin_.get());
 
   client_.reset();
   state_ = kIdle;
 }
 
@@ skipping 28 matching lines @@
     mojom::BlobPtr blob = Blobify(buffer, length, capture_format_);
     if (blob)
       cb.Run(std::move(blob));
   }
 }
 
 bool VideoCaptureDeviceWin::CreateCapabilityMap() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ScopedComPtr<IAMStreamConfig> stream_config;
   HRESULT hr = output_capture_pin_.QueryInterface(stream_config.Receive());
-  if (FAILED(hr)) {
-    DPLOG(ERROR) << "Failed to get IAMStreamConfig interface from "
-                    "capture device: " << logging::SystemErrorCodeToString(hr);
+  DLOG_IF_WITH_HRESULT("Failed to get IAMStreamConfig from capture device", hr);
+  if (FAILED(hr))
     return false;
-  }
 
   // Get interface used for getting the frame rate.
   ScopedComPtr<IAMVideoControl> video_control;
   hr = capture_filter_.QueryInterface(video_control.Receive());
-  DLOG_IF(WARNING, FAILED(hr)) << "IAMVideoControl Interface NOT SUPPORTED: "
-                               << logging::SystemErrorCodeToString(hr);
 
   int count = 0, size = 0;
   hr = stream_config->GetNumberOfCapabilities(&count, &size);
-  if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to GetNumberOfCapabilities: "
-                << logging::SystemErrorCodeToString(hr);
+  DLOG_IF_WITH_HRESULT("Failed to GetNumberOfCapabilities", hr);
+  if (FAILED(hr))
     return false;
-  }
 
   std::unique_ptr<BYTE[]> caps(new BYTE[size]);
   for (int stream_index = 0; stream_index < count; ++stream_index) {
     ScopedMediaType media_type;
     hr = stream_config->GetStreamCaps(stream_index, media_type.Receive(),
                                       caps.get());
     // GetStreamCaps() may return S_FALSE, so don't use FAILED() or SUCCEED()
     // macros here since they'll trigger incorrectly.
     if (hr != S_OK) {
-      DLOG(ERROR) << "Failed to GetStreamCaps: "
-                  << logging::SystemErrorCodeToString(hr);
+      DLOG(ERROR) << "Failed to GetStreamCaps";
       return false;
     }
 
     if (media_type->majortype == MEDIATYPE_Video &&
         media_type->formattype == FORMAT_VideoInfo) {
       VideoCaptureFormat format;
       format.pixel_format =
           TranslateMediaSubtypeToPixelFormat(media_type->subtype);
       if (format.pixel_format == PIXEL_FORMAT_UNKNOWN)
         continue;
@@ skipping 56 matching lines @@
     data.Property.Set = PROPSETID_VIDCAP_VIDEOPROCAMP;
     data.Property.Id = KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY;
     data.Property.Flags = KSPROPERTY_TYPE_SET;
     data.Value =
         (power_line_frequency == media::PowerLineFrequency::FREQUENCY_50HZ) ? 1
                                                                             : 2;
     data.Flags = KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL;
     hr = ks_propset->Set(PROPSETID_VIDCAP_VIDEOPROCAMP,
                          KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY, &data,
                          sizeof(data), &data, sizeof(data));
-    DLOG_IF(ERROR, FAILED(hr)) << "Anti-flicker setting failed: "
-                               << logging::SystemErrorCodeToString(hr);
-    DVLOG_IF(2, SUCCEEDED(hr)) << "Anti-flicker set correctly.";
-  } else {
-    DVLOG(2) << "Anti-flicker setting not supported.";
+    DLOG_IF_WITH_HRESULT("Anti-flicker setting failed", hr);
   }
 }
 
 void VideoCaptureDeviceWin::SetErrorState(
     const tracked_objects::Location& from_here,
-    const std::string& reason) {
+    const std::string& reason,
+    HRESULT hr) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  DLOG_IF_WITH_HRESULT(reason, hr);
   state_ = kError;
   client_->OnError(from_here, reason);
 }
 }  // namespace media