MJPEG acceleration for video capture using VAAPI

content/browser/renderer_host/media/video_capture_device_client.cc

Index: content/browser/renderer_host/media/video_capture_device_client.cc
diff --git a/content/browser/renderer_host/media/video_capture_device_client.cc b/content/browser/renderer_host/media/video_capture_device_client.cc
index 66b7fdb3d5d8064233e13585558b4a3894daac4e..faf6501895b705270b5d48fb921218df8059bb34 100644
--- a/content/browser/renderer_host/media/video_capture_device_client.cc
+++ b/content/browser/renderer_host/media/video_capture_device_client.cc
@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
+#include "content/browser/renderer_host/gpu_jpeg_decode_accelerator_adapter.h"
 #include "content/browser/renderer_host/media/video_capture_buffer_pool.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/public/browser/browser_thread.h"
@@ -27,16 +28,15 @@ class AutoReleaseBuffer : public media::VideoCaptureDevice::Client::Buffer {
   AutoReleaseBuffer(const scoped_refptr<VideoCaptureBufferPool>& pool,
                     int buffer_id,
                     void* data,
-                    size_t size)
-      : pool_(pool),
-        id_(buffer_id),
-        data_(data),
-        size_(size) {
+                    size_t size,
+                    base::SharedMemoryHandle handle)
+      : pool_(pool), id_(buffer_id), data_(data), size_(size), handle_(handle) {
     DCHECK(pool_.get());
   }
   int id() const override { return id_; }
   void* data() const override { return data_; }
   size_t size() const override { return size_; }
+  base::SharedMemoryHandle handle() const override { return handle_; }
 
  private:
   ~AutoReleaseBuffer() override { pool_->RelinquishProducerReservation(id_); }
@@ -45,6 +45,7 @@ class AutoReleaseBuffer : public media::VideoCaptureDevice::Client::Buffer {
   const int id_;
   void* const data_;
   const size_t size_;
+  const base::SharedMemoryHandle handle_;
 };
 
 VideoCaptureDeviceClient::VideoCaptureDeviceClient(
@@ -52,9 +53,12 @@ VideoCaptureDeviceClient::VideoCaptureDeviceClient(
     const scoped_refptr<VideoCaptureBufferPool>& buffer_pool)
     : controller_(controller),
       buffer_pool_(buffer_pool),
-      last_captured_pixel_format_(media::PIXEL_FORMAT_UNKNOWN) {}
+      last_captured_pixel_format_(media::PIXEL_FORMAT_UNKNOWN) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+}
 
-VideoCaptureDeviceClient::~VideoCaptureDeviceClient() {}
+VideoCaptureDeviceClient::~VideoCaptureDeviceClient() {
+}
 
 void VideoCaptureDeviceClient::OnIncomingCapturedData(
     const uint8* data,
@@ -68,11 +72,28 @@ void VideoCaptureDeviceClient::OnIncomingCapturedData(
     OnLog("Pixel format: " + media::VideoCaptureFormat::PixelFormatToString(
                                  frame_format.pixel_format));
     last_captured_pixel_format_ = frame_format.pixel_format;
+
+    if (frame_format.pixel_format == media::PIXEL_FORMAT_MJPEG &&
+        !external_jpeg_decoder_ &&
+        GpuJpegDecodeAcceleratorAdapter::Supported()) {
+      external_jpeg_decoder_.reset(new GpuJpegDecodeAcceleratorAdapter(this));
+      if (!external_jpeg_decoder_->Initialize()) {
+        // Reset external_jpeg_decoder_ to fallback to software decode.
+        external_jpeg_decoder_.reset();
+      }
+    }
   }
 
   if (!frame_format.IsValid())
     return;
 
+  if (external_jpeg_decoder_ && rotation == 0 &&
+      !external_jpeg_decoder_->IsFailed()) {
+    external_jpeg_decoder_->DecodeCapturedData(data, length, frame_format,

[mcasas, 2015/04/16 23:55:14]

Add here DCHECK_EQ(frame_format.pixel_format, media::PIXEL_FORMAT_MJPEG); ?
Remember that a client may change the passed format on a per frame basis.

[kcwu, 2015/04/20 17:48:00]

Done.
Since the format may change on a per frame basis, I make it as condition instead
of CHECK.

+                                               rotation, timestamp);
+    return;
+  }
+
   // |chopped_{width,height} and |new_unrotated_{width,height}| are the lowest
   // bit decomposition of {width, height}, grabbing the odd and even parts.
   const int chopped_width = frame_format.frame_size.width() & 1;
@@ -316,10 +337,11 @@ VideoCaptureDeviceClient::ReserveOutputBuffer(media::VideoPixelFormat format,
     return NULL;
   void* data;
   size_t size;
-  buffer_pool_->GetBufferInfo(buffer_id, &data, &size);
+  base::SharedMemoryHandle handle;
+  buffer_pool_->GetBufferInfo(buffer_id, &data, &size, &handle);
 
   scoped_refptr<media::VideoCaptureDevice::Client::Buffer> output_buffer(
-      new AutoReleaseBuffer(buffer_pool_, buffer_id, data, size));
+      new AutoReleaseBuffer(buffer_pool_, buffer_id, data, size, handle));
 
   if (buffer_id_to_drop != VideoCaptureBufferPool::kInvalidId) {
     BrowserThread::PostTask(BrowserThread::IO,