MJPEG acceleration for video capture using VAAPI

media/video/capture/linux/video_capture_device_linux.cc

 // Copyright (c) 2012 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 "media/video/capture/linux/video_capture_device_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <poll.h>
 #if defined(OS_OPENBSD)
@@ skipping 344 matching lines @@
                         : V4L2_CID_POWER_LINE_FREQUENCY_60HZ;
     HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_S_CTRL, &control));
   }
 
   capture_format_.frame_size.SetSize(video_fmt.fmt.pix.width,
                                      video_fmt.fmt.pix.height);
   capture_format_.frame_rate = frame_rate;
   capture_format_.pixel_format =
       V4l2FourCcToChromiumPixelFormat(video_fmt.fmt.pix.pixelformat);
 
+  if (capture_format_.pixel_format == PIXEL_FORMAT_MJPEG) {
+    // TODO(kcwu) remove this hacky api
+    if (!client_->InitializeJpegDecoder()) {

[wuchengli, 2015/03/23 06:30:15]

How about calling this when |last_captured_pixel_format_| is first set to
PIXEL_FORMAT_MJPEG in video_capture_device_client.cc? VideoCaptureDeviceClient
should be the one that decides to use jpeg decoder. If Android wants to support
jpeg decoder, they shouldn't need to modify video_capture_device_android.cc.

[kcwu, 2015/03/30 18:12:14]

Done.

+      SetErrorState("InitializeJpegDecoder failed");
+      return;
+    }
+  }
+
   if (!AllocateVideoBuffers()) {
     SetErrorState("Allocate buffer failed (Cannot recover from this error)");
     return;
   }
 
   const v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_STREAMON, &type)) < 0) {
     SetErrorState("VIDIOC_STREAMON failed");
     return;
   }
@@ skipping 56 matching lines @@
     }
   } else {
     timeout_count_ = 0;
   }
 
   // Check if the driver has filled a buffer.
   if (device_pfd.revents & POLLIN) {
     v4l2_buffer buffer = {};
      buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
      buffer.memory = V4L2_MEMORY_MMAP;
+    LOG(ERROR) << "DQBUF";
     if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_DQBUF, &buffer)) < 0) {
       SetErrorState("Failed to dequeue capture buffer");
       return;
     }
     client_->OnIncomingCapturedData(
         static_cast<uint8*>(buffer_pool_[buffer.index].start),
         buffer.bytesused,
         capture_format_,
         rotation_,
         base::TimeTicks::Now());
 
+    LOG(ERROR) << "QBUF";
     if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_QBUF, &buffer)) < 0)
       SetErrorState("Failed to enqueue capture buffer");
   }
 
   v4l2_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureDeviceLinux::V4L2CaptureDelegate::DoCapture,
                  this));
 }
 
@@ skipping 62 matching lines @@
 }
 
 void VideoCaptureDeviceLinux::V4L2CaptureDelegate::SetErrorState(
     const std::string& reason) {
   DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
   is_capturing_ = false;
   client_->OnError(reason);
 }
 
 }  // namespace media