| // 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/capture/video/mac/sample_buffer_transformer_mac.h" |
| |
| #include <tuple> |
| |
| #include "base/logging.h" |
| #include "base/mac/scoped_cftyperef.h" |
| #include "build/build_config.h" |
| #include "media/capture/video/mac/test/pixel_buffer_test_utils_mac.h" |
| #include "media/capture/video/mac/video_capture_device_avfoundation_utils_mac.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/libyuv/include/libyuv/convert.h" |
| |
| namespace media { |
| |
| namespace { |
| |
| // Example single colored .jpg file (created with MSPaint). It is of RGB color |
| // (255, 127, 63). |
| const uint8_t kExampleJpegData[] = { |
| 0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, |
| 0x01, 0x01, 0x00, 0x60, 0x00, 0x60, 0x00, 0x00, 0xff, 0xdb, 0x00, 0x43, |
| 0x00, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, |
| 0x02, 0x02, 0x02, 0x03, 0x05, 0x03, 0x03, 0x03, 0x03, 0x03, 0x06, 0x04, |
| 0x04, 0x03, 0x05, 0x07, 0x06, 0x07, 0x07, 0x07, 0x06, 0x07, 0x07, 0x08, |
| 0x09, 0x0b, 0x09, 0x08, 0x08, 0x0a, 0x08, 0x07, 0x07, 0x0a, 0x0d, 0x0a, |
| 0x0a, 0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x07, 0x09, 0x0e, 0x0f, 0x0d, 0x0c, |
| 0x0e, 0x0b, 0x0c, 0x0c, 0x0c, 0xff, 0xdb, 0x00, 0x43, 0x01, 0x02, 0x02, |
| 0x02, 0x03, 0x03, 0x03, 0x06, 0x03, 0x03, 0x06, 0x0c, 0x08, 0x07, 0x08, |
| 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, |
| 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, |
| 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, |
| 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, |
| 0x0c, 0x0c, 0xff, 0xc0, 0x00, 0x11, 0x08, 0x00, 0x10, 0x00, 0x20, 0x03, |
| 0x01, 0x22, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xc4, 0x00, |
| 0x1f, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, |
| 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x10, 0x00, |
| 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, |
| 0x00, 0x01, 0x7d, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, |
| 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, |
| 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, |
| 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, |
| 0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, |
| 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, |
| 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, |
| 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, |
| 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, |
| 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, |
| 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, |
| 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, |
| 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, |
| 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xff, 0xc4, 0x00, |
| 0x1f, 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, |
| 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, |
| 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x11, 0x00, |
| 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, |
| 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, |
| 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, |
| 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, |
| 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, |
| 0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, |
| 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, |
| 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, |
| 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, |
| 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, |
| 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, |
| 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, |
| 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, |
| 0xd8, 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, |
| 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xff, 0xda, 0x00, |
| 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, 0x00, 0xf7, |
| 0x8a, 0x28, 0xa2, 0xbf, 0x89, 0xcf, 0xf4, 0x50, 0x28, 0xa2, 0x8a, 0x00, |
| 0xff, 0xd9}; |
| constexpr size_t kExampleJpegDataSize = 638; |
| constexpr uint32_t kExampleJpegWidth = 32; |
| constexpr uint32_t kExampleJpegHeight = 16; |
| constexpr uint32_t kExampleJpegScaledDownWidth = 16; |
| constexpr uint32_t kExampleJpegScaledDownHeight = 8; |
| |
| const uint8_t kInvalidJpegData[] = { |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; |
| constexpr size_t kInvalidJpegDataSize = 24; |
| |
| constexpr uint8_t kColorR = 255u; |
| constexpr uint8_t kColorG = 127u; |
| constexpr uint8_t kColorB = 63u; |
| |
| constexpr unsigned int kFullResolutionWidth = 128; |
| constexpr unsigned int kFullResolutionHeight = 96; |
| constexpr unsigned int kScaledDownResolutionWidth = 64; |
| constexpr unsigned int kScaledDownResolutionHeight = 48; |
| |
| // NV12 a.k.a. 420v |
| constexpr OSType kPixelFormatNv12 = |
| kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange; |
| // UYVY a.k.a. 2vuy |
| constexpr OSType kPixelFormatUyvy = kCVPixelFormatType_422YpCbCr8; |
| // YUY2 a.k.a. yuvs |
| constexpr OSType kPixelFormatYuy2 = kCVPixelFormatType_422YpCbCr8_yuvs; |
| // I420 a.k.a. y420 |
| constexpr OSType kPixelFormatI420 = kCVPixelFormatType_420YpCbCr8Planar; |
| |
| auto SupportedCaptureFormats() { |
| return ::testing::Values(kPixelFormatNv12, kPixelFormatUyvy, |
| kPixelFormatYuy2); |
| } |
| |
| auto SupportedOutputFormats() { |
| return ::testing::Values(kPixelFormatNv12, kPixelFormatI420); |
| } |
| |
| // Gives parameterized tests a readable suffix. |
| // E.g. ".../yuvsTo420v" instead of ".../4" |
| std::string TestParametersOSTypeTupleToString( |
| testing::TestParamInfo<std::tuple<OSType, OSType>> info) { |
| OSType input_pixel_format; |
| OSType output_pixel_format; |
| std::tie(input_pixel_format, output_pixel_format) = info.param; |
| return MacFourCCToString(input_pixel_format) + std::string("To") + |
| MacFourCCToString(output_pixel_format); |
| } |
| std::string TestParametersOSTypeToString(testing::TestParamInfo<OSType> info) { |
| return MacFourCCToString(info.param); |
| } |
| |
| base::ScopedCFTypeRef<CVPixelBufferRef> CreatePixelBuffer(OSType pixel_format, |
| int width, |
| int height, |
| uint8_t r, |
| uint8_t g, |
| uint8_t b) { |
| // Create a YUVS buffer in main memory. |
| std::unique_ptr<ByteArrayPixelBuffer> yuvs_buffer = |
| CreateYuvsPixelBufferFromSingleRgbColor(width, height, r, g, b); |
| // Convert and/or transfer to a pixel buffer that has an IOSurface. |
| base::ScopedCFTypeRef<CVPixelBufferRef> pixel_buffer = |
| PixelBufferPool::Create(pixel_format, width, height, 1)->CreateBuffer(); |
| PixelBufferTransferer transferer; |
| bool success = |
| transferer.TransferImage(yuvs_buffer->pixel_buffer, pixel_buffer); |
| DCHECK(success); |
| return pixel_buffer; |
| } |
| |
| enum class PixelBufferType { |
| kIoSurfaceBacked, |
| kIoSurfaceMissing, |
| }; |
| |
| void NonPlanarCvPixelBufferReleaseCallback(void* releaseRef, const void* data) { |
| free(const_cast<void*>(data)); |
| } |
| |
| void PlanarCvPixelBufferReleaseCallback(void* releaseRef, |
| const void* data, |
| size_t size, |
| size_t num_planes, |
| const void* planes[]) { |
| free(const_cast<void*>(data)); |
| for (size_t plane = 0; plane < num_planes; ++plane) |
| free(const_cast<void*>(planes[plane])); |
| } |
| |
| std::pair<uint8_t*, size_t> GetDataAndStride(CVPixelBufferRef pixel_buffer, |
| size_t plane) { |
| if (CVPixelBufferIsPlanar(pixel_buffer)) { |
| return {static_cast<uint8_t*>( |
| CVPixelBufferGetBaseAddressOfPlane(pixel_buffer, plane)), |
| CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer, plane)}; |
| } else { |
| DCHECK_EQ(plane, 0u) << "Non-planar pixel buffers only have 1 plane."; |
| return {static_cast<uint8_t*>(CVPixelBufferGetBaseAddress(pixel_buffer)), |
| CVPixelBufferGetBytesPerRow(pixel_buffer)}; |
| } |
| } |
| |
| base::ScopedCFTypeRef<CVPixelBufferRef> AddPadding( |
| CVPixelBufferRef pixel_buffer, |
| OSType pixel_format, |
| int width, |
| int height, |
| int padding) { |
| size_t num_planes = CVPixelBufferGetPlaneCount(pixel_buffer); |
| size_t padded_size = 0; |
| std::vector<size_t> plane_widths; |
| std::vector<size_t> plane_heights; |
| std::vector<size_t> plane_strides; |
| if (CVPixelBufferIsPlanar(pixel_buffer)) { |
| for (size_t plane = 0; plane < num_planes; ++plane) { |
| size_t plane_stride = |
| CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer, plane); |
| size_t padded_stride = plane_stride + padding; |
| size_t h = CVPixelBufferGetHeightOfPlane(pixel_buffer, plane); |
| size_t w = CVPixelBufferGetWidthOfPlane(pixel_buffer, plane); |
| plane_heights.push_back(h); |
| plane_widths.push_back(w); |
| plane_strides.push_back(padded_stride); |
| padded_size += h * padded_stride; |
| } |
| } else { |
| // CVPixelBufferGetPlaneCount returns 0 for non-planar buffers. |
| num_planes = 1; |
| size_t plane_stride = CVPixelBufferGetBytesPerRow(pixel_buffer); |
| size_t padded_stride = plane_stride + padding; |
| size_t h = CVPixelBufferGetHeight(pixel_buffer); |
| padded_size += h * padded_stride; |
| plane_heights.push_back(h); |
| plane_strides.push_back(padded_stride); |
| } |
| std::vector<void*> plane_address; |
| CHECK_EQ( |
| CVPixelBufferLockBaseAddress(pixel_buffer, kCVPixelBufferLock_ReadOnly), |
| kCVReturnSuccess); |
| // Allocate and copy each plane. |
| for (size_t plane = 0; plane < num_planes; ++plane) { |
| plane_address.push_back( |
| calloc(1, plane_strides[plane] * plane_heights[plane])); |
| uint8_t* dst_ptr = static_cast<uint8_t*>(plane_address[plane]); |
| uint8_t* src_ptr; |
| size_t plane_stride; |
| std::tie(src_ptr, plane_stride) = GetDataAndStride(pixel_buffer, plane); |
| CHECK(dst_ptr); |
| CHECK(src_ptr); |
| for (size_t r = 0; r < plane_heights[plane]; ++r) { |
| memcpy(dst_ptr, src_ptr, plane_stride); |
| src_ptr += plane_stride; |
| dst_ptr += plane_strides[plane]; |
| } |
| } |
| CHECK_EQ( |
| CVPixelBufferUnlockBaseAddress(pixel_buffer, kCVPixelBufferLock_ReadOnly), |
| kCVReturnSuccess); |
| |
| base::ScopedCFTypeRef<CVPixelBufferRef> padded_pixel_buffer; |
| CVReturn create_buffer_result; |
| if (CVPixelBufferIsPlanar(pixel_buffer)) { |
| // Without some memory block the callback won't be called and we leak the |
| // planar data. |
| void* descriptor = calloc(1, sizeof(CVPlanarPixelBufferInfo_YCbCrPlanar)); |
| create_buffer_result = CVPixelBufferCreateWithPlanarBytes( |
| nullptr, width, height, pixel_format, descriptor, 0, num_planes, |
| plane_address.data(), plane_widths.data(), plane_heights.data(), |
| plane_strides.data(), &PlanarCvPixelBufferReleaseCallback, |
| plane_strides.data(), nullptr, padded_pixel_buffer.InitializeInto()); |
| } else { |
| create_buffer_result = CVPixelBufferCreateWithBytes( |
| nullptr, width, height, pixel_format, plane_address[0], |
| plane_strides[0], &NonPlanarCvPixelBufferReleaseCallback, nullptr, |
| nullptr, padded_pixel_buffer.InitializeInto()); |
| } |
| DCHECK_EQ(create_buffer_result, kCVReturnSuccess); |
| return padded_pixel_buffer; |
| } |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> CreateSampleBuffer( |
| OSType pixel_format, |
| int width, |
| int height, |
| uint8_t r, |
| uint8_t g, |
| uint8_t b, |
| PixelBufferType pixel_buffer_type, |
| size_t padding = 0) { |
| base::ScopedCFTypeRef<CVPixelBufferRef> pixel_buffer = |
| CreatePixelBuffer(pixel_format, width, height, r, g, b); |
| if (padding != 0) { |
| CHECK_EQ(pixel_buffer_type, PixelBufferType::kIoSurfaceMissing) |
| << "Padding does not work with IOSurfaces."; |
| } |
| if (pixel_buffer_type == PixelBufferType::kIoSurfaceMissing) { |
| // Our pixel buffer currently has an IOSurface. To get rid of it, we perform |
| // a pixel buffer transfer to a destination pixel buffer that is not backed |
| // by an IOSurface. The resulting pixel buffer will have the desired color. |
| base::ScopedCFTypeRef<CVPixelBufferRef> iosurfaceless_pixel_buffer; |
| CVReturn create_buffer_result = |
| CVPixelBufferCreate(nullptr, width, height, pixel_format, nullptr, |
| iosurfaceless_pixel_buffer.InitializeInto()); |
| DCHECK_EQ(create_buffer_result, kCVReturnSuccess); |
| PixelBufferTransferer transferer; |
| bool success = |
| transferer.TransferImage(pixel_buffer, iosurfaceless_pixel_buffer); |
| DCHECK(success); |
| DCHECK(!CVPixelBufferGetIOSurface(iosurfaceless_pixel_buffer)); |
| pixel_buffer = iosurfaceless_pixel_buffer; |
| |
| if (padding > 0) { |
| pixel_buffer = |
| AddPadding(pixel_buffer, pixel_format, width, height, padding); |
| } |
| } |
| |
| // Wrap the pixel buffer in a sample buffer. |
| base::ScopedCFTypeRef<CMFormatDescriptionRef> format_description; |
| OSStatus status = CMVideoFormatDescriptionCreateForImageBuffer( |
| nil, pixel_buffer, format_description.InitializeInto()); |
| DCHECK(status == noErr); |
| |
| // Dummy information to make CMSampleBufferCreateForImageBuffer() happy. |
| CMSampleTimingInfo timing_info; |
| timing_info.decodeTimeStamp = kCMTimeInvalid; |
| timing_info.presentationTimeStamp = CMTimeMake(0, CMTimeScale(NSEC_PER_SEC)); |
| timing_info.duration = |
| CMTimeMake(33 * NSEC_PER_MSEC, CMTimeScale(NSEC_PER_SEC)); // 30 fps |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> sample_buffer; |
| status = CMSampleBufferCreateForImageBuffer( |
| nil, pixel_buffer, YES, nil, nullptr, format_description, &timing_info, |
| sample_buffer.InitializeInto()); |
| DCHECK(status == noErr); |
| return sample_buffer; |
| } |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> CreateMjpegSampleBuffer( |
| const uint8_t* mjpeg_data, |
| size_t mjpeg_data_size, |
| size_t width, |
| size_t height) { |
| CMBlockBufferCustomBlockSource source = {0}; |
| source.FreeBlock = [](void* refcon, void* doomedMemoryBlock, |
| size_t sizeInBytes) { |
| // Do nothing. The data to be released is not dynamically allocated in this |
| // test code. |
| }; |
| |
| base::ScopedCFTypeRef<CMBlockBufferRef> data_buffer; |
| OSStatus status = CMBlockBufferCreateWithMemoryBlock( |
| nil, const_cast<void*>(static_cast<const void*>(mjpeg_data)), |
| mjpeg_data_size, nil, &source, 0, mjpeg_data_size, 0, |
| data_buffer.InitializeInto()); |
| DCHECK(status == noErr); |
| |
| base::ScopedCFTypeRef<CMFormatDescriptionRef> format_description; |
| status = CMVideoFormatDescriptionCreate(nil, kCMVideoCodecType_JPEG_OpenDML, |
| width, height, nil, |
| format_description.InitializeInto()); |
| DCHECK(status == noErr); |
| |
| // Dummy information to make CMSampleBufferCreateReady() happy. |
| CMSampleTimingInfo timing_info; |
| timing_info.decodeTimeStamp = kCMTimeInvalid; |
| timing_info.presentationTimeStamp = CMTimeMake(0, CMTimeScale(NSEC_PER_SEC)); |
| timing_info.duration = |
| CMTimeMake(33 * NSEC_PER_MSEC, CMTimeScale(NSEC_PER_SEC)); // 30 fps |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> sample_buffer; |
| status = CMSampleBufferCreateReady(nil, data_buffer, format_description, 1, 1, |
| &timing_info, 1, &kExampleJpegDataSize, |
| sample_buffer.InitializeInto()); |
| DCHECK(status == noErr); |
| return sample_buffer; |
| } |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> CreateExampleMjpegSampleBuffer() { |
| // Sanity-check the example data. |
| int width; |
| int height; |
| int result = |
| libyuv::MJPGSize(kExampleJpegData, kExampleJpegDataSize, &width, &height); |
| DCHECK(result == 0); |
| DCHECK_EQ(width, static_cast<int>(kExampleJpegWidth)); |
| DCHECK_EQ(height, static_cast<int>(kExampleJpegHeight)); |
| return CreateMjpegSampleBuffer(kExampleJpegData, kExampleJpegDataSize, |
| kExampleJpegWidth, kExampleJpegHeight); |
| } |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> CreateInvalidMjpegSampleBuffer() { |
| return CreateMjpegSampleBuffer(kInvalidJpegData, kInvalidJpegDataSize, |
| kExampleJpegWidth, kExampleJpegHeight); |
| } |
| |
| } // namespace |
| |
| class SampleBufferTransformerPixelTransferTest |
| : public ::testing::Test, |
| public ::testing::WithParamInterface<std::tuple<OSType, OSType>> {}; |
| |
| TEST_P(SampleBufferTransformerPixelTransferTest, CanConvertFullScale) { |
| OSType input_pixel_format; |
| OSType output_pixel_format; |
| std::tie(input_pixel_format, output_pixel_format) = GetParam(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> input_sample_buffer = |
| CreateSampleBuffer(input_pixel_format, kFullResolutionWidth, |
| kFullResolutionHeight, kColorR, kColorG, kColorB, |
| PixelBufferType::kIoSurfaceBacked); |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| transformer->Reconfigure( |
| SampleBufferTransformer::Transformer::kPixelBufferTransfer, |
| output_pixel_format, |
| gfx::Size(kFullResolutionWidth, kFullResolutionHeight), 1); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_pixel_buffer = |
| transformer->Transform(input_sample_buffer); |
| |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_pixel_buffer)); |
| EXPECT_EQ(kFullResolutionWidth, CVPixelBufferGetWidth(output_pixel_buffer)); |
| EXPECT_EQ(kFullResolutionHeight, CVPixelBufferGetHeight(output_pixel_buffer)); |
| EXPECT_TRUE( |
| PixelBufferIsSingleColor(output_pixel_buffer, kColorR, kColorG, kColorB)); |
| } |
| |
| #if defined(ARCH_CPU_ARM64) |
| // Bulk-disabled for arm64 bot stabilization: https://crbug.com/1154345 |
| #define MAYBE_CanConvertAndScaleDown DISABLED_CanConvertAndScaleDown |
| #else |
| #define MAYBE_CanConvertAndScaleDown CanConvertAndScaleDown |
| #endif |
| |
| TEST_P(SampleBufferTransformerPixelTransferTest, MAYBE_CanConvertAndScaleDown) { |
| OSType input_pixel_format; |
| OSType output_pixel_format; |
| std::tie(input_pixel_format, output_pixel_format) = GetParam(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> input_sample_buffer = |
| CreateSampleBuffer(input_pixel_format, kFullResolutionWidth, |
| kFullResolutionHeight, kColorR, kColorG, kColorB, |
| PixelBufferType::kIoSurfaceBacked); |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| transformer->Reconfigure( |
| SampleBufferTransformer::Transformer::kPixelBufferTransfer, |
| output_pixel_format, |
| gfx::Size(kScaledDownResolutionWidth, kScaledDownResolutionHeight), 1); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_pixel_buffer = |
| transformer->Transform(input_sample_buffer); |
| |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_pixel_buffer)); |
| EXPECT_EQ(kScaledDownResolutionWidth, |
| CVPixelBufferGetWidth(output_pixel_buffer)); |
| EXPECT_EQ(kScaledDownResolutionHeight, |
| CVPixelBufferGetHeight(output_pixel_buffer)); |
| EXPECT_TRUE( |
| PixelBufferIsSingleColor(output_pixel_buffer, kColorR, kColorG, kColorB)); |
| } |
| |
| TEST_P(SampleBufferTransformerPixelTransferTest, |
| CanConvertAndScaleDownWhenIoSurfaceIsMissing) { |
| OSType input_pixel_format; |
| OSType output_pixel_format; |
| std::tie(input_pixel_format, output_pixel_format) = GetParam(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> input_sample_buffer = |
| CreateSampleBuffer(input_pixel_format, kFullResolutionWidth, |
| kFullResolutionHeight, kColorR, kColorG, kColorB, |
| PixelBufferType::kIoSurfaceMissing); |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| transformer->Reconfigure( |
| SampleBufferTransformer::Transformer::kPixelBufferTransfer, |
| output_pixel_format, |
| gfx::Size(kScaledDownResolutionWidth, kScaledDownResolutionHeight), 1); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_pixel_buffer = |
| transformer->Transform(input_sample_buffer); |
| |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_pixel_buffer)); |
| EXPECT_EQ(kScaledDownResolutionWidth, |
| CVPixelBufferGetWidth(output_pixel_buffer)); |
| EXPECT_EQ(kScaledDownResolutionHeight, |
| CVPixelBufferGetHeight(output_pixel_buffer)); |
| EXPECT_TRUE( |
| PixelBufferIsSingleColor(output_pixel_buffer, kColorR, kColorG, kColorB)); |
| } |
| |
| TEST_P(SampleBufferTransformerPixelTransferTest, |
| CanConvertWithPaddingFullScale) { |
| OSType input_pixel_format; |
| OSType output_pixel_format; |
| std::tie(input_pixel_format, output_pixel_format) = GetParam(); |
| base::ScopedCFTypeRef<CMSampleBufferRef> input_sample_buffer = |
| CreateSampleBuffer(input_pixel_format, kFullResolutionWidth, |
| kFullResolutionHeight, kColorR, kColorG, kColorB, |
| PixelBufferType::kIoSurfaceMissing, /*padding*/ 100); |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| transformer->Reconfigure( |
| SampleBufferTransformer::Transformer::kPixelBufferTransfer, |
| output_pixel_format, |
| gfx::Size(kFullResolutionWidth, kFullResolutionHeight), 1); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_pixel_buffer = |
| transformer->Transform(input_sample_buffer); |
| |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_pixel_buffer)); |
| EXPECT_EQ(kFullResolutionWidth, CVPixelBufferGetWidth(output_pixel_buffer)); |
| EXPECT_EQ(kFullResolutionHeight, CVPixelBufferGetHeight(output_pixel_buffer)); |
| EXPECT_TRUE( |
| PixelBufferIsSingleColor(output_pixel_buffer, kColorR, kColorG, kColorB)); |
| } |
| |
| TEST_P(SampleBufferTransformerPixelTransferTest, |
| CanConvertAndScaleWithPadding) { |
| OSType input_pixel_format; |
| OSType output_pixel_format; |
| std::tie(input_pixel_format, output_pixel_format) = GetParam(); |
| base::ScopedCFTypeRef<CMSampleBufferRef> input_sample_buffer = |
| CreateSampleBuffer(input_pixel_format, kFullResolutionWidth, |
| kFullResolutionHeight, kColorR, kColorG, kColorB, |
| PixelBufferType::kIoSurfaceMissing, /*padding*/ 100); |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| transformer->Reconfigure( |
| SampleBufferTransformer::Transformer::kPixelBufferTransfer, |
| output_pixel_format, |
| gfx::Size(kScaledDownResolutionWidth, kScaledDownResolutionHeight), 1); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_pixel_buffer = |
| transformer->Transform(input_sample_buffer); |
| |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_pixel_buffer)); |
| EXPECT_EQ(kScaledDownResolutionWidth, |
| CVPixelBufferGetWidth(output_pixel_buffer)); |
| EXPECT_EQ(kScaledDownResolutionHeight, |
| CVPixelBufferGetHeight(output_pixel_buffer)); |
| EXPECT_TRUE( |
| PixelBufferIsSingleColor(output_pixel_buffer, kColorR, kColorG, kColorB)); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(SampleBufferTransformerTest, |
| SampleBufferTransformerPixelTransferTest, |
| ::testing::Combine(SupportedCaptureFormats(), |
| SupportedOutputFormats()), |
| TestParametersOSTypeTupleToString); |
| |
| class SampleBufferTransformerLibyuvTest |
| : public ::testing::Test, |
| public ::testing::WithParamInterface<std::tuple<OSType, OSType>> {}; |
| |
| TEST_P(SampleBufferTransformerLibyuvTest, CanConvertFullScale) { |
| OSType input_pixel_format; |
| OSType output_pixel_format; |
| std::tie(input_pixel_format, output_pixel_format) = GetParam(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> input_sample_buffer = |
| CreateSampleBuffer(input_pixel_format, kFullResolutionWidth, |
| kFullResolutionHeight, kColorR, kColorG, kColorB, |
| PixelBufferType::kIoSurfaceBacked); |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| transformer->Reconfigure( |
| SampleBufferTransformer::Transformer::kLibyuv, output_pixel_format, |
| gfx::Size(kFullResolutionWidth, kFullResolutionHeight), 1); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_pixel_buffer = |
| transformer->Transform(input_sample_buffer); |
| |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_pixel_buffer)); |
| EXPECT_EQ(kFullResolutionWidth, CVPixelBufferGetWidth(output_pixel_buffer)); |
| EXPECT_EQ(kFullResolutionHeight, CVPixelBufferGetHeight(output_pixel_buffer)); |
| EXPECT_TRUE( |
| PixelBufferIsSingleColor(output_pixel_buffer, kColorR, kColorG, kColorB)); |
| } |
| |
| TEST_P(SampleBufferTransformerLibyuvTest, MAYBE_CanConvertAndScaleDown) { |
| OSType input_pixel_format; |
| OSType output_pixel_format; |
| std::tie(input_pixel_format, output_pixel_format) = GetParam(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> input_sample_buffer = |
| CreateSampleBuffer(input_pixel_format, kFullResolutionWidth, |
| kFullResolutionHeight, kColorR, kColorG, kColorB, |
| PixelBufferType::kIoSurfaceBacked); |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| transformer->Reconfigure( |
| SampleBufferTransformer::Transformer::kLibyuv, output_pixel_format, |
| gfx::Size(kScaledDownResolutionWidth, kScaledDownResolutionHeight), 1); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_pixel_buffer = |
| transformer->Transform(input_sample_buffer); |
| |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_pixel_buffer)); |
| EXPECT_EQ(kScaledDownResolutionWidth, |
| CVPixelBufferGetWidth(output_pixel_buffer)); |
| EXPECT_EQ(kScaledDownResolutionHeight, |
| CVPixelBufferGetHeight(output_pixel_buffer)); |
| EXPECT_TRUE( |
| PixelBufferIsSingleColor(output_pixel_buffer, kColorR, kColorG, kColorB)); |
| } |
| |
| TEST_P(SampleBufferTransformerLibyuvTest, CanConvertWithPaddingFullScale) { |
| OSType input_pixel_format; |
| OSType output_pixel_format; |
| std::tie(input_pixel_format, output_pixel_format) = GetParam(); |
| base::ScopedCFTypeRef<CMSampleBufferRef> input_sample_buffer = |
| CreateSampleBuffer(input_pixel_format, kFullResolutionWidth, |
| kFullResolutionHeight, kColorR, kColorG, kColorB, |
| PixelBufferType::kIoSurfaceMissing, /*padding*/ 100); |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| transformer->Reconfigure( |
| SampleBufferTransformer::Transformer::kLibyuv, output_pixel_format, |
| gfx::Size(kFullResolutionWidth, kFullResolutionHeight), 1); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_pixel_buffer = |
| transformer->Transform(input_sample_buffer); |
| |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_pixel_buffer)); |
| EXPECT_EQ(kFullResolutionWidth, CVPixelBufferGetWidth(output_pixel_buffer)); |
| EXPECT_EQ(kFullResolutionHeight, CVPixelBufferGetHeight(output_pixel_buffer)); |
| EXPECT_TRUE( |
| PixelBufferIsSingleColor(output_pixel_buffer, kColorR, kColorG, kColorB)); |
| } |
| |
| TEST_P(SampleBufferTransformerLibyuvTest, CanConvertAndScaleWithPadding) { |
| OSType input_pixel_format; |
| OSType output_pixel_format; |
| std::tie(input_pixel_format, output_pixel_format) = GetParam(); |
| base::ScopedCFTypeRef<CMSampleBufferRef> input_sample_buffer = |
| CreateSampleBuffer(input_pixel_format, kFullResolutionWidth, |
| kFullResolutionHeight, kColorR, kColorG, kColorB, |
| PixelBufferType::kIoSurfaceMissing, /*padding*/ 100); |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| transformer->Reconfigure( |
| SampleBufferTransformer::Transformer::kLibyuv, output_pixel_format, |
| gfx::Size(kScaledDownResolutionWidth, kScaledDownResolutionHeight), 1); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_pixel_buffer = |
| transformer->Transform(input_sample_buffer); |
| |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_pixel_buffer)); |
| EXPECT_EQ(kScaledDownResolutionWidth, |
| CVPixelBufferGetWidth(output_pixel_buffer)); |
| EXPECT_EQ(kScaledDownResolutionHeight, |
| CVPixelBufferGetHeight(output_pixel_buffer)); |
| EXPECT_TRUE( |
| PixelBufferIsSingleColor(output_pixel_buffer, kColorR, kColorG, kColorB)); |
| } |
| |
| TEST_P(SampleBufferTransformerLibyuvTest, |
| CanConvertAndScaleDownWhenIoSurfaceIsMissing) { |
| OSType input_pixel_format; |
| OSType output_pixel_format; |
| std::tie(input_pixel_format, output_pixel_format) = GetParam(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> input_sample_buffer = |
| CreateSampleBuffer(input_pixel_format, kFullResolutionWidth, |
| kFullResolutionHeight, kColorR, kColorG, kColorB, |
| PixelBufferType::kIoSurfaceMissing); |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| transformer->Reconfigure( |
| SampleBufferTransformer::Transformer::kLibyuv, output_pixel_format, |
| gfx::Size(kScaledDownResolutionWidth, kScaledDownResolutionHeight), 1); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_pixel_buffer = |
| transformer->Transform(input_sample_buffer); |
| |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_pixel_buffer)); |
| EXPECT_EQ(kScaledDownResolutionWidth, |
| CVPixelBufferGetWidth(output_pixel_buffer)); |
| EXPECT_EQ(kScaledDownResolutionHeight, |
| CVPixelBufferGetHeight(output_pixel_buffer)); |
| EXPECT_TRUE( |
| PixelBufferIsSingleColor(output_pixel_buffer, kColorR, kColorG, kColorB)); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(SampleBufferTransformerTest, |
| SampleBufferTransformerLibyuvTest, |
| ::testing::Combine(SupportedCaptureFormats(), |
| SupportedOutputFormats()), |
| TestParametersOSTypeTupleToString); |
| |
| class SampleBufferTransformerMjpegTest |
| : public ::testing::Test, |
| public ::testing::WithParamInterface<OSType> {}; |
| |
| TEST_P(SampleBufferTransformerMjpegTest, CanConvertFullScale) { |
| OSType output_pixel_format = GetParam(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> input_sample_buffer = |
| CreateExampleMjpegSampleBuffer(); |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| transformer->Reconfigure(SampleBufferTransformer::Transformer::kLibyuv, |
| output_pixel_format, |
| gfx::Size(kExampleJpegWidth, kExampleJpegHeight), 1); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_pixel_buffer = |
| transformer->Transform(input_sample_buffer); |
| |
| EXPECT_EQ(kExampleJpegWidth, CVPixelBufferGetWidth(output_pixel_buffer)); |
| EXPECT_EQ(kExampleJpegHeight, CVPixelBufferGetHeight(output_pixel_buffer)); |
| EXPECT_TRUE( |
| PixelBufferIsSingleColor(output_pixel_buffer, kColorR, kColorG, kColorB)); |
| } |
| |
| TEST_P(SampleBufferTransformerMjpegTest, MAYBE_CanConvertAndScaleDown) { |
| OSType output_pixel_format = GetParam(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> input_sample_buffer = |
| CreateExampleMjpegSampleBuffer(); |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| transformer->Reconfigure( |
| SampleBufferTransformer::Transformer::kLibyuv, output_pixel_format, |
| gfx::Size(kExampleJpegScaledDownWidth, kExampleJpegScaledDownHeight), 1); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_pixel_buffer = |
| transformer->Transform(input_sample_buffer); |
| |
| EXPECT_EQ(kExampleJpegScaledDownWidth, |
| CVPixelBufferGetWidth(output_pixel_buffer)); |
| EXPECT_EQ(kExampleJpegScaledDownHeight, |
| CVPixelBufferGetHeight(output_pixel_buffer)); |
| EXPECT_TRUE( |
| PixelBufferIsSingleColor(output_pixel_buffer, kColorR, kColorG, kColorB)); |
| } |
| |
| TEST_P(SampleBufferTransformerMjpegTest, |
| AttemptingToTransformInvalidMjpegFailsGracefully) { |
| OSType output_pixel_format = GetParam(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> input_sample_buffer = |
| CreateInvalidMjpegSampleBuffer(); |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| transformer->Reconfigure(SampleBufferTransformer::Transformer::kLibyuv, |
| output_pixel_format, |
| gfx::Size(kExampleJpegWidth, kExampleJpegHeight), 1); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_pixel_buffer = |
| transformer->Transform(input_sample_buffer); |
| EXPECT_FALSE(output_pixel_buffer); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(SampleBufferTransformerTest, |
| SampleBufferTransformerMjpegTest, |
| SupportedOutputFormats(), |
| TestParametersOSTypeToString); |
| |
| TEST(SampleBufferTransformerBestTransformerForNv12OutputTest, |
| SourceAndDestinationResolutionMatches_InputSampleBuffer) { |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> sample0 = CreateSampleBuffer( |
| kPixelFormatNv12, kFullResolutionWidth, kFullResolutionHeight, kColorR, |
| kColorG, kColorB, PixelBufferType::kIoSurfaceMissing); |
| |
| transformer->Reconfigure( |
| SampleBufferTransformer::GetBestTransformerForNv12Output(sample0), |
| kPixelFormatNv12, media::GetSampleBufferSize(sample0)); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_buffer = |
| transformer->Transform(sample0); |
| |
| EXPECT_EQ(gfx::Size(kFullResolutionWidth, kFullResolutionHeight), |
| transformer->destination_size()); |
| EXPECT_EQ(kFullResolutionWidth, CVPixelBufferGetWidth(output_buffer)); |
| EXPECT_EQ(kFullResolutionHeight, CVPixelBufferGetHeight(output_buffer)); |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_buffer)); |
| // Because sample0 has no underlying IOSurface, it should not be returned from |
| // the transformer. |
| EXPECT_NE(output_buffer.get(), CMSampleBufferGetImageBuffer(sample0.get())); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> sample1 = CreateSampleBuffer( |
| kPixelFormatNv12, kScaledDownResolutionWidth, kScaledDownResolutionHeight, |
| kColorR, kColorG, kColorB, PixelBufferType::kIoSurfaceBacked); |
| |
| transformer->Reconfigure( |
| SampleBufferTransformer::GetBestTransformerForNv12Output(sample1), |
| kPixelFormatNv12, media::GetSampleBufferSize(sample1)); |
| output_buffer = transformer->Transform(sample1); |
| |
| EXPECT_EQ(gfx::Size(kScaledDownResolutionWidth, kScaledDownResolutionHeight), |
| transformer->destination_size()); |
| EXPECT_EQ(kScaledDownResolutionWidth, CVPixelBufferGetWidth(output_buffer)); |
| EXPECT_EQ(kScaledDownResolutionHeight, CVPixelBufferGetHeight(output_buffer)); |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_buffer)); |
| // Because sample1 does have an IOSurface, it can be returned directly. |
| EXPECT_EQ(output_buffer.get(), CMSampleBufferGetImageBuffer(sample1.get())); |
| } |
| |
| // Same test as above, verifying that Transform() methods work on pixel buffers |
| // directly (so that there's no need to have a sample buffer). |
| TEST(SampleBufferTransformerBestTransformerForNv12OutputTest, |
| SourceAndDestinationResolutionMatches_InputPixelBuffer) { |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> sample0 = CreateSampleBuffer( |
| kPixelFormatNv12, kFullResolutionWidth, kFullResolutionHeight, kColorR, |
| kColorG, kColorB, PixelBufferType::kIoSurfaceMissing); |
| CVPixelBufferRef pixel0 = CMSampleBufferGetImageBuffer(sample0); |
| ASSERT_TRUE(pixel0); |
| |
| transformer->Reconfigure( |
| SampleBufferTransformer::kBestTransformerForPixelBufferToNv12Output, |
| kPixelFormatNv12, media::GetPixelBufferSize(pixel0)); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_buffer = |
| transformer->Transform(pixel0); |
| |
| EXPECT_EQ(gfx::Size(kFullResolutionWidth, kFullResolutionHeight), |
| transformer->destination_size()); |
| EXPECT_EQ(kFullResolutionWidth, CVPixelBufferGetWidth(output_buffer)); |
| EXPECT_EQ(kFullResolutionHeight, CVPixelBufferGetHeight(output_buffer)); |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_buffer)); |
| // Because pixel0 has no underlying IOSurface, it should not be returned from |
| // the transformer. |
| EXPECT_NE(output_buffer.get(), pixel0); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> sample1 = CreateSampleBuffer( |
| kPixelFormatNv12, kScaledDownResolutionWidth, kScaledDownResolutionHeight, |
| kColorR, kColorG, kColorB, PixelBufferType::kIoSurfaceBacked); |
| CVPixelBufferRef pixel1 = CMSampleBufferGetImageBuffer(sample1); |
| ASSERT_TRUE(pixel1); |
| |
| transformer->Reconfigure( |
| SampleBufferTransformer::kBestTransformerForPixelBufferToNv12Output, |
| kPixelFormatNv12, media::GetPixelBufferSize(pixel1)); |
| output_buffer = transformer->Transform(pixel1); |
| |
| EXPECT_EQ(gfx::Size(kScaledDownResolutionWidth, kScaledDownResolutionHeight), |
| transformer->destination_size()); |
| EXPECT_EQ(kScaledDownResolutionWidth, CVPixelBufferGetWidth(output_buffer)); |
| EXPECT_EQ(kScaledDownResolutionHeight, CVPixelBufferGetHeight(output_buffer)); |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_buffer)); |
| // Because pixel1 does have an IOSurface, it can be returned directly. |
| EXPECT_EQ(output_buffer.get(), pixel1); |
| } |
| |
| TEST(SampleBufferTransformerBestTransformerForNv12OutputTest, |
| CanConvertAndScaleDown_InputPixelBuffer) { |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> sample_buffer = CreateSampleBuffer( |
| kPixelFormatNv12, kFullResolutionWidth, kFullResolutionHeight, kColorR, |
| kColorG, kColorB, PixelBufferType::kIoSurfaceBacked); |
| CVPixelBufferRef pixel_buffer = CMSampleBufferGetImageBuffer(sample_buffer); |
| ASSERT_TRUE(pixel_buffer); |
| |
| transformer->Reconfigure( |
| SampleBufferTransformer::kBestTransformerForPixelBufferToNv12Output, |
| kPixelFormatNv12, |
| gfx::Size(kScaledDownResolutionWidth, kScaledDownResolutionHeight)); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_buffer = |
| transformer->Transform(pixel_buffer); |
| |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_buffer)); |
| EXPECT_EQ(kScaledDownResolutionWidth, CVPixelBufferGetWidth(output_buffer)); |
| EXPECT_EQ(kScaledDownResolutionHeight, CVPixelBufferGetHeight(output_buffer)); |
| EXPECT_TRUE( |
| PixelBufferIsSingleColor(output_buffer, kColorR, kColorG, kColorB)); |
| } |
| |
| TEST(SampleBufferTransformerBestTransformerForNv12OutputTest, |
| DestinationPixelFormatIsAlwaysNv12) { |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> sample = CreateSampleBuffer( |
| kPixelFormatNv12, kScaledDownResolutionWidth, kScaledDownResolutionHeight, |
| kColorR, kColorG, kColorB, PixelBufferType::kIoSurfaceBacked); |
| transformer->Reconfigure( |
| SampleBufferTransformer::GetBestTransformerForNv12Output(sample), |
| kPixelFormatNv12, media::GetSampleBufferSize(sample)); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_buffer = |
| transformer->Transform(sample); |
| EXPECT_EQ(kPixelFormatNv12, transformer->destination_pixel_format()); |
| EXPECT_EQ(kPixelFormatNv12, |
| IOSurfaceGetPixelFormat(CVPixelBufferGetIOSurface(output_buffer))); |
| |
| sample = CreateSampleBuffer(kPixelFormatUyvy, kScaledDownResolutionWidth, |
| kScaledDownResolutionHeight, kColorR, kColorG, |
| kColorB, PixelBufferType::kIoSurfaceBacked); |
| transformer->Reconfigure( |
| SampleBufferTransformer::GetBestTransformerForNv12Output(sample), |
| kPixelFormatNv12, media::GetSampleBufferSize(sample)); |
| output_buffer = transformer->Transform(sample); |
| EXPECT_EQ(kPixelFormatNv12, transformer->destination_pixel_format()); |
| EXPECT_EQ(kPixelFormatNv12, |
| IOSurfaceGetPixelFormat(CVPixelBufferGetIOSurface(output_buffer))); |
| |
| sample = CreateSampleBuffer(kPixelFormatYuy2, kScaledDownResolutionWidth, |
| kScaledDownResolutionHeight, kColorR, kColorG, |
| kColorB, PixelBufferType::kIoSurfaceBacked); |
| transformer->Reconfigure( |
| SampleBufferTransformer::GetBestTransformerForNv12Output(sample), |
| kPixelFormatNv12, media::GetSampleBufferSize(sample)); |
| output_buffer = transformer->Transform(sample); |
| EXPECT_EQ(kPixelFormatNv12, transformer->destination_pixel_format()); |
| EXPECT_EQ(kPixelFormatNv12, |
| IOSurfaceGetPixelFormat(CVPixelBufferGetIOSurface(output_buffer))); |
| |
| sample = CreateSampleBuffer(kPixelFormatI420, kScaledDownResolutionWidth, |
| kScaledDownResolutionHeight, kColorR, kColorG, |
| kColorB, PixelBufferType::kIoSurfaceBacked); |
| transformer->Reconfigure( |
| SampleBufferTransformer::GetBestTransformerForNv12Output(sample), |
| kPixelFormatNv12, media::GetSampleBufferSize(sample)); |
| output_buffer = transformer->Transform(sample); |
| EXPECT_EQ(kPixelFormatNv12, transformer->destination_pixel_format()); |
| EXPECT_EQ(kPixelFormatNv12, |
| IOSurfaceGetPixelFormat(CVPixelBufferGetIOSurface(output_buffer))); |
| |
| sample = CreateExampleMjpegSampleBuffer(); |
| transformer->Reconfigure( |
| SampleBufferTransformer::GetBestTransformerForNv12Output(sample), |
| kPixelFormatNv12, media::GetSampleBufferSize(sample)); |
| output_buffer = transformer->Transform(sample); |
| EXPECT_EQ(kPixelFormatNv12, transformer->destination_pixel_format()); |
| EXPECT_EQ(kPixelFormatNv12, |
| IOSurfaceGetPixelFormat(CVPixelBufferGetIOSurface(output_buffer))); |
| } |
| |
| TEST(SampleBufferTransformerBestTransformerForNv12OutputTest, |
| UsesBestTransformerPaths) { |
| std::unique_ptr<SampleBufferTransformer> transformer = |
| SampleBufferTransformer::Create(); |
| |
| base::ScopedCFTypeRef<CMSampleBufferRef> sample = CreateSampleBuffer( |
| kPixelFormatNv12, kScaledDownResolutionWidth, kScaledDownResolutionHeight, |
| kColorR, kColorG, kColorB, PixelBufferType::kIoSurfaceBacked); |
| transformer->Reconfigure( |
| SampleBufferTransformer::GetBestTransformerForNv12Output(sample), |
| kPixelFormatNv12, media::GetSampleBufferSize(sample)); |
| base::ScopedCFTypeRef<CVPixelBufferRef> output_buffer = |
| transformer->Transform(sample); |
| EXPECT_EQ(SampleBufferTransformer::Transformer::kPixelBufferTransfer, |
| transformer->transformer()); |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_buffer)); |
| |
| sample = CreateSampleBuffer(kPixelFormatUyvy, kScaledDownResolutionWidth, |
| kScaledDownResolutionHeight, kColorR, kColorG, |
| kColorB, PixelBufferType::kIoSurfaceBacked); |
| transformer->Reconfigure( |
| SampleBufferTransformer::GetBestTransformerForNv12Output(sample), |
| kPixelFormatNv12, media::GetSampleBufferSize(sample)); |
| output_buffer = transformer->Transform(sample); |
| EXPECT_EQ(SampleBufferTransformer::Transformer::kPixelBufferTransfer, |
| transformer->transformer()); |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_buffer)); |
| |
| sample = CreateSampleBuffer(kPixelFormatYuy2, kScaledDownResolutionWidth, |
| kScaledDownResolutionHeight, kColorR, kColorG, |
| kColorB, PixelBufferType::kIoSurfaceBacked); |
| transformer->Reconfigure( |
| SampleBufferTransformer::GetBestTransformerForNv12Output(sample), |
| kPixelFormatNv12, media::GetSampleBufferSize(sample)); |
| output_buffer = transformer->Transform(sample); |
| EXPECT_EQ(SampleBufferTransformer::Transformer::kPixelBufferTransfer, |
| transformer->transformer()); |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_buffer)); |
| |
| sample = CreateSampleBuffer(kPixelFormatI420, kScaledDownResolutionWidth, |
| kScaledDownResolutionHeight, kColorR, kColorG, |
| kColorB, PixelBufferType::kIoSurfaceBacked); |
| transformer->Reconfigure( |
| SampleBufferTransformer::GetBestTransformerForNv12Output(sample), |
| kPixelFormatNv12, media::GetSampleBufferSize(sample)); |
| output_buffer = transformer->Transform(sample); |
| EXPECT_EQ(SampleBufferTransformer::Transformer::kPixelBufferTransfer, |
| transformer->transformer()); |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_buffer)); |
| |
| sample = CreateExampleMjpegSampleBuffer(); |
| transformer->Reconfigure( |
| SampleBufferTransformer::GetBestTransformerForNv12Output(sample), |
| kPixelFormatNv12, media::GetSampleBufferSize(sample)); |
| output_buffer = transformer->Transform(sample); |
| EXPECT_EQ(SampleBufferTransformer::Transformer::kLibyuv, |
| transformer->transformer()); |
| EXPECT_TRUE(CVPixelBufferGetIOSurface(output_buffer)); |
| } |
| |
| } // namespace media |
