Merge VideoCaptureDevice::Capability with media::VideoCaptureCapability

media/video/capture/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/video/capture/win/video_capture_device_win.h"
 
 #include <algorithm>
 #include <list>
 
 #include "base/string_util.h"
@@ skipping 130 matching lines @@
     CoTaskMemFree(mt);
   }
 }
 
 // Help structure used for comparing video capture capabilities.
 struct ResolutionDiff {
   int capability_index;
   int diff_height;
   int diff_width;
   int diff_frame_rate;
-  media::VideoCaptureDevice::Format color;
+  media::VideoCaptureCapability::Format color;
 };
 
 bool CompareHeight(const ResolutionDiff& item1, const ResolutionDiff& item2) {
   return abs(item1.diff_height) < abs(item2.diff_height);
 }
 
 bool CompareWidth(const ResolutionDiff& item1, const ResolutionDiff& item2) {
   return abs(item1.diff_width) < abs(item2.diff_width);
 }
 
@@ skipping 169 matching lines @@
     int height,
     int frame_rate,
     VideoCaptureDevice::EventHandler* observer) {
   if (state_ != kIdle)
     return;
 
   observer_ = observer;
   // Get the camera capability that best match the requested resolution.
   const int capability_index = GetBestMatchedCapability(width, height,
                                                         frame_rate);
-  Capability capability = capabilities_[capability_index];
+  VideoCaptureCapability capability = capabilities_[capability_index];
 
   // Reduce the frame rate if the requested frame rate is lower
   // than the capability.
   if (capability.frame_rate > frame_rate)
     capability.frame_rate = frame_rate;
 
   AM_MEDIA_TYPE* pmt = NULL;
   VIDEO_STREAM_CONFIG_CAPS caps;
 
   ScopedComPtr<IAMStreamConfig> stream_config;
@@ skipping 14 matching lines @@
     }
     // Set the sink filter to request this capability.
     sink_filter_->SetRequestedMediaCapability(capability);
     // Order the capture device to use this capability.
     hr = stream_config->SetFormat(pmt);
   }
 
   if (FAILED(hr))
     SetErrorState("Failed to set capture device output format");
 
