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>
@@ skipping 51 matching lines @@
 }
 
 V4L2VideoEncodeAccelerator::OutputRecord::OutputRecord()
     : at_device(false), address(NULL), length(0) {
 }
 
 V4L2VideoEncodeAccelerator::OutputRecord::~OutputRecord() {
 }
 
 V4L2VideoEncodeAccelerator::V4L2VideoEncodeAccelerator(
-    scoped_ptr<V4L2Device> device)
+    const 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 681 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