// Copyright 2020 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/mac/vt_config_util.h"

#include <CoreMedia/CoreMedia.h>

#include "base/containers/span.h"
#include "base/mac/foundation_util.h"
#include "base/mac/mac_util.h"
#include "base/mac/sdk_forward_declarations.h"
#include "base/strings/sys_string_conversions.h"
#include "media/base/mac/color_space_util_mac.h"
#include "media/formats/mp4/box_definitions.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace {

std::string GetStrValue(CFDictionaryRef dict, CFStringRef key) {
  return base::SysCFStringRefToUTF8(
      base::mac::CFCastStrict<CFStringRef>(CFDictionaryGetValue(dict, key)));
}

CFStringRef GetCFStrValue(CFDictionaryRef dict, CFStringRef key) {
  return base::mac::CFCastStrict<CFStringRef>(CFDictionaryGetValue(dict, key));
}

int GetIntValue(CFDictionaryRef dict, CFStringRef key) {
  CFNumberRef value =
      base::mac::CFCastStrict<CFNumberRef>(CFDictionaryGetValue(dict, key));
  int result;
  return CFNumberGetValue(value, kCFNumberIntType, &result) ? result : -1;
}

bool GetBoolValue(CFDictionaryRef dict, CFStringRef key) {
  return CFBooleanGetValue(
      base::mac::CFCastStrict<CFBooleanRef>(CFDictionaryGetValue(dict, key)));
}

base::span<const uint8_t> GetDataValue(CFDictionaryRef dict, CFStringRef key) {
  CFDataRef data =
      base::mac::CFCastStrict<CFDataRef>(CFDictionaryGetValue(dict, key));
  return data ? base::span<const uint8_t>(
                    reinterpret_cast<const uint8_t*>(CFDataGetBytePtr(data)),
                    CFDataGetLength(data))
              : base::span<const uint8_t>();
}

base::span<const uint8_t> GetNestedDataValue(CFDictionaryRef dict,
                                             CFStringRef key1,
                                             CFStringRef key2) {
  CFDictionaryRef nested_dict = base::mac::CFCastStrict<CFDictionaryRef>(
      CFDictionaryGetValue(dict, key1));
  return GetDataValue(nested_dict, key2);
}

base::ScopedCFTypeRef<CVImageBufferRef> CreateCVImageBuffer(
    media::VideoColorSpace cs) {
  base::ScopedCFTypeRef<CFDictionaryRef> fmt(CreateFormatExtensions(
      kCMVideoCodecType_H264, media::H264PROFILE_MAIN, cs, gfx::HDRMetadata()));

  base::ScopedCFTypeRef<CVImageBufferRef> image_buffer;
  OSStatus err =
      CVPixelBufferCreate(kCFAllocatorDefault, 16, 16,
                          kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange,
                          nullptr, image_buffer.InitializeInto());
  if (err != noErr) {
    EXPECT_EQ(err, noErr);
    return base::ScopedCFTypeRef<CVImageBufferRef>();
  }

  CVBufferSetAttachments(image_buffer.get(), fmt,
                         kCVAttachmentMode_ShouldNotPropagate);
  return image_buffer;
}

base::ScopedCFTypeRef<CMFormatDescriptionRef> CreateFormatDescription(
    CFStringRef primaries,
    CFStringRef transfer,
    CFStringRef matrix) {
  base::ScopedCFTypeRef<CFMutableDictionaryRef> extensions(
      CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
                                &kCFTypeDictionaryKeyCallBacks,
                                &kCFTypeDictionaryValueCallBacks));

  if (primaries) {
    CFDictionarySetValue(
        extensions, kCMFormatDescriptionExtension_ColorPrimaries, primaries);
  }
  if (transfer) {
    CFDictionarySetValue(
        extensions, kCMFormatDescriptionExtension_TransferFunction, transfer);
  }
  if (matrix) {
    CFDictionarySetValue(extensions, kCMFormatDescriptionExtension_YCbCrMatrix,
                         matrix);
  }
  base::ScopedCFTypeRef<CMFormatDescriptionRef> result;
  CMFormatDescriptionCreate(nullptr, kCMMediaType_Video,
                            kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange,
                            extensions.get(), result.InitializeInto());
  return result;
}

gfx::ColorSpace ToBT709_APPLE(gfx::ColorSpace cs) {
  return gfx::ColorSpace(cs.GetPrimaryID(),
                         gfx::ColorSpace::TransferID::BT709_APPLE,
                         cs.GetMatrixID(), cs.GetRangeID());
}

