Use BITMAPINFOHEADER from capture capability enumeration when using MJPG

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 <ks.h>
 #include <ksmedia.h>
 
 #include <algorithm>
@@ skipping 160 matching lines @@
   DVLOG(2) << "Device (also) supports an unknown media type " << guid_str;
 #endif
   return PIXEL_FORMAT_UNKNOWN;
 }
 
 void VideoCaptureDeviceWin::ScopedMediaType::Free() {
   if (!media_type_)
     return;
 
   DeleteMediaType(media_type_);
-  media_type_= NULL;
+  media_type_ = NULL;
 }
 
 AM_MEDIA_TYPE** VideoCaptureDeviceWin::ScopedMediaType::Receive() {
   DCHECK(!media_type_);
   return &media_type_;
 }
 
 // Release the format block for a media type.
 // http://msdn.microsoft.com/en-us/library/dd375432(VS.85).aspx
 void VideoCaptureDeviceWin::ScopedMediaType::FreeMediaType(AM_MEDIA_TYPE* mt) {
@@ skipping 120 matching lines @@
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(CalledOnValidThread());
   if (state_ != kIdle)
     return;
 
   client_ = client.Pass();
 
   // Get the camera capability that best match the requested format.
   const CapabilityWin found_capability =
       GetBestMatchedCapability(params.requested_format, capabilities_);
-  VideoCaptureFormat format = found_capability.supported_format;
 
   // Reduce the frame rate if the requested frame rate is lower
   // than the capability.
-  format.frame_rate =
-      std::min(format.frame_rate, params.requested_format.frame_rate);
+  float frame_rate = std::min(found_capability.supported_format.frame_rate,
+                              params.requested_format.frame_rate);
 
   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;
   }
 
   int count = 0, size = 0;
   hr = stream_config->GetNumberOfCapabilities(&count, &size);
@@ skipping 10 matching lines @@
   // FAILED macro can't be used.
   hr = stream_config->GetStreamCaps(
       found_capability.stream_index, media_type.Receive(), caps.get());
   if (hr != S_OK) {
     SetErrorState("Failed to get capture device capabilities");
     return;
   }
   if (media_type->formattype == FORMAT_VideoInfo) {
     VIDEOINFOHEADER* h =
         reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
-    if (format.frame_rate > 0)
-      h->AvgTimePerFrame = kSecondsToReferenceTime / format.frame_rate;
+    if (frame_rate > 0)
+      h->AvgTimePerFrame = kSecondsToReferenceTime / frame_rate;
   }
   // Set the sink filter to request this format.
-  sink_filter_->SetRequestedMediaFormat(format);
+  sink_filter_->SetRequestedMediaFormat(
+    found_capability.supported_format.pixel_format, frame_rate,
+    found_capability.info_header);
   // Order the capture device to use this format.
   hr = stream_config->SetFormat(media_type.get());
   if (FAILED(hr)) {
     // TODO(grunell): Log the error. http://crbug.com/405016.
     SetErrorState("Failed to set capture device output format");
     return;
   }
 
   SetAntiFlickerInCaptureFilter();
 
@@ skipping 135 matching lines @@
           time_per_frame = *std::min_element(max_fps.get(),
                                              max_fps.get() + list_size);
         }
       }
 
       format.frame_rate =
           (time_per_frame > 0)
               ? (kSecondsToReferenceTime / static_cast<float>(time_per_frame))
               : 0.0;
 
-      capabilities_.emplace_back(stream_index, format);
+      capabilities_.emplace_back(stream_index, format, h->bmiHeader);
     }
   }
 
   return !capabilities_.empty();
 }
 
 // Set the power line frequency removal in |capture_filter_| if available.
 void VideoCaptureDeviceWin::SetAntiFlickerInCaptureFilter() {
   const int power_line_frequency = GetPowerLineFrequencyForLocation();
   if (power_line_frequency != kPowerLine50Hz &&
@@ skipping 82 matching lines @@
     return E_FAIL;
   return S_OK;
 }
 
 void VideoCaptureDeviceWin::SetErrorState(const std::string& reason) {
   DCHECK(CalledOnValidThread());
   state_ = kError;
   client_->OnError(reason);
 }
 }  // namespace media