MJPEG acceleration for video capture, browser part

content/browser/renderer_host/gpu_jpeg_decoder.cc

Index: content/browser/renderer_host/gpu_jpeg_decoder.cc
diff --git a/content/browser/renderer_host/gpu_jpeg_decoder.cc b/content/browser/renderer_host/gpu_jpeg_decoder.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bf9c0dccd3a20207a066cd6be726ac75de482bdc
--- /dev/null
+++ b/content/browser/renderer_host/gpu_jpeg_decoder.cc
@@ -0,0 +1,205 @@
+// Copyright 2015 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 "content/browser/renderer_host/gpu_jpeg_decoder.h"
+
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "base/logging.h"
+#include "base/strings/stringprintf.h"
+#include "base/trace_event/trace_event.h"
+#include "content/browser/gpu/browser_gpu_channel_host_factory.h"
+#include "content/common/gpu/client/gpu_jpeg_decode_accelerator_host.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/common/content_switches.h"
+#include "media/base/video_frame.h"
+
+namespace content {
+
+// static
+bool GpuJpegDecoder::Supported() {
+  // A lightweight check for caller to avoid IPC latency for known unsupported
+  // platform. Initialize() can do the real platform supporting check but it
+  // requires an IPC even for platforms that do not support HW decoder.
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableAcceleratedMjpegDecode)) {
+// TODO(kcwu): move this information to GpuInfo.
+#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
+    return true;
+#endif
+  }
+  return false;
+}
+
+GpuJpegDecoder::GpuJpegDecoder(const DecodeDoneCB& decode_done_cb,
+                               const ErrorCB& error_cb)
+    : gpu_channel_event_(false /* manual reset */,
+                         false /* initially_signaled */),
+      decode_done_cb_(decode_done_cb),
+      error_cb_(error_cb),
+      next_bitstream_buffer_id_(0),
+      in_buffer_(media::JpegDecodeAccelerator::kInvalidBitstreamBufferId,
+                 base::SharedMemory::NULLHandle(),
+                 0) {
+}
+
+GpuJpegDecoder::~GpuJpegDecoder() {
+  DCHECK(CalledOnValidThread());
+
+  // |decoder_| guarantees no more JpegDecodeAccelerator::Client callbacks
+  // on IO thread after deletion.
+  decoder_.reset();
+
+  // |gpu_channel_host_| should outlive |decoder_|, so |gpu_channel_host_|
+  // must be released after |decoder_| is been destroyed.
+  gpu_channel_host_ = nullptr;
+}
+
+bool GpuJpegDecoder::IsDecoding_Locked() {
+  lock_.AssertAcquired();
+  return !decode_done_closure_.is_null();
+}
+
+bool GpuJpegDecoder::Initialize() {
+  DVLOG(3) << __func__;
+  DCHECK(CalledOnValidThread());
+  // Not on IO thread. Otherwise deadlock.
+  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  DCHECK(BrowserGpuChannelHostFactory::instance());
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&BrowserGpuChannelHostFactory::EstablishGpuChannel,
+                 base::Unretained(BrowserGpuChannelHostFactory::instance()),

[piman, 2015/06/05 23:07:51]

BrowserGpuChannelHostFactory is a UI thread class. You should consider this to
be invalid to call from another thread (and Unretained could be unsafe).

Instead you should post a task to the UI thread to a free function that can then
do BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(...)

[kcwu, 2015/06/17 14:35:37]

Done.

+                 CAUSE_FOR_GPU_LAUNCH_JPEGDECODEACCELERATOR_INITIALIZE,
+                 base::Bind(&GpuJpegDecoder::GpuChannelEstablished,
+                            base::Unretained(this))));
+  gpu_channel_event_.Wait();

[piman, 2015/06/05 23:07:51]

Which thread is this called on? It seems like this could cause a deadlock on
termination when the UI thread joins this thread.

I would like to say that a way to make this work would be to establish the
channel on the UI thread before even creating this class (it's done anyway for
the UI), and inject it in the constructor (or in Initialize), but I don't know
how all this flows. If I understand correctly, this gets called when you start
receiving encoded capture packets. So maybe a way is to post the task at that
point, and delay decoding of the packets (keeping them in a queue or discarding)
until the reply/establish is done.

[kcwu, 2015/06/17 14:35:37]

Done.
I added a function ReadyToDecode, which indicates the establish is done. Before
that, it still uses software decode,  so no frames are drop.