void AssertHasEmptyHDRMetadata(CFDictionaryRef fmt) {
  if (__builtin_available(macos 10.13, *)) {
    // We constructed with an empty HDRMetadata, so all values should be zero.
    auto mdcv = GetDataValue(
        fmt, kCMFormatDescriptionExtension_MasteringDisplayColorVolume);
    ASSERT_EQ(24u, mdcv.size());
    for (size_t i = 0; i < mdcv.size(); ++i)
      EXPECT_EQ(0u, mdcv[i]);

    auto clli =
        GetDataValue(fmt, kCMFormatDescriptionExtension_ContentLightLevelInfo);
    ASSERT_EQ(4u, clli.size());
    for (size_t i = 0; i < clli.size(); ++i)
      EXPECT_EQ(0u, clli[i]);
  }
}

constexpr char kBitDepthKey[] = "BitsPerComponent";
constexpr char kVpccKey[] = "vpcC";

}  // namespace

namespace media {

TEST(VTConfigUtil, CreateFormatExtensions_H264_BT709) {
  base::ScopedCFTypeRef<CFDictionaryRef> fmt(
      CreateFormatExtensions(kCMVideoCodecType_H264, H264PROFILE_MAIN,
                             VideoColorSpace::REC709(), absl::nullopt));
  EXPECT_EQ("avc1", GetStrValue(fmt, kCMFormatDescriptionExtension_FormatName));
  EXPECT_EQ(24, GetIntValue(fmt, kCMFormatDescriptionExtension_Depth));
  EXPECT_EQ(kCMFormatDescriptionColorPrimaries_ITU_R_709_2,
            GetCFStrValue(fmt, kCMFormatDescriptionExtension_ColorPrimaries));
  EXPECT_EQ(kCMFormatDescriptionTransferFunction_ITU_R_709_2,
            GetCFStrValue(fmt, kCMFormatDescriptionExtension_TransferFunction));
  EXPECT_EQ(kCMFormatDescriptionYCbCrMatrix_ITU_R_709_2,
            GetCFStrValue(fmt, kCMFormatDescriptionExtension_YCbCrMatrix));
  EXPECT_FALSE(GetBoolValue(fmt, kCMFormatDescriptionExtension_FullRangeVideo));

  if (__builtin_available(macos 10.13, *)) {
    EXPECT_TRUE(
        GetDataValue(fmt,
                     kCMFormatDescriptionExtension_MasteringDisplayColorVolume)
            .empty());
    EXPECT_TRUE(
        GetDataValue(fmt, kCMFormatDescriptionExtension_ContentLightLevelInfo)
            .empty());
  }
}

TEST(VTConfigUtil, CreateFormatExtensions_H264_BT2020_PQ) {
  base::ScopedCFTypeRef<CFDictionaryRef> fmt(CreateFormatExtensions(
      kCMVideoCodecType_H264, H264PROFILE_MAIN,
      VideoColorSpace(VideoColorSpace::PrimaryID::BT2020,
                      VideoColorSpace::TransferID::SMPTEST2084,
                      VideoColorSpace::MatrixID::BT2020_NCL,
                      gfx::ColorSpace::RangeID::FULL),
      gfx::HDRMetadata()));
  EXPECT_EQ("avc1", GetStrValue(fmt, kCMFormatDescriptionExtension_FormatName));
  EXPECT_EQ(24, GetIntValue(fmt, kCMFormatDescriptionExtension_Depth));

  if (__builtin_available(macos 10.13, *)) {
    EXPECT_EQ(kCMFormatDescriptionColorPrimaries_ITU_R_2020,
              GetCFStrValue(fmt, kCMFormatDescriptionExtension_ColorPrimaries));
    EXPECT_EQ(
        kCMFormatDescriptionTransferFunction_SMPTE_ST_2084_PQ,
        GetCFStrValue(fmt, kCMFormatDescriptionExtension_TransferFunction));
    EXPECT_EQ(kCMFormatDescriptionYCbCrMatrix_ITU_R_2020,
              GetCFStrValue(fmt, kCMFormatDescriptionExtension_YCbCrMatrix));
  }
  EXPECT_TRUE(GetBoolValue(fmt, kCMFormatDescriptionExtension_FullRangeVideo));
  AssertHasEmptyHDRMetadata(fmt);
}

TEST(VTConfigUtil, CreateFormatExtensions_H264_BT2020_HLG) {
  base::ScopedCFTypeRef<CFDictionaryRef> fmt(CreateFormatExtensions(
      kCMVideoCodecType_H264, H264PROFILE_MAIN,
      VideoColorSpace(VideoColorSpace::PrimaryID::BT2020,
                      VideoColorSpace::TransferID::ARIB_STD_B67,
                      VideoColorSpace::MatrixID::BT2020_NCL,
                      gfx::ColorSpace::RangeID::FULL),
      gfx::HDRMetadata()));
  EXPECT_EQ("avc1", GetStrValue(fmt, kCMFormatDescriptionExtension_FormatName));
  EXPECT_EQ(24, GetIntValue(fmt, kCMFormatDescriptionExtension_Depth));

  if (__builtin_available(macos 10.13, *)) {
    EXPECT_EQ(kCMFormatDescriptionColorPrimaries_ITU_R_2020,
              GetCFStrValue(fmt, kCMFormatDescriptionExtension_ColorPrimaries));
    EXPECT_EQ(
        kCMFormatDescriptionTransferFunction_ITU_R_2100_HLG,
        GetCFStrValue(fmt, kCMFormatDescriptionExtension_TransferFunction));
    EXPECT_EQ(kCMFormatDescriptionYCbCrMatrix_ITU_R_2020,
              GetCFStrValue(fmt, kCMFormatDescriptionExtension_YCbCrMatrix));
  }
  EXPECT_TRUE(GetBoolValue(fmt, kCMFormatDescriptionExtension_FullRangeVideo));
  AssertHasEmptyHDRMetadata(fmt);
}

TEST(VTConfigUtil, CreateFormatExtensions_HDRMetadata) {
  // Values from real YouTube HDR content.
  gfx::HDRMetadata hdr_meta;
  hdr_meta.max_content_light_level = 1000;
  hdr_meta.max_frame_average_light_level = 600;
  auto& cv_metadata = hdr_meta.color_volume_metadata;
  cv_metadata.luminance_min = 0;
  cv_metadata.luminance_max = 1000;
  cv_metadata.primary_r = gfx::PointF(0.68, 0.32);
  cv_metadata.primary_g = gfx::PointF(0.2649, 0.69);
  cv_metadata.primary_b = gfx::PointF(0.15, 0.06);
  cv_metadata.white_point = gfx::PointF(0.3127, 0.3290);

  base::ScopedCFTypeRef<CFDictionaryRef> fmt(CreateFormatExtensions(
      kCMVideoCodecType_H264, H264PROFILE_MAIN,
      VideoColorSpace(VideoColorSpace::PrimaryID::BT2020,
                      VideoColorSpace::TransferID::SMPTEST2084,
                      VideoColorSpace::MatrixID::BT2020_NCL,
                      gfx::ColorSpace::RangeID::FULL),
      hdr_meta));
  if (__builtin_available(macos 10.13, *)) {
    {
      auto mdcv = GetDataValue(
          fmt, kCMFormatDescriptionExtension_MasteringDisplayColorVolume);
      ASSERT_EQ(24u, mdcv.size());
      std::unique_ptr<mp4::BoxReader> box_reader(
          mp4::BoxReader::ReadConcatentatedBoxes(mdcv.data(), mdcv.size(),
                                                 nullptr));
      mp4::MasteringDisplayColorVolume mdcv_box;
      ASSERT_TRUE(mdcv_box.Parse(box_reader.get()));
      EXPECT_EQ(mdcv_box.display_primaries_gx, cv_metadata.primary_g.x());
      EXPECT_EQ(mdcv_box.display_primaries_gy, cv_metadata.primary_g.y());
      EXPECT_EQ(mdcv_box.display_primaries_bx, cv_metadata.primary_b.x());
      EXPECT_EQ(mdcv_box.display_primaries_by, cv_metadata.primary_b.y());
      EXPECT_EQ(mdcv_box.display_primaries_rx, cv_metadata.primary_r.x());
      EXPECT_EQ(mdcv_box.display_primaries_ry, cv_metadata.primary_r.y());
      EXPECT_EQ(mdcv_box.white_point_x, cv_metadata.white_point.x());
      EXPECT_EQ(mdcv_box.white_point_y, cv_metadata.white_point.y());
      EXPECT_EQ(mdcv_box.max_display_mastering_luminance,
                cv_metadata.luminance_max);
      EXPECT_EQ(mdcv_box.min_display_mastering_luminance,
                cv_metadata.luminance_min);
    }

    {
      auto clli = GetDataValue(
          fmt, kCMFormatDescriptionExtension_ContentLightLevelInfo);
      ASSERT_EQ(4u, clli.size());
      std::unique_ptr<mp4::BoxReader> box_reader(
          mp4::BoxReader::ReadConcatentatedBoxes(clli.data(), clli.size(),
                                                 nullptr));
      mp4::ContentLightLevelInformation clli_box;
      ASSERT_TRUE(clli_box.Parse(box_reader.get()));
      EXPECT_EQ(clli_box.max_content_light_level,
                hdr_meta.max_content_light_level);
      EXPECT_EQ(clli_box.max_pic_average_light_level,
                hdr_meta.max_frame_average_light_level);
    }
  }
}

TEST(VTConfigUtil, CreateFormatExtensions_VP9Profile0) {
  constexpr VideoCodecProfile kTestProfile = VP9PROFILE_PROFILE0;
  const auto kTestColorSpace = VideoColorSpace::REC709();
  base::ScopedCFTypeRef<CFDictionaryRef> fmt(CreateFormatExtensions(
      kCMVideoCodecType_VP9, kTestProfile, kTestColorSpace, absl::nullopt));
  EXPECT_EQ(8, GetIntValue(fmt, base::SysUTF8ToCFStringRef(kBitDepthKey)));

  auto vpcc = GetNestedDataValue(
      fmt, kCMFormatDescriptionExtension_SampleDescriptionExtensionAtoms,
      base::SysUTF8ToCFStringRef(kVpccKey));
  std::unique_ptr<mp4::BoxReader> box_reader(
      mp4::BoxReader::ReadConcatentatedBoxes(vpcc.data(), vpcc.size(),
                                             nullptr));
  mp4::VPCodecConfigurationRecord vpcc_box;
  ASSERT_TRUE(vpcc_box.Parse(box_reader.get()));
  ASSERT_EQ(kTestProfile, vpcc_box.profile);
  ASSERT_EQ(kTestColorSpace, vpcc_box.color_space);
}

TEST(VTConfigUtil, CreateFormatExtensions_VP9Profile2) {
  constexpr VideoCodecProfile kTestProfile = VP9PROFILE_PROFILE2;
  const VideoColorSpace kTestColorSpace(
      VideoColorSpace::PrimaryID::BT2020,
      VideoColorSpace::TransferID::SMPTEST2084,
      VideoColorSpace::MatrixID::BT2020_NCL, gfx::ColorSpace::RangeID::LIMITED);
  base::ScopedCFTypeRef<CFDictionaryRef> fmt(CreateFormatExtensions(
      kCMVideoCodecType_VP9, kTestProfile, kTestColorSpace, absl::nullopt));
  EXPECT_EQ(10, GetIntValue(fmt, base::SysUTF8ToCFStringRef(kBitDepthKey)));

  auto vpcc = GetNestedDataValue(
      fmt, kCMFormatDescriptionExtension_SampleDescriptionExtensionAtoms,
      base::SysUTF8ToCFStringRef(kVpccKey));
  std::unique_ptr<mp4::BoxReader> box_reader(
      mp4::BoxReader::ReadConcatentatedBoxes(vpcc.data(), vpcc.size(),
                                             nullptr));
  mp4::VPCodecConfigurationRecord vpcc_box;
  ASSERT_TRUE(vpcc_box.Parse(box_reader.get()));
  ASSERT_EQ(kTestProfile, vpcc_box.profile);
  ASSERT_EQ(kTestColorSpace, vpcc_box.color_space);
}

TEST(VTConfigUtil, GetImageBufferColorSpace_BT601) {
  auto cs = VideoColorSpace::REC601();
  auto image_buffer = CreateCVImageBuffer(cs);
  ASSERT_TRUE(image_buffer);

  // macOS doesn't have a SMPTE170M transfer function, apps are supposed to use
  // kCMFormatDescriptionTransferFunction_ITU_R_709_2 instead for SDR content.
  cs.primaries = VideoColorSpace::PrimaryID::SMPTE240M;
  auto expected_cs = ToBT709_APPLE(cs.ToGfxColorSpace());
  EXPECT_EQ(expected_cs, GetImageBufferColorSpace(image_buffer));
}

TEST(VTConfigUtil, GetImageBufferColorSpace_BT709) {
  auto cs = VideoColorSpace::REC709();
  auto image_buffer = CreateCVImageBuffer(cs);
  ASSERT_TRUE(image_buffer);

  // macOS returns a special BT709_APPLE transfer function since it doesn't use
  // the same gamma level as is standardized.
  auto expected_cs = ToBT709_APPLE(cs.ToGfxColorSpace());
  EXPECT_EQ(expected_cs, GetImageBufferColorSpace(image_buffer));
}

TEST(VTConfigUtil, GetImageBufferColorSpace_GAMMA22) {
  auto cs = VideoColorSpace(VideoColorSpace::PrimaryID::SMPTE240M,
                            VideoColorSpace::TransferID::GAMMA22,
                            VideoColorSpace::MatrixID::SMPTE240M,
                            gfx::ColorSpace::RangeID::LIMITED);
  auto image_buffer = CreateCVImageBuffer(cs);
  ASSERT_TRUE(image_buffer);
  EXPECT_EQ(cs.ToGfxColorSpace(), GetImageBufferColorSpace(image_buffer));
}

TEST(VTConfigUtil, GetImageBufferColorSpace_GAMMA28) {
  auto cs = VideoColorSpace(VideoColorSpace::PrimaryID::SMPTE240M,
                            VideoColorSpace::TransferID::GAMMA28,
                            VideoColorSpace::MatrixID::SMPTE240M,
                            gfx::ColorSpace::RangeID::LIMITED);
  auto image_buffer = CreateCVImageBuffer(cs);
  ASSERT_TRUE(image_buffer);
  EXPECT_EQ(cs.ToGfxColorSpace(), GetImageBufferColorSpace(image_buffer));
}

TEST(VTConfigUtil, GetImageBufferColorSpace_BT2020_PQ) {
  auto cs = VideoColorSpace(VideoColorSpace::PrimaryID::BT2020,
                            VideoColorSpace::TransferID::SMPTEST2084,
                            VideoColorSpace::MatrixID::BT2020_NCL,
                            gfx::ColorSpace::RangeID::LIMITED);
  auto image_buffer = CreateCVImageBuffer(cs);
  ASSERT_TRUE(image_buffer);
  auto image_buffer_cs = GetImageBufferColorSpace(image_buffer);

  // When BT.2020 is unavailable the default should be BT.709.
  if (base::mac::IsAtLeastOS10_13()) {
    EXPECT_EQ(cs.ToGfxColorSpace(), image_buffer_cs);
  } else {
    // 10.12 doesn't have HDR transfer functions.
    cs.transfer = VideoColorSpace::TransferID::BT709;
    EXPECT_EQ(cs.ToGfxColorSpace(), image_buffer_cs);
  }
}

TEST(VTConfigUtil, GetImageBufferColorSpace_BT2020_HLG) {
  auto cs = VideoColorSpace(VideoColorSpace::PrimaryID::BT2020,
                            VideoColorSpace::TransferID::ARIB_STD_B67,
                            VideoColorSpace::MatrixID::BT2020_NCL,
                            gfx::ColorSpace::RangeID::LIMITED);
  auto image_buffer = CreateCVImageBuffer(cs);
  ASSERT_TRUE(image_buffer);
  auto image_buffer_cs = GetImageBufferColorSpace(image_buffer);

  // When BT.2020 is unavailable the default should be BT.709.
  if (base::mac::IsAtLeastOS10_13()) {
    EXPECT_EQ(cs.ToGfxColorSpace(), image_buffer_cs);
  } else {
    // 10.12 doesn't have HDR transfer functions.
    cs.transfer = VideoColorSpace::TransferID::BT709;
    EXPECT_EQ(cs.ToGfxColorSpace(), image_buffer_cs);
  }
}

TEST(VTConfigUtil, FormatDescriptionInvalid) {
  auto format_descriptor =
      CreateFormatDescription(CFSTR("Cows"), CFSTR("Go"), CFSTR("Moo"));
  ASSERT_TRUE(format_descriptor);
  auto cs = GetFormatDescriptionColorSpace(format_descriptor);
  EXPECT_EQ(gfx::ColorSpace::CreateREC709(), cs);
}

TEST(VTConfigUtil, FormatDescriptionBT709) {
  auto format_descriptor =
      CreateFormatDescription(kCMFormatDescriptionColorPrimaries_ITU_R_709_2,
                              kCMFormatDescriptionTransferFunction_ITU_R_709_2,
                              kCMFormatDescriptionYCbCrMatrix_ITU_R_709_2);
  ASSERT_TRUE(format_descriptor);
  auto cs = GetFormatDescriptionColorSpace(format_descriptor);
  EXPECT_EQ(ToBT709_APPLE(gfx::ColorSpace::CreateREC709()), cs);
}

}  // namespace media