components/arc/video_accelerator/gpu_arc_video_protected_buffer_allocator.cc

// Copyright 2018 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 "components/arc/video_accelerator/gpu_arc_video_protected_buffer_allocator.h"

#include <limits>
#include <utility>

#include "base/files/platform_file.h"
#include "base/files/scoped_file.h"
#include "base/numerics/safe_conversions.h"
#include "components/arc/video_accelerator/arc_video_accelerator_util.h"
#include "components/arc/video_accelerator/protected_buffer_allocator.h"
#include "components/arc/video_accelerator/protected_buffer_manager.h"
#include "media/gpu/format_utils.h"
#include "mojo/public/c/system/types.h"
#include "mojo/public/cpp/system/platform_handle.h"
#include "ui/gfx/geometry/size.h"

#define VLOGF(level) VLOG(level) << __func__ << "(): "

namespace arc {
// static
std::unique_ptr<GpuArcVideoProtectedBufferAllocator>
GpuArcVideoProtectedBufferAllocator::Create(
    scoped_refptr<ProtectedBufferManager> protected_buffer_manager) {
  auto protected_buffer_allocator =
      protected_buffer_manager->CreateProtectedBufferAllocator(
          protected_buffer_manager);
  if (!protected_buffer_allocator)
    return nullptr;
  return std::unique_ptr<GpuArcVideoProtectedBufferAllocator>(
      new GpuArcVideoProtectedBufferAllocator(
          std::move(protected_buffer_allocator)));
}

GpuArcVideoProtectedBufferAllocator::GpuArcVideoProtectedBufferAllocator(
    std::unique_ptr<ProtectedBufferAllocator> protected_buffer_allocator)
    : protected_buffer_allocator_(std::move(protected_buffer_allocator)) {}

GpuArcVideoProtectedBufferAllocator::~GpuArcVideoProtectedBufferAllocator() {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  VLOGF(2);
}

void GpuArcVideoProtectedBufferAllocator::AllocateProtectedSharedMemory(
    mojo::ScopedHandle handle_fd,
    uint64_t size,
    AllocateProtectedSharedMemoryCallback callback) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  base::ScopedFD fd = UnwrapFdFromMojoHandle(std::move(handle_fd));
  if (!fd.is_valid()) {
    std::move(callback).Run(false);
    return;
  }
  if (!base::IsValueInRangeForNumericType<size_t>(size)) {
    VLOGF(1) << "size is too large to fit in size_t"
             << ", size=" << size
             << ", size_t max=" << std::numeric_limits<size_t>::max();
    std::move(callback).Run(false);
    return;
  }
  VLOGF(2) << "size=" << size;
  std::move(callback).Run(
      protected_buffer_allocator_->AllocateProtectedSharedMemory(
          std::move(fd), static_cast<size_t>(size)));
}

void GpuArcVideoProtectedBufferAllocator::AllocateProtectedNativePixmap(
    mojo::ScopedHandle handle_fd,
    mojom::HalPixelFormat format,
    const gfx::Size& picture_size,
    AllocateProtectedNativePixmapCallback callback) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  base::ScopedFD fd = UnwrapFdFromMojoHandle(std::move(handle_fd));
  if (!fd.is_valid()) {
    std::move(callback).Run(false);
    return;
  }
  media::VideoPixelFormat pixel_format;
  switch (format) {
    case arc::mojom::HalPixelFormat::HAL_PIXEL_FORMAT_YV12:
      pixel_format = media::PIXEL_FORMAT_YV12;
      break;
    case arc::mojom::HalPixelFormat::HAL_PIXEL_FORMAT_NV12:
      pixel_format = media::PIXEL_FORMAT_NV12;
      break;
    default:
      VLOGF(1) << "Unsupported format: " << format;
      std::move(callback).Run(false);
      return;
  }
  VLOGF(2) << "format=" << media::VideoPixelFormatToString(pixel_format)
           << ", picture_size=" << picture_size.ToString();
  std::move(callback).Run(
      protected_buffer_allocator_->AllocateProtectedNativePixmap(
          std::move(fd), media::VideoPixelFormatToGfxBufferFormat(pixel_format),
          picture_size));
  return;
}

void GpuArcVideoProtectedBufferAllocator::ReleaseProtectedBuffer(
    mojo::ScopedHandle handle_fd) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  base::ScopedFD fd = UnwrapFdFromMojoHandle(std::move(handle_fd));
  if (!fd.is_valid())
    return;
  VLOGF(2);
  protected_buffer_allocator_->ReleaseProtectedBuffer(std::move(fd));
}
}  // namespace arc