-  if (capability.color == VideoCaptureDevice::kMJPEG && !mjpg_filter_.get()) {
+  if (capability.color == VideoCaptureCapability::kMJPEG &&
+      !mjpg_filter_.get()) {
     // Create MJPG filter if we need it.
     hr = mjpg_filter_.CreateInstance(CLSID_MjpegDec, NULL, CLSCTX_INPROC);
 
     if (SUCCEEDED(hr)) {
       GetPin(mjpg_filter_, PINDIR_INPUT, GUID_NULL, input_mjpg_pin_.Receive());
       GetPin(mjpg_filter_, PINDIR_OUTPUT, GUID_NULL,
              output_mjpg_pin_.Receive());
       hr = graph_builder_->AddFilter(mjpg_filter_, NULL);
     }
 
     if (FAILED(hr)) {
       mjpg_filter_.Release();
       input_mjpg_pin_.Release();
       output_mjpg_pin_.Release();
     }
   }
 
-  if (capability.color == VideoCaptureDevice::kMJPEG && mjpg_filter_.get()) {
+  if (capability.color == VideoCaptureCapability::kMJPEG &&
+      mjpg_filter_.get()) {
     // Connect the camera to the MJPEG decoder.
     hr = graph_builder_->ConnectDirect(output_capture_pin_, input_mjpg_pin_,
                                        NULL);
     // Connect the MJPEG filter to the Capture filter.
     hr += graph_builder_->ConnectDirect(output_mjpg_pin_, input_sink_pin_,
                                         NULL);
   } else {
     hr = graph_builder_->ConnectDirect(output_capture_pin_, input_sink_pin_,
                                        NULL);
   }
 
   if (FAILED(hr)) {
     SetErrorState("Failed to connect the Capture graph.");
     return;
   }
 
   hr = media_control_->Pause();
   if (FAILED(hr)) {
     SetErrorState("Failed to Pause the Capture device. "
                   "Is it already occupied?");
     return;
   }
 
   // Get the capability back from the sink filter after the filter have been
   // connected.
-  const Capability& used_capability = sink_filter_->ResultingCapability();
+  const VideoCaptureCapability& used_capability
+      = sink_filter_->ResultingCapability();
   observer_->OnFrameInfo(used_capability);
 
   state_ = kAllocated;
 }
 
 void VideoCaptureDeviceWin::Start() {
   if (state_ != kAllocated)
     return;
 
   HRESULT hr = media_control_->Run();
@@ skipping 77 matching lines @@
   for (int i = 0; i < count; ++i) {
     hr = stream_config->GetStreamCaps(i, &media_type,
                                       reinterpret_cast<BYTE*>(&caps));
     if (FAILED(hr)) {
       DVLOG(2) << "Failed to GetStreamCaps";
       return false;
     }
 
     if (media_type->majortype == MEDIATYPE_Video &&
         media_type->formattype == FORMAT_VideoInfo) {
-      Capability capability;
+      VideoCaptureCapability capability;
       REFERENCE_TIME time_per_frame = 0;
 
       VIDEOINFOHEADER* h =
           reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
       capability.width = h->bmiHeader.biWidth;
       capability.height = h->bmiHeader.biHeight;
       time_per_frame = h->AvgTimePerFrame;
 
       // Try to get the max frame rate from IAMVideoControl.
       if (video_control.get()) {
@@ skipping 23 matching lines @@
         }
       } else {
         // Get frame rate from VIDEOINFOHEADER since IAMVideoControl is
         // not supported.
         capability.frame_rate = (time_per_frame > 0) ?
             static_cast<int>(kSecondsToReferenceTime / time_per_frame) : 0;
       }
 
       // We can't switch MEDIATYPE :~(.
       if (media_type->subtype == kMediaSubTypeI420) {
-        capability.color = VideoCaptureDevice::kI420;
+        capability.color = VideoCaptureCapability::kI420;
       } else if (media_type->subtype == MEDIASUBTYPE_IYUV) {
         // This is identical to kI420.
-        capability.color = VideoCaptureDevice::kI420;
+        capability.color = VideoCaptureCapability::kI420;
       } else if (media_type->subtype == MEDIASUBTYPE_RGB24) {
-        capability.color = VideoCaptureDevice::kRGB24;
+        capability.color = VideoCaptureCapability::kRGB24;
       } else if (media_type->subtype == MEDIASUBTYPE_YUY2) {
-        capability.color = VideoCaptureDevice::kYUY2;
+        capability.color = VideoCaptureCapability::kYUY2;
       } else if (media_type->subtype == MEDIASUBTYPE_MJPG) {
-        capability.color = VideoCaptureDevice::kMJPEG;
+        capability.color = VideoCaptureCapability::kMJPEG;
       } else {
         WCHAR guid_str[128];
         StringFromGUID2(media_type->subtype, guid_str, arraysize(guid_str));
         DVLOG(2) << "Device support unknown media type " << guid_str;
         continue;
       }
       capabilities_[i] = capability;
     }
     DeleteMediaType(media_type);
     media_type = NULL;
   }
 
   return capabilities_.size() > 0;
 }
 
 // Loops through the list of capabilities and returns an index of the best
 // matching capability.
 // The algorithm prioritize height, width, frame rate and color format in that
 // order.
 int VideoCaptureDeviceWin::GetBestMatchedCapability(int requested_width,
                                                     int requested_height,
                                                     int requested_frame_rate) {
   std::list<ResolutionDiff> diff_list;
 
   // Loop through the candidates to create a list of differentials between the
   // requested resolution and the camera capability.
   for (CapabilityMap::iterator iterator = capabilities_.begin();
        iterator != capabilities_.end();
        ++iterator) {
-    Capability capability = iterator->second;
+    VideoCaptureCapability capability = iterator->second;
 
     ResolutionDiff diff;
     diff.capability_index = iterator->first;
     diff.diff_width = capability.width - requested_width;
     diff.diff_height = capability.height - requested_height;
     diff.diff_frame_rate = capability.frame_rate - requested_frame_rate;
     diff.color = capability.color;
     diff_list.push_back(diff);
   }
 
@@ skipping 37 matching lines @@
   return diff_list.front().capability_index;
 }
 
 void VideoCaptureDeviceWin::SetErrorState(const char* reason) {
   DLOG(ERROR) << reason;
   state_ = kError;
   observer_->OnError();
 }
 
 }  // namespace media