// 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 "media/gpu/chromeos/libyuv_image_processor_backend.h"

#include "base/containers/contains.h"
#include "base/memory/ptr_util.h"
#include "base/numerics/checked_math.h"
#include "media/gpu/chromeos/fourcc.h"
#include "media/gpu/macros.h"
#include "media/gpu/video_frame_mapper.h"
#include "media/gpu/video_frame_mapper_factory.h"
#include "third_party/libyuv/include/libyuv/convert.h"
#include "third_party/libyuv/include/libyuv/convert_from.h"
#include "third_party/libyuv/include/libyuv/convert_from_argb.h"
#include "third_party/libyuv/include/libyuv/rotate.h"
#include "third_party/libyuv/include/libyuv/scale.h"

namespace media {

namespace {

// TODO(https://bugs.chromium.org/p/libyuv/issues/detail?id=840): Remove
// this once libyuv implements NV12Rotate() and use the libyuv::NV12Rotate().
int NV12Rotate(uint8_t* tmp_buffer,
               const uint8_t* src_y,
               int src_stride_y,
               const uint8_t* src_uv,
               int src_stride_uv,
               uint8_t* dst_y,
               int dst_stride_y,
               uint8_t* dst_uv,
               int dst_stride_uv,
               int width,
               int height,
               VideoRotation relative_rotation) {
  libyuv::RotationModeEnum rotation = libyuv::kRotate0;
  int tmp_width = width;
  int tmp_height = height;
  switch (relative_rotation) {
    case VIDEO_ROTATION_0:
      NOTREACHED() << "Unexpected rotation: " << rotation;
      return -1;
    case VIDEO_ROTATION_90:
      rotation = libyuv::kRotate90;
      tmp_width = height;
      tmp_height = width;
      break;
    case VIDEO_ROTATION_180:
      rotation = libyuv::kRotate180;
      tmp_width = width;
      tmp_height = height;
      break;
    case VIDEO_ROTATION_270:
      rotation = libyuv::kRotate270;
      tmp_width = height;
      tmp_height = width;
      break;
  }

  // Rotating.
  int tmp_uv_width = 0;
  int tmp_uv_height = 0;
  if (!(base::CheckAdd<int>(tmp_width, 1) / 2).AssignIfValid(&tmp_uv_width) ||
      !(base::CheckAdd<int>(tmp_height, 1) / 2).AssignIfValid(&tmp_uv_height)) {
    VLOGF(1) << "Overflow occurred for " << tmp_width << "x" << tmp_height;
    return -1;
  }
  uint8_t* const tmp_u = tmp_buffer;
  uint8_t* const tmp_v = tmp_u + tmp_uv_width * tmp_uv_height;

  // Rotate the NV12 planes to I420.
  int ret = libyuv::NV12ToI420Rotate(
      src_y, src_stride_y, src_uv, src_stride_uv, dst_y, dst_stride_y, tmp_u,
      tmp_uv_width, tmp_v, tmp_uv_width, width, height, rotation);
  if (ret != 0)
    return ret;

  // Merge the UV planes into the destination.
  libyuv::MergeUVPlane(tmp_u, tmp_uv_width, tmp_v, tmp_uv_width, dst_uv,
                       dst_stride_uv, tmp_uv_width, tmp_uv_height);
  return 0;
}

enum class SupportResult {
  Supported,
  SupportedWithI420Pivot,
  SupportedWithNV12Pivot,
  Unsupported,
};

enum class Transform {
  kConversion,
  kScaling,
  kRotation,
};

SupportResult IsConversionSupported(Fourcc input_fourcc,
                                    Fourcc output_fourcc,
                                    Transform transform) {
  static constexpr struct {
    uint32_t input;
    uint32_t output;
    Transform transform;
    SupportResult support_result;
  } kSupportFormatConversionArray[] = {
#define CONV(in, out, trans, result) \
  {Fourcc::in, Fourcc::out, Transform::trans, SupportResult::result}
      // Conversion.
      CONV(AB24, NV12, kConversion, SupportedWithI420Pivot),
      CONV(AR24, NV12, kConversion, Supported),
      CONV(NV12, NV12, kConversion, Supported),
      CONV(XB24, NV12, kConversion, SupportedWithI420Pivot),
      CONV(YM16, NV12, kConversion, Supported),
      CONV(YM16, YU12, kConversion, Supported),
      CONV(YU12, NV12, kConversion, Supported),
      CONV(YU12, YU12, kConversion, Supported),
      CONV(YUYV, NV12, kConversion, Supported),
      CONV(YUYV, YU12, kConversion, Supported),
      CONV(YV12, NV12, kConversion, Supported),
      // Scaling.
      CONV(NV12, NV12, kScaling, Supported),
      CONV(YM16, NV12, kScaling, SupportedWithNV12Pivot),
      CONV(YM16, YU12, kScaling, SupportedWithI420Pivot),
      CONV(YU12, YU12, kScaling, Supported),
      CONV(YUYV, NV12, kScaling, SupportedWithNV12Pivot),
      CONV(YUYV, YU12, kScaling, SupportedWithI420Pivot),
      // Rotating.
      CONV(NV12, NV12, kRotation, SupportedWithI420Pivot),
#undef CONV
  };

  const auto single_input_fourcc = input_fourcc.ToSinglePlanar();
  const auto single_output_fourcc = output_fourcc.ToSinglePlanar();
  if (!single_input_fourcc || !single_output_fourcc)
    return SupportResult::Unsupported;

  // Compare fourccs by formatting single planar formats because LibyuvIP can
  // process either single- or multi-planar formats.
  for (const auto& conv : kSupportFormatConversionArray) {
    const auto conv_input_fourcc = Fourcc::FromUint32(conv.input);
    const auto conv_output_fourcc = Fourcc::FromUint32(conv.output);
    if (!conv_input_fourcc || !conv_output_fourcc)
      continue;
    const auto single_conv_input_fourcc = conv_input_fourcc->ToSinglePlanar();
    const auto single_conv_output_fourcc = conv_output_fourcc->ToSinglePlanar();
    if (!single_conv_input_fourcc || !single_conv_output_fourcc)
      continue;

    if (single_input_fourcc == single_conv_input_fourcc &&
        single_output_fourcc == single_conv_output_fourcc &&
        transform == conv.transform) {
      return conv.support_result;
    }
  }

  return SupportResult::Unsupported;
}

}  // namespace

// static
std::unique_ptr<ImageProcessorBackend> LibYUVImageProcessorBackend::Create(
    const PortConfig& input_config,
    const PortConfig& output_config,
    const std::vector<OutputMode>& preferred_output_modes,
    VideoRotation relative_rotation,
    ErrorCB error_cb,
    scoped_refptr<base::SequencedTaskRunner> backend_task_runner) {
  VLOGF(2);

  std::unique_ptr<VideoFrameMapper> input_frame_mapper;
  // LibYUVImageProcessorBackend supports only memory-based video frame for
  // input.
  VideoFrame::StorageType input_storage_type = VideoFrame::STORAGE_UNKNOWN;
  for (auto input_type : input_config.preferred_storage_types) {
    if (input_type == VideoFrame::STORAGE_DMABUFS ||
        input_type == VideoFrame::STORAGE_GPU_MEMORY_BUFFER) {
      input_frame_mapper = VideoFrameMapperFactory::CreateMapper(
          input_config.fourcc.ToVideoPixelFormat(), input_type, true);
      if (input_frame_mapper) {
        input_storage_type = input_type;
        break;
      }
    }

    if (VideoFrame::IsStorageTypeMappable(input_type)) {
      input_storage_type = input_type;
      break;
    }
  }
  if (input_storage_type == VideoFrame::STORAGE_UNKNOWN) {
    VLOGF(2) << "Unsupported input storage type";
    return nullptr;
  }

  std::unique_ptr<VideoFrameMapper> output_frame_mapper;
  VideoFrame::StorageType output_storage_type = VideoFrame::STORAGE_UNKNOWN;
  for (auto output_type : output_config.preferred_storage_types) {
    if (output_type == VideoFrame::STORAGE_DMABUFS ||
        output_type == VideoFrame::STORAGE_GPU_MEMORY_BUFFER) {
      output_frame_mapper = VideoFrameMapperFactory::CreateMapper(
          output_config.fourcc.ToVideoPixelFormat(), output_type, true);
      if (output_frame_mapper) {
        output_storage_type = output_type;
        break;
      }
    }

    if (VideoFrame::IsStorageTypeMappable(output_type)) {
      output_storage_type = output_type;
      break;
    }
  }
  if (output_storage_type == VideoFrame::STORAGE_UNKNOWN) {
    VLOGF(2) << "Unsupported output storage type";
    return nullptr;
  }

  if (!base::Contains(preferred_output_modes, OutputMode::IMPORT)) {
    VLOGF(2) << "Only support OutputMode::IMPORT";
    return nullptr;
  }

  const gfx::Size& input_size = input_config.visible_rect.size();
  const gfx::Size& output_size = output_config.visible_rect.size();
  Transform transform = Transform::kConversion;
  if (relative_rotation != VIDEO_ROTATION_0) {
    transform = Transform::kRotation;
    bool size_mismatch = false;
    if (relative_rotation == VIDEO_ROTATION_180) {
      size_mismatch = input_size.width() != output_size.width() ||
                      input_size.height() != output_size.height();
    } else {  // For VIDEO_ROTATION_90 and 270.
      size_mismatch = input_size.width() != output_size.height() ||
                      input_size.height() != output_size.width();
    }
    if (size_mismatch) {
      VLOGF(1) << "input and output resolution mismatch: "
               << "input=" << input_size.ToString()
               << ", output=" << output_size.ToString();
      return nullptr;
    }
  } else if (input_size.width() != output_size.width() ||
             input_size.height() != output_size.height()) {
    transform = Transform::kScaling;
  }
  SupportResult res = IsConversionSupported(input_config.fourcc,
                                            output_config.fourcc, transform);
  if (res == SupportResult::Unsupported) {
    VLOGF(2) << "Conversion from " << input_size.ToString() << "/"
             << input_config.fourcc.ToString() << " to "
             << output_size.ToString() << "/" << output_config.fourcc.ToString()
             << " with rotation " << relative_rotation << " is not supported";
    return nullptr;
  }

  if (input_config.fourcc.ToVideoPixelFormat() ==
      output_config.fourcc.ToVideoPixelFormat()) {
    if (output_config.visible_rect.origin() != gfx::Point(0, 0)) {
      VLOGF(2) << "Output visible rectangle is not (0, 0), "
               << "output_config.visible_rect="
               << output_config.visible_rect.ToString();
      return nullptr;
    }
  }

  scoped_refptr<VideoFrame> intermediate_frame;
  if (res == SupportResult::SupportedWithI420Pivot ||
      res == SupportResult::SupportedWithNV12Pivot) {
    intermediate_frame = VideoFrame::CreateFrame(
        res == SupportResult::SupportedWithI420Pivot ? PIXEL_FORMAT_I420
                                                     : PIXEL_FORMAT_NV12,
        input_config.visible_rect.size(),
        gfx::Rect(input_config.visible_rect.size()),
        input_config.visible_rect.size(), base::TimeDelta());
    if (!intermediate_frame) {
      VLOGF(1) << "Failed to create intermediate frame";
      return nullptr;
    }
  }

  auto processor =
      base::WrapUnique<ImageProcessorBackend>(new LibYUVImageProcessorBackend(
          std::move(input_frame_mapper), std::move(output_frame_mapper),
          std::move(intermediate_frame),
          PortConfig(input_config.fourcc, input_config.size,
                     input_config.planes, input_config.visible_rect,
                     {input_storage_type}),
          PortConfig(output_config.fourcc, output_config.size,
                     output_config.planes, output_config.visible_rect,
                     {output_storage_type}),
          OutputMode::IMPORT, relative_rotation, std::move(error_cb),
          std::move(backend_task_runner)));
  VLOGF(2) << "LibYUVImageProcessorBackend created for converting from "
           << input_config.ToString() << " to " << output_config.ToString();
  return processor;
}

LibYUVImageProcessorBackend::LibYUVImageProcessorBackend(
    std::unique_ptr<VideoFrameMapper> input_frame_mapper,
    std::unique_ptr<VideoFrameMapper> output_frame_mapper,
    scoped_refptr<VideoFrame> intermediate_frame,
    const PortConfig& input_config,
    const PortConfig& output_config,
    OutputMode output_mode,
    VideoRotation relative_rotation,
    ErrorCB error_cb,
    scoped_refptr<base::SequencedTaskRunner> backend_task_runner)
    : ImageProcessorBackend(input_config,
                            output_config,
                            output_mode,
                            relative_rotation,
                            std::move(error_cb),
                            std::move(backend_task_runner)),
      input_frame_mapper_(std::move(input_frame_mapper)),
      output_frame_mapper_(std::move(output_frame_mapper)),
      intermediate_frame_(std::move(intermediate_frame)) {}

LibYUVImageProcessorBackend::~LibYUVImageProcessorBackend() {
  DCHECK_CALLED_ON_VALID_SEQUENCE(backend_sequence_checker_);
}

void LibYUVImageProcessorBackend::Process(
    scoped_refptr<VideoFrame> input_frame,
    scoped_refptr<VideoFrame> output_frame,
    FrameReadyCB cb) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(backend_sequence_checker_);
  DVLOGF(4);
  if (input_frame->storage_type() == VideoFrame::STORAGE_DMABUFS ||
      input_frame->storage_type() == VideoFrame::STORAGE_GPU_MEMORY_BUFFER) {
    DCHECK_NE(input_frame_mapper_.get(), nullptr);
    input_frame = input_frame_mapper_->Map(std::move(input_frame));
    if (!input_frame) {
      VLOGF(1) << "Failed to map input VideoFrame";
      error_cb_.Run();
      return;
    }
  }

