MJPEG acceleration for video capture using VAAPI

content/common/gpu/media/vaapi_jpeg_decode_accelerator.cc

+// 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/common/gpu/media/vaapi_jpeg_decode_accelerator.h"
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/metrics/histogram.h"
+#include "base/stl_util.h"
+#include "base/strings/string_util.h"
+#include "base/trace_event/trace_event.h"
+#include "content/common/gpu/gpu_channel.h"
+#include "content/common/gpu/media/vaapi_picture.h"
+#include "media/base/bind_to_current_loop.h"
+#include "media/base/video_frame.h"
+#include "media/filters/jpeg_parser.h"
+#include "media/video/picture.h"
+#include "ui/gl/gl_bindings.h"
+
+static void ReportVaapiError() {
+}
+
+namespace content {
+
+VaapiJpegDecodeAccelerator::DecodeRequest::DecodeRequest(
+    media::BitstreamBuffer bitstream_buffer,
+    scoped_refptr<media::VideoFrame> video_frame)
+    : bitstream_buffer(bitstream_buffer), video_frame(video_frame) {
+}
+
+VaapiJpegDecodeAccelerator::DecodeRequest::~DecodeRequest() {
+}
+
+void VaapiJpegDecodeAccelerator::NotifyError(int32_t bitstream_buffer_id,
+                                             Error error) {
+  if (message_loop_ != base::MessageLoop::current()) {
+    DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+    message_loop_->PostTask(FROM_HERE,
+                            base::Bind(&VaapiJpegDecodeAccelerator::NotifyError,
+                                       weak_this_, bitstream_buffer_id, error));
+    return;
+  }
+
+  Cleanup();
+
+  LOG(ERROR) << "Notifying of error " << error;
+  if (client_) {
+    client_->NotifyError(bitstream_buffer_id, error);
+    client_ptr_factory_.reset();
+  }
+}
+
+VaapiJpegDecodeAccelerator::VaapiJpegDecodeAccelerator(
+    const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
+    : state_(kUninitialized),
+      message_loop_(base::MessageLoop::current()),
+      io_message_loop_(io_message_loop),
+      decoder_thread_("VaapiJpegDecoderThread"),
+      va_surface_(VA_INVALID_SURFACE),
+      weak_this_factory_(this) {
+  weak_this_ = weak_this_factory_.GetWeakPtr();
+}
+
+VaapiJpegDecodeAccelerator::~VaapiJpegDecodeAccelerator() {
+  DCHECK_EQ(message_loop_, base::MessageLoop::current());
+}
+
+bool VaapiJpegDecodeAccelerator::Initialize(Client* client) {
+  DCHECK_EQ(message_loop_, base::MessageLoop::current());
+
+  client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
+  client_ = client_ptr_factory_->GetWeakPtr();
+
+  base::AutoLock auto_lock(lock_);
+  DCHECK_EQ(state_, kUninitialized);
+
+  vaapi_wrapper_ =
+      VaapiWrapper::Create(VaapiWrapper::kDecode, VAProfileJPEGBaseline,
+                           base::Bind(&ReportVaapiError));
+
+  if (!vaapi_wrapper_.get()) {
+    DLOG(ERROR) << "Failed initializing VAAPI";
+    return false;
+  }
+
+  CHECK(decoder_thread_.Start());
+  decoder_thread_proxy_ = decoder_thread_.message_loop_proxy();
+
+  state_ = kInitialized;
+  return true;
+}
+
+bool VaapiJpegDecodeAccelerator::OutputPicture(
+    VASurfaceID va_surface_id,
+    int32_t input_id,
+    const scoped_refptr<media::VideoFrame>& video_frame) {
+  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+
+  TRACE_EVENT1("jpeg", "VaapiJpegDecodeAccelerator::OutputPicture", "input_id",
+               input_id);
+
+  DVLOG(3) << "Outputting VASurface " << va_surface_id
+           << " into video_frame associate to input buffer id " << input_id;
+
+  VAImage image;
+  VAImageFormat format;
+  const uint32_t kI420Fourcc = VA_FOURCC('I', '4', '2', '0');
+  memset(&image, 0, sizeof(image));
+  memset(&format, 0, sizeof(format));
+  format.fourcc = kI420Fourcc;
+  format.byte_order = VA_LSB_FIRST;
+  format.bits_per_pixel = 12;  // 12 for I420
+
+  void* mem;
+  gfx::Size coded_size = video_frame->coded_size();
+  if (!vaapi_wrapper_->GetVaImage(va_surface_id, &format, coded_size, &image,
+                                  &mem)) {
+    DLOG(ERROR) << "Cannot get VAImage";
+    return false;
+  }
+
+  uint8* frame_mem = video_frame->data(media::VideoFrame::kYPlane);
+  size_t frame_buffer_size =
+      media::VideoFrame::AllocationSize(media::VideoFrame::I420, coded_size);
+  memcpy(frame_mem, mem, frame_buffer_size);
+
+  vaapi_wrapper_->ReturnVaImage(&image);
+
+  if (client_)
+    client_->VideoFrameReady(input_id);
+
+  return true;
+}
+
+void VaapiJpegDecodeAccelerator::QueueNewDecodeRequest(
+    const media::BitstreamBuffer& bitstream_buffer,
+    const scoped_refptr<media::VideoFrame>& video_frame) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+
+  // Set up a new decode request and queue it for later.
+  linked_ptr<DecodeRequest> input_buffer(
+      new DecodeRequest(bitstream_buffer, video_frame));
+  base::AutoLock auto_lock(lock_);
+  decode_requests_.push(input_buffer);
+}
+
+void VaapiJpegDecodeAccelerator::DecodeTask() {
+  DVLOG(3) << __func__;
+  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  TRACE_EVENT0("jpeg", "DecodeTask");
+  linked_ptr<DecodeRequest> request;
+  {
+    base::AutoLock auto_lock(lock_);
+
+    DCHECK(!decode_requests_.empty());
+    request = decode_requests_.front();
+    decode_requests_.pop();
+  }
+
+  do {
+    DVLOG(4) << "Mapping new input buffer id: "
+             << request->bitstream_buffer.id()
+             << " size: " << (int)request->bitstream_buffer.size();
+
+    scoped_ptr<base::SharedMemory> shm(
+        new base::SharedMemory(request->bitstream_buffer.handle(), true));
+    if (!shm->Map(request->bitstream_buffer.size())) {
+      LOG(ERROR) << "Failed to map input buffer";
+      NotifyError(request->bitstream_buffer.id(), UNREADABLE_INPUT);
+      break;
+    }
+
+    media::JpegParseResult parse_result;
+
+    if (!media::ParseJpegPicture(
+            reinterpret_cast<const uint8_t*>(shm->memory()),
+            request->bitstream_buffer.size(), &parse_result)) {
+      DLOG(ERROR) << "ParseJpegPicture failed";
+      NotifyError(request->bitstream_buffer.id(),
+                  media::JpegDecodeAccelerator::PARSE_JPEG_FAILED);
+      break;
+    }
+
+    // Reuse VASurface if size doesn't change.
+    // This is not only optimization, but also to avoid libva resoruce leak.
+    // crosbug.com/p/39584
+    gfx::Size coded_size(parse_result.frame_header.coded_width,
+                         parse_result.frame_header.coded_height);
+    if (coded_size != last_coded_size_ || va_surface_ == VA_INVALID_SURFACE) {
+      vaapi_wrapper_->DestroySurfaces();
+      std::vector<VASurfaceID> va_surfaces;
+      if (!vaapi_wrapper_->CreateSurfaces(coded_size, 1, &va_surfaces))
+        break;
+      va_surface_ = va_surfaces[0];
+      last_coded_size_ = coded_size;
+    }
+
+    if (!VaapiJpegDecoder::Decode(vaapi_wrapper_.get(), parse_result,
+                                  va_surface_)) {
+      LOG(ERROR) << "Decode failed";
+      NotifyError(request->bitstream_buffer.id(),
+                  media::JpegDecodeAccelerator::PLATFORM_FAILURE);
+      break;
+    }
+
+    if (!OutputPicture(va_surface_, request->bitstream_buffer.id(),
+                       request->video_frame)) {
+      LOG(ERROR) << "Output failed";
+      NotifyError(request->bitstream_buffer.id(),
+                  media::JpegDecodeAccelerator::PLATFORM_FAILURE);
+      break;
+    }
+  } while (0);
+}
+
+void VaapiJpegDecodeAccelerator::Decode(
+    const media::BitstreamBuffer& bitstream_buffer,
+    const scoped_refptr<media::VideoFrame>& video_frame) {
+  DVLOG(3) << __func__;
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+
+  TRACE_EVENT1("jpeg", "Decode", "input_id", bitstream_buffer.id());
+  QueueNewDecodeRequest(bitstream_buffer, video_frame);
+
+  decoder_thread_proxy_->PostTask(
+      FROM_HERE, base::Bind(&VaapiJpegDecodeAccelerator::DecodeTask,
+                            base::Unretained(this)));
+}
+
+void VaapiJpegDecodeAccelerator::Cleanup() {
+  DCHECK_EQ(message_loop_, base::MessageLoop::current());
+
+  base::AutoLock auto_lock(lock_);
+  if (state_ == kUninitialized)
+    return;
+
+  DVLOG(1) << "Destroying VaapiJpegDecodeAccelerator";
+
+  client_ptr_factory_.reset();
+  weak_this_factory_.InvalidateWeakPtrs();
+
+  {
+    base::AutoUnlock auto_unlock(lock_);
+    decoder_thread_.Stop();
+  }
+
+  state_ = kUninitialized;
+}
+
+void VaapiJpegDecodeAccelerator::Destroy() {
+  DCHECK_EQ(message_loop_, base::MessageLoop::current());
+  Cleanup();
+  delete this;
+}
+
+}  // namespace content