Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-23 21:01:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
902392c3b3
gecko-dev/gfx/ycbcr/scale_yuv_argb.cpp
Michael Froman 318bb2d6ff Bug 1698699 - P7 - add missing include for hybrid builds. r=ng 
Depends on D150312

Differential Revision: https://phabricator.services.mozilla.com/D150480
2022-06-28 16:29:41 +00:00

1133 lines
38 KiB
C++
Raw Blame History

/*
* Copyright 2011 The LibYuv Project Authors. All rights reserved.
* Copyright 2016 Mozilla Foundation
*
* 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 "libyuv/scale.h"
#include <assert.h>
#include <string.h>
#include "libyuv/convert_argb.h"
#include "libyuv/cpu_id.h"
#include "libyuv/row.h"
#include "libyuv/scale_row.h"
#include "libyuv/video_common.h"
#include "mozilla/gfx/Types.h"
#ifdef __cplusplus
namespace libyuv {
extern "C" {
#endif
// YUV to RGB conversion and scaling functions were implemented by referencing
// scale_argb.cc
//
// libyuv already has ScaleYUVToARGBBilinearUp(), but its implementation is not
// completed yet. Implementations of the functions are based on it.
// At first, ScaleYUVToARGBBilinearUp() was implemented by modifying the
// libyuv's one. Then all another functions were implemented similarly.
//
// Function relationship between yuv_convert.cpp and scale_argb.cc are like
// the followings
// - ScaleYUVToARGBDown2() <-- ScaleARGBDown2()
// - ScaleYUVToARGBDownEven() <-- ScaleARGBDownEven()
// - ScaleYUVToARGBBilinearDown() <-- ScaleARGBBilinearDown()
// - ScaleYUVToARGBBilinearUp() <-- ScaleARGBBilinearUp() and ScaleYUVToARGBBilinearUp() in libyuv
// - ScaleYUVToARGBSimple() <-- ScaleARGBSimple()
// - ScaleYUVToARGB() <-- ScaleARGB() // Removed some function calls for simplicity.
// - YUVToARGBScale() <-- ARGBScale()
//
// Callings and selections of InterpolateRow() and ScaleARGBFilterCols() were
// kept as same as possible.
//
// The followings changes were done to each scaling functions.
//
// -[1] Allocate YUV conversion buffer and use it as source buffer of scaling.
// Its usage is borrowed from the libyuv's ScaleYUVToARGBBilinearUp().
// -[2] Conversion from YUV to RGB was abstracted as YUVBuferIter.
// It is for handling multiple yuv color formats.
// -[3] Modified scaling functions as to handle YUV conversion buffer and
// use YUVBuferIter.
// -[4] Color conversion function selections in YUVBuferIter were borrowed from
// I444ToARGBMatrix(), I422ToARGBMatrix() and I420ToARGBMatrix()
typedef mozilla::gfx::YUVColorSpace YUVColorSpace;
struct YUVBuferIter {
int src_width;
int src_height;
int src_stride_y;
int src_stride_u;
int src_stride_v;
const uint8_t* src_y;
const uint8_t* src_u;
const uint8_t* src_v;
uint32_t src_fourcc;
const struct YuvConstants* yuvconstants;
int y_index;
const uint8_t* src_row_y;
const uint8_t* src_row_u;
const uint8_t* src_row_v;
void (*YUVToARGBRow)(const uint8_t* y_buf,
const uint8_t* u_buf,
const uint8_t* v_buf,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width);
void (*MoveTo)(YUVBuferIter& iter, int y_index);
void (*MoveToNextRow)(YUVBuferIter& iter);
};
void YUVBuferIter_InitI422(YUVBuferIter& iter) {
iter.YUVToARGBRow = I422ToARGBRow_C;
#if defined(HAS_I422TOARGBROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3)) {
iter.YUVToARGBRow = I422ToARGBRow_Any_SSSE3;
if (IS_ALIGNED(iter.src_width, 8)) {
iter.YUVToARGBRow = I422ToARGBRow_SSSE3;
}
}
#endif
#if defined(HAS_I422TOARGBROW_AVX2)
if (TestCpuFlag(kCpuHasAVX2)) {
iter.YUVToARGBRow = I422ToARGBRow_Any_AVX2;
if (IS_ALIGNED(iter.src_width, 16)) {
iter.YUVToARGBRow = I422ToARGBRow_AVX2;
}
}
#endif
#if defined(HAS_I422TOARGBROW_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
iter.YUVToARGBRow = I422ToARGBRow_Any_NEON;
if (IS_ALIGNED(iter.src_width, 8)) {
iter.YUVToARGBRow = I422ToARGBRow_NEON;
}
}
#endif
#if defined(HAS_I422TOARGBROW_DSPR2)
if (TestCpuFlag(kCpuHasDSPR2) && IS_ALIGNED(iter.src_width, 4) &&
IS_ALIGNED(iter.src_y, 4) && IS_ALIGNED(iter.src_stride_y, 4) &&
IS_ALIGNED(iter.src_u, 2) && IS_ALIGNED(iter.src_stride_u, 2) &&
IS_ALIGNED(iter.src_v, 2) && IS_ALIGNED(iter.src_stride_v, 2) {
// Always satisfy IS_ALIGNED(argb_cnv_row, 4) && IS_ALIGNED(argb_cnv_rowstride, 4)
iter.YUVToARGBRow = I422ToARGBRow_DSPR2;
}
#endif
}
void YUVBuferIter_InitI444(YUVBuferIter& iter) {
iter.YUVToARGBRow = I444ToARGBRow_C;
#if defined(HAS_I444TOARGBROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3)) {
iter.YUVToARGBRow = I444ToARGBRow_Any_SSSE3;
if (IS_ALIGNED(iter.src_width, 8)) {
iter.YUVToARGBRow = I444ToARGBRow_SSSE3;
}
}
#endif
#if defined(HAS_I444TOARGBROW_AVX2)
if (TestCpuFlag(kCpuHasAVX2)) {
iter.YUVToARGBRow = I444ToARGBRow_Any_AVX2;
if (IS_ALIGNED(iter.src_width, 16)) {
iter.YUVToARGBRow = I444ToARGBRow_AVX2;
}
}
#endif
#if defined(HAS_I444TOARGBROW_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
iter.YUVToARGBRow = I444ToARGBRow_Any_NEON;
if (IS_ALIGNED(iter.src_width, 8)) {
iter.YUVToARGBRow = I444ToARGBRow_NEON;
}
}
#endif
}
static void YUVBuferIter_MoveToForI444(YUVBuferIter& iter, int y_index) {
iter.y_index = y_index;
iter.src_row_y = iter.src_y + y_index * iter.src_stride_y;
iter.src_row_u = iter.src_u + y_index * iter.src_stride_u;
iter.src_row_v = iter.src_v + y_index * iter.src_stride_v;
}
static void YUVBuferIter_MoveToNextRowForI444(YUVBuferIter& iter) {
iter.src_row_y += iter.src_stride_y;
iter.src_row_u += iter.src_stride_u;
iter.src_row_v += iter.src_stride_v;
iter.y_index++;
}
static void YUVBuferIter_MoveToForI422(YUVBuferIter& iter, int y_index) {
iter.y_index = y_index;
iter.src_row_y = iter.src_y + y_index * iter.src_stride_y;
iter.src_row_u = iter.src_u + y_index * iter.src_stride_u;
iter.src_row_v = iter.src_v + y_index * iter.src_stride_v;
}
static void YUVBuferIter_MoveToNextRowForI422(YUVBuferIter& iter) {
iter.src_row_y += iter.src_stride_y;
iter.src_row_u += iter.src_stride_u;
iter.src_row_v += iter.src_stride_v;
iter.y_index++;
}
static void YUVBuferIter_MoveToForI420(YUVBuferIter& iter, int y_index) {
const int kYShift = 1; // Shift Y by 1 to convert Y plane to UV coordinate.
int uv_y_index = y_index >> kYShift;
iter.y_index = y_index;
iter.src_row_y = iter.src_y + y_index * iter.src_stride_y;
iter.src_row_u = iter.src_u + uv_y_index * iter.src_stride_u;
iter.src_row_v = iter.src_v + uv_y_index * iter.src_stride_v;
}
static void YUVBuferIter_MoveToNextRowForI420(YUVBuferIter& iter) {
iter.src_row_y += iter.src_stride_y;
if (iter.y_index & 1) {
iter.src_row_u += iter.src_stride_u;
iter.src_row_v += iter.src_stride_v;
}
iter.y_index++;
}
static __inline void YUVBuferIter_ConvertToARGBRow(YUVBuferIter& iter, uint8_t* argb_row) {
iter.YUVToARGBRow(iter.src_row_y, iter.src_row_u, iter.src_row_v, argb_row, iter.yuvconstants, iter.src_width);
}
void YUVBuferIter_Init(YUVBuferIter& iter, uint32_t src_fourcc, YUVColorSpace yuv_color_space) {
iter.src_fourcc = src_fourcc;
iter.y_index = 0;
iter.src_row_y = iter.src_y;
iter.src_row_u = iter.src_u;
iter.src_row_v = iter.src_v;
switch (yuv_color_space) {
case YUVColorSpace::BT2020:
iter.yuvconstants = &kYuv2020Constants;
break;
case YUVColorSpace::BT709:
iter.yuvconstants = &kYuvH709Constants;
break;
default:
iter.yuvconstants = &kYuvI601Constants;
}
if (src_fourcc == FOURCC_I444) {
YUVBuferIter_InitI444(iter);
iter.MoveTo = YUVBuferIter_MoveToForI444;
iter.MoveToNextRow = YUVBuferIter_MoveToNextRowForI444;
} else if(src_fourcc == FOURCC_I422){
YUVBuferIter_InitI422(iter);
iter.MoveTo = YUVBuferIter_MoveToForI422;
iter.MoveToNextRow = YUVBuferIter_MoveToNextRowForI422;
} else {
assert(src_fourcc == FOURCC_I420); // Should be FOURCC_I420
YUVBuferIter_InitI422(iter);
iter.MoveTo = YUVBuferIter_MoveToForI420;
iter.MoveToNextRow = YUVBuferIter_MoveToNextRowForI420;
}
}
// ScaleARGB ARGB, 1/2
// This is an optimized version for scaling down a ARGB to 1/2 of
// its original size.
static void ScaleYUVToARGBDown2(int src_width, int src_height,
int dst_width, int dst_height,
int src_stride_y,
int src_stride_u,
int src_stride_v,
int dst_stride_argb,
const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* dst_argb,
int x, int dx, int y, int dy,
enum FilterMode filtering,
uint32_t src_fourcc,
YUVColorSpace yuv_color_space) {
int j;
// Allocate 2 rows of ARGB for source conversion.
const int kRowSize = (src_width * 4 + 15) & ~15;
align_buffer_64(argb_cnv_row, kRowSize * 2);
uint8_t* argb_cnv_rowptr = argb_cnv_row;
int argb_cnv_rowstride = kRowSize;
YUVBuferIter iter;
iter.src_width = src_width;
iter.src_height = src_height;
iter.src_stride_y = src_stride_y;
iter.src_stride_u = src_stride_u;
iter.src_stride_v = src_stride_v;
iter.src_y = src_y;
iter.src_u = src_u;
iter.src_v = src_v;
YUVBuferIter_Init(iter, src_fourcc, yuv_color_space);
void (*ScaleARGBRowDown2)(const uint8_t* src_argb, ptrdiff_t src_stride,
uint8_t* dst_argb, int dst_width) =
filtering == kFilterNone ? ScaleARGBRowDown2_C :
(filtering == kFilterLinear ? ScaleARGBRowDown2Linear_C :
ScaleARGBRowDown2Box_C);
assert(dx == 65536 * 2); // Test scale factor of 2.
assert((dy & 0x1ffff) == 0); // Test vertical scale is multiple of 2.
// Advance to odd row, even column.
int yi = y >> 16;
iter.MoveTo(iter, yi);
ptrdiff_t x_offset;
if (filtering == kFilterBilinear) {
x_offset = (x >> 16) * 4;
} else {
x_offset = ((x >> 16) - 1) * 4;
}
#if defined(HAS_SCALEARGBROWDOWN2_SSE2)
if (TestCpuFlag(kCpuHasSSE2)) {
ScaleARGBRowDown2 = filtering == kFilterNone ? ScaleARGBRowDown2_Any_SSE2 :
(filtering == kFilterLinear ? ScaleARGBRowDown2Linear_Any_SSE2 :
ScaleARGBRowDown2Box_Any_SSE2);
if (IS_ALIGNED(dst_width, 4)) {
ScaleARGBRowDown2 = filtering == kFilterNone ? ScaleARGBRowDown2_SSE2 :
(filtering == kFilterLinear ? ScaleARGBRowDown2Linear_SSE2 :
ScaleARGBRowDown2Box_SSE2);
}
}
#endif
#if defined(HAS_SCALEARGBROWDOWN2_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
ScaleARGBRowDown2 = filtering == kFilterNone ? ScaleARGBRowDown2_Any_NEON :
(filtering == kFilterLinear ? ScaleARGBRowDown2Linear_Any_NEON :
ScaleARGBRowDown2Box_Any_NEON);
if (IS_ALIGNED(dst_width, 8)) {
ScaleARGBRowDown2 = filtering == kFilterNone ? ScaleARGBRowDown2_NEON :
(filtering == kFilterLinear ? ScaleARGBRowDown2Linear_NEON :
ScaleARGBRowDown2Box_NEON);
}
}
#endif
const int dyi = dy >> 16;
int lastyi = yi;
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);
// Prepare next row if necessary
if (filtering != kFilterLinear) {
if ((yi + dyi) < (src_height - 1)) {
iter.MoveTo(iter, yi + dyi);
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr + argb_cnv_rowstride);
} else {
argb_cnv_rowstride = 0;
}
}
if (filtering == kFilterLinear) {
argb_cnv_rowstride = 0;
}
const int max_yi = src_height - 1;
const int max_yi_minus_dyi = max_yi - dyi;
for (j = 0; j < dst_height; ++j) {
if (yi != lastyi) {
if (yi > max_yi) {
yi = max_yi;
}
if (yi != lastyi) {
if (filtering == kFilterLinear) {
iter.MoveTo(iter, yi);
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);
lastyi = yi;
} else {
// Prepare current row
if (yi == iter.y_index) {
argb_cnv_rowptr = argb_cnv_rowptr + argb_cnv_rowstride;
argb_cnv_rowstride = - argb_cnv_rowstride;
} else {
iter.MoveTo(iter, yi);
argb_cnv_rowptr = argb_cnv_row;
argb_cnv_rowstride = kRowSize;
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);
}
// Prepare next row if necessary
if (iter.y_index < max_yi) {
int next_yi = yi < max_yi_minus_dyi ? yi + dyi : max_yi;
iter.MoveTo(iter, next_yi);
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr + argb_cnv_rowstride);
} else {
argb_cnv_rowstride = 0;
}
lastyi = yi;
}
}
}
ScaleARGBRowDown2(argb_cnv_rowptr + x_offset, argb_cnv_rowstride, dst_argb, dst_width);
dst_argb += dst_stride_argb;
yi += dyi;
}
free_aligned_buffer_64(argb_cnv_row);
}
// ScaleARGB ARGB Even
// This is an optimized version for scaling down a ARGB to even
// multiple of its original size.
static void ScaleYUVToARGBDownEven(int src_width, int src_height,
int dst_width, int dst_height,
int src_stride_y,
int src_stride_u,
int src_stride_v,
int dst_stride_argb,
const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* dst_argb,
int x, int dx, int y, int dy,
enum FilterMode filtering,
uint32_t src_fourcc,
YUVColorSpace yuv_color_space) {
int j;
// Allocate 2 rows of ARGB for source conversion.
const int kRowSize = (src_width * 4 + 15) & ~15;
align_buffer_64(argb_cnv_row, kRowSize * 2);
uint8_t* argb_cnv_rowptr = argb_cnv_row;
int argb_cnv_rowstride = kRowSize;
int col_step = dx >> 16;
void (*ScaleARGBRowDownEven)(const uint8_t* src_argb, ptrdiff_t src_stride,
int src_step, uint8_t* dst_argb, int dst_width) =
filtering ? ScaleARGBRowDownEvenBox_C : ScaleARGBRowDownEven_C;
assert(IS_ALIGNED(src_width, 2));
assert(IS_ALIGNED(src_height, 2));
int yi = y >> 16;
const ptrdiff_t x_offset = (x >> 16) * 4;
#if defined(HAS_SCALEARGBROWDOWNEVEN_SSE2)
if (TestCpuFlag(kCpuHasSSE2)) {
ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_Any_SSE2 :
ScaleARGBRowDownEven_Any_SSE2;
if (IS_ALIGNED(dst_width, 4)) {
ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_SSE2 :
ScaleARGBRowDownEven_SSE2;
}
}
#endif
#if defined(HAS_SCALEARGBROWDOWNEVEN_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_Any_NEON :
ScaleARGBRowDownEven_Any_NEON;
if (IS_ALIGNED(dst_width, 4)) {
ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_NEON :
ScaleARGBRowDownEven_NEON;
}
}
#endif
YUVBuferIter iter;
iter.src_width = src_width;
iter.src_height = src_height;
iter.src_stride_y = src_stride_y;
iter.src_stride_u = src_stride_u;
iter.src_stride_v = src_stride_v;
iter.src_y = src_y;
iter.src_u = src_u;
iter.src_v = src_v;
YUVBuferIter_Init(iter, src_fourcc, yuv_color_space);
const int dyi = dy >> 16;
int lastyi = yi;
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);
// Prepare next row if necessary
if (filtering != kFilterLinear) {
if ((yi + dyi) < (src_height - 1)) {
iter.MoveTo(iter, yi + dyi);
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr + argb_cnv_rowstride);
} else {
argb_cnv_rowstride = 0;
}
}
if (filtering == kFilterLinear) {
argb_cnv_rowstride = 0;
}
const int max_yi = src_height - 1;
const int max_yi_minus_dyi = max_yi - dyi;
for (j = 0; j < dst_height; ++j) {
if (yi != lastyi) {
if (yi > max_yi) {
yi = max_yi;
}
if (yi != lastyi) {
if (filtering == kFilterLinear) {
iter.MoveTo(iter, yi);
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);
lastyi = yi;
} else {
// Prepare current row
if (yi == iter.y_index) {
argb_cnv_rowptr = argb_cnv_rowptr + argb_cnv_rowstride;
argb_cnv_rowstride = - argb_cnv_rowstride;
} else {
iter.MoveTo(iter, yi);
argb_cnv_rowptr = argb_cnv_row;
argb_cnv_rowstride = kRowSize;
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);
}
// Prepare next row if necessary
if (iter.y_index < max_yi) {
int next_yi = yi < max_yi_minus_dyi ? yi + dyi : max_yi;
iter.MoveTo(iter, next_yi);
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr + argb_cnv_rowstride);
} else {
argb_cnv_rowstride = 0;
}
lastyi = yi;
}
}
}
ScaleARGBRowDownEven(argb_cnv_rowptr + x_offset, argb_cnv_rowstride, col_step, dst_argb, dst_width);
dst_argb += dst_stride_argb;
yi += dyi;
}
free_aligned_buffer_64(argb_cnv_row);
}
// Scale YUV to ARGB down with bilinear interpolation.
static void ScaleYUVToARGBBilinearDown(int src_width, int src_height,
int dst_width, int dst_height,
int src_stride_y,
int src_stride_u,
int src_stride_v,
int dst_stride_argb,
const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* dst_argb,
int x, int dx, int y, int dy,
enum FilterMode filtering,
uint32_t src_fourcc,
YUVColorSpace yuv_color_space) {
int j;
void (*InterpolateRow)(uint8_t* dst_argb, const uint8_t* src_argb,
ptrdiff_t src_stride, int dst_width, int source_y_fraction) =
InterpolateRow_C;
void (*ScaleARGBFilterCols)(uint8_t* dst_argb, const uint8_t* src_argb,
int dst_width, int x, int dx) =
(src_width >= 32768) ? ScaleARGBFilterCols64_C : ScaleARGBFilterCols_C;
int64_t xlast = x + (int64_t)(dst_width - 1) * dx;
int64_t xl = (dx >= 0) ? x : xlast;
int64_t xr = (dx >= 0) ? xlast : x;
int clip_src_width;
xl = (xl >> 16) & ~3; // Left edge aligned.
xr = (xr >> 16) + 1; // Right most pixel used. Bilinear uses 2 pixels.
xr = (xr + 1 + 3) & ~3; // 1 beyond 4 pixel aligned right most pixel.
if (xr > src_width) {
xr = src_width;
}
clip_src_width = (int)(xr - xl) * 4; // Width aligned to 4.
const ptrdiff_t xl_offset = xl * 4;
x -= (int)(xl << 16);
// Allocate 2 row of ARGB for source conversion.
const int kRowSize = (src_width * 4 + 15) & ~15;
align_buffer_64(argb_cnv_row, kRowSize * 2);
uint8_t* argb_cnv_rowptr = argb_cnv_row;
int argb_cnv_rowstride = kRowSize;
#if defined(HAS_INTERPOLATEROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3)) {
InterpolateRow = InterpolateRow_Any_SSSE3;
if (IS_ALIGNED(clip_src_width, 16)) {
InterpolateRow = InterpolateRow_SSSE3;
}
}
#endif
#if defined(HAS_INTERPOLATEROW_AVX2)
if (TestCpuFlag(kCpuHasAVX2)) {
InterpolateRow = InterpolateRow_Any_AVX2;
if (IS_ALIGNED(clip_src_width, 32)) {
InterpolateRow = InterpolateRow_AVX2;
}
}
#endif
#if defined(HAS_INTERPOLATEROW_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
InterpolateRow = InterpolateRow_Any_NEON;
if (IS_ALIGNED(clip_src_width, 16)) {
InterpolateRow = InterpolateRow_NEON;
}
}
#endif
#if defined(HAS_INTERPOLATEROW_DSPR2)
if (TestCpuFlag(kCpuHasDSPR2) &&
IS_ALIGNED(src_argb, 4) && IS_ALIGNED(argb_cnv_rowstride, 4)) {
InterpolateRow = InterpolateRow_Any_DSPR2;
if (IS_ALIGNED(clip_src_width, 4)) {
InterpolateRow = InterpolateRow_DSPR2;
}
}
#endif
#if defined(HAS_SCALEARGBFILTERCOLS_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
ScaleARGBFilterCols = ScaleARGBFilterCols_SSSE3;
}
#endif
#if defined(HAS_SCALEARGBFILTERCOLS_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
ScaleARGBFilterCols = ScaleARGBFilterCols_Any_NEON;
if (IS_ALIGNED(dst_width, 4)) {
ScaleARGBFilterCols = ScaleARGBFilterCols_NEON;
}
}
#endif
int yi = y >> 16;
YUVBuferIter iter;
iter.src_width = src_width;
iter.src_height = src_height;
iter.src_stride_y = src_stride_y;
iter.src_stride_u = src_stride_u;
iter.src_stride_v = src_stride_v;
iter.src_y = src_y;
iter.src_u = src_u;
iter.src_v = src_v;
YUVBuferIter_Init(iter, src_fourcc, yuv_color_space);
iter.MoveTo(iter, yi);
// TODO(fbarchard): Consider not allocating row buffer for kFilterLinear.
// Allocate a row of ARGB.
align_buffer_64(row, clip_src_width * 4);
int lastyi = yi;
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);
// Prepare next row if necessary
if (filtering != kFilterLinear) {
if ((yi + 1) < src_height) {
iter.MoveToNextRow(iter);
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr + argb_cnv_rowstride);
} else {
argb_cnv_rowstride = 0;
}
}
const int max_y = (src_height - 1) << 16;
const int max_yi = src_height - 1;
for (j = 0; j < dst_height; ++j) {
yi = y >> 16;
if (yi != lastyi) {
if (y > max_y) {
y = max_y;
yi = y >> 16;
}
if (yi != lastyi) {
if (filtering == kFilterLinear) {
iter.MoveTo(iter, yi);
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);
lastyi = yi;
} else {
// Prepare current row
if (yi == iter.y_index) {
argb_cnv_rowptr = argb_cnv_rowptr + argb_cnv_rowstride;
argb_cnv_rowstride = - argb_cnv_rowstride;
} else {
iter.MoveTo(iter, yi);
argb_cnv_rowptr = argb_cnv_row;
argb_cnv_rowstride = kRowSize;
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);
}
// Prepare next row if necessary
if (iter.y_index < max_yi) {
iter.MoveToNextRow(iter);
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr + argb_cnv_rowstride);
} else {
argb_cnv_rowstride = 0;
}
lastyi = yi;
}
}
}
if (filtering == kFilterLinear) {
ScaleARGBFilterCols(dst_argb, argb_cnv_rowptr + xl_offset, dst_width, x, dx);
} else {
int yf = (y >> 8) & 255;
InterpolateRow(row, argb_cnv_rowptr + xl_offset, argb_cnv_rowstride, clip_src_width, yf);
ScaleARGBFilterCols(dst_argb, row, dst_width, x, dx);
}
dst_argb += dst_stride_argb;
y += dy;
}
free_aligned_buffer_64(row);
free_aligned_buffer_64(argb_cnv_row);
}
// Scale YUV to ARGB up with bilinear interpolation.
static void ScaleYUVToARGBBilinearUp(int src_width, int src_height,
int dst_width, int dst_height,
int src_stride_y,
int src_stride_u,
int src_stride_v,
int dst_stride_argb,
const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* dst_argb,
int x, int dx, int y, int dy,
enum FilterMode filtering,
uint32_t src_fourcc,
YUVColorSpace yuv_color_space) {
int j;
void (*InterpolateRow)(uint8_t* dst_argb, const uint8_t* src_argb,
ptrdiff_t src_stride, int dst_width, int source_y_fraction) =
InterpolateRow_C;
void (*ScaleARGBFilterCols)(uint8_t* dst_argb, const uint8_t* src_argb,
int dst_width, int x, int dx) =
filtering ? ScaleARGBFilterCols_C : ScaleARGBCols_C;
const int max_y = (src_height - 1) << 16;
// Allocate 1 row of ARGB for source conversion.
align_buffer_64(argb_cnv_row, src_width * 4);
#if defined(HAS_INTERPOLATEROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3)) {
InterpolateRow = InterpolateRow_Any_SSSE3;
if (IS_ALIGNED(dst_width, 4)) {
InterpolateRow = InterpolateRow_SSSE3;
}
}
#endif
#if defined(HAS_INTERPOLATEROW_AVX2)
if (TestCpuFlag(kCpuHasAVX2)) {
InterpolateRow = InterpolateRow_Any_AVX2;
if (IS_ALIGNED(dst_width, 8)) {
InterpolateRow = InterpolateRow_AVX2;
}
}
#endif
#if defined(HAS_INTERPOLATEROW_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
InterpolateRow = InterpolateRow_Any_NEON;
if (IS_ALIGNED(dst_width, 4)) {
InterpolateRow = InterpolateRow_NEON;
}
}
#endif
#if defined(HAS_INTERPOLATEROW_DSPR2)
if (TestCpuFlag(kCpuHasDSPR2) &&
IS_ALIGNED(dst_argb, 4) && IS_ALIGNED(dst_stride_argb, 4)) {
InterpolateRow = InterpolateRow_DSPR2;
}
#endif
if (src_width >= 32768) {
ScaleARGBFilterCols = filtering ?
ScaleARGBFilterCols64_C : ScaleARGBCols64_C;
}
#if defined(HAS_SCALEARGBFILTERCOLS_SSSE3)
if (filtering && TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {
ScaleARGBFilterCols = ScaleARGBFilterCols_SSSE3;
}
#endif
#if defined(HAS_SCALEARGBFILTERCOLS_NEON)
if (filtering && TestCpuFlag(kCpuHasNEON)) {
ScaleARGBFilterCols = ScaleARGBFilterCols_Any_NEON;
if (IS_ALIGNED(dst_width, 4)) {
ScaleARGBFilterCols = ScaleARGBFilterCols_NEON;
}
}
#endif
#if defined(HAS_SCALEARGBCOLS_SSE2)
if (!filtering && TestCpuFlag(kCpuHasSSE2) && src_width < 32768) {
ScaleARGBFilterCols = ScaleARGBCols_SSE2;
}
#endif
#if defined(HAS_SCALEARGBCOLS_NEON)
if (!filtering && TestCpuFlag(kCpuHasNEON)) {
ScaleARGBFilterCols = ScaleARGBCols_Any_NEON;
if (IS_ALIGNED(dst_width, 8)) {
ScaleARGBFilterCols = ScaleARGBCols_NEON;
}
}
#endif
if (!filtering && src_width * 2 == dst_width && x < 0x8000) {
ScaleARGBFilterCols = ScaleARGBColsUp2_C;
#if defined(HAS_SCALEARGBCOLSUP2_SSE2)
if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(dst_width, 8)) {
ScaleARGBFilterCols = ScaleARGBColsUp2_SSE2;
}
#endif
}
if (y > max_y) {
y = max_y;
}
int yi = y >> 16;
YUVBuferIter iter;
iter.src_width = src_width;
iter.src_height = src_height;
iter.src_stride_y = src_stride_y;
iter.src_stride_u = src_stride_u;
iter.src_stride_v = src_stride_v;
iter.src_y = src_y;
iter.src_u = src_u;
iter.src_v = src_v;
YUVBuferIter_Init(iter, src_fourcc, yuv_color_space);
iter.MoveTo(iter, yi);
// Allocate 2 rows of ARGB.
const int kRowSize = (dst_width * 4 + 15) & ~15;
align_buffer_64(row, kRowSize * 2);
uint8_t* rowptr = row;
int rowstride = kRowSize;
int lastyi = yi;
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_row);
ScaleARGBFilterCols(rowptr, argb_cnv_row, dst_width, x, dx);
if (filtering == kFilterLinear) {
rowstride = 0;
}
// Prepare next row if necessary
if (filtering != kFilterLinear) {
if ((yi + 1) < src_height) {
iter.MoveToNextRow(iter);
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_row);
ScaleARGBFilterCols(rowptr + rowstride, argb_cnv_row, dst_width, x, dx);
}else {
rowstride = 0;
}
}
const int max_yi = src_height - 1;
for (j = 0; j < dst_height; ++j) {
yi = y >> 16;
if (yi != lastyi) {
if (y > max_y) {
y = max_y;
yi = y >> 16;
}
if (yi != lastyi) {
if (filtering == kFilterLinear) {
iter.MoveToNextRow(iter);
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_row);
ScaleARGBFilterCols(rowptr, argb_cnv_row, dst_width, x, dx);
} else {
// Prepare next row if necessary
if (yi < max_yi) {
iter.MoveToNextRow(iter);
rowptr += rowstride;
rowstride = -rowstride;
// TODO(fbarchard): Convert the clipped region of row.
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_row);
ScaleARGBFilterCols(rowptr + rowstride, argb_cnv_row, dst_width, x, dx);
} else {
rowstride = 0;
}
}
lastyi = yi;
}
}
if (filtering == kFilterLinear) {
InterpolateRow(dst_argb, rowptr, 0, dst_width * 4, 0);
} else {
int yf = (y >> 8) & 255;
InterpolateRow(dst_argb, rowptr, rowstride, dst_width * 4, yf);
}
dst_argb += dst_stride_argb;
y += dy;
}
free_aligned_buffer_64(row);
free_aligned_buffer_64(argb_cnv_row);
}
// Scale ARGB to/from any dimensions, without interpolation.
// Fixed point math is used for performance: The upper 16 bits
// of x and dx is the integer part of the source position and
// the lower 16 bits are the fixed decimal part.
static void ScaleYUVToARGBSimple(int src_width, int src_height,
int dst_width, int dst_height,
int src_stride_y,
int src_stride_u,
int src_stride_v,
int dst_stride_argb,
const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* dst_argb,
int x, int dx, int y, int dy,
uint32_t src_fourcc,
YUVColorSpace yuv_color_space) {
int j;
void (*ScaleARGBCols)(uint8_t* dst_argb, const uint8_t* src_argb,
int dst_width, int x, int dx) =
(src_width >= 32768) ? ScaleARGBCols64_C : ScaleARGBCols_C;
// Allocate 1 row of ARGB for source conversion.
align_buffer_64(argb_cnv_row, src_width * 4);
#if defined(HAS_SCALEARGBCOLS_SSE2)
if (TestCpuFlag(kCpuHasSSE2) && src_width < 32768) {
ScaleARGBCols = ScaleARGBCols_SSE2;
}
#endif
#if defined(HAS_SCALEARGBCOLS_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
ScaleARGBCols = ScaleARGBCols_Any_NEON;
if (IS_ALIGNED(dst_width, 8)) {
ScaleARGBCols = ScaleARGBCols_NEON;
}
}
#endif
if (src_width * 2 == dst_width && x < 0x8000) {
ScaleARGBCols = ScaleARGBColsUp2_C;
#if defined(HAS_SCALEARGBCOLSUP2_SSE2)
if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(dst_width, 8)) {
ScaleARGBCols = ScaleARGBColsUp2_SSE2;
}
#endif
}
int yi = y >> 16;
YUVBuferIter iter;
iter.src_width = src_width;
iter.src_height = src_height;
iter.src_stride_y = src_stride_y;
iter.src_stride_u = src_stride_u;
iter.src_stride_v = src_stride_v;
iter.src_y = src_y;
iter.src_u = src_u;
iter.src_v = src_v;
YUVBuferIter_Init(iter, src_fourcc, yuv_color_space);
iter.MoveTo(iter, yi);
int lasty = yi;
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_row);
for (j = 0; j < dst_height; ++j) {
yi = y >> 16;
if (yi != lasty) {
iter.MoveTo(iter, yi);
YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_row);
lasty = yi;
}
ScaleARGBCols(dst_argb, argb_cnv_row, dst_width, x, dx);
dst_argb += dst_stride_argb;
y += dy;
}
free_aligned_buffer_64(argb_cnv_row);
}
static void YUVToARGBCopy(const uint8_t* src_y, int src_stride_y,
const uint8_t* src_u, int src_stride_u,
const uint8_t* src_v, int src_stride_v,
int src_width, int src_height,
uint8_t* dst_argb, int dst_stride_argb,
int dst_width, int dst_height,
uint32_t src_fourcc,
YUVColorSpace yuv_color_space)
{
YUVBuferIter iter;
iter.src_width = src_width;
iter.src_height = src_height;
iter.src_stride_y = src_stride_y;
iter.src_stride_u = src_stride_u;
iter.src_stride_v = src_stride_v;
iter.src_y = src_y;
iter.src_u = src_u;
iter.src_v = src_v;
YUVBuferIter_Init(iter, src_fourcc, yuv_color_space);
for (int j = 0; j < dst_height; ++j) {
YUVBuferIter_ConvertToARGBRow(iter, dst_argb);
iter.MoveToNextRow(iter);
dst_argb += dst_stride_argb;
}
}
static void ScaleYUVToARGB(const uint8_t* src_y, int src_stride_y,
const uint8_t* src_u, int src_stride_u,
const uint8_t* src_v, int src_stride_v,
int src_width, int src_height,
uint8_t* dst_argb, int dst_stride_argb,
int dst_width, int dst_height,
enum FilterMode filtering,
uint32_t src_fourcc,
YUVColorSpace yuv_color_space)
{
// Initial source x/y coordinate and step values as 16.16 fixed point.
int x = 0;
int y = 0;
int dx = 0;
int dy = 0;
// ARGB does not support box filter yet, but allow the user to pass it.
// Simplify filtering when possible.
filtering = ScaleFilterReduce(src_width, src_height,
dst_width, dst_height,
filtering);
ScaleSlope(src_width, src_height, dst_width, dst_height, filtering,
&x, &y, &dx, &dy);
// Special case for integer step values.
if (((dx | dy) & 0xffff) == 0) {
if (!dx || !dy) { // 1 pixel wide and/or tall.
filtering = kFilterNone;
} else {
// Optimized even scale down. ie 2, 4, 6, 8, 10x.
if (!(dx & 0x10000) && !(dy & 0x10000)) {
if (dx == 0x20000) {
// Optimized 1/2 downsample.
ScaleYUVToARGBDown2(src_width, src_height,
dst_width, dst_height,
src_stride_y,
src_stride_u,
src_stride_v,
dst_stride_argb,
src_y,
src_u,
src_v,
dst_argb,
x, dx, y, dy,
filtering,
src_fourcc,
yuv_color_space);
return;
}
ScaleYUVToARGBDownEven(src_width, src_height,
dst_width, dst_height,
src_stride_y,
src_stride_u,
src_stride_v,
dst_stride_argb,
src_y,
src_u,
src_v,
dst_argb,
x, dx, y, dy,
filtering,
src_fourcc,
yuv_color_space);
return;
}
// Optimized odd scale down. ie 3, 5, 7, 9x.
if ((dx & 0x10000) && (dy & 0x10000)) {
filtering = kFilterNone;
if (dx == 0x10000 && dy == 0x10000) {
// Straight conversion and copy.
YUVToARGBCopy(src_y, src_stride_y,
src_u, src_stride_u,
src_v, src_stride_v,
src_width, src_height,
dst_argb, dst_stride_argb,
dst_width, dst_height,
src_fourcc,
yuv_color_space);
return;
}
}
}
}
if (filtering && dy < 65536) {
ScaleYUVToARGBBilinearUp(src_width, src_height,
dst_width, dst_height,
src_stride_y,
src_stride_u,
src_stride_v,
dst_stride_argb,
src_y,
src_u,
src_v,
dst_argb,
x, dx, y, dy,
filtering,
src_fourcc,
yuv_color_space);
return;
}
if (filtering) {
ScaleYUVToARGBBilinearDown(src_width, src_height,
dst_width, dst_height,
src_stride_y,
src_stride_u,
src_stride_v,
dst_stride_argb,
src_y,
src_u,
src_v,
dst_argb,
x, dx, y, dy,
filtering,
src_fourcc,
yuv_color_space);
return;
}
ScaleYUVToARGBSimple(src_width, src_height,
dst_width, dst_height,
src_stride_y,
src_stride_u,
src_stride_v,
dst_stride_argb,
src_y,
src_u,
src_v,
dst_argb,
x, dx, y, dy,
src_fourcc,
yuv_color_space);
}
bool IsConvertSupported(uint32_t src_fourcc)
{
if (src_fourcc == FOURCC_I444 ||
src_fourcc == FOURCC_I422 ||
src_fourcc == FOURCC_I420) {
return true;
}
return false;
}
LIBYUV_API
int YUVToARGBScale(const uint8_t* src_y, int src_stride_y,
const uint8_t* src_u, int src_stride_u,
const uint8_t* src_v, int src_stride_v,
uint32_t src_fourcc,
YUVColorSpace yuv_color_space,
int src_width, int src_height,
uint8_t* dst_argb, int dst_stride_argb,
int dst_width, int dst_height,
enum FilterMode filtering)
{
if (!src_y || !src_u || !src_v ||
src_width == 0 || src_height == 0 ||
!dst_argb || dst_width <= 0 || dst_height <= 0) {
return -1;
}
if (!IsConvertSupported(src_fourcc)) {
return -1;
}
ScaleYUVToARGB(src_y, src_stride_y,
src_u, src_stride_u,
src_v, src_stride_v,
src_width, src_height,
dst_argb, dst_stride_argb,
dst_width, dst_height,
filtering,
src_fourcc,
yuv_color_space);
return 0;
}
#ifdef __cplusplus
} // extern "C"
} // namespace libyuv
#endif
Reference in New Issue View Git Blame Copy Permalink