  // We don't replace |output_frame| with a mapped frame, because |output_frame|
  // is the output of ImageProcessor.
  scoped_refptr<VideoFrame> mapped_frame = output_frame;
  if (output_frame->storage_type() == VideoFrame::STORAGE_DMABUFS ||
      output_frame->storage_type() == VideoFrame::STORAGE_GPU_MEMORY_BUFFER) {
    DCHECK_NE(output_frame_mapper_.get(), nullptr);
    mapped_frame = output_frame_mapper_->Map(output_frame);
    if (!mapped_frame) {
      VLOGF(1) << "Failed to map output VideoFrame";
      error_cb_.Run();
      return;
    }
  }
  int res = DoConversion(input_frame.get(), mapped_frame.get());
  if (res != 0) {
    VLOGF(1) << "libyuv returns non-zero code: " << res;
    error_cb_.Run();
    return;
  }
  output_frame->set_timestamp(input_frame->timestamp());

  std::move(cb).Run(std::move(output_frame));
}

int LibYUVImageProcessorBackend::DoConversion(const VideoFrame* const input,
                                              VideoFrame* const output) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(backend_sequence_checker_);

#define Y_U_V_DATA(fr)                                                        \
  fr->visible_data(VideoFrame::kYPlane), fr->stride(VideoFrame::kYPlane),     \
      fr->visible_data(VideoFrame::kUPlane), fr->stride(VideoFrame::kUPlane), \
      fr->visible_data(VideoFrame::kVPlane), fr->stride(VideoFrame::kVPlane)

