// Copyright 2021 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 "media/renderers/video_frame_rgba_to_yuva_converter.h"

#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "components/viz/common/gpu/raster_context_provider.h"
#include "components/viz/common/resources/resource_format_utils.h"
#include "gpu/command_buffer/client/raster_interface.h"
#include "gpu/command_buffer/client/shared_image_interface.h"
#include "gpu/command_buffer/common/mailbox_holder.h"
#include "media/base/simple_sync_token_client.h"
#include "media/base/wait_and_replace_sync_token_client.h"
#include "media/renderers/video_frame_yuv_converter.h"
#include "media/renderers/video_frame_yuv_mailboxes_holder.h"
#include "skia/ext/rgba_to_yuva.h"
#include "third_party/skia/include/core/SkImage.h"
#include "third_party/skia/include/gpu/GrDirectContext.h"
#include "ui/gfx/gpu_memory_buffer.h"

namespace {

// Given a gpu::MailboxHolder and a viz::RasterContextProvider, create scoped
// access to the texture as an SkImage.
class ScopedAcceleratedSkImage {
 public:
  static std::unique_ptr<ScopedAcceleratedSkImage> Create(
      viz::RasterContextProvider* provider,
      viz::ResourceFormat format,
      const gfx::Size& size,
      const gfx::ColorSpace& color_space,
      GrSurfaceOrigin surface_origin,
      const gpu::MailboxHolder& mailbox_holder) {
    auto* ri = provider->RasterInterface();
    DCHECK(ri);
    GrDirectContext* gr_context = provider->GrContext();
    DCHECK(gr_context);

    if (!mailbox_holder.mailbox.IsSharedImage()) {
      DLOG(ERROR) << "Cannot created SkImage for non-SharedImage mailbox.";
      return nullptr;
    }

    ri->WaitSyncTokenCHROMIUM(mailbox_holder.sync_token.GetConstData());

    uint32_t texture_id =
        ri->CreateAndConsumeForGpuRaster(mailbox_holder.mailbox);
    if (!texture_id) {
      DLOG(ERROR) << "Failed to create texture for mailbox.";
      return nullptr;
    }
    ri->BeginSharedImageAccessDirectCHROMIUM(
        texture_id, GL_SHARED_IMAGE_ACCESS_MODE_READ_CHROMIUM);

    GrGLTextureInfo gl_info = {
        mailbox_holder.texture_target,
        texture_id,
        viz::TextureStorageFormat(format),
    };
    GrBackendTexture backend_texture(size.width(), size.height(),
                                     GrMipmapped::kNo, gl_info);

    SkColorType color_type = viz::ResourceFormatToClosestSkColorType(
        /*gpu_compositing=*/true, format);
    sk_sp<SkImage> sk_image = SkImage::MakeFromTexture(
        gr_context, backend_texture, surface_origin, color_type,
        kOpaque_SkAlphaType, color_space.ToSkColorSpace());
    if (!sk_image) {
      DLOG(ERROR) << "Failed to SkImage for StaticBitmapImage.";
      ri->EndSharedImageAccessDirectCHROMIUM(texture_id);
      ri->DeleteGpuRasterTexture(texture_id);
      return nullptr;
    }

    return base::WrapUnique<ScopedAcceleratedSkImage>(
        new ScopedAcceleratedSkImage(provider, texture_id,
                                     std::move(sk_image)));
  }

  ~ScopedAcceleratedSkImage() {
    auto* ri = provider_->RasterInterface();
    DCHECK(ri);
    GrDirectContext* gr_context = provider_->GrContext();
    DCHECK(gr_context);

    sk_image_ = nullptr;
    if (texture_id_) {
      ri->EndSharedImageAccessDirectCHROMIUM(texture_id_);
      ri->DeleteGpuRasterTexture(texture_id_);
    }
  }

  sk_sp<SkImage> sk_image() { return sk_image_; }

 private:
  ScopedAcceleratedSkImage(viz::RasterContextProvider* provider,
                           uint32_t texture_id,
                           sk_sp<SkImage> sk_image)
      : provider_(provider), texture_id_(texture_id), sk_image_(sk_image) {}

  viz::RasterContextProvider* const provider_;
  uint32_t texture_id_ = 0;
  sk_sp<SkImage> sk_image_;
};

}  // namespace

