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

content/common/gpu/media/v4l2_slice_video_decode_accelerator.cc

 // Copyright 2015 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 <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
 #include <sys/eventfd.h>
@@ skipping 37 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) << __FUNCTION__ << "(): ioctl() failed: " << #type; \
   } while (0)
 
 namespace content {
 
+// static
+const uint32_t V4L2SliceVideoDecodeAccelerator::supported_input_fourccs_[] = {
+    V4L2_PIX_FMT_H264_SLICE, V4L2_PIX_FMT_VP8_FRAME,
+};
+
 class V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface
     : public base::RefCounted<V4L2DecodeSurface> {
  public:
   using ReleaseCB = base::Callback<void(int)>;
 
   V4L2DecodeSurface(int32_t bitstream_id,
                     int input_record,
                     int output_record,
                     const ReleaseCB& release_cb);
 
@@ skipping 361 matching lines @@
 
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
 bool V4L2SliceVideoDecodeAccelerator::Initialize(const Config& config,
                                                  Client* client) {
   DVLOGF(3) << "profile: " << config.profile;
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
+  DCHECK_EQ(state_, kUninitialized);
+
   if (config.is_encrypted) {
     NOTREACHED() << "Encrypted streams are not supported for this VDA";
     return false;
   }
 
-  DCHECK(child_task_runner_->BelongsToCurrentThread());
-  DCHECK_EQ(state_, kUninitialized);
+  if (!device_->SupportsDecodeProfileForV4L2PixelFormats(
+          config.profile, arraysize(supported_input_fourccs_),
+          supported_input_fourccs_)) {
+    DVLOGF(1) << "unsupported profile " << config.profile;
+    return false;
+  }
 
   client_ptr_factory_.reset(
       new base::WeakPtrFactory<VideoDecodeAccelerator::Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
 
   video_profile_ = config.profile;
 
   if (video_profile_ >= media::H264PROFILE_MIN &&
       video_profile_ <= media::H264PROFILE_MAX) {
     h264_accelerator_.reset(new V4L2H264Accelerator(this));
     decoder_.reset(new H264Decoder(h264_accelerator_.get()));
   } else if (video_profile_ >= media::VP8PROFILE_MIN &&
              video_profile_ <= media::VP8PROFILE_MAX) {
     vp8_accelerator_.reset(new V4L2VP8Accelerator(this));
     decoder_.reset(new VP8Decoder(vp8_accelerator_.get()));
   } else {
-    DLOG(ERROR) << "Unsupported profile " << video_profile_;
+    NOTREACHED() << "Unsupported profile " << video_profile_;
     return false;
   }
 
   // TODO(posciak): This needs to be queried once supported.
   input_planes_count_ = 1;
   output_planes_count_ = 1;
 
   if (egl_display_ == EGL_NO_DISPLAY) {
     LOG(ERROR) << "Initialize(): could not get EGLDisplay";
     return false;
@@ skipping 2063 matching lines @@
   return true;
 }
 
 // static
 media::VideoDecodeAccelerator::SupportedProfiles
 V4L2SliceVideoDecodeAccelerator::GetSupportedProfiles() {
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (!device)
     return SupportedProfiles();
 
-  const uint32_t supported_formats[] = {
-      V4L2_PIX_FMT_H264_SLICE, V4L2_PIX_FMT_VP8_FRAME};
-  return device->GetSupportedDecodeProfiles(arraysize(supported_formats),
-                                            supported_formats);
+  return device->GetSupportedDecodeProfiles(arraysize(supported_input_fourccs_),
+                                            supported_input_fourccs_);
 }
 
 }  // namespace content