Add accelerated video decoder interface, VP8 and H.264 implementations and hook up to V4L2SVDA.

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 <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/numerics/safe_conversions.h"
 #include "content/common/gpu/media/v4l2_video_decode_accelerator.h"
 #include "media/base/media_switches.h"
 #include "media/filters/h264_parser.h"
 #include "ui/gl/scoped_binders.h"
 
-#define NOTIFY_ERROR(x)                            \
-  do {                                             \
-    SetDecoderState(kError);                       \
-    LOG(ERROR) << "calling NotifyError(): " << x;  \
-    NotifyError(x);                                \
+#define NOTIFY_ERROR(x)                        \
+  do {                                         \
+    LOG(ERROR) << "Setting error state:" << x; \
+    SetErrorState(x);                          \
   } while (0)
 
 #define IOCTL_OR_ERROR_RETURN_VALUE(type, arg, value)              \
   do {                                                             \
     if (device_->Ioctl(type, arg) != 0) {                          \
       PLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type;  \
       NOTIFY_ERROR(PLATFORM_FAILURE);                              \
       return value;                                                \
     }                                                              \
   } while (0)
@@ skipping 111 matching lines @@
     const media::Picture& picture)
     : cleared(cleared), picture(picture) {}
 
 V4L2VideoDecodeAccelerator::PictureRecord::~PictureRecord() {}
 
 V4L2VideoDecodeAccelerator::V4L2VideoDecodeAccelerator(
     EGLDisplay egl_display,
     EGLContext egl_context,
     const base::WeakPtr<Client>& io_client,
     const base::Callback<bool(void)>& make_context_current,
-    scoped_ptr<V4L2Device> device,
+    scoped_refptr<V4L2Device> device,

[scherkus (not reviewing), 2015/01/13 01:25:00]

const ref

[Pawel Osciak, 2015/01/13 11:33:35]

Done.

     const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy)
     : child_message_loop_proxy_(base::MessageLoopProxy::current()),
       io_message_loop_proxy_(io_message_loop_proxy),
       io_client_(io_client),
       decoder_thread_("V4L2DecoderThread"),
       decoder_state_(kUninitialized),
-      device_(device.Pass()),
+      device_(device),
       decoder_delay_bitstream_buffer_id_(-1),
       decoder_current_input_buffer_(-1),
       decoder_decode_buffer_tasks_scheduled_(0),
       decoder_frames_at_client_(0),
       decoder_flushing_(false),
       resolution_change_pending_(false),
       resolution_change_reset_pending_(false),
       decoder_partial_frame_pending_(false),
       input_streamon_(false),
       input_buffer_queued_count_(0),
@@ skipping 52 matching lines @@
       DVLOG(2) << "Initialize(): profile VP9PROFILE_ANY";
       break;
     default:
       DLOG(ERROR) << "Initialize(): unsupported profile=" << profile;
       return false;
   };
   video_profile_ = profile;
 
   if (egl_display_ == EGL_NO_DISPLAY) {
     LOG(ERROR) << "Initialize(): could not get EGLDisplay";
-    NOTIFY_ERROR(PLATFORM_FAILURE);
     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";
-    NOTIFY_ERROR(PLATFORM_FAILURE);
     return false;
   }
 
   if (!gfx::g_driver_egl.ext.b_EGL_KHR_fence_sync) {
     LOG(ERROR) << "Initialize(): context does not have EGL_KHR_fence_sync";
-    NOTIFY_ERROR(PLATFORM_FAILURE);
     return false;
   }
 
   // Capabilities check.
   struct v4l2_capability caps;
   const __u32 kCapsRequired =
       V4L2_CAP_VIDEO_CAPTURE_MPLANE |
       V4L2_CAP_VIDEO_OUTPUT_MPLANE |
       V4L2_CAP_STREAMING;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps);
   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
     LOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP"
         ", caps check failed: 0x" << std::hex << caps.capabilities;