#define Y_V_U_DATA(fr)                                                        \
  fr->visible_data(VideoFrame::kYPlane), fr->stride(VideoFrame::kYPlane),     \
      fr->visible_data(VideoFrame::kVPlane), fr->stride(VideoFrame::kVPlane), \
      fr->visible_data(VideoFrame::kUPlane), fr->stride(VideoFrame::kUPlane)

#define Y_UV_DATA(fr)                                                     \
  fr->visible_data(VideoFrame::kYPlane), fr->stride(VideoFrame::kYPlane), \
      fr->visible_data(VideoFrame::kUVPlane), fr->stride(VideoFrame::kUVPlane)

#define YUY2_DATA(fr) \
  fr->visible_data(VideoFrame::kYPlane), fr->stride(VideoFrame::kYPlane)

#define RGB_DATA(fr) \
  fr->visible_data(VideoFrame::kARGBPlane), fr->stride(VideoFrame::kARGBPlane)

#define LIBYUV_FUNC(func, i, o)                      \
  libyuv::func(i, o, output->visible_rect().width(), \
               output->visible_rect().height())

  if (output->format() == PIXEL_FORMAT_NV12) {
    switch (input->format()) {
      case PIXEL_FORMAT_I420:
        return LIBYUV_FUNC(I420ToNV12, Y_U_V_DATA(input), Y_UV_DATA(output));
      case PIXEL_FORMAT_YV12:
        return LIBYUV_FUNC(I420ToNV12, Y_V_U_DATA(input), Y_UV_DATA(output));

      // RGB conversions. NOTE: Libyuv functions called here are named in
      // little-endian manner.
      case PIXEL_FORMAT_ARGB:
        return LIBYUV_FUNC(ARGBToNV12, RGB_DATA(input), Y_UV_DATA(output));
      case PIXEL_FORMAT_XBGR:
      case PIXEL_FORMAT_ABGR: {
        // There is no libyuv function to convert to RGBA to NV12. Therefore, we
        // convert RGBA to I420 tentatively and thereafter convert the tentative
        // one to NV12.
        DCHECK_EQ(intermediate_frame_->format(), PIXEL_FORMAT_I420);
        int ret = LIBYUV_FUNC(ABGRToI420, RGB_DATA(input),
                              Y_U_V_DATA(intermediate_frame_));
        if (ret != 0)
          return ret;
        return LIBYUV_FUNC(I420ToNV12, Y_U_V_DATA(intermediate_frame_),
                           Y_UV_DATA(output));
      }
      case PIXEL_FORMAT_NV12:
        // Rotation mode.
        if (relative_rotation_ != VIDEO_ROTATION_0) {
          // The size of |tmp_buffer| of NV12Rotate() should be
          // 2 * ceil(|output_visible_rect_.width()| / 2) *
          // ceil(|output_visible_rect_.height()| / 2), which used to store
          // temporary U and V planes for I420 data. Although
          // |intermediate_frame_->data(0)| is much larger than the required
          // size, we use the frame to simplify the code.
          return NV12Rotate(intermediate_frame_->data(0), Y_UV_DATA(input),
                            Y_UV_DATA(output), input->visible_rect().width(),
                            input->visible_rect().height(), relative_rotation_);
        }
        // Scaling mode.
        return libyuv::NV12Scale(
            Y_UV_DATA(input), input->visible_rect().width(),
            input->visible_rect().height(), Y_UV_DATA(output),
            output->visible_rect().width(), output->visible_rect().height(),
            libyuv::kFilterBilinear);

      case PIXEL_FORMAT_YUY2:
        if (input->visible_rect().size() == output->visible_rect().size()) {
          return LIBYUV_FUNC(YUY2ToNV12, YUY2_DATA(input), Y_UV_DATA(output));
        } else {
          DCHECK_EQ(intermediate_frame_->format(), PIXEL_FORMAT_NV12);
          int ret = libyuv::YUY2ToNV12(
              YUY2_DATA(input), Y_UV_DATA(intermediate_frame_),
              intermediate_frame_->visible_rect().width(),
              intermediate_frame_->visible_rect().height());
          if (ret != 0)
            return ret;
          return libyuv::NV12Scale(
              Y_UV_DATA(intermediate_frame_),
              intermediate_frame_->visible_rect().width(),
              intermediate_frame_->visible_rect().height(), Y_UV_DATA(output),
              output->visible_rect().width(), output->visible_rect().height(),
              libyuv::kFilterBilinear);
        }
      case PIXEL_FORMAT_I422:
        if (input->visible_rect().size() == output->visible_rect().size()) {
          return LIBYUV_FUNC(I422ToNV21, Y_V_U_DATA(input), Y_UV_DATA(output));
        } else {
          DCHECK_EQ(intermediate_frame_->format(), PIXEL_FORMAT_NV12);
          int ret = libyuv::I422ToNV21(
              Y_V_U_DATA(input), Y_UV_DATA(intermediate_frame_),
              intermediate_frame_->visible_rect().width(),
              intermediate_frame_->visible_rect().height());
          if (ret != 0)
            return ret;
          return libyuv::NV12Scale(
              Y_UV_DATA(intermediate_frame_),
              intermediate_frame_->visible_rect().width(),
              intermediate_frame_->visible_rect().height(), Y_UV_DATA(output),
              output->visible_rect().width(), output->visible_rect().height(),
              libyuv::kFilterBilinear);
        }
      default:
        VLOGF(1) << "Unexpected input format: " << input->format();
        return -1;
    }
  }

  if (output->format() == PIXEL_FORMAT_I420) {
    switch (input->format()) {
      case PIXEL_FORMAT_I420:
        return libyuv::I420Scale(
            Y_U_V_DATA(input), input->visible_rect().width(),
            input->visible_rect().height(), Y_U_V_DATA(output),
            output->visible_rect().width(), output->visible_rect().height(),
            libyuv::kFilterBilinear);
      case PIXEL_FORMAT_YUY2:
        if (input->visible_rect().size() == output->visible_rect().size()) {
          return LIBYUV_FUNC(YUY2ToI420, YUY2_DATA(input), Y_U_V_DATA(output));
        } else {
          DCHECK_EQ(intermediate_frame_->format(), PIXEL_FORMAT_I420);
          int ret = libyuv::YUY2ToI420(
              YUY2_DATA(input), Y_U_V_DATA(intermediate_frame_),
              intermediate_frame_->visible_rect().width(),
              intermediate_frame_->visible_rect().height());
          if (ret != 0)
            return ret;
          return libyuv::I420Scale(
              Y_U_V_DATA(intermediate_frame_),
              intermediate_frame_->visible_rect().width(),
              intermediate_frame_->visible_rect().height(), Y_U_V_DATA(output),
              output->visible_rect().width(), output->visible_rect().height(),
              libyuv::kFilterBilinear);
        }
      case PIXEL_FORMAT_I422:
        if (input->visible_rect().size() == output->visible_rect().size()) {
          return LIBYUV_FUNC(I422ToI420, Y_U_V_DATA(input), Y_U_V_DATA(output));
        } else {
          DCHECK_EQ(intermediate_frame_->format(), PIXEL_FORMAT_I420);
          int ret = libyuv::I422ToI420(
              Y_U_V_DATA(input), Y_U_V_DATA(intermediate_frame_),
              intermediate_frame_->visible_rect().width(),
              intermediate_frame_->visible_rect().height());
          if (ret != 0)
            return ret;
          return libyuv::I420Scale(
              Y_U_V_DATA(intermediate_frame_),
              intermediate_frame_->visible_rect().width(),
              intermediate_frame_->visible_rect().height(), Y_U_V_DATA(output),
              output->visible_rect().width(), output->visible_rect().height(),
              libyuv::kFilterBilinear);
        }
      default:
        VLOGF(1) << "Unexpected input format: " << input->format();
        return -1;
    }
  }

#undef Y_U_V_DATA
#undef Y_V_U_DATA
#undef Y_UV_DATA
#undef RGB_DATA
#undef LIBYUV_FUNC

  VLOGF(1) << "Unexpected output format: " << output->format();
  return -1;
}

}  // namespace media