/* * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ #include "common_video/libyuv/include/webrtc_libyuv.h" #include #include #include #include #include "api/scoped_refptr.h" #include "api/video/i420_buffer.h" #include "api/video/video_frame.h" #include "api/video/video_frame_buffer.h" #include "common_video/include/video_frame_buffer.h" #include "rtc_base/checks.h" #include "third_party/libyuv/include/libyuv/compare.h" #include "third_party/libyuv/include/libyuv/convert.h" #include "third_party/libyuv/include/libyuv/convert_from.h" #include "third_party/libyuv/include/libyuv/planar_functions.h" #include "third_party/libyuv/include/libyuv/rotate.h" #include "third_party/libyuv/include/libyuv/scale.h" #include "third_party/libyuv/include/libyuv/video_common.h" namespace webrtc { size_t CalcBufferSize(VideoType type, int width, int height) { RTC_DCHECK_GE(width, 0); RTC_DCHECK_GE(height, 0); switch (type) { case VideoType::kI420: case VideoType::kIYUV: case VideoType::kYV12: case VideoType::kNV12: { int half_width = (width + 1) >> 1; int half_height = (height + 1) >> 1; return width * height + half_width * half_height * 2; } case VideoType::kRGB565: case VideoType::kYUY2: case VideoType::kUYVY: return width * height * 2; case VideoType::kRGB24: case VideoType::kBGR24: return width * height * 3; case VideoType::kBGRA: case VideoType::kARGB: case VideoType::kABGR: return width * height * 4; case VideoType::kMJPEG: case VideoType::kUnknown: break; } RTC_DCHECK_NOTREACHED() << "Unexpected pixel format " << type; return 0; } int ExtractBuffer(const scoped_refptr& input_frame, size_t size, uint8_t* buffer) { RTC_DCHECK(buffer); if (!input_frame) return -1; int width = input_frame->width(); int height = input_frame->height(); size_t length = CalcBufferSize(VideoType::kI420, width, height); if (size < length) { return -1; } int chroma_width = input_frame->ChromaWidth(); int chroma_height = input_frame->ChromaHeight(); libyuv::I420Copy(input_frame->DataY(), input_frame->StrideY(), input_frame->DataU(), input_frame->StrideU(), input_frame->DataV(), input_frame->StrideV(), buffer, width, buffer + width * height, chroma_width, buffer + width * height + chroma_width * chroma_height, chroma_width, width, height); return static_cast(length); } int ExtractBuffer(const VideoFrame& input_frame, size_t size, uint8_t* buffer) { return ExtractBuffer(input_frame.video_frame_buffer()->ToI420(), size, buffer); } int ConvertVideoType(VideoType video_type) { switch (video_type) { case VideoType::kUnknown: return libyuv::FOURCC_ANY; case VideoType::kI420: return libyuv::FOURCC_I420; case VideoType::kIYUV: // same as VideoType::kYV12 case VideoType::kYV12: return libyuv::FOURCC_YV12; case VideoType::kRGB24: return libyuv::FOURCC_24BG; case VideoType::kBGR24: return libyuv::FOURCC_RAW; case VideoType::kABGR: return libyuv::FOURCC_ABGR; case VideoType::kRGB565: return libyuv::FOURCC_RGBP; case VideoType::kYUY2: return libyuv::FOURCC_YUY2; case VideoType::kUYVY: return libyuv::FOURCC_UYVY; case VideoType::kMJPEG: return libyuv::FOURCC_MJPG; case VideoType::kARGB: return libyuv::FOURCC_ARGB; case VideoType::kBGRA: return libyuv::FOURCC_BGRA; case VideoType::kNV12: return libyuv::FOURCC_NV12; } RTC_DCHECK_NOTREACHED() << "Unexpected pixel format " << video_type; return libyuv::FOURCC_ANY; } int ConvertFromI420(const VideoFrame& src_frame, VideoType dst_video_type, int dst_sample_size, uint8_t* dst_frame) { scoped_refptr i420_buffer = src_frame.video_frame_buffer()->ToI420(); return libyuv::ConvertFromI420( i420_buffer->DataY(), i420_buffer->StrideY(), i420_buffer->DataU(), i420_buffer->StrideU(), i420_buffer->DataV(), i420_buffer->StrideV(), dst_frame, dst_sample_size, src_frame.width(), src_frame.height(), ConvertVideoType(dst_video_type)); } int ConvertToI420(const uint8_t* sample, size_t sample_size, uint8_t* dst_y, int dst_stride_y, uint8_t* dst_u, int dst_stride_u, uint8_t* dst_v, int dst_stride_v, int src_width, int src_height, int src_stride, int dst_width, int dst_height, uint32_t rotation, uint32_t fourcc) { if (src_height == INT_MIN || dst_height == INT_MIN) { return -1; } const int abs_src_height = (src_height < 0) ? -src_height : src_height; const int abs_dst_height = (dst_height < 0) ? -dst_height : dst_height; if (!dst_y || !dst_u || !dst_v || !sample || src_width <= 0 || src_width > INT_MAX / 4 || dst_width <= 0 || src_height == 0 || dst_height == 0 || dst_width > src_width || abs_dst_height > abs_src_height) { return -1; } uint32_t format = libyuv::CanonicalFourCC(fourcc); // Calculate the unpadded stride if no explicit value is set. if (src_stride == 0) { switch (format) { case libyuv::FOURCC_YUY2: case libyuv::FOURCC_UYVY: case libyuv::FOURCC_RGBP: case libyuv::FOURCC_RGBO: case libyuv::FOURCC_R444: src_stride = src_width * 2; break; case libyuv::FOURCC_24BG: case libyuv::FOURCC_RAW: src_stride = src_width * 3; break; case libyuv::FOURCC_ARGB: case libyuv::FOURCC_BGRA: case libyuv::FOURCC_ABGR: case libyuv::FOURCC_RGBA: src_stride = src_width * 4; break; case libyuv::FOURCC_I400: case libyuv::FOURCC_NV12: case libyuv::FOURCC_NV21: case libyuv::FOURCC_I420: case libyuv::FOURCC_YV12: case libyuv::FOURCC_I422: case libyuv::FOURCC_YV16: // Follow the V4L2 definition for strides of subsampled formats: // > To avoid ambiguities drivers must return a bytesperline value // > rounded up to a multiple of the scale factor. // https://www.kernel.org/doc/html/v7.1/userspace-api/media/v4l/pixfmt-v4l2.html src_stride = (src_width + 1) & ~1; break; case libyuv::FOURCC_I444: case libyuv::FOURCC_YV24: src_stride = src_width; break; case libyuv::FOURCC_MJPG: break; default: return -1; } } else { switch (format) { case libyuv::FOURCC_YUY2: case libyuv::FOURCC_UYVY: case libyuv::FOURCC_I400: case libyuv::FOURCC_NV12: case libyuv::FOURCC_NV21: case libyuv::FOURCC_I420: case libyuv::FOURCC_YV12: case libyuv::FOURCC_I422: case libyuv::FOURCC_YV16: // Follow the V4L2 definition for strides of subsampled formats: // > To avoid ambiguities drivers must return a bytesperline value // > rounded up to a multiple of the scale factor. // https://www.kernel.org/doc/html/v7.1/userspace-api/media/v4l/pixfmt-v4l2.html if ((src_stride % 2) != 0) return -1; break; default: break; } } int r = 0; const bool need_buf = (rotation && format != libyuv::FOURCC_I420 && format != libyuv::FOURCC_NV12 && format != libyuv::FOURCC_NV21 && format != libyuv::FOURCC_YV12) || dst_y == sample; const int inv_dst_height = (src_height < 0) ? -abs_dst_height : abs_dst_height; uint8_t* rotate_buffer = NULL; uint8_t* tmp_y; uint8_t* tmp_u; uint8_t* tmp_v; int tmp_y_stride; int tmp_u_stride; int tmp_v_stride; // One pass rotation is available for some formats. For the rest, convert // to I420 (with optional vertical flipping) into a temporary I420 buffer, // and then rotate the I420 to the final destination buffer. // For in-place conversion, if destination dst_y is same as source sample, // also enable temporary buffer. if (need_buf) { size_t y_size = (size_t)dst_width * abs_dst_height; size_t uv_size = (size_t)((dst_width + 1) / 2) * ((abs_dst_height + 1) / 2); if (uv_size > SIZE_MAX / 2 || y_size > SIZE_MAX - uv_size * 2) { return -1; // Invalid size. } const size_t rotate_buffer_size = y_size + uv_size * 2; rotate_buffer = new uint8_t[rotate_buffer_size]; if (!rotate_buffer) { return 1; // Out of memory runtime error. } tmp_y = dst_y; tmp_u = dst_u; tmp_v = dst_v; tmp_y_stride = dst_stride_y; tmp_u_stride = dst_stride_u; tmp_v_stride = dst_stride_v; dst_y = rotate_buffer; dst_u = dst_y + y_size; dst_v = dst_u + uv_size; dst_stride_y = dst_width; dst_stride_u = dst_stride_v = ((dst_width + 1) / 2); } switch (format) { // Single plane formats case libyuv::FOURCC_YUY2: { r = libyuv::YUY2ToI420(sample, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; } case libyuv::FOURCC_UYVY: { r = libyuv::UYVYToI420(sample, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; } case libyuv::FOURCC_RGBP: r = libyuv::RGB565ToI420(sample, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; case libyuv::FOURCC_RGBO: r = libyuv::ARGB1555ToI420(sample, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; case libyuv::FOURCC_R444: r = libyuv::ARGB4444ToI420(sample, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; case libyuv::FOURCC_24BG: r = libyuv::RGB24ToI420(sample, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; case libyuv::FOURCC_RAW: r = libyuv::RAWToI420(sample, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; case libyuv::FOURCC_ARGB: r = libyuv::ARGBToI420(sample, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; case libyuv::FOURCC_BGRA: r = libyuv::BGRAToI420(sample, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; case libyuv::FOURCC_ABGR: r = libyuv::ABGRToI420(sample, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; case libyuv::FOURCC_RGBA: r = libyuv::RGBAToI420(sample, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; case libyuv::FOURCC_I400: r = libyuv::I400ToI420(sample, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; // Biplanar formats case libyuv::FOURCC_NV12: { const uint8_t* src_y = sample; const uint8_t* src_uv = src_y + ((ptrdiff_t)src_stride * abs_src_height); r = libyuv::NV12ToI420Rotate(src_y, src_stride, src_uv, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height, (libyuv::RotationMode)rotation); break; } case libyuv::FOURCC_NV21: { const uint8_t* src_y = sample; const uint8_t* src_uv = src_y + ((ptrdiff_t)src_stride * abs_src_height); // Call NV12 but with dst_u and dst_v parameters swapped. r = libyuv::NV12ToI420Rotate(src_y, src_stride, src_uv, src_stride, dst_y, dst_stride_y, dst_v, dst_stride_v, dst_u, dst_stride_u, dst_width, inv_dst_height, (libyuv::RotationMode)rotation); break; } // Triplanar formats case libyuv::FOURCC_I420: case libyuv::FOURCC_YV12: { const uint8_t* src_y = sample; const uint8_t* src_u; const uint8_t* src_v; // Follow the V4L2 definition: // > When the image format is planar the bytesperline value applies to the // > first plane and is divided by the same factor as the width field for // > the other planes. // https://www.kernel.org/doc/html/v7.1/userspace-api/media/v4l/pixfmt-v4l2.html int halfstride = src_stride / 2; int halfheight = (abs_src_height + 1) / 2; if (format == libyuv::FOURCC_YV12) { src_v = src_y + (ptrdiff_t)src_stride * abs_src_height; src_u = src_v + halfstride * (ptrdiff_t)halfheight; } else { src_u = src_y + (ptrdiff_t)src_stride * abs_src_height; src_v = src_u + halfstride * (ptrdiff_t)halfheight; } r = libyuv::I420Rotate(src_y, src_stride, src_u, halfstride, src_v, halfstride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height, (libyuv::RotationMode)rotation); break; } case libyuv::FOURCC_I422: case libyuv::FOURCC_YV16: { const uint8_t* src_y = sample; const uint8_t* src_u; const uint8_t* src_v; // Follow the V4L2 definition: // > When the image format is planar the bytesperline value applies to the // > first plane and is divided by the same factor as the width field for // > the other planes. // https://www.kernel.org/doc/html/v7.1/userspace-api/media/v4l/pixfmt-v4l2.html int halfstride = src_stride / 2; if (format == libyuv::FOURCC_YV16) { src_v = src_y + (ptrdiff_t)src_stride * abs_src_height; src_u = src_v + halfstride * (ptrdiff_t)abs_src_height; } else { src_u = src_y + (ptrdiff_t)src_stride * abs_src_height; src_v = src_u + halfstride * (ptrdiff_t)abs_src_height; } r = libyuv::I422ToI420(src_y, src_stride, src_u, halfstride, src_v, halfstride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; } case libyuv::FOURCC_I444: case libyuv::FOURCC_YV24: { const uint8_t* src_y = sample; const uint8_t* src_u; const uint8_t* src_v; if (format == libyuv::FOURCC_YV24) { src_v = src_y + src_stride * (ptrdiff_t)abs_src_height; src_u = src_v + src_stride * (ptrdiff_t)abs_src_height; } else { src_u = src_y + src_stride * (ptrdiff_t)abs_src_height; src_v = src_u + src_stride * (ptrdiff_t)abs_src_height; } r = libyuv::I444ToI420(src_y, src_stride, src_u, src_stride, src_v, src_stride, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, inv_dst_height); break; } #ifdef HAVE_LIBYUV_JPEG case libyuv::FOURCC_MJPG: r = libyuv::MJPGToI420(sample, sample_size, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, src_width, abs_src_height, dst_width, inv_dst_height); break; #endif default: r = -1; // unknown fourcc - return failure code. } if (need_buf) { if (!r) { r = libyuv::I420Rotate(dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, tmp_y, tmp_y_stride, tmp_u, tmp_u_stride, tmp_v, tmp_v_stride, dst_width, abs_dst_height, (libyuv::RotationMode)rotation); } free(rotate_buffer); } return r; } scoped_refptr ScaleI420ABuffer( const I420ABufferInterface& buffer, int target_width, int target_height) { scoped_refptr yuv_buffer = I420Buffer::Create(target_width, target_height); yuv_buffer->ScaleFrom(buffer); scoped_refptr axx_buffer = I420Buffer::Create(target_width, target_height); libyuv::ScalePlane(buffer.DataA(), buffer.StrideA(), buffer.width(), buffer.height(), axx_buffer->MutableDataY(), axx_buffer->StrideY(), target_width, target_height, libyuv::kFilterBox); scoped_refptr merged_buffer = WrapI420ABuffer( yuv_buffer->width(), yuv_buffer->height(), yuv_buffer->DataY(), yuv_buffer->StrideY(), yuv_buffer->DataU(), yuv_buffer->StrideU(), yuv_buffer->DataV(), yuv_buffer->StrideV(), axx_buffer->DataY(), axx_buffer->StrideY(), // To keep references alive. [yuv_buffer, axx_buffer] {}); return merged_buffer; } scoped_refptr ScaleVideoFrameBuffer( const I420BufferInterface& source, int dst_width, int dst_height) { scoped_refptr scaled_buffer = I420Buffer::Create(dst_width, dst_height); scaled_buffer->ScaleFrom(source); return scaled_buffer; } double I420SSE(const I420BufferInterface& ref_buffer, const I420BufferInterface& test_buffer) { RTC_DCHECK_EQ(ref_buffer.width(), test_buffer.width()); RTC_DCHECK_EQ(ref_buffer.height(), test_buffer.height()); const uint64_t width = test_buffer.width(); const uint64_t height = test_buffer.height(); const uint64_t sse_y = libyuv::ComputeSumSquareErrorPlane( ref_buffer.DataY(), ref_buffer.StrideY(), test_buffer.DataY(), test_buffer.StrideY(), width, height); const int width_uv = (width + 1) >> 1; const int height_uv = (height + 1) >> 1; const uint64_t sse_u = libyuv::ComputeSumSquareErrorPlane( ref_buffer.DataU(), ref_buffer.StrideU(), test_buffer.DataU(), test_buffer.StrideU(), width_uv, height_uv); const uint64_t sse_v = libyuv::ComputeSumSquareErrorPlane( ref_buffer.DataV(), ref_buffer.StrideV(), test_buffer.DataV(), test_buffer.StrideV(), width_uv, height_uv); const double samples = width * height + 2 * (width_uv * height_uv); const double sse = sse_y + sse_u + sse_v; return sse / (samples * 255.0 * 255.0); } // Compute PSNR for an I420A frame (all planes). Can upscale test frame. double I420APSNR(const I420ABufferInterface& ref_buffer, const I420ABufferInterface& test_buffer) { RTC_DCHECK_GE(ref_buffer.width(), test_buffer.width()); RTC_DCHECK_GE(ref_buffer.height(), test_buffer.height()); if ((ref_buffer.width() != test_buffer.width()) || (ref_buffer.height() != test_buffer.height())) { scoped_refptr scaled_buffer = ScaleI420ABuffer(test_buffer, ref_buffer.width(), ref_buffer.height()); return I420APSNR(ref_buffer, *scaled_buffer); } const int width = test_buffer.width(); const int height = test_buffer.height(); const uint64_t sse_y = libyuv::ComputeSumSquareErrorPlane( ref_buffer.DataY(), ref_buffer.StrideY(), test_buffer.DataY(), test_buffer.StrideY(), width, height); const int width_uv = (width + 1) >> 1; const int height_uv = (height + 1) >> 1; const uint64_t sse_u = libyuv::ComputeSumSquareErrorPlane( ref_buffer.DataU(), ref_buffer.StrideU(), test_buffer.DataU(), test_buffer.StrideU(), width_uv, height_uv); const uint64_t sse_v = libyuv::ComputeSumSquareErrorPlane( ref_buffer.DataV(), ref_buffer.StrideV(), test_buffer.DataV(), test_buffer.StrideV(), width_uv, height_uv); const uint64_t sse_a = libyuv::ComputeSumSquareErrorPlane( ref_buffer.DataA(), ref_buffer.StrideA(), test_buffer.DataA(), test_buffer.StrideA(), width, height); const uint64_t samples = 2 * (uint64_t)width * (uint64_t)height + 2 * ((uint64_t)width_uv * (uint64_t)height_uv); const uint64_t sse = sse_y + sse_u + sse_v + sse_a; const double psnr = libyuv::SumSquareErrorToPsnr(sse, samples); return (psnr > kPerfectPSNR) ? kPerfectPSNR : psnr; } // Compute PSNR for an I420A frame (all planes) double I420APSNR(const VideoFrame* ref_frame, const VideoFrame* test_frame) { if (!ref_frame || !test_frame) return -1; RTC_DCHECK(ref_frame->video_frame_buffer()->type() == VideoFrameBuffer::Type::kI420A); RTC_DCHECK(test_frame->video_frame_buffer()->type() == VideoFrameBuffer::Type::kI420A); return I420APSNR(*ref_frame->video_frame_buffer()->GetI420A(), *test_frame->video_frame_buffer()->GetI420A()); } // Compute PSNR for an I420 frame (all planes). Can upscale test frame. double I420PSNR(const I420BufferInterface& ref_buffer, const I420BufferInterface& test_buffer) { RTC_DCHECK_GE(ref_buffer.width(), test_buffer.width()); RTC_DCHECK_GE(ref_buffer.height(), test_buffer.height()); if ((ref_buffer.width() != test_buffer.width()) || (ref_buffer.height() != test_buffer.height())) { scoped_refptr scaled_buffer = I420Buffer::Create(ref_buffer.width(), ref_buffer.height()); scaled_buffer->ScaleFrom(test_buffer); return I420PSNR(ref_buffer, *scaled_buffer); } double psnr = libyuv::I420Psnr( ref_buffer.DataY(), ref_buffer.StrideY(), ref_buffer.DataU(), ref_buffer.StrideU(), ref_buffer.DataV(), ref_buffer.StrideV(), test_buffer.DataY(), test_buffer.StrideY(), test_buffer.DataU(), test_buffer.StrideU(), test_buffer.DataV(), test_buffer.StrideV(), test_buffer.width(), test_buffer.height()); // LibYuv sets the max psnr value to 128, we restrict it here. // In case of 0 mse in one frame, 128 can skew the results significantly. return (psnr > kPerfectPSNR) ? kPerfectPSNR : psnr; } // Compute PSNR for an I420 frame (all planes) double I420PSNR(const VideoFrame* ref_frame, const VideoFrame* test_frame) { if (!ref_frame || !test_frame) return -1; return I420PSNR(*ref_frame->video_frame_buffer()->ToI420(), *test_frame->video_frame_buffer()->ToI420()); } double I420WeightedPSNR(const I420BufferInterface& ref_buffer, const I420BufferInterface& test_buffer) { RTC_DCHECK_GE(ref_buffer.width(), test_buffer.width()); RTC_DCHECK_GE(ref_buffer.height(), test_buffer.height()); if ((ref_buffer.width() != test_buffer.width()) || (ref_buffer.height() != test_buffer.height())) { scoped_refptr scaled_ref_buffer = I420Buffer::Create(test_buffer.width(), test_buffer.height()); scaled_ref_buffer->ScaleFrom(ref_buffer); return I420WeightedPSNR(*scaled_ref_buffer, test_buffer); } // Luma. int width_y = test_buffer.width(); int height_y = test_buffer.height(); uint64_t sse_y = libyuv::ComputeSumSquareErrorPlane( ref_buffer.DataY(), ref_buffer.StrideY(), test_buffer.DataY(), test_buffer.StrideY(), width_y, height_y); uint64_t num_samples_y = (uint64_t)width_y * (uint64_t)height_y; double psnr_y = libyuv::SumSquareErrorToPsnr(sse_y, num_samples_y); // Chroma. int width_uv = (width_y + 1) >> 1; int height_uv = (height_y + 1) >> 1; uint64_t sse_u = libyuv::ComputeSumSquareErrorPlane( ref_buffer.DataU(), ref_buffer.StrideU(), test_buffer.DataU(), test_buffer.StrideU(), width_uv, height_uv); uint64_t num_samples_uv = (uint64_t)width_uv * (uint64_t)height_uv; double psnr_u = libyuv::SumSquareErrorToPsnr(sse_u, num_samples_uv); uint64_t sse_v = libyuv::ComputeSumSquareErrorPlane( ref_buffer.DataV(), ref_buffer.StrideV(), test_buffer.DataV(), test_buffer.StrideV(), width_uv, height_uv); double psnr_v = libyuv::SumSquareErrorToPsnr(sse_v, num_samples_uv); // Weights from Ohm et. al 2012. double psnr_yuv = (6.0 * psnr_y + psnr_u + psnr_v) / 8.0; return (psnr_yuv > kPerfectPSNR) ? kPerfectPSNR : psnr_yuv; } // Compute SSIM for an I420A frame (all planes). Can upscale test frame. double I420ASSIM(const I420ABufferInterface& ref_buffer, const I420ABufferInterface& test_buffer) { RTC_DCHECK_GE(ref_buffer.width(), test_buffer.width()); RTC_DCHECK_GE(ref_buffer.height(), test_buffer.height()); if ((ref_buffer.width() != test_buffer.width()) || (ref_buffer.height() != test_buffer.height())) { scoped_refptr scaled_buffer = ScaleI420ABuffer(test_buffer, ref_buffer.width(), ref_buffer.height()); return I420ASSIM(ref_buffer, *scaled_buffer); } const double yuv_ssim = libyuv::I420Ssim( ref_buffer.DataY(), ref_buffer.StrideY(), ref_buffer.DataU(), ref_buffer.StrideU(), ref_buffer.DataV(), ref_buffer.StrideV(), test_buffer.DataY(), test_buffer.StrideY(), test_buffer.DataU(), test_buffer.StrideU(), test_buffer.DataV(), test_buffer.StrideV(), test_buffer.width(), test_buffer.height()); const double a_ssim = libyuv::CalcFrameSsim( ref_buffer.DataA(), ref_buffer.StrideA(), test_buffer.DataA(), test_buffer.StrideA(), test_buffer.width(), test_buffer.height()); return (yuv_ssim + (a_ssim * 0.8)) / 1.8; } // Compute SSIM for an I420A frame (all planes) double I420ASSIM(const VideoFrame* ref_frame, const VideoFrame* test_frame) { if (!ref_frame || !test_frame) return -1; RTC_DCHECK(ref_frame->video_frame_buffer()->type() == VideoFrameBuffer::Type::kI420A); RTC_DCHECK(test_frame->video_frame_buffer()->type() == VideoFrameBuffer::Type::kI420A); return I420ASSIM(*ref_frame->video_frame_buffer()->GetI420A(), *test_frame->video_frame_buffer()->GetI420A()); } // Compute SSIM for an I420 frame (all planes). Can upscale test_buffer. double I420SSIM(const I420BufferInterface& ref_buffer, const I420BufferInterface& test_buffer) { RTC_DCHECK_GE(ref_buffer.width(), test_buffer.width()); RTC_DCHECK_GE(ref_buffer.height(), test_buffer.height()); if ((ref_buffer.width() != test_buffer.width()) || (ref_buffer.height() != test_buffer.height())) { scoped_refptr scaled_buffer = I420Buffer::Create(ref_buffer.width(), ref_buffer.height()); scaled_buffer->ScaleFrom(test_buffer); return I420SSIM(ref_buffer, *scaled_buffer); } return libyuv::I420Ssim( ref_buffer.DataY(), ref_buffer.StrideY(), ref_buffer.DataU(), ref_buffer.StrideU(), ref_buffer.DataV(), ref_buffer.StrideV(), test_buffer.DataY(), test_buffer.StrideY(), test_buffer.DataU(), test_buffer.StrideU(), test_buffer.DataV(), test_buffer.StrideV(), test_buffer.width(), test_buffer.height()); } double I420SSIM(const VideoFrame* ref_frame, const VideoFrame* test_frame) { if (!ref_frame || !test_frame) return -1; return I420SSIM(*ref_frame->video_frame_buffer()->ToI420(), *test_frame->video_frame_buffer()->ToI420()); } void NV12Scale(uint8_t* tmp_buffer, const uint8_t* src_y, int src_stride_y, const uint8_t* src_uv, int src_stride_uv, int src_width, int src_height, uint8_t* dst_y, int dst_stride_y, uint8_t* dst_uv, int dst_stride_uv, int dst_width, int dst_height) { const int src_chroma_width = (src_width + 1) / 2; const int src_chroma_height = (src_height + 1) / 2; if (src_width == dst_width && src_height == dst_height) { // No scaling. libyuv::CopyPlane(src_y, src_stride_y, dst_y, dst_stride_y, src_width, src_height); libyuv::CopyPlane(src_uv, src_stride_uv, dst_uv, dst_stride_uv, src_chroma_width * 2, src_chroma_height); return; } // Scaling. // Allocate temporary memory for spitting UV planes and scaling them. const int dst_chroma_width = (dst_width + 1) / 2; const int dst_chroma_height = (dst_height + 1) / 2; uint8_t* const src_u = tmp_buffer; uint8_t* const src_v = src_u + src_chroma_width * src_chroma_height; uint8_t* const dst_u = src_v + src_chroma_width * src_chroma_height; uint8_t* const dst_v = dst_u + dst_chroma_width * dst_chroma_height; // Split source UV plane into separate U and V plane using the temporary data. libyuv::SplitUVPlane(src_uv, src_stride_uv, src_u, src_chroma_width, src_v, src_chroma_width, src_chroma_width, src_chroma_height); // Scale the planes. libyuv::I420Scale( src_y, src_stride_y, src_u, src_chroma_width, src_v, src_chroma_width, src_width, src_height, dst_y, dst_stride_y, dst_u, dst_chroma_width, dst_v, dst_chroma_width, dst_width, dst_height, libyuv::kFilterBox); // Merge the UV planes into the destination. libyuv::MergeUVPlane(dst_u, dst_chroma_width, dst_v, dst_chroma_width, dst_uv, dst_stride_uv, dst_chroma_width, dst_chroma_height); } NV12ToI420Scaler::NV12ToI420Scaler() = default; NV12ToI420Scaler::~NV12ToI420Scaler() = default; void NV12ToI420Scaler::NV12ToI420Scale(const uint8_t* src_y, int src_stride_y, const uint8_t* src_uv, int src_stride_uv, int src_width, int src_height, uint8_t* dst_y, int dst_stride_y, uint8_t* dst_u, int dst_stride_u, uint8_t* dst_v, int dst_stride_v, int dst_width, int dst_height) { if (src_width == dst_width && src_height == dst_height) { // No scaling. tmp_uv_planes_.clear(); tmp_uv_planes_.shrink_to_fit(); libyuv::NV12ToI420(src_y, src_stride_y, src_uv, src_stride_uv, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, src_width, src_height); return; } // Scaling. // Allocate temporary memory for spitting UV planes. const int src_uv_width = (src_width + 1) / 2; const int src_uv_height = (src_height + 1) / 2; tmp_uv_planes_.resize(src_uv_width * src_uv_height * 2); tmp_uv_planes_.shrink_to_fit(); // Split source UV plane into separate U and V plane using the temporary data. uint8_t* const src_u = tmp_uv_planes_.data(); uint8_t* const src_v = tmp_uv_planes_.data() + src_uv_width * src_uv_height; libyuv::SplitUVPlane(src_uv, src_stride_uv, src_u, src_uv_width, src_v, src_uv_width, src_uv_width, src_uv_height); // Scale the planes into the destination. libyuv::I420Scale(src_y, src_stride_y, src_u, src_uv_width, src_v, src_uv_width, src_width, src_height, dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v, dst_width, dst_height, libyuv::kFilterBox); } } // namespace webrtc