Log error messages in windows video capture

media/video/capture/win/video_capture_device_factory_win.cc

 // Copyright 2014 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/video/capture/win/video_capture_device_factory_win.h"
 
 #include <mfapi.h>
 #include <mferror.h>
 
 #include "base/command_line.h"
@@ skipping 181 matching lines @@
       hr = devices[i]->GetAllocatedString(
           MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, &id,
           &id_size);
       if (SUCCEEDED(hr)) {
         device_names->push_back(Name(
             base::SysWideToUTF8(std::wstring(name, name_size)),
             base::SysWideToUTF8(std::wstring(id, id_size)),
             Name::MEDIA_FOUNDATION));
       }
     }
-    if (FAILED(hr))
-      DLOG(WARNING) << "GetAllocatedString failed: " << std::hex << hr;
+    DLOG_IF(ERROR, FAILED(hr)) << "GetAllocatedString failed: "
+                               << logging::SystemErrorCodeToString(hr);
     devices[i]->Release();
   }
 }
 
 static void GetDeviceSupportedFormatsDirectShow(const Name& device,
                                                 VideoCaptureFormats* formats) {
   DVLOG(1) << "GetDeviceSupportedFormatsDirectShow for " << device.name();
   ScopedComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr = dev_enum.CreateInstance(CLSID_SystemDeviceEnum, NULL,
                                        CLSCTX_INPROC);
   if (FAILED(hr))
     return;
 
   ScopedComPtr<IEnumMoniker> enum_moniker;
   hr = dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
                                        enum_moniker.Receive(), 0);
   // CreateClassEnumerator returns S_FALSE on some Windows OS when no camera
   // exists. Therefore the FAILED macro can't be used.
   if (hr != S_OK)
     return;
 
   // Walk the capture devices. No need to check for device presence again, that
   // is caught in GetDeviceFilter(). "google camera adapter" and old VFW devices
   // are already skipped in the previous GetDeviceNames() enumeration.
   base::win::ScopedComPtr<IBaseFilter> capture_filter;
   hr = VideoCaptureDeviceWin::GetDeviceFilter(device,
                                               capture_filter.Receive());
   if (!capture_filter) {
-    DVLOG(2) << "Failed to create capture filter.";
+    DLOG(ERROR) << "Failed to create capture filter: "
+                << logging::SystemErrorCodeToString(hr);
     return;
   }
 
   base::win::ScopedComPtr<IPin> output_capture_pin(
       VideoCaptureDeviceWin::GetPin(capture_filter,
                                     PINDIR_OUTPUT,
                                     PIN_CATEGORY_CAPTURE));
   if (!output_capture_pin) {
-    DVLOG(2) << "Failed to get capture output pin";
+    DLOG(ERROR) << "Failed to get capture output pin";
     return;
   }
 
   ScopedComPtr<IAMStreamConfig> stream_config;
   hr = output_capture_pin.QueryInterface(stream_config.Receive());
   if (FAILED(hr)) {
-    DVLOG(2) << "Failed to get IAMStreamConfig interface from "
-                "capture device";
+    DLOG(ERROR) << "Failed to get IAMStreamConfig interface from "
+                   "capture device: " << logging::SystemErrorCodeToString(hr);
     return;
   }
 
   int count = 0, size = 0;
   hr = stream_config->GetNumberOfCapabilities(&count, &size);
   if (FAILED(hr)) {
-    DVLOG(2) << "Failed to GetNumberOfCapabilities";
+    DLOG(ERROR) << "GetNumberOfCapabilities failed: "
+                << logging::SystemErrorCodeToString(hr);
     return;
   }
 
   scoped_ptr<BYTE[]> caps(new BYTE[size]);
   for (int i = 0; i < count; ++i) {
     VideoCaptureDeviceWin::ScopedMediaType media_type;
     hr = stream_config->GetStreamCaps(i, 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) {
-      DVLOG(2) << "Failed to GetStreamCaps";
+      DLOG(ERROR) << "GetStreamCaps failed: "
+                  << logging::SystemErrorCodeToString(hr);
       return;
     }
 
     if (media_type->majortype == MEDIATYPE_Video &&
         media_type->formattype == FORMAT_VideoInfo) {
       VideoCaptureFormat format;
       format.pixel_format =
           VideoCaptureDeviceWin::TranslateMediaSubtypeToPixelFormat(
               media_type->subtype);
       if (format.pixel_format == PIXEL_FORMAT_UNKNOWN)
@@ skipping 21 matching lines @@
   ScopedComPtr<IMFMediaSource> source;
   if (!CreateVideoCaptureDeviceMediaFoundation(device.id().c_str(),
                                                source.Receive())) {
     return;
   }
 
   base::win::ScopedComPtr<IMFSourceReader> reader;
   HRESULT hr =
       MFCreateSourceReaderFromMediaSource(source, NULL, reader.Receive());
   if (FAILED(hr)) {
-    DLOG(ERROR) << "MFCreateSourceReaderFromMediaSource: " << std::hex << hr;
+    DLOG(ERROR) << "MFCreateSourceReaderFromMediaSource failed: "
+                << logging::SystemErrorCodeToString(hr);
     return;
   }
 
   DWORD stream_index = 0;
   ScopedComPtr<IMFMediaType> type;
   while (SUCCEEDED(reader->GetNativeMediaType(
              kFirstVideoStream, stream_index, type.Receive()))) {
     UINT32 width, height;
     hr = MFGetAttributeSize(type, MF_MT_FRAME_SIZE, &width, &height);
     if (FAILED(hr)) {
-      DLOG(ERROR) << "MFGetAttributeSize: " << std::hex << hr;
+      DLOG(ERROR) << "MFGetAttributeSize failed: "
+                  << logging::SystemErrorCodeToString(hr);
       return;
     }
     VideoCaptureFormat capture_format;
     capture_format.frame_size.SetSize(width, height);
 
     UINT32 numerator, denominator;
     hr = MFGetAttributeRatio(type, MF_MT_FRAME_RATE, &numerator, &denominator);
     if (FAILED(hr)) {
-      DLOG(ERROR) << "MFGetAttributeSize: " << std::hex << hr;
+      DLOG(ERROR) << "MFGetAttributeSize failed: "
+                  << logging::SystemErrorCodeToString(hr);
       return;
     }
     capture_format.frame_rate = denominator
         ? static_cast<float>(numerator) / denominator : 0.0f;
 
     GUID type_guid;
     hr = type->GetGUID(MF_MT_SUBTYPE, &type_guid);
     if (FAILED(hr)) {
-      DLOG(ERROR) << "GetGUID: " << std::hex << hr;
+      DLOG(ERROR) << "GetGUID failed: "
+                  << logging::SystemErrorCodeToString(hr);
       return;
     }
     VideoCaptureDeviceMFWin::FormatFromGuid(type_guid,
                                             &capture_format.pixel_format);
     type.Release();
     formats->push_back(capture_format);
     ++stream_index;
 
     DVLOG(1) << device.name() << " resolution: "
              << capture_format.frame_size.ToString() << ", fps: "
@@ skipping 69 matching lines @@
     const Name& device,
     VideoCaptureFormats* formats) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (use_media_foundation_)
     GetDeviceSupportedFormatsMediaFoundation(device, formats);
   else
     GetDeviceSupportedFormatsDirectShow(device, formats);
 }
 
 }  // namespace media