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

content/common/gpu/media/v4l2_video_encode_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 <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/numerics/safe_conversions.h"
 #include "content/common/gpu/media/v4l2_video_encode_accelerator.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/bitstream_buffer.h"
 
-#define NOTIFY_ERROR(x)                            \
-  do {                                             \
-    SetEncoderState(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(kPlatformFailureError);                         \
       return value;                                                \
     }                                                              \
   } while (0)
@@ skipping 27 matching lines @@
 }
 
 V4L2VideoEncodeAccelerator::OutputRecord::OutputRecord()
     : at_device(false), address(NULL), length(0) {
 }
 
 V4L2VideoEncodeAccelerator::OutputRecord::~OutputRecord() {
 }
 
 V4L2VideoEncodeAccelerator::V4L2VideoEncodeAccelerator(
-    scoped_ptr<V4L2Device> device)
+    scoped_refptr<V4L2Device> device)
     : child_message_loop_proxy_(base::MessageLoopProxy::current()),
       output_buffer_byte_size_(0),
       device_input_format_(media::VideoFrame::UNKNOWN),
       input_planes_count_(0),
       output_format_fourcc_(0),
       encoder_state_(kUninitialized),
       stream_header_size_(0),
-      device_(device.Pass()),
+      device_(device),
       input_streamon_(false),
       input_buffer_queued_count_(0),
       input_memory_type_(V4L2_MEMORY_USERPTR),
       output_streamon_(false),
       output_buffer_queued_count_(0),
       encoder_thread_("V4L2EncoderThread"),
       device_poll_thread_("V4L2EncoderDevicePollThread"),
       weak_this_ptr_factory_(this) {
   weak_this_ = weak_this_ptr_factory_.GetWeakPtr();
 }
@@ skipping 40 matching lines @@
 
   if (!SetFormats(input_format, output_profile)) {
     LOG(ERROR) << "Failed setting up formats";
     return false;
   }
 
   if (input_format != device_input_format_) {
     DVLOG(1) << "Input format not supported by the HW, will convert to "
              << media::VideoFrame::FormatToString(device_input_format_);
 
-    scoped_ptr<V4L2Device> device =
+    scoped_refptr<V4L2Device> device =
         V4L2Device::Create(V4L2Device::kImageProcessor);
-    image_processor_.reset(new V4L2ImageProcessor(device.Pass()));
+    image_processor_.reset(new V4L2ImageProcessor(device));
 
     // Convert from input_format to device_input_format_, keeping the size
     // at visible_size_ and requiring the output buffers to be of at least
     // input_allocated_size_.
     if (!image_processor_->Initialize(
             input_format,
             device_input_format_,
             visible_size_,
             visible_size_,
             input_allocated_size_,
@@ skipping 10 matching lines @@
   if (!CreateOutputBuffers())
     return false;
 
   if (!encoder_thread_.Start()) {
     LOG(ERROR) << "Initialize(): encoder thread failed to start";
     return false;
   }
 
   RequestEncodingParametersChange(initial_bitrate, kInitialFramerate);
 
-  SetEncoderState(kInitialized);
+  encoder_state_ = kInitialized;
 
   child_message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&Client::RequireBitstreamBuffers,
                  client_,
                  kInputBufferCount,
                  image_processor_.get() ?
                      image_processor_->input_allocated_size() :
                      input_allocated_size_,
                  output_buffer_byte_size_));
@@ skipping 88 matching lines @@
                    base::Unretained(this)));
     // DestroyTask() will put the encoder into kError state and cause all tasks
     // to no-op.
     encoder_thread_.Stop();
   } else {
     // Otherwise, call the destroy task directly.
     DestroyTask();
   }
 
   // Set to kError state just in case.
-  SetEncoderState(kError);
+  encoder_state_ = kError;
 
   delete this;
 }
 
 std::vector<media::VideoEncodeAccelerator::SupportedProfile>
 V4L2VideoEncodeAccelerator::GetSupportedProfiles() {
   std::vector<SupportedProfile> profiles;
   SupportedProfile profile;
   profile.max_resolution.SetSize(1920, 1088);
   profile.max_framerate_numerator = 30;
@@ skipping 481 matching lines @@
             &V4L2VideoEncodeAccelerator::NotifyError, weak_this_, error));
     return;
   }
 
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
-void V4L2VideoEncodeAccelerator::SetEncoderState(State state) {
-  DVLOG(3) << "SetEncoderState(): state=" << state;
-
+void V4L2VideoEncodeAccelerator::SetErrorState(Error error) {
   // We can touch encoder_state_ only if this is the encoder thread or the
   // encoder thread isn't running.
   if (encoder_thread_.message_loop() != NULL &&
       encoder_thread_.message_loop() != base::MessageLoop::current()) {
     encoder_thread_.message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&V4L2VideoEncodeAccelerator::SetEncoderState,
-                   base::Unretained(this),
-                   state));
-  } else {
-    encoder_state_ = state;
+        FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::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 (encoder_state_ != kError && encoder_state_ != kUninitialized)
+    NotifyError(error);
+
+  encoder_state_ = kError;
 }
 
 void V4L2VideoEncodeAccelerator::RequestEncodingParametersChangeTask(
     uint32 bitrate,
     uint32 framerate) {
   DVLOG(3) << "RequestEncodingParametersChangeTask(): bitrate=" << bitrate
            << ", framerate=" << framerate;
   DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
 
   if (bitrate < 1)
@@ skipping 23 matching lines @@
   IOCTL_OR_ERROR_RETURN(VIDIOC_S_PARM, &parms);
 }
 
 bool V4L2VideoEncodeAccelerator::SetOutputFormat(
     media::VideoCodecProfile output_profile) {
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
   DCHECK(!output_streamon_);
 
   output_format_fourcc_ =
-      V4L2Device::VideoCodecProfileToV4L2PixFmt(output_profile);
+      V4L2Device::VideoCodecProfileToV4L2PixFmt(output_profile, false);
   if (!output_format_fourcc_) {
     LOG(ERROR) << "Initialize(): invalid output_profile=" << output_profile;
     return false;
   }
 
   output_buffer_byte_size_ = kOutputBufferSize;
 
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
@@ skipping 289 matching lines @@
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   output_buffer_map_.clear();
   free_output_buffers_.clear();
 }
 
 }  // namespace content