RtcVideoDecoder: fall back to SW decode for unsupported profiles/resolutions

content/renderer/media/rtc_video_decoder.cc

 // Copyright 2013 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 "content/renderer/media/rtc_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 197 matching lines @@
   // change gracefully need to have their clients cover for them, and we do that
   // here.
 #ifdef ANDROID
   const bool kVDACanHandleMidstreamResize = false;
 #else
   const bool kVDACanHandleMidstreamResize = true;
 #endif
 
   bool need_to_reset_for_midstream_resize = false;
   if (inputImage._frameType == webrtc::kKeyFrame) {
-    DVLOG(2) << "Got key frame. size=" << inputImage._encodedWidth << "x"
-             << inputImage._encodedHeight;
+    gfx::Size new_frame_size(inputImage._encodedWidth,
+                             inputImage._encodedHeight);
+    DVLOG(2) << "Got key frame. size=" << new_frame_size.ToString();
+
+    if (new_frame_size.width() > max_resolution_.width() ||
+        new_frame_size.width() < min_resolution_.width() ||
+        new_frame_size.height() > max_resolution_.height() ||
+        new_frame_size.height() < min_resolution_.height()) {
+      DVLOG(1) << "Resolution unsupported, falling back to software decode";
+      return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
+    }
+
     gfx::Size prev_frame_size = frame_size_;
-    frame_size_.SetSize(inputImage._encodedWidth, inputImage._encodedHeight);
+    frame_size_ = new_frame_size;
     if (!kVDACanHandleMidstreamResize && !prev_frame_size.IsEmpty() &&
         prev_frame_size != frame_size_) {
       need_to_reset_for_midstream_resize = true;
     }
   } else if (IsFirstBufferAfterReset(next_bitstream_buffer_id_,
                                      reset_bitstream_buffer_id_)) {
     // TODO(wuchengli): VDA should handle it. Remove this when
     // http://crosbug.com/p/21913 is fixed.
     DVLOG(1) << "The first frame should be a key frame. Drop this.";
     return WEBRTC_VIDEO_CODEC_ERROR;
@@ skipping 416 matching lines @@
     // This picture was dismissed while in display, so we postponed deletion.
     factories_->DeleteTexture(texture_id);
     return;
   }
 
   // DestroyVDA() might already have been called.
   if (vda_)
     vda_->ReusePictureBuffer(picture_buffer_id);
 }
 
+bool RTCVideoDecoder::IsProfileSupported(media::VideoCodecProfile profile) {
+  DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
+  media::VideoDecodeAccelerator::SupportedProfiles supported_profiles =
+      factories_->GetVideoDecodeAcceleratorSupportedProfiles();
+
+  for (const auto& supported_profile : supported_profiles) {
+    if (profile == supported_profile.profile) {
+      min_resolution_ = supported_profile.min_resolution;
+      max_resolution_ = supported_profile.max_resolution;
+      return true;
+    }
+  }
+
+  return false;
+}
+
 void RTCVideoDecoder::CreateVDA(media::VideoCodecProfile profile,
                                 base::WaitableEvent* waiter) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
-  vda_ = factories_->CreateVideoDecodeAccelerator();
-  if (vda_ && !vda_->Initialize(profile, this))
-    vda_.release()->Destroy();
+
+  if (!IsProfileSupported(profile)) {
+    DVLOG(1) << "Unsupported profile " << profile;
+  } else {
+    vda_ = factories_->CreateVideoDecodeAccelerator();
+    if (vda_ && !vda_->Initialize(profile, this))
+      vda_.release()->Destroy();
+  }
+
   waiter->Signal();
 }
 
 void RTCVideoDecoder::DestroyTextures() {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   // Not destroying PictureBuffers in |picture_buffers_at_display_| yet, since
   // their textures may still be in use by the user of this RTCVideoDecoder.
   for (PictureBufferTextureMap::iterator it =
            picture_buffers_at_display_.begin();
@@ skipping 104 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoDecoderInitDecodeSuccess", sample);
   return status;
 }
 
 void RTCVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace content