Reland: Reorganize media::VideoCapture* types

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/command_line.h"
@@ skipping 323 matching lines @@
   hr = graph_builder_->AddFilter(sink_filter_, NULL);
   if (FAILED(hr)) {
     DVLOG(2)<< "Failed to add the send filter to the graph.";
     return false;
   }
 
   return CreateCapabilityMap();
 }
 
 void VideoCaptureDeviceWin::AllocateAndStart(
-    const VideoCaptureCapability& capture_format,
+    const VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(CalledOnValidThread());
   if (state_ != kIdle)
     return;
 
   client_ = client.Pass();
 
   // Get the camera capability that best match the requested resolution.
   const VideoCaptureCapabilityWin& found_capability =
-      capabilities_.GetBestMatchedCapability(capture_format.width,
-                                             capture_format.height,
-                                             capture_format.frame_rate);
-  VideoCaptureCapability capability = found_capability;
+      capabilities_.GetBestMatchedFormat(
+          params.requested_format.frame_size.width(),
+          params.requested_format.frame_size.height(),
+          params.requested_format.frame_rate);
+  VideoCaptureFormat format = found_capability.supported_format;
 
   // Reduce the frame rate if the requested frame rate is lower
   // than the capability.
-  if (capability.frame_rate > capture_format.frame_rate)
-    capability.frame_rate = capture_format.frame_rate;
+  if (format.frame_rate > params.requested_format.frame_rate)
+    format.frame_rate = params.requested_format.frame_rate;
 
   AM_MEDIA_TYPE* pmt = NULL;
   VIDEO_STREAM_CONFIG_CAPS caps;
 
   ScopedComPtr<IAMStreamConfig> stream_config;
   HRESULT hr = output_capture_pin_.QueryInterface(stream_config.Receive());
   if (FAILED(hr)) {
     SetErrorState("Can't get the Capture format settings");
     return;
   }
 
   // Get the windows capability from the capture device.
   hr = stream_config->GetStreamCaps(found_capability.stream_index, &pmt,
                                     reinterpret_cast<BYTE*>(&caps));
   if (SUCCEEDED(hr)) {
     if (pmt->formattype == FORMAT_VideoInfo) {
       VIDEOINFOHEADER* h = reinterpret_cast<VIDEOINFOHEADER*>(pmt->pbFormat);
-      if (capability.frame_rate > 0)
-        h->AvgTimePerFrame = kSecondsToReferenceTime / capability.frame_rate;
+      if (format.frame_rate > 0)
+        h->AvgTimePerFrame = kSecondsToReferenceTime / format.frame_rate;
     }
-    // Set the sink filter to request this capability.
-    sink_filter_->SetRequestedMediaCapability(capability);
-    // Order the capture device to use this capability.
+    // Set the sink filter to request this format.
+    sink_filter_->SetRequestedMediaFormat(format);
+    // Order the capture device to use this format.
     hr = stream_config->SetFormat(pmt);
   }
 
   if (FAILED(hr))
     SetErrorState("Failed to set capture device output format");
 
-  if (capability.color == PIXEL_FORMAT_MJPEG &&
-      !mjpg_filter_.get()) {
+  if (format.pixel_format == PIXEL_FORMAT_MJPEG && !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 == PIXEL_FORMAT_MJPEG &&
-      mjpg_filter_.get()) {
+  if (format.pixel_format == PIXEL_FORMAT_MJPEG && 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
+  // Get the format back from the sink filter after the filter have been
   // connected.
-  current_setting_ = sink_filter_->ResultingCapability();
+  capture_format_ = sink_filter_->ResultingFormat();
 
   // Start capturing.
   hr = media_control_->Run();
   if (FAILED(hr)) {
     SetErrorState("Failed to start the Capture device.");
     return;
   }
 
   state_ = kCapturing;
 }
@@ skipping 23 matching lines @@
     return;
   }
   client_.reset();
   state_ = kIdle;
 }
 
 // Implements SinkFilterObserver::SinkFilterObserver.
 void VideoCaptureDeviceWin::FrameReceived(const uint8* buffer,
                                           int length) {
   client_->OnIncomingCapturedFrame(
-      buffer, length, base::Time::Now(), 0, false, false, current_setting_);
+      buffer, length, base::Time::Now(), 0, false, false, capture_format_);
 }
 
 bool VideoCaptureDeviceWin::CreateCapabilityMap() {
   DCHECK(CalledOnValidThread());
   ScopedComPtr<IAMStreamConfig> stream_config;
   HRESULT hr = output_capture_pin_.QueryInterface(stream_config.Receive());
   if (FAILED(hr)) {
     DVLOG(2) << "Failed to get IAMStreamConfig interface from "
                 "capture device";
     return false;
@@ skipping 22 matching lines @@
     if (hr != S_OK) {
       DVLOG(2) << "Failed to GetStreamCaps";
       return false;
     }
 
     if (media_type->majortype == MEDIATYPE_Video &&
         media_type->formattype == FORMAT_VideoInfo) {
       VideoCaptureCapabilityWin capability(i);
       VIDEOINFOHEADER* h =
           reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
-      capability.width = h->bmiHeader.biWidth;
-      capability.height = h->bmiHeader.biHeight;
+      capability.supported_format.frame_size.SetSize(h->bmiHeader.biWidth,
+                                                     h->bmiHeader.biHeight);
 
       // Try to get a better |time_per_frame| from IAMVideoControl.  If not, use
       // the value from VIDEOINFOHEADER.
       REFERENCE_TIME time_per_frame = h->AvgTimePerFrame;
       if (video_control) {
         ScopedCoMem<LONGLONG> max_fps;
         LONG list_size = 0;
-        SIZE size = { capability.width, capability.height };
+        SIZE size = {capability.supported_format.frame_size.width(),
+                     capability.supported_format.frame_size.height()};
 
         // GetFrameRateList doesn't return max frame rate always
         // eg: Logitech Notebook. This may be due to a bug in that API
         // because GetFrameRateList array is reversed in the above camera. So
         // a util method written. Can't assume the first value will return
         // the max fps.
         hr = video_control->GetFrameRateList(output_capture_pin_, i, size,
                                              &list_size, &max_fps);
         // Sometimes |list_size| will be > 0, but max_fps will be NULL.  Some
         // drivers may return an HRESULT of S_FALSE which SUCCEEDED() translates
         // into success, so explicitly check S_OK.  See http://crbug.com/306237.
         if (hr == S_OK && list_size > 0 && max_fps) {
           time_per_frame = *std::min_element(max_fps.get(),
                                              max_fps.get() + list_size);
         }
       }
 
-      capability.frame_rate = (time_per_frame > 0) ?
-          static_cast<int>(kSecondsToReferenceTime / time_per_frame) : 0;
+      capability.supported_format.frame_rate =
+          (time_per_frame > 0)
+              ? static_cast<int>(kSecondsToReferenceTime / time_per_frame)
+              : 0;
 
       // DirectShow works at the moment only on integer frame_rate but the
       // best capability matching class works on rational frame rates.
-      capability.frame_rate_numerator = capability.frame_rate;
+      capability.frame_rate_numerator = capability.supported_format.frame_rate;
       capability.frame_rate_denominator = 1;
 
       // We can't switch MEDIATYPE :~(.
       if (media_type->subtype == kMediaSubTypeI420) {
-        capability.color = PIXEL_FORMAT_I420;
+        capability.supported_format.pixel_format = PIXEL_FORMAT_I420;
       } else if (media_type->subtype == MEDIASUBTYPE_IYUV) {
         // This is identical to PIXEL_FORMAT_I420.
-        capability.color = PIXEL_FORMAT_I420;
+        capability.supported_format.pixel_format = PIXEL_FORMAT_I420;
       } else if (media_type->subtype == MEDIASUBTYPE_RGB24) {
-        capability.color = PIXEL_FORMAT_RGB24;
+        capability.supported_format.pixel_format = PIXEL_FORMAT_RGB24;
       } else if (media_type->subtype == MEDIASUBTYPE_YUY2) {
-        capability.color = PIXEL_FORMAT_YUY2;
+        capability.supported_format.pixel_format = PIXEL_FORMAT_YUY2;
       } else if (media_type->subtype == MEDIASUBTYPE_MJPG) {
-        capability.color = PIXEL_FORMAT_MJPEG;
+        capability.supported_format.pixel_format = PIXEL_FORMAT_MJPEG;
       } else if (media_type->subtype == MEDIASUBTYPE_UYVY) {
-        capability.color = PIXEL_FORMAT_UYVY;
+        capability.supported_format.pixel_format = PIXEL_FORMAT_UYVY;
       } else if (media_type->subtype == MEDIASUBTYPE_ARGB32) {
-        capability.color = PIXEL_FORMAT_ARGB;
+        capability.supported_format.pixel_format = PIXEL_FORMAT_ARGB;
       } else {
         WCHAR guid_str[128];
         StringFromGUID2(media_type->subtype, guid_str, arraysize(guid_str));
         DVLOG(2) << "Device supports (also) an unknown media type " << guid_str;
         continue;
       }
       capabilities_.Add(capability);
     }
     DeleteMediaType(media_type);
     media_type = NULL;
   }
 
   return !capabilities_.empty();
 }
 
 void VideoCaptureDeviceWin::SetErrorState(const char* reason) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << reason;
   state_ = kError;
   client_->OnError();
 }
 }  // namespace media