namespace media {

bool CopyRGBATextureToVideoFrame(viz::RasterContextProvider* provider,
                                 viz::ResourceFormat src_format,
                                 const gfx::Size& src_size,
                                 const gfx::ColorSpace& src_color_space,
                                 GrSurfaceOrigin src_surface_origin,
                                 const gpu::MailboxHolder& src_mailbox_holder,
                                 VideoFrame* dst_video_frame,
                                 gpu::SyncToken& completion_sync_token) {
  DCHECK_EQ(dst_video_frame->format(), PIXEL_FORMAT_NV12);

  auto* ri = provider->RasterInterface();
  DCHECK(ri);

  if (!provider->GrContext()) {
    SkYUVAInfo yuva_info =
        VideoFrameYUVMailboxesHolder::VideoFrameGetSkYUVAInfo(dst_video_frame);
    gpu::Mailbox yuva_mailboxes[SkYUVAInfo::kMaxPlanes];
    ri->WaitSyncTokenCHROMIUM(src_mailbox_holder.sync_token.GetConstData());
    for (int plane = 0; plane < yuva_info.numPlanes(); ++plane) {
      gpu::MailboxHolder dst_mailbox_holder =
          dst_video_frame->mailbox_holder(plane);
      ri->WaitSyncTokenCHROMIUM(dst_mailbox_holder.sync_token.GetConstData());
      yuva_mailboxes[plane] = dst_mailbox_holder.mailbox;
    }
    ri->ConvertRGBAToYUVAMailboxes(
        yuva_info.yuvColorSpace(), yuva_info.planeConfig(),
        yuva_info.subsampling(), yuva_mailboxes, src_mailbox_holder.mailbox);
  } else {
    // Create an accelerated SkImage for the source.
    auto scoped_sk_image = ScopedAcceleratedSkImage::Create(
        provider, src_format, src_size, src_color_space, src_surface_origin,
        src_mailbox_holder);
    if (!scoped_sk_image) {
      DLOG(ERROR) << "Failed to create accelerated SkImage for RGBA to YUVA "
                     "conversion.";
      return false;
    }

    // Create SkSurfaces for the destination planes.
    sk_sp<SkSurface> sk_surfaces[SkYUVAInfo::kMaxPlanes];
    SkSurface* sk_surface_ptrs[SkYUVAInfo::kMaxPlanes] = {nullptr};
    VideoFrameYUVMailboxesHolder holder;
    if (!holder.VideoFrameToPlaneSkSurfaces(dst_video_frame, provider,
                                            sk_surfaces)) {
      DLOG(ERROR) << "Failed to create SkSurfaces for VideoFrame.";
      return false;
    }

    // Make GrContext wait for `dst_video_frame`. Waiting on the mailbox tokens
    // here ensures that all writes are completed in cases where the underlying
    // GpuMemoryBuffer and SharedImage resources have been reused.
    ri->Flush();
    WaitAndReplaceSyncTokenClient client(ri);
    for (int plane = 0; plane < holder.yuva_info().numPlanes(); ++plane) {
      sk_surface_ptrs[plane] = sk_surfaces[plane].get();
      dst_video_frame->UpdateMailboxHolderSyncToken(plane, &client);
    }

    // Do the blit.
    skia::BlitRGBAToYUVA(scoped_sk_image->sk_image().get(), sk_surface_ptrs,
                         holder.yuva_info());
    provider->GrContext()->flushAndSubmit(false);
  }
  ri->Flush();

  const size_t num_planes = dst_video_frame->layout().num_planes();

  // For shared memory GMBs on Windows we needed to explicitly request a copy
  // from the shared image GPU texture to the GMB. Set `completion_sync_token`
  // to mark the completion of the copy.
  if (dst_video_frame->HasGpuMemoryBuffer() &&
      dst_video_frame->GetGpuMemoryBuffer()->GetType() ==
          gfx::SHARED_MEMORY_BUFFER) {
    auto* sii = provider->SharedImageInterface();

    gpu::SyncToken blit_done_sync_token;
    ri->GenUnverifiedSyncTokenCHROMIUM(blit_done_sync_token.GetData());

    for (size_t plane = 0; plane < num_planes; ++plane) {
      const auto& mailbox = dst_video_frame->mailbox_holder(plane).mailbox;
      sii->CopyToGpuMemoryBuffer(blit_done_sync_token, mailbox);
    }

    completion_sync_token = sii->GenVerifiedSyncToken();
  } else {
    ri->GenSyncTokenCHROMIUM(completion_sync_token.GetData());
  }

  // Make access to the `dst_video_frame` wait on copy completion. We also
  // update the ReleaseSyncToken here since it's used when the underlying
  // GpuMemoryBuffer and SharedImage resources are returned to the pool.
  SimpleSyncTokenClient simple_client(completion_sync_token);
  for (size_t plane = 0; plane < num_planes; ++plane)
    dst_video_frame->UpdateMailboxHolderSyncToken(plane, &simple_client);
  dst_video_frame->UpdateReleaseSyncToken(&simple_client);
  return true;
}

}  // namespace media