Win video capture: Fix capture format and frame buffer mismatch

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>
@@ skipping 394 matching lines @@
     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", 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.", hr);
     return;
   }
 
   state_ = kCapturing;
 }
 
@@ skipping 20 matching lines @@
   // DirectShow has other means of capturing still pictures, e.g. connecting a
   // SampleGrabber filter to a PIN_CATEGORY_STILL of |capture_filter_|. This
   // way, however, is not widespread and proves too cumbersome, so we just grab
   // the next captured frame instead.
   take_photo_callbacks_.push(std::move(callback));
 }
 
 // Implements SinkFilterObserver::SinkFilterObserver.
 void VideoCaptureDeviceWin::FrameReceived(const uint8_t* buffer,
                                           int length,
+                                          const VideoCaptureFormat& format,
                                           base::TimeDelta timestamp) {
   if (first_ref_time_.is_null())
     first_ref_time_ = base::TimeTicks::Now();
 
   // There is a chance that the platform does not provide us with the timestamp,
   // in which case, we use reference time to calculate a timestamp.
   if (timestamp == media::kNoTimestamp)
     timestamp = base::TimeTicks::Now() - first_ref_time_;
 
-  client_->OnIncomingCapturedData(buffer, length, capture_format_, 0,
+  client_->OnIncomingCapturedData(buffer, length, format, 0,
                                   base::TimeTicks::Now(), timestamp);
 
   while (!take_photo_callbacks_.empty()) {
     TakePhotoCallback cb = std::move(take_photo_callbacks_.front());
     take_photo_callbacks_.pop();
 
-    mojom::BlobPtr blob = Blobify(buffer, length, capture_format_);
+    mojom::BlobPtr blob = Blobify(buffer, length, 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());
   DLOG_IF_FAILED_WITH_HRESULT(
@@ skipping 103 matching lines @@
 void VideoCaptureDeviceWin::SetErrorState(
     const tracked_objects::Location& from_here,
     const std::string& reason,
     HRESULT hr) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DLOG_IF_FAILED_WITH_HRESULT(reason, hr);
   state_ = kError;
   client_->OnError(from_here, reason);
 }
 }  // namespace media