V4L2(S)VDA: Check if device handles profile for supported fourccs on init.

content/common/gpu/media/v4l2_video_decode_accelerator.cc

 // Copyright 2014 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 <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
@@ skipping 38 matching lines @@
   IOCTL_OR_ERROR_RETURN_VALUE(type, arg, false, #type)
 
 #define IOCTL_OR_LOG_ERROR(type, arg)                              \
   do {                                                             \
     if (device_->Ioctl(type, arg) != 0)                            \
       PLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type;  \
   } while (0)
 
 namespace content {
 
+// static
+const uint32_t V4L2VideoDecodeAccelerator::supported_input_fourccs_[] = {
+    V4L2_PIX_FMT_H264, V4L2_PIX_FMT_VP8, V4L2_PIX_FMT_VP9,
+};
+
 struct V4L2VideoDecodeAccelerator::BitstreamBufferRef {
   BitstreamBufferRef(
       base::WeakPtr<Client>& client,
       scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner,
       base::SharedMemory* shm,
       size_t size,
       int32_t input_id);
   ~BitstreamBufferRef();
   const base::WeakPtr<Client> client;
   const scoped_refptr<base::SingleThreadTaskRunner> client_task_runner;
@@ skipping 128 matching lines @@
 
   // These maps have members that should be manually destroyed, e.g. file
   // descriptors, mmap() segments, etc.
   DCHECK(input_buffer_map_.empty());
   DCHECK(output_buffer_map_.empty());
 }
 
 bool V4L2VideoDecodeAccelerator::Initialize(const Config& config,
                                             Client* client) {
   DVLOG(3) << "Initialize()";
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
+  DCHECK_EQ(decoder_state_, kUninitialized);
+
   if (config.is_encrypted) {
     NOTREACHED() << "Encrypted streams are not supported for this VDA";
     return false;
   }
 
-  DCHECK(child_task_runner_->BelongsToCurrentThread());
-  DCHECK_EQ(decoder_state_, kUninitialized);
+  if (!device_->SupportsDecodeProfileForV4L2PixelFormats(
+          config.profile, arraysize(supported_input_fourccs_),
+          supported_input_fourccs_)) {
+    DVLOG(1) << "Initialize(): unsupported profile=" << config.profile;
+    return false;
+  }
 
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
 
-  switch (config.profile) {
-    case media::H264PROFILE_BASELINE:
-      DVLOG(2) << "Initialize(): profile H264PROFILE_BASELINE";
-      break;
-    case media::H264PROFILE_MAIN:
-      DVLOG(2) << "Initialize(): profile H264PROFILE_MAIN";
-      break;
-    case media::H264PROFILE_HIGH:
-      DVLOG(2) << "Initialize(): profile H264PROFILE_HIGH";
-      break;
-    case media::VP8PROFILE_ANY:
-      DVLOG(2) << "Initialize(): profile VP8PROFILE_ANY";
-      break;
-    case media::VP9PROFILE_ANY:
-      DVLOG(2) << "Initialize(): profile VP9PROFILE_ANY";
-      break;
-    default:
-      DLOG(ERROR) << "Initialize(): unsupported profile=" << config.profile;
-      return false;
-  };
   video_profile_ = config.profile;
 
   if (egl_display_ == EGL_NO_DISPLAY) {
     LOG(ERROR) << "Initialize(): could not get EGLDisplay";
     return false;
   }
 
   // We need the context to be initialized to query extensions.
   if (!make_context_current_.Run()) {
     LOG(ERROR) << "Initialize(): could not make context current";
@@ skipping 220 matching lines @@
 
 bool V4L2VideoDecodeAccelerator::CanDecodeOnIOThread() { return true; }
 
 // static
 media::VideoDecodeAccelerator::SupportedProfiles
 V4L2VideoDecodeAccelerator::GetSupportedProfiles() {
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (!device)
     return SupportedProfiles();
 
-  const uint32_t supported_formats[] = {
-      V4L2_PIX_FMT_H264, V4L2_PIX_FMT_VP8, V4L2_PIX_FMT_VP9};
-  return device->GetSupportedDecodeProfiles(arraysize(supported_formats),
-                                            supported_formats);
+  return device->GetSupportedDecodeProfiles(arraysize(supported_input_fourccs_),
+                                            supported_input_fourccs_);
 }
 
 void V4L2VideoDecodeAccelerator::DecodeTask(
     const media::BitstreamBuffer& bitstream_buffer) {
   DVLOG(3) << "DecodeTask(): input_id=" << bitstream_buffer.id();
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_NE(decoder_state_, kUninitialized);
   TRACE_EVENT1("Video Decoder", "V4L2VDA::DecodeTask", "input_id",
                bitstream_buffer.id());
 
@@ skipping 1557 matching lines @@
 
 void V4L2VideoDecodeAccelerator::PictureCleared() {
   DVLOG(3) << "PictureCleared(). clearing count=" << picture_clearing_count_;
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_GT(picture_clearing_count_, 0);
   picture_clearing_count_--;
   SendPictureReady();
 }
 
 }  // namespace content