| // Copyright 2015 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "ui/gfx/mac/io_surface.h" |
| |
| #include <Availability.h> |
| #include <CoreGraphics/CoreGraphics.h> |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include "base/apple/mach_logging.h" |
| #include "base/bits.h" |
| #include "base/command_line.h" |
| #include "base/feature_list.h" |
| #include "base/logging.h" |
| #include "base/mac/mac_util.h" |
| #include "base/metrics/histogram_macros.h" |
| #include "base/trace_event/trace_event.h" |
| #include "components/viz/common/resources/shared_image_format.h" |
| #include "ui/gfx/color_space.h" |
| #include "ui/gfx/icc_profile.h" |
| #include "ui/gfx/mac/color_space_util.h" |
| |
| namespace gfx { |
| |
| namespace { |
| |
| void AddIntegerValue(CFMutableDictionaryRef dictionary, |
| const CFStringRef key, |
| int32_t value) { |
| base::apple::ScopedCFTypeRef<CFNumberRef> number( |
| CFNumberCreate(nullptr, kCFNumberSInt32Type, &value)); |
| CFDictionaryAddValue(dictionary, key, number.get()); |
| } |
| |
| // Return the expected four character code pixel format for an IOSurface with |
| // the specified viz::SharedImageFormat. |
| uint32_t SharedImageFormatToIOSurfacePixelFormat(viz::SharedImageFormat format, |
| bool override_rgba_to_bgra) { |
| if (format == viz::SinglePlaneFormat::kR_8) { |
| return 'L008'; |
| } else if (format == viz::SinglePlaneFormat::kR_F16) { |
| return 'L00h'; |
| } else if (format == viz::SinglePlaneFormat::kRG_88) { |
| return '2C08'; |
| } else if (format == viz::SinglePlaneFormat::kR_16) { |
| return 'L016'; |
| } else if (format == viz::SinglePlaneFormat::kRG_1616) { |
| return '2C16'; |
| } else if (format == viz::SinglePlaneFormat::kBGRA_1010102) { |
| return 'l10r'; // little-endian ARGB2101010 full-range ARGB |
| } else if (format == viz::SinglePlaneFormat::kBGRA_8888 || |
| format == viz::SinglePlaneFormat::kBGRX_8888) { |
| return 'BGRA'; |
| } else if (format == viz::SinglePlaneFormat::kRGBA_8888 || |
| format == viz::SinglePlaneFormat::kRGBX_8888) { |
| return override_rgba_to_bgra ? 'BGRA' : 'RGBA'; |
| } else if (format == viz::SinglePlaneFormat::kRGBA_F16) { |
| return 'RGhA'; |
| } else if (format == viz::MultiPlaneFormat::kNV12) { |
| return '420v'; |
| } else if (format == viz::MultiPlaneFormat::kNV12A) { |
| return 'v0a8'; |
| } else if (format == viz::MultiPlaneFormat::kP010) { |
| return 'x420'; |
| } else { |
| // Technically RGBA_1010102 should be accepted as 'R10k', but then it won't |
| // be supported by CGLTexImageIOSurface2D(), so it's best to reject it here. |
| NOTREACHED(); |
| } |
| } |
| |
| } // namespace |
| |
| namespace internal { |
| |
| // static |
| mach_port_t IOSurfaceMachPortTraits::Retain(mach_port_t port) { |
| kern_return_t kr = |
| mach_port_mod_refs(mach_task_self(), port, MACH_PORT_RIGHT_SEND, 1); |
| MACH_LOG_IF(ERROR, kr != KERN_SUCCESS, kr) |
| << "IOSurfaceMachPortTraits::Retain mach_port_mod_refs"; |
| return port; |
| } |
| |
| // static |
| void IOSurfaceMachPortTraits::Release(mach_port_t port) { |
| kern_return_t kr = mach_port_deallocate(mach_task_self(), port); |
| MACH_LOG_IF(ERROR, kr != KERN_SUCCESS, kr) |
| << "IOSurfaceMachPortTraits::Release mach_port_deallocate"; |
| } |
| |
| // Common method used by IOSurfaceSetColorSpace and IOSurfaceCanSetColorSpace. |
| bool IOSurfaceSetColorSpace(IOSurfaceRef io_surface, |
| const ColorSpace& color_space) { |
| // Allow but ignore invalid color spaces. |
| if (!color_space.IsValid()) |
| return true; |
| |
| // Prefer using named spaces. |
| CFStringRef color_space_name = nullptr; |
| if (color_space == ColorSpace::CreateSRGB() || |
| color_space == ColorSpace::CreateREC709()) { |
| color_space_name = kCGColorSpaceSRGB; |
| } else if (color_space == ColorSpace::CreateDisplayP3D65()) { |
| color_space_name = kCGColorSpaceDisplayP3; |
| } else if (color_space == ColorSpace::CreateExtendedSRGB()) { |
| color_space_name = kCGColorSpaceExtendedSRGB; |
| } else if (color_space == ColorSpace::CreateSRGBLinear()) { |
| color_space_name = kCGColorSpaceExtendedLinearSRGB; |
| } |
| |
| // The symbols kCGColorSpaceITUR_2020_PQ_EOTF and kCGColorSpaceITUR_2020_HLG |
| // have been deprecated. Claim that we were able to set the color space, |
| // because the path that will render these color spaces will use the |
| // HDRCopier, which will manually convert them to a non-deprecated format. |
| // https://crbug.com/1108627: Bug wherein these symbols are deprecated and |
| // also not available in some SDK versions. |
| // https://crbug.com/1101041: Introduces the HDR copier. |
| // https://crbug.com/1061723: Discussion of issues related to HLG. |
| if (color_space == ColorSpace(ColorSpace::PrimaryID::BT2020, |
| ColorSpace::TransferID::PQ, |
| ColorSpace::MatrixID::BT2020_NCL, |
| ColorSpace::RangeID::LIMITED)) { |
| color_space_name = kCGColorSpaceITUR_2100_PQ; |
| } else if (color_space == ColorSpace(ColorSpace::PrimaryID::BT2020, |
| ColorSpace::TransferID::HLG, |
| ColorSpace::MatrixID::BT2020_NCL, |
| ColorSpace::RangeID::LIMITED)) { |
| color_space_name = kCGColorSpaceITUR_2100_HLG; |
| } |
| |
| // https://crbug.com/1488397: Set parameters that will be rendering YUV |
| // content. |
| // TODO(b/304442486): Add gamma support here. |
| { |
| CFStringRef primaries = nullptr; |
| CFStringRef transfer = nullptr; |
| CFStringRef matrix = nullptr; |
| if (ColorSpaceToCVImageBufferKeys(color_space, /*prefer_srgb_trfn=*/true, |
| &primaries, &transfer, &matrix)) { |
| IOSurfaceSetValue(io_surface, CFSTR("IOSurfaceColorPrimaries"), |
| primaries); |
| IOSurfaceSetValue(io_surface, CFSTR("IOSurfaceTransferFunction"), |
| transfer); |
| IOSurfaceSetValue(io_surface, CFSTR("IOSurfaceYCbCrMatrix"), matrix); |
| } |
| } |
| |
| if (color_space_name) { |
| IOSurfaceSetValue(io_surface, CFSTR("IOSurfaceColorSpace"), |
| color_space_name); |
| return true; |
| } |
| |
| gfx::ColorSpace as_rgb = color_space.GetAsRGB(); |
| gfx::ColorSpace as_full_range_rgb = color_space.GetAsFullRangeRGB(); |
| |
| // IOSurfaces do not support full-range YUV video. Fortunately, the hardware |
| // decoders never produce full-range video. |
| // https://crbug.com/882627 |
| if (color_space != as_rgb && as_rgb == as_full_range_rgb) |
| return false; |
| |
| // Generate an ICCProfile from the parametric color space. |
| ICCProfile icc_profile = ICCProfile::FromColorSpace(as_full_range_rgb); |
| if (!icc_profile.IsValid()) |
| return false; |
| |
| // Package it as a CFDataRef and send it to the IOSurface. |
| std::vector<char> icc_profile_data = icc_profile.GetData(); |
| base::apple::ScopedCFTypeRef<CFDataRef> cf_data_icc_profile(CFDataCreate( |
| nullptr, reinterpret_cast<const UInt8*>(icc_profile_data.data()), |
| icc_profile_data.size())); |
| |
| IOSurfaceSetValue(io_surface, CFSTR("IOSurfaceColorSpace"), |
| cf_data_icc_profile.get()); |
| return true; |
| } |
| |
| } // namespace internal |
| |
| ScopedIOSurface CreateIOSurface(const gfx::Size& size, |
| viz::SharedImageFormat format, |
| bool should_clear, |
| bool override_rgba_to_bgra) { |
| TRACE_EVENT0("ui", "CreateIOSurface"); |
| base::TimeTicks start_time = base::TimeTicks::Now(); |
| |
| base::apple::ScopedCFTypeRef<CFMutableDictionaryRef> properties( |
| CFDictionaryCreateMutable(kCFAllocatorDefault, 0, |
| &kCFTypeDictionaryKeyCallBacks, |
| &kCFTypeDictionaryValueCallBacks)); |
| AddIntegerValue(properties.get(), kIOSurfaceWidth, size.width()); |
| AddIntegerValue(properties.get(), kIOSurfaceHeight, size.height()); |
| AddIntegerValue( |
| properties.get(), kIOSurfacePixelFormat, |
| SharedImageFormatToIOSurfacePixelFormat(format, override_rgba_to_bgra)); |
| |
| // Don't specify plane information unless there are indeed multiple planes |
| // because DisplayLink drivers do not support this. |
| // http://crbug.com/527556 |
| size_t num_planes = format.NumberOfPlanes(); |
| if (num_planes > 1) { |
| base::apple::ScopedCFTypeRef<CFMutableArrayRef> planes(CFArrayCreateMutable( |
| kCFAllocatorDefault, num_planes, &kCFTypeArrayCallBacks)); |
| size_t total_bytes_alloc = 0; |
| for (size_t plane = 0; plane < num_planes; ++plane) { |
| const gfx::Size plane_size = format.GetPlaneSize(plane, size); |
| const size_t plane_width = plane_size.width(); |
| const size_t plane_height = plane_size.height(); |
| size_t plane_bytes_per_element = format.NumChannelsInPlane(plane); |
| if (format.channel_format() != |
| viz::SharedImageFormat::ChannelFormat::k8) { |
| plane_bytes_per_element *= 2; |
| } |
| const size_t plane_bytes_per_row = |
| IOSurfaceAlignProperty(kIOSurfacePlaneBytesPerRow, |
| base::bits::AlignUp(plane_width, size_t{2}) * |
| plane_bytes_per_element); |
| const size_t plane_bytes_alloc = IOSurfaceAlignProperty( |
| kIOSurfacePlaneSize, |
| base::bits::AlignUp(plane_height, size_t{2}) * plane_bytes_per_row); |
| const size_t plane_offset = |
| IOSurfaceAlignProperty(kIOSurfacePlaneOffset, total_bytes_alloc); |
| |
| base::apple::ScopedCFTypeRef<CFMutableDictionaryRef> plane_info( |
| CFDictionaryCreateMutable(kCFAllocatorDefault, 0, |
| &kCFTypeDictionaryKeyCallBacks, |
| &kCFTypeDictionaryValueCallBacks)); |
| AddIntegerValue(plane_info.get(), kIOSurfacePlaneWidth, plane_width); |
| AddIntegerValue(plane_info.get(), kIOSurfacePlaneHeight, plane_height); |
| AddIntegerValue(plane_info.get(), kIOSurfacePlaneBytesPerElement, |
| plane_bytes_per_element); |
| AddIntegerValue(plane_info.get(), kIOSurfacePlaneBytesPerRow, |
| plane_bytes_per_row); |
| AddIntegerValue(plane_info.get(), kIOSurfacePlaneSize, plane_bytes_alloc); |
| AddIntegerValue(plane_info.get(), kIOSurfacePlaneOffset, plane_offset); |
| CFArrayAppendValue(planes.get(), plane_info.get()); |
| total_bytes_alloc = plane_offset + plane_bytes_alloc; |
| } |
| CFDictionaryAddValue(properties.get(), kIOSurfacePlaneInfo, planes.get()); |
| |
| total_bytes_alloc = |
| IOSurfaceAlignProperty(kIOSurfaceAllocSize, total_bytes_alloc); |
| AddIntegerValue(properties.get(), kIOSurfaceAllocSize, total_bytes_alloc); |
| } else { |
| const size_t bytes_per_element = format.BytesPerPixel(); |
| const size_t bytes_per_row = IOSurfaceAlignProperty( |
| kIOSurfaceBytesPerRow, |
| base::bits::AlignUp(static_cast<size_t>(size.width()), size_t{2}) * |
| bytes_per_element); |
| const size_t bytes_alloc = IOSurfaceAlignProperty( |
| kIOSurfaceAllocSize, |
| base::bits::AlignUp(static_cast<size_t>(size.height()), size_t{2}) * |
| bytes_per_row); |
| AddIntegerValue(properties.get(), kIOSurfaceBytesPerElement, |
| bytes_per_element); |
| AddIntegerValue(properties.get(), kIOSurfaceBytesPerRow, bytes_per_row); |
| AddIntegerValue(properties.get(), kIOSurfaceAllocSize, bytes_alloc); |
| } |
| |
| ScopedIOSurface io_surface(IOSurfaceCreate(properties.get())); |
| if (!io_surface) { |
| LOG(ERROR) << "Failed to allocate IOSurface of size " << size.ToString() |
| << "."; |
| return ScopedIOSurface(); |
| } |
| |
| if (should_clear) { |
| // Zero-initialize the IOSurface. Calling IOSurfaceLock/IOSurfaceUnlock |
| // appears to be sufficient. https://crbug.com/584760#c17 |
| kern_return_t r = IOSurfaceLock(io_surface.get(), 0, nullptr); |
| DCHECK_EQ(KERN_SUCCESS, r); |
| r = IOSurfaceUnlock(io_surface.get(), 0, nullptr); |
| DCHECK_EQ(KERN_SUCCESS, r); |
| } |
| |
| // Ensure that all IOSurfaces start as sRGB. |
| IOSurfaceSetValue(io_surface.get(), CFSTR("IOSurfaceColorSpace"), |
| kCGColorSpaceSRGB); |
| |
| UMA_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES( |
| "GPU.IOSurface.CreationTimeUs", base::TimeTicks::Now() - start_time, |
| base::Microseconds(1), base::Milliseconds(50), /*bucket_count=*/100); |
| |
| return io_surface; |
| } |
| |
| #if BUILDFLAG(IS_IOS) |
| void ExportIOSurfaceSharedMemoryRegion( |
| IOSurfaceRef io_surface, |
| base::UnsafeSharedMemoryRegion& shared_memory_region, |
| std::array<uint32_t, kMaxIOSurfacePlanes>& plane_strides, |
| std::array<uint32_t, kMaxIOSurfacePlanes>& plane_offsets) { |
| CHECK(io_surface); |
| |
| const void* io_surface_base_addr = IOSurfaceGetBaseAddress(io_surface); |
| const size_t io_surface_alloc_size = IOSurfaceGetAllocSize(io_surface); |
| |
| memory_object_size_t alloc_size = io_surface_alloc_size; |
| base::apple::ScopedMachSendRight named_right; |
| kern_return_t kr = mach_make_memory_entry_64( |
| mach_task_self(), &alloc_size, |
| reinterpret_cast<memory_object_offset_t>(io_surface_base_addr), |
| VM_PROT_READ | VM_PROT_WRITE, |
| base::apple::ScopedMachSendRight::Receiver(named_right).get(), |
| MACH_PORT_NULL); |
| MACH_CHECK(kr == KERN_SUCCESS, kr) << "mach_make_memory_entry_64"; |
| CHECK_GE(alloc_size, io_surface_alloc_size); |
| |
| using base::subtle::PlatformSharedMemoryRegion; |
| auto platform_shared_memory_region = PlatformSharedMemoryRegion::Take( |
| std::move(named_right), PlatformSharedMemoryRegion::Mode::kUnsafe, |
| alloc_size, base::UnguessableToken::Create()); |
| CHECK(platform_shared_memory_region.IsValid()); |
| |
| shared_memory_region = base::UnsafeSharedMemoryRegion::Deserialize( |
| std::move(platform_shared_memory_region)); |
| CHECK(shared_memory_region.IsValid()); |
| |
| // IOSurfaceGetPlaneCount returns 0 for single-plane surfaces. |
| const size_t plane_count = std::max(1ul, IOSurfaceGetPlaneCount(io_surface)); |
| plane_strides = {}; |
| plane_offsets = {}; |
| for (size_t plane = 0; plane < plane_count; plane++) { |
| plane_strides[plane] = base::checked_cast<uint32_t>( |
| IOSurfaceGetBytesPerRowOfPlane(io_surface, plane)); |
| |
| const void* io_surface_plane_addr = |
| IOSurfaceGetBaseAddressOfPlane(io_surface, plane); |
| plane_offsets[plane] = base::checked_cast<uint32_t>( |
| reinterpret_cast<intptr_t>(io_surface_plane_addr) - |
| reinterpret_cast<intptr_t>(io_surface_base_addr)); |
| } |
| } |
| #endif |
| |
| bool IOSurfaceCanSetColorSpace(const ColorSpace& color_space) { |
| return internal::IOSurfaceSetColorSpace(nullptr, color_space); |
| } |
| |
| void IOSurfaceSetColorSpace(IOSurfaceRef io_surface, |
| const ColorSpace& color_space) { |
| if (!internal::IOSurfaceSetColorSpace(io_surface, color_space)) { |
| DLOG(ERROR) << "Failed to set color space for IOSurface: " |
| << color_space.ToString(); |
| } |
| } |
| |
| ScopedIOSurface IOSurfaceMachPortToIOSurface( |
| ScopedRefCountedIOSurfaceMachPort io_surface_mach_port) { |
| ScopedIOSurface io_surface; |
| if (!io_surface_mach_port) { |
| DLOG(ERROR) << "Invalid mach port."; |
| return io_surface; |
| } |
| io_surface.reset(IOSurfaceLookupFromMachPort(io_surface_mach_port.get())); |
| if (!io_surface) { |
| DLOG(ERROR) << "Unable to lookup IOSurface."; |
| return io_surface; |
| } |
| return io_surface; |
| } |
| |
| } // namespace gfx |