-    NOTIFY_ERROR(PLATFORM_FAILURE);
     return false;
   }
 
   if (!SetupFormats())
     return false;
 
   // Subscribe to the resolution change event.
   struct v4l2_event_subscription sub;
   memset(&sub, 0, sizeof(sub));
   sub.type = V4L2_EVENT_RESOLUTION_CHANGE;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_SUBSCRIBE_EVENT, &sub);
 
   if (video_profile_ >= media::H264PROFILE_MIN &&
       video_profile_ <= media::H264PROFILE_MAX) {
     decoder_h264_parser_.reset(new media::H264Parser());
   }
 
   if (!CreateInputBuffers())
     return false;
 
   if (!decoder_thread_.Start()) {
     LOG(ERROR) << "Initialize(): decoder thread failed to start";
-    NOTIFY_ERROR(PLATFORM_FAILURE);
     return false;
   }
 
+  decoder_state_ = kInitialized;
+
   // StartDevicePoll will NOTIFY_ERROR on failure, so IgnoreResult is fine here.
   decoder_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(
           base::IgnoreResult(&V4L2VideoDecodeAccelerator::StartDevicePoll),
           base::Unretained(this)));
 
-  SetDecoderState(kInitialized);
   return true;
 }
 
 void V4L2VideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DVLOG(1) << "Decode(): input_id=" << bitstream_buffer.id()
            << ", size=" << bitstream_buffer.size();
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   // DecodeTask() will take care of running a DecodeBufferTask().
@@ skipping 116 matching lines @@
     decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
         &V4L2VideoDecodeAccelerator::DestroyTask, base::Unretained(this)));
     pictures_assigned_.Signal();
     // DestroyTask() will cause the decoder_thread_ to flush all tasks.
     decoder_thread_.Stop();
   } else {
     // Otherwise, call the destroy task directly.
     DestroyTask();
   }
 
-  // Set to kError state just in case.
-  SetDecoderState(kError);
-
   delete this;
 }
 
 bool V4L2VideoDecodeAccelerator::CanDecodeOnIOThread() { return true; }
 
 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);
@@ skipping 1138 matching lines @@
         &V4L2VideoDecodeAccelerator::NotifyError, weak_this_, error));
     return;
   }
 
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
-void V4L2VideoDecodeAccelerator::SetDecoderState(State state) {
-  DVLOG(3) << "SetDecoderState(): state=" << state;
-
+void V4L2VideoDecodeAccelerator::SetErrorState(Error error) {
   // We can touch decoder_state_ only if this is the decoder thread or the
   // decoder thread isn't running.
   if (decoder_thread_.message_loop() != NULL &&
       decoder_thread_.message_loop() != base::MessageLoop::current()) {
     decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
-        &V4L2VideoDecodeAccelerator::SetDecoderState,
-        base::Unretained(this), state));
-  } else {
-    decoder_state_ = state;
+        &V4L2VideoDecodeAccelerator::SetErrorState,
+        base::Unretained(this), error));
+    return;
   }
+
+  // Post NotifyError only if we are already initialized, as the API does
+  // not allow doing so before that.
+  if (decoder_state_ != kError && decoder_state_ != kUninitialized)
+    NotifyError(error);
+
+  decoder_state_ = kError;
 }
 
 bool V4L2VideoDecodeAccelerator::GetFormatInfo(struct v4l2_format* format,
                                                  bool* again) {
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
 
   *again = false;
   memset(format, 0, sizeof(*format));
   format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   if (device_->Ioctl(VIDIOC_G_FMT, format) != 0) {
@@ skipping 76 matching lines @@
   return true;
 }
 
 bool V4L2VideoDecodeAccelerator::SetupFormats() {
   // We always run this as we prepare to initialize.
   DCHECK_EQ(decoder_state_, kUninitialized);
   DCHECK(!input_streamon_);
   DCHECK(!output_streamon_);
 
   __u32 input_format_fourcc =
-      V4L2Device::VideoCodecProfileToV4L2PixFmt(video_profile_);
+      V4L2Device::VideoCodecProfileToV4L2PixFmt(video_profile_, false);
   if (!input_format_fourcc) {
     NOTREACHED();
     return false;
   }
 
   size_t input_size;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kIgnoreResolutionLimitsForAcceleratedVideoDecode))
     input_size = kInputBufferMaxSizeFor4k;
   else
@@ skipping 252 matching lines @@
   gfx::Size new_size(base::checked_cast<int>(format.fmt.pix_mp.width),
                      base::checked_cast<int>(format.fmt.pix_mp.height));
   if (frame_buffer_size_ != new_size) {
     DVLOG(3) << "IsResolutionChangeNecessary(): Resolution change detected";
     return true;
   }
   return false;
 }
 
 }  // namespace content