Reland: Reorganize media::VideoCapture* types

media/video/capture/win/video_capture_device_mf_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_mf_win.h"
 
 #include <mfapi.h>
 #include <mferror.h>
 
 #include "base/lazy_instance.h"
@@ skipping 76 matching lines @@
   for (int i = 0; i < arraysize(kFormatMap); ++i) {
     if (kFormatMap[i].guid == guid) {
       *format = kFormatMap[i].format;
       return true;
     }
   }
 
   return false;
 }
 
-bool GetFrameSize(IMFMediaType* type, int* width, int* height) {
+bool GetFrameSize(IMFMediaType* type, gfx::Size* frame_size) {
   UINT32 width32, height32;
   if (FAILED(MFGetAttributeSize(type, MF_MT_FRAME_SIZE, &width32, &height32)))
     return false;
-  *width = width32;
-  *height = height32;
+  frame_size->SetSize(width32, height32);
   return true;
 }
 
 bool GetFrameRate(IMFMediaType* type,
                   int* frame_rate_numerator,
                   int* frame_rate_denominator) {
   UINT32 numerator, denominator;
   if (FAILED(MFGetAttributeRatio(type, MF_MT_FRAME_RATE, &numerator,
                                  &denominator))||
       !denominator) {
     return false;
   }
   *frame_rate_numerator = numerator;
   *frame_rate_denominator = denominator;
   return true;
 }
 
 bool FillCapabilitiesFromType(IMFMediaType* type,
                               VideoCaptureCapabilityWin* capability) {
   GUID type_guid;
   if (FAILED(type->GetGUID(MF_MT_SUBTYPE, &type_guid)) ||
-      !FormatFromGuid(type_guid, &capability->color) ||
-      !GetFrameSize(type, &capability->width, &capability->height) ||
+      !GetFrameSize(type, &capability->supported_format.frame_size) ||
       !GetFrameRate(type,
                     &capability->frame_rate_numerator,
-                    &capability->frame_rate_denominator)) {
+                    &capability->frame_rate_denominator) ||
+      !FormatFromGuid(type_guid, &capability->supported_format.pixel_format)) {
     return false;
   }
   // Keep the integer version of the frame_rate for (potential) returns.
-  capability->frame_rate =
+  capability->supported_format.frame_rate =
       capability->frame_rate_numerator / capability->frame_rate_denominator;
 
   return true;
 }
 
 HRESULT FillCapabilities(IMFSourceReader* source,
                          CapabilityList* capabilities) {
   DWORD stream_index = 0;
   ScopedComPtr<IMFMediaType> type;
   HRESULT hr;
@@ skipping 187 matching lines @@
   DCHECK(attributes);
 
   callback_ = new MFReaderCallback(this);
   attributes->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, callback_.get());
 
   return SUCCEEDED(MFCreateSourceReaderFromMediaSource(source, attributes,
                                                        reader_.Receive()));
 }
 
 void VideoCaptureDeviceMFWin::AllocateAndStart(
-    const VideoCaptureCapability& capture_format,
+    const VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(CalledOnValidThread());
 
   base::AutoLock lock(lock_);
 
   client_ = client.Pass();
   DCHECK_EQ(capture_, false);
 
   CapabilityList capabilities;
   HRESULT hr = S_OK;
   if (!reader_ || FAILED(hr = FillCapabilities(reader_, &capabilities))) {
     OnError(hr);
     return;
   }
 
   VideoCaptureCapabilityWin found_capability =
-      capabilities.GetBestMatchedCapability(capture_format.width,
-                                            capture_format.height,
-                                            capture_format.frame_rate);
-  DLOG(INFO) << "Chosen capture format= (" << found_capability.width << "x"
-             << found_capability.height << ")@("
-             << found_capability.frame_rate_numerator << "/"
-             << found_capability.frame_rate_denominator << ")fps";
+      capabilities.GetBestMatchedFormat(
+          params.requested_format.frame_size.width(),
+          params.requested_format.frame_size.height(),
+          params.requested_format.frame_rate);
 
   ScopedComPtr<IMFMediaType> type;
   if (FAILED(hr = reader_->GetNativeMediaType(
           MF_SOURCE_READER_FIRST_VIDEO_STREAM, found_capability.stream_index,
           type.Receive())) ||
       FAILED(hr = reader_->SetCurrentMediaType(
           MF_SOURCE_READER_FIRST_VIDEO_STREAM, NULL, type))) {
     OnError(hr);
     return;
   }
 
   if (FAILED(hr = reader_->ReadSample(MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0,
                                       NULL, NULL, NULL, NULL))) {
     OnError(hr);
     return;
   }
-  current_setting_ = found_capability;
+  capture_format_ = found_capability.supported_format;
   capture_ = true;
 }
 
 void VideoCaptureDeviceMFWin::StopAndDeAllocate() {
   DCHECK(CalledOnValidThread());
   base::WaitableEvent flushed(false, false);
   const int kFlushTimeOutInMs = 1000;
   bool wait = false;
   {
     base::AutoLock lock(lock_);
@@ skipping 26 matching lines @@
     bool flip_vert,
     bool flip_horiz) {
   base::AutoLock lock(lock_);
   if (data && client_.get())
     client_->OnIncomingCapturedFrame(data,
                                      length,
                                      time_stamp,
                                      rotation,
                                      flip_vert,
                                      flip_horiz,
-                                     current_setting_);
+                                     capture_format_);
 
   if (capture_) {
     HRESULT hr = reader_->ReadSample(MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0,
                                      NULL, NULL, NULL, NULL);
     if (FAILED(hr)) {
       // If running the *VideoCap* unit tests on repeat, this can sometimes
       // fail with HRESULT_FROM_WINHRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION).
       // It's not clear to me why this is, but it is possible that it has
       // something to do with this bug:
       // http://support.microsoft.com/kb/979567
       OnError(hr);
     }
   }
 }
 
 void VideoCaptureDeviceMFWin::OnError(HRESULT hr) {
   DLOG(ERROR) << "VideoCaptureDeviceMFWin: " << std::hex << hr;
   if (client_.get())
     client_->OnError();
 }
 
 }  // namespace media