Add optional max supported resolution on MediaFoundationVideoEncodeAccelerator

media/gpu/media_foundation_video_encode_accelerator_win.cc

 // Copyright 2016 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/gpu/media_foundation_video_encode_accelerator_win.h"
 
 #pragma warning(push)
 #pragma warning(disable : 4800)  // Disable warning for added padding.
 
 #include <codecapi.h>
@@ skipping 16 matching lines @@
 using base::win::ScopedComPtr;
 using media::mf::MediaBufferScopedPointer;
 
 namespace media {
 
 namespace {
 
 const int32_t kDefaultTargetBitrate = 5000000;
 const size_t kMaxFrameRateNumerator = 30;
 const size_t kMaxFrameRateDenominator = 1;
-const size_t kMaxResolutionWidth = 3840;
-const size_t kMaxResolutionHeight = 2176;
+const size_t kMaxResolutionWidth = 1920;
+const size_t kMaxResolutionHeight = 1088;
 const size_t kNumInputBuffers = 3;
 // Media Foundation uses 100 nanosecond units for time, see
 // https://msdn.microsoft.com/en-us/library/windows/desktop/ms697282(v=vs.85).aspx
 const size_t kOneMicrosecondInMFSampleTimeUnits = 10;
 const size_t kOutputSampleBufferSizeRatio = 4;
 
 constexpr const wchar_t* const kMediaFoundationVideoEncoderDLLs[] = {
     L"mf.dll", L"mfplat.dll",
 };
 
+// Resolutions that some platforms support, should be listed in ascending order.
+constexpr const gfx::Size kOptionalMaxResolutions[] = {gfx::Size(3840, 2176)};
+
 }  // namespace
 
 class MediaFoundationVideoEncodeAccelerator::EncodeOutput {
  public:
   EncodeOutput(uint32_t size, bool key_frame, base::TimeDelta timestamp)
       : keyframe(key_frame), capture_timestamp(timestamp), data_(size) {}
 
   uint8_t* memory() { return data_.data(); }
 
   int size() const { return static_cast<int>(data_.size()); }
@@ skipping 35 matching lines @@
 }
 
 VideoEncodeAccelerator::SupportedProfiles
 MediaFoundationVideoEncodeAccelerator::GetSupportedProfiles() {
   TRACE_EVENT0("gpu,startup",
                "MediaFoundationVideoEncodeAccelerator::GetSupportedProfiles");
   DVLOG(3) << __func__;
   DCHECK(main_client_task_runner_->BelongsToCurrentThread());
 
   SupportedProfiles profiles;
-
   target_bitrate_ = kDefaultTargetBitrate;
   frame_rate_ = kMaxFrameRateNumerator / kMaxFrameRateDenominator;
   input_visible_size_ = gfx::Size(kMaxResolutionWidth, kMaxResolutionHeight);
   if (!CreateHardwareEncoderMFT() || !SetEncoderModes() ||
       !InitializeInputOutputSamples()) {
     ReleaseEncoderResources();
     DVLOG(1)
         << "Hardware encode acceleration is not available on this platform.";
     return profiles;
   }
+
+  gfx::Size highest_supported_resolution = input_visible_size_;
+  for (const auto& resolution : kOptionalMaxResolutions) {
+    DCHECK_GT(resolution.GetArea(), highest_supported_resolution.GetArea());
+    if (!IsResolutionSupported(resolution))
+      break;
+    highest_supported_resolution = resolution;
+  }
   ReleaseEncoderResources();
 
   SupportedProfile profile;
   // More profiles can be supported here, but they should be available in SW
   // fallback as well.
   profile.profile = H264PROFILE_BASELINE;
   profile.max_framerate_numerator = kMaxFrameRateNumerator;
   profile.max_framerate_denominator = kMaxFrameRateDenominator;
-  profile.max_resolution = gfx::Size(kMaxResolutionWidth, kMaxResolutionHeight);
+  profile.max_resolution = highest_supported_resolution;
   profiles.push_back(profile);
   return profiles;
 }
 
 bool MediaFoundationVideoEncodeAccelerator::Initialize(
     VideoPixelFormat format,
     const gfx::Size& input_visible_size,
     VideoCodecProfile output_profile,
     uint32_t initial_bitrate,
     Client* client) {
@@ skipping 308 matching lines @@
   var.ulVal = eAVEncAdaptiveMode_Resolution;
   hr = codec_api_->SetValue(&CODECAPI_AVEncAdaptiveMode, &var);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set FrameRate", false);
   var.vt = VT_BOOL;
   var.boolVal = VARIANT_TRUE;
   hr = codec_api_->SetValue(&CODECAPI_AVLowLatencyMode, &var);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set LowLatencyMode", false);
   return SUCCEEDED(hr);
 }
 
+bool MediaFoundationVideoEncodeAccelerator::IsResolutionSupported(
+    const gfx::Size& resolution) {
+  DCHECK(main_client_task_runner_->BelongsToCurrentThread());
+  DCHECK(encoder_);
+
+  HRESULT hr =
+      MFSetAttributeSize(imf_output_media_type_.get(), MF_MT_FRAME_SIZE,
+                         resolution.width(), resolution.height());
+  RETURN_ON_HR_FAILURE(hr, "Couldn't set frame size", false);
+  hr = encoder_->SetOutputType(output_stream_id_, imf_output_media_type_.get(),
+                               0);
+  RETURN_ON_HR_FAILURE(hr, "Couldn't set output media type", false);
+
+  hr = MFSetAttributeSize(imf_input_media_type_.get(), MF_MT_FRAME_SIZE,
+                          resolution.width(), resolution.height());
+  RETURN_ON_HR_FAILURE(hr, "Couldn't set frame size", false);
+  hr = encoder_->SetInputType(input_stream_id_, imf_input_media_type_.get(), 0);
+  RETURN_ON_HR_FAILURE(hr, "Couldn't set input media type", false);
+
+  return true;
+}
+
 void MediaFoundationVideoEncodeAccelerator::NotifyError(
     VideoEncodeAccelerator::Error error) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
   main_client_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Client::NotifyError, main_client_, error));
 }
 
 void MediaFoundationVideoEncodeAccelerator::EncodeTask(
     scoped_refptr<VideoFrame> frame,
     bool force_keyframe) {
@@ skipping 197 matching lines @@
 void MediaFoundationVideoEncodeAccelerator::ReleaseEncoderResources() {
   encoder_.Release();
   codec_api_.Release();
   imf_input_media_type_.Release();
   imf_output_media_type_.Release();
   input_sample_.Release();
   output_sample_.Release();
 }
 
 }  // namespace content