Add ArcGpuVideoDecodeAccelerator.

chrome/gpu/arc_gpu_video_decode_accelerator.cc

+// Copyright 2016 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 "base/callback_helpers.h"
+#include "base/logging.h"
+#include "base/run_loop.h"
+#include "chrome/gpu/arc_gpu_video_decode_accelerator.h"
+#include "content/public/common/gpu_video_decode_accelerator_factory.h"
+
+namespace chromeos {
+namespace arc {
+
+ArcGpuVideoDecodeAccelerator::InputRecord::InputRecord(
+    int32_t bitstream_buffer_id,
+    uint32_t buffer_index,
+    int64_t timestamp)
+    : bitstream_buffer_id(bitstream_buffer_id),
+      buffer_index(buffer_index),
+      timestamp(timestamp) {}
+
+ArcGpuVideoDecodeAccelerator::ArcGpuVideoDecodeAccelerator()
+    : pending_eos_output_buffer_(false),
+      arc_client_(nullptr),
+      next_bitstream_buffer_id_(0),
+      output_buffer_size_(0) {}
+
+ArcGpuVideoDecodeAccelerator::~ArcGpuVideoDecodeAccelerator() {}
+
+// An arbitrary chosen limit of the number of buffers. The number of
+// buffers used is requested from the client side (less trusted).
+static const size_t kMaxBufferCount = 128;
+
+bool ArcGpuVideoDecodeAccelerator::Initialize(
+    const Config& config,
+    ArcVideoAccelerator::Client* client) {
+  DVLOG(5) << "Initialize(device=" << config.device_type
+           << ", input_pixel_format=" << config.input_pixel_format
+           << ", num_input_buffers=" << config.num_input_buffers << ")";
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (config.device_type != Config::DEVICE_DECODER)
+    return false;
+  DCHECK(client);
+  DCHECK(!arc_client_);
+  arc_client_ = client;
+
+  if (config.num_input_buffers > kMaxBufferCount) {
+    DLOG(ERROR) << "Request too many buffers: " << config.num_input_buffers;
+    return false;
+  }
+  input_buffer_info_.resize(config.num_input_buffers);
+
+  media::VideoDecodeAccelerator::Config vda_config;
+  switch (config.input_pixel_format) {
+    case HAL_PIXEL_FORMAT_H264:
+      vda_config.profile = media::H264PROFILE_MAIN;
+      break;
+    case HAL_PIXEL_FORMAT_VP8:
+      vda_config.profile = media::VP8PROFILE_ANY;
+      break;
+    default:
+      DLOG(ERROR) << "Unsupported input format: " << config.input_pixel_format;
+      return false;
+  }
+  vda_config.output_mode =
+      media::VideoDecodeAccelerator::Config::OutputMode::IMPORT;
+
+  scoped_ptr<content::GpuVideoDecodeAcceleratorFactory> vda_factory =
+      content::GpuVideoDecodeAcceleratorFactory::CreateWithNoGL();
+  vda_ = std::move(vda_factory->CreateVDA(this, vda_config));
+  if (!vda_) {
+    DLOG(ERROR) << "Failed to create VDA.";
+    return false;
+  }
+  return true;
+}
+
+void ArcGpuVideoDecodeAccelerator::SetNumberOfOutputBuffers(size_t number) {
+  DVLOG(5) << "SetNumberOfOutputBuffers(" << number << ")";
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!vda_) {
+    DLOG(ERROR) << "VDA not initialized";
+    arc_client_->OnError(ILLEGAL_STATE);

[kcwu, 2016/03/18 06:30:11]

If not Initialize() yet, arc_client_ will be probably null as well.

[Owen Lin, 2016/03/24 03:01:10]

Done.

+    return;
+  }
+
+  if (number > kMaxBufferCount) {
+    DLOG(ERROR) << "Too many buffers: " << number;
+    arc_client_->OnError(INVALID_ARGUMENT);
+    return;
+  }
+
+  std::vector<media::PictureBuffer> buffers;
+  for (int32_t id = 0, n = number; id < n; ++id) {
+    // TODO: Make sure the |coded_size| is what we want.
+    buffers.push_back(media::PictureBuffer(id, coded_size_, 0));
+  }
+  vda_->AssignPictureBuffers(buffers);
+
+  pending_import_buffer_.clear();
+  pending_import_buffer_.resize(number);
+}
+
+void ArcGpuVideoDecodeAccelerator::BindSharedMemory(PortType port,
+                                                    uint32_t index,
+                                                    int ashmem_fd,
+                                                    off_t offset,
+                                                    size_t length) {
+  DVLOG(5) << "ArcGVDA::BindSharedMemory, offset: " << offset
+           << ", length: " << length;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!vda_) {
+    DLOG(ERROR) << "VDA not initialized";
+    arc_client_->OnError(ILLEGAL_STATE);
+    return;
+  }
+
+  // Make sure we will close the file descriptor.
+  base::ScopedFD handle(ashmem_fd);
+  if (port != PORT_INPUT) {
+    DLOG(ERROR) << "SharedBuffer is only supported for input";
+    arc_client_->OnError(INVALID_ARGUMENT);
+    return;
+  }
+  if (!ValidatePortAndIndex(port, index)) {
+    arc_client_->OnError(INVALID_ARGUMENT);
+    return;
+  }
+  InputBufferInfo* input_info = &input_buffer_info_[index];
+  input_info->handle = std::move(handle);
+  input_info->offset = offset;
+  input_info->length = length;
+}
+
+void ArcGpuVideoDecodeAccelerator::BindDmabuf(PortType port,
+                                              uint32_t index,
+                                              int dmabuf_fd) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!vda_) {
+    DLOG(ERROR) << "VDA not initialized";
+    arc_client_->OnError(ILLEGAL_STATE);
+    return;
+  }
+
+  // Make sure we will close the file descriptor.
+  base::ScopedFD handle(dmabuf_fd);
+  if (port != PORT_OUTPUT) {
+    DLOG(ERROR) << "GraphicBuffer is only supported for input";
+    arc_client_->OnError(INVALID_ARGUMENT);
+    return;
+  }
+  if (!ValidatePortAndIndex(port, index)) {
+    arc_client_->OnError(INVALID_ARGUMENT);
+    return;
+  }
+  pending_import_buffer_[index] = std::move(handle);
+}
+
+void ArcGpuVideoDecodeAccelerator::UseBuffer(PortType port,
+                                             uint32_t index,
+                                             const BufferMetadata& metadata) {
+  DVLOG(5) << "UseBuffer(port=" << port << ", index=" << index
+           << ", metadata=(bytes_used=" << metadata.bytes_used
+           << ", timestamp=" << metadata.timestamp << ")";
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!vda_) {
+    DLOG(ERROR) << "VDA not initialized";
+    arc_client_->OnError(ILLEGAL_STATE);
+    return;
+  }
+  if (!ValidatePortAndIndex(port, index)) {
+    arc_client_->OnError(INVALID_ARGUMENT);
+    return;
+  }
+  switch (port) {
+    case PORT_INPUT: {
+      InputBufferInfo* input_info = &input_buffer_info_[index];
+      int32_t bitstream_buffer_id = next_bitstream_buffer_id_;
+      // Mask against 30 bits, to avoid (undefined) wraparound on signed
+      // integer.
+      next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x3FFFFFFF;
+      SetInputRecord(bitstream_buffer_id, index, metadata.timestamp);
+      int dup_fd = HANDLE_EINTR(dup(input_info->handle.get()));
+      if (dup_fd < 0) {
+        DLOG(ERROR) << "dup() failed.";
+        arc_client_->OnError(PLATFORM_FAILURE);
+        return;
+      }
+      vda_->Decode(media::BitstreamBuffer(
+          bitstream_buffer_id, base::SharedMemoryHandle(dup_fd, true),
+          metadata.bytes_used, input_info->offset));
+      if (metadata.flags & BUFFER_FLAG_EOS) {
+        vda_->Flush(true);
+      }
+      break;
+    }
+    case PORT_OUTPUT: {
+      SendEosIfNeededOrReusePicture(index);
+      break;
+    }
+    default:
+      NOTREACHED();
+  }
+}
+
+void ArcGpuVideoDecodeAccelerator::Reset() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!vda_) {
+    DLOG(ERROR) << "VDA not initialized";
+    arc_client_->OnError(ILLEGAL_STATE);
+    return;
+  }
+  base::RunLoop loop;
+  reset_done_callback_ = loop.QuitClosure();
+  vda_->Reset();
+  base::MessageLoop::ScopedNestableTaskAllower allow(
+      base::MessageLoop::current());
+  // Wait for the ResetDone callback.
+  loop.Run();
+}
+
+void ArcGpuVideoDecodeAccelerator::ProvidePictureBuffers(
+    size_t requested_num_of_buffers,
+    const gfx::Size& dimensions,
+    uint32_t texture_target) {
+  DVLOG(5) << "ProvidePictureBuffers("
+           << "requested_num_of_buffers=" << requested_num_of_buffers
+           << ", dimensions=" << dimensions.ToString() << ")";
+  DCHECK(thread_checker_.CalledOnValidThread());
+  coded_size_ = dimensions;
+  // TODO(owenlin): use VDA::GetOutputFormat() here and calculate correct
+  //                |buffer_size|.
+  VideoFormat video_format;
+  video_format.buffer_size = dimensions.GetArea() * 3 / 2;
+  output_buffer_size_ = video_format.buffer_size;
+  video_format.min_num_buffers = requested_num_of_buffers;
+  video_format.coded_width = dimensions.width();
+  video_format.coded_height = dimensions.height();
+  // TODO(owenlin): How to get visible size?
+  video_format.crop_top = 0;
+  video_format.crop_left = 0;
+  video_format.crop_width = dimensions.width();
+  video_format.crop_height = dimensions.height();
+  arc_client_->OnOutputFormatChanged(video_format);
+}
+
+void ArcGpuVideoDecodeAccelerator::DismissPictureBuffer(
+    int32_t picture_buffer) {
+  // no-op
+}
+
+void ArcGpuVideoDecodeAccelerator::PictureReady(const media::Picture& picture) {
+  DVLOG(5) << "PictureReady(picture_buffer_id=" << picture.picture_buffer_id()
+           << ", bitstream_buffer_id=" << picture.bitstream_buffer_id();
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // Empty buffer, returned in Flushing.
+  if (picture.bitstream_buffer_id() == -1) {
+    buffers_pending_eos_.push(picture.picture_buffer_id());
+    return;
+  }
+  InputRecord* input_record = FindInputRecord(picture.bitstream_buffer_id());
+  if (input_record == nullptr) {
+    DLOG(ERROR) << "Cannot find for bitstream buffer id: "
+                << picture.bitstream_buffer_id();
+    arc_client_->OnError(PLATFORM_FAILURE);
+    return;
+  }
+
+  BufferMetadata metadata;
+  metadata.timestamp = input_record->timestamp;
+  metadata.bytes_used = output_buffer_size_;
+  arc_client_->OnBufferDone(PORT_OUTPUT, picture.picture_buffer_id(), metadata);
+}
+
+void ArcGpuVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer(
+    int32_t bitstream_buffer_id) {
+  DVLOG(5) << "NotifyEndOfBitstreamBuffer(" << bitstream_buffer_id << ")";
+  DCHECK(thread_checker_.CalledOnValidThread());
+  InputRecord* input_record = FindInputRecord(bitstream_buffer_id);
+  if (input_record == nullptr) {
+    arc_client_->OnError(PLATFORM_FAILURE);
+    return;
+  }
+  arc_client_->OnBufferDone(PORT_INPUT, input_record->buffer_index,
+                            BufferMetadata());
+}
+
+void ArcGpuVideoDecodeAccelerator::NotifyFlushDone() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  pending_eos_output_buffer_ = true;
+  while (!buffers_pending_eos_.empty()) {
+    SendEosIfNeededOrReusePicture(buffers_pending_eos_.front());
+    buffers_pending_eos_.pop();
+  }
+}
+
+void ArcGpuVideoDecodeAccelerator::NotifyResetDone() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  base::ResetAndReturn(&reset_done_callback_).Run();
+}
+
+static ArcVideoAccelerator::Error ConvertErrorCode(
+    media::VideoDecodeAccelerator::Error error) {
+  switch (error) {
+    case media::VideoDecodeAccelerator::ILLEGAL_STATE:
+      return ArcVideoAccelerator::ILLEGAL_STATE;
+    case media::VideoDecodeAccelerator::INVALID_ARGUMENT:
+      return ArcVideoAccelerator::INVALID_ARGUMENT;
+    case media::VideoDecodeAccelerator::UNREADABLE_INPUT:
+      return ArcVideoAccelerator::UNREADABLE_INPUT;
+    case media::VideoDecodeAccelerator::PLATFORM_FAILURE:
+      return ArcVideoAccelerator::PLATFORM_FAILURE;
+    default:
+      DLOG(ERROR) << "Unknown error: " << error;
+      return ArcVideoAccelerator::PLATFORM_FAILURE;
+  }
+}
+
+void ArcGpuVideoDecodeAccelerator::NotifyError(
+    media::VideoDecodeAccelerator::Error error) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DLOG(ERROR) << "Error notified: " << error;
+  arc_client_->OnError(ConvertErrorCode(error));
+}
+
+void ArcGpuVideoDecodeAccelerator::SendEosIfNeededOrReusePicture(
+    uint32_t index) {
+  if (pending_eos_output_buffer_) {
+    BufferMetadata metadata;
+    metadata.flags = BUFFER_FLAG_EOS;
+    arc_client_->OnBufferDone(PORT_OUTPUT, index, metadata);
+    pending_eos_output_buffer_ = false;
+  } else {
+    if (pending_import_buffer_[index].is_valid()) {
+      std::vector<gfx::GpuMemoryBufferHandle> buffers;
+      buffers.push_back(gfx::GpuMemoryBufferHandle());
+      buffers.back().native_pixmap_handle.fd =
+          base::FileDescriptor(pending_import_buffer_[index].release(), true);
+      vda_->ImportBufferForPicture(index, buffers);
+      DCHECK(!pending_import_buffer_[index].is_valid());
+    } else {
+      vda_->ReusePictureBuffer(index);
+    }
+  }
+}
+
+void ArcGpuVideoDecodeAccelerator::SetInputRecord(int32_t bitstream_buffer_id,
+                                                  uint32_t buffer_index,
+                                                  int64_t timestamp) {
+  input_records_.push_front(
+      InputRecord(bitstream_buffer_id, buffer_index, timestamp));
+  // The same value copied from media::GpuVideoDecoder.
+  const size_t kMaxNumberOfInputRecords = 128;
+  if (input_records_.size() > kMaxNumberOfInputRecords)
+    input_records_.pop_back();
+}
+
+ArcGpuVideoDecodeAccelerator::InputRecord*
+ArcGpuVideoDecodeAccelerator::FindInputRecord(int32_t bitstream_buffer_id) {
+  for (auto& record : input_records_) {
+    if (record.bitstream_buffer_id == bitstream_buffer_id)
+      return &record;
+  }
+  return nullptr;
+}
+
+bool ArcGpuVideoDecodeAccelerator::ValidatePortAndIndex(PortType port,
+                                                        uint32_t index) {
+  switch (port) {
+    case PORT_INPUT:
+      if (index >= input_buffer_info_.size()) {
+        DLOG(ERROR) << "Invalid index: " << index;
+        return false;
+      }
+      return true;
+    case PORT_OUTPUT:
+      if (index >= pending_import_buffer_.size()) {
+        DLOG(ERROR) << "Invalid index: " << index;
+        return false;
+      }
+      return true;
+    default:
+      DLOG(ERROR) << "Invalid port: " << port;
+      return false;
+  }
+}
+
+}  // namespace arc
+}  // namespace chromeos