+  if (!gpu_channel_host_) {
+    LOG(ERROR) << "Failed to establish GPU channel for JPEG decoder";
+    return false;
+  }
+
+  decoder_ = gpu_channel_host_->CreateJpegDecoder(this);
+  if (!decoder_) {
+    return false;
+  }
+
+  return true;
+}
+
+void GpuJpegDecoder::GpuChannelEstablished() {
+  DCHECK(BrowserGpuChannelHostFactory::instance()->IsMainThread());
+
+  gpu_channel_host_ = BrowserGpuChannelHostFactory::instance()->GetGpuChannel();
+  gpu_channel_event_.Signal();
+}
+
+void GpuJpegDecoder::VideoFrameReady(int32_t bitstream_buffer_id) {
+  DVLOG(3) << __func__;
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  TRACE_EVENT0("jpeg", "GpuJpegDecoder::VideoFrameReady");
+  base::AutoLock lock(lock_);
+
+  if (!IsDecoding_Locked()) {
+    LOG(ERROR) << "Got decode response while not decoding";
+    return;
+  }
+
+  if (bitstream_buffer_id != in_buffer_.id()) {
+    LOG(ERROR) << "Unexpected bitstream_buffer_id " << bitstream_buffer_id
+               << ", expected " << in_buffer_.id();
+    return;
+  }
+
+  decode_done_closure_.Run();
+  decode_done_closure_.Reset();
+
+  TRACE_EVENT_ASYNC_END0("jpeg", "GpuJpegDecoder decoding",
+                         bitstream_buffer_id);
+}
+
+void GpuJpegDecoder::NotifyError(int32_t bitstream_buffer_id,
+                                 media::JpegDecodeAccelerator::Error error) {
+  DVLOG(3) << __func__;
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  LOG(ERROR) << "Decode error, bitstream_buffer_id=" << bitstream_buffer_id;
+
+  base::AutoLock lock(lock_);
+  decode_done_closure_.Reset();
+
+  error_cb_.Run(
+      base::StringPrintf("Decode error, bitstream_buffer_id=%d, error=%d",
+                         bitstream_buffer_id, error));
+}
+
+void GpuJpegDecoder::DecodeCapturedData(
+    const uint8* data,
+    size_t in_buffer_size,
+    const media::VideoCaptureFormat& frame_format,
+    const base::TimeTicks& timestamp,
+    scoped_ptr<media::VideoCaptureDevice::Client::Buffer> out_buffer) {
+  DCHECK(CalledOnValidThread());
+
+  TRACE_EVENT_ASYNC_BEGIN0("jpeg", "GpuJpegDecoder decoding",
+                           next_bitstream_buffer_id_);
+  TRACE_EVENT0("jpeg", "GpuJpegDecoder::DecodeCapturedData");
+
+  // TODO(kcwu): enqueue decode requests in case decoding is not fast enough
+  // (say, if decoding time is longer than 16ms for 60fps 4k image)
+  {
+    base::AutoLock lock(lock_);
+    if (IsDecoding_Locked()) {
+      DVLOG(1) << "Drop captured frame. Previous jpeg frame is still decoding";
+      return;
+    }
+  }
+
+  // Enlarge input buffer if necessary.
+  if (!in_shared_memory_.get() ||
+      in_buffer_size > in_shared_memory_->mapped_size()) {
+    // Reserve 2x space to avoid frequent reallocations for initial frames.
+    const size_t reserved_size = 2 * in_buffer_size;
+    in_shared_memory_.reset(new base::SharedMemory);
+    if (!in_shared_memory_->CreateAndMapAnonymous(reserved_size)) {
+      base::AutoLock lock(lock_);
+      error_cb_.Run(base::StringPrintf("CreateAndMapAnonymous failed, size=%zd",
+                                       reserved_size));
+      return;
+    }
+  }
+  memcpy(in_shared_memory_->memory(), data, in_buffer_size);
+
+  // No need to lock for |in_buffer_| since IsDecoding_Locked() is false.
+  in_buffer_ = media::BitstreamBuffer(
+      next_bitstream_buffer_id_, in_shared_memory_->handle(), in_buffer_size);
+  // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
+  next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x3FFFFFFF;
+
+  const gfx::Size dimensions = frame_format.frame_size;
+  base::SharedMemoryHandle out_handle(out_buffer->AsPlatformHandle(), true);
+  scoped_refptr<media::VideoFrame> out_frame =
+      media::VideoFrame::WrapExternalSharedMemory(
+          media::VideoFrame::I420,                  // format
+          dimensions,                               // coded_size
+          gfx::Rect(dimensions),                    // visible_rect
+          dimensions,                               // natural_size
+          static_cast<uint8*>(out_buffer->data()),  // data
+          out_buffer->size(),                       // data_size
+          out_handle,                               // handle
+          0,                                        // shared_memory_offset
+          base::TimeDelta());                       // timestamp
+  DCHECK(out_frame.get());
+  out_frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
+                                   frame_format.frame_rate);
+
+  {
+    base::AutoLock lock(lock_);
+    decode_done_closure_ = base::Bind(
+        decode_done_cb_, base::Passed(&out_buffer), out_frame, timestamp);
+  }
+  decoder_->Decode(in_buffer_, out_frame);
+}
+
+}  // namespace content