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..801c77cdc15707e529ea58b4a128977c7e733c69
--- /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/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 "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.
+// 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)
+    : jpeg_thread_("GpuJpegDecoderThread"),
+      jpeg_event_(false, false),

[mcasas, 2015/05/27 18:08:43]

jpeg_event( false /* manual reset */, false /* initially_signaled */), ?

[kcwu, 2015/06/02 15:09:56]

Done.

+      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());
+}
+
+bool GpuJpegDecoder::IsDecoding() {
+  DCHECK(jpeg_task_runner_->BelongsToCurrentThread());
+  return !decode_done_closure_.is_null();
+}
+
+bool GpuJpegDecoder::Initialize() {
+  DVLOG(3) << __func__;
+  DCHECK(CalledOnValidThread());
+  DCHECK(!jpeg_thread_.IsRunning());
+
+  if (!jpeg_thread_.Start()) {
+    LOG(ERROR) << "Failed to start decoding thread.";
+    return false;
+  }
+  jpeg_task_runner_ = jpeg_thread_.task_runner();
+
+  jpeg_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&GpuJpegDecoder::InitializeOnJpegThread,
+                            base::Unretained(this)));
+  jpeg_event_.Wait();
+
+  if (!decoder_) {
+    jpeg_thread_.Stop();
+    return false;
+  }
+
+  return true;
+}
+
+void GpuJpegDecoder::InitializeOnJpegThread() {
+  DCHECK(jpeg_task_runner_->BelongsToCurrentThread());
+  GpuChannelHost* const host =
+      BrowserGpuChannelHostFactory::instance()->GetGpuChannel();
+  decoder_ = host->CreateJpegDecoder(this);
+  jpeg_event_.Signal();
+}
+
+void GpuJpegDecoder::VideoFrameReady(int32_t bitstream_buffer_id) {
+  DVLOG(3) << __func__;
+  DCHECK(jpeg_task_runner_->BelongsToCurrentThread());
+  TRACE_EVENT0("jpeg", "GpuJpegDecoder::VideoFrameReady");
+
+  if (!IsDecoding()) {
+    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(jpeg_task_runner_->BelongsToCurrentThread());
+  LOG(ERROR) << "Decode error, bitstream_buffer_id=" << bitstream_buffer_id;
+
+  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());
+
+  jpeg_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &GpuJpegDecoder::DecodeCapturedDataOnJpegThread,
+          base::Unretained(this),

[mcasas, 2015/05/27 18:08:43]

Isn't this a bad idea?

[kcwu, 2015/06/03 14:30:07]

jpeg thread is removed.

+          data,
+          in_buffer_size,
+          frame_format,
+          timestamp,
+          base::Passed(&out_buffer)));
+
+  // Wait until |data| is copied out.
+  jpeg_event_.Wait();

[mcasas, 2015/05/27 18:08:43]

I have a few objections/remarks to the wait-signal semaphore 
construction, beyond the fact that Chromium is supposed to
be asynchronous in general.

One is that, if VCDeviceClient gets destroyed and has a 
GpuJpegDecoder Wait()ing, how's that supposed to go about?
Maybe we could use TimedWait() ISO Wait() and add some
large timeout value, and signal OnError() if appropriate. 
WDYT?

[kcwu, 2015/06/03 14:30:07]

jpeg thread is removed.

+}
+
+

[mcasas, 2015/05/27 18:08:43]

Remove empty line.

[kcwu, 2015/06/02 15:09:56]

Done.

+void GpuJpegDecoder::DecodeCapturedDataOnJpegThread(
+    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(jpeg_task_runner_->BelongsToCurrentThread());
+  TRACE_EVENT_ASYNC_BEGIN0("jpeg", "GpuJpegDecoder decoding",
+                           next_bitstream_buffer_id_);
+  TRACE_EVENT0("jpeg", "GpuJpegDecoder::DecodeCapturedDataOnJpegThread");
+
+  // TODO(kcwu): enqueue decode requests in case decoding is not fast enough
+  // (say, if decoding time is longer than 16ms for 60fps 4k image)
+  if (IsDecoding()) {
+    DVLOG(1) << "Drop captured frame. Previous jpeg frame is still decoding";
+    jpeg_event_.Signal();

[mcasas, 2015/05/27 18:08:43]

The other objection, DecodeCapturedDataOnJpegThread() has 
three return paths and you need to explicitly Signal() on each. 
You can make a local 

class AutoReleaseWaitableEVent {
 public:
  AutoReleaseWaitableEvent(base::WaitableEvent& completion) 
    : completion_(completion) {}
  ~AutoReleaseWaitableEvent() {
    completion_.Signal()
  }

 private:
  const base::WaitableEvent& completion_;
}

And locally wrap |jpeg_event_| ?

[kcwu, 2015/06/02 15:09:56]

Acknowledged.

+    return;
+  }
+
+  // Enlarge input buffer if necessary.
+  if (!in_shared_memory_.get() ||
+      in_buffer_size > in_shared_memory_->mapped_size()) {
+    // Reserve 2x space to avoid frequently reallocate for initial frames.

[mcasas, 2015/05/27 18:08:43]

s/frequently reallocate/frequent reallocations/

[kcwu, 2015/06/02 15:09:56]

Done.

+    size_t reserved_size = 2 * in_buffer_size;

[mcasas, 2015/05/27 18:08:43]

const

[kcwu, 2015/06/02 15:09:56]

Done.

+    in_shared_memory_.reset(new base::SharedMemory);
+    if (!in_shared_memory_->CreateAndMapAnonymous(reserved_size)) {
+      error_cb_.Run(base::StringPrintf("CreateAndMapAnonymous failed, size=%zd",
+                                       reserved_size));
+      jpeg_event_.Signal();
+      return;
+    }
+  }
+  memcpy(in_shared_memory_->memory(), data, in_buffer_size);
+  jpeg_event_.Signal();
+
+  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;
+  scoped_refptr<media::VideoFrame> out_frame =
+      media::VideoFrame::WrapExternalPackedMemory(
+          media::VideoFrame::I420,
+          dimensions,
+          gfx::Rect(dimensions),
+          dimensions,
+          reinterpret_cast<uint8*>(out_buffer->data()),
+          out_buffer->size(),
+          base::SharedMemoryHandle(out_buffer->AsPlatformHandle(), true),
+          0,
+          base::TimeDelta(),
+          base::Closure());
+  DCHECK(out_frame.get());
+  out_frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
+                                   frame_format.frame_rate);
+
+  decode_done_closure_ = base::Bind(decode_done_cb_, base::Passed(&out_buffer),
+                                    out_frame, timestamp);
+  decoder_->Decode(in_buffer_, out_frame);
+}
+
+}  // namespace content