coffee/libyuv
1
0
Fork 0
mirror of https://chromium.googlesource.com/libyuv/libyuv synced 2025-12-06 08:46:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

I420ToRGB24MatrixFilter function added

Browse Source 
- Implemented as 3 steps: Upsample UV to 4:4:4, I444ToARGB, ARGBToRGB24
- Fix some build warnings for missing prototypes.

Pixel 4
I420ToRGB24_Opt (743 ms)
I420ToRGB24Filter_Opt (1331 ms)

Windows with skylake xeon:
x86 32 bit
I420ToRGB24_Opt (387 ms)
I420ToRGB24Filter_Opt (571 ms)
x64 64 bit
I420ToRGB24_Opt (384 ms)
I420ToRGB24Filter_Opt (582 ms)


Bug: libyuv:938, libyuv:830
Change-Id: Ie27f70816ec084437014f8a1c630ae011ee2348c
Reviewed-on: https://chromium-review.googlesource.com/c/libyuv/libyuv/+/3900298
Reviewed-by: Wan-Teh Chang <wtc@google.com>
This commit is contained in:
Frank Barchard 2022-09-16 11:12:39 -07:00 committed by Frank Barchard
parent 3e38ce5058
commit f71c83552d
19 changed files with 549 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.chromium
View File

@ -1,6 +1,6 @@
Name: libyuv
URL: http://code.google.com/p/libyuv/
Version: 1840
Version: 1841
License: BSD
License File: LICENSE

15
include/libyuv/convert_argb.h
View File

@ -1975,6 +1975,21 @@ int I422ToARGBMatrixFilter(const uint8_t* src_y,
int height,
enum FilterMode filter);
// Convert I420 to RGB24 with matrix and UV filter mode.
LIBYUV_API
int I420ToRGB24MatrixFilter(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,
uint8_t* dst_rgb24,
int dst_stride_rgb24,
const struct YuvConstants* yuvconstants,
int width,
int height,
enum FilterMode filter);
// Convert I010 to AR30 with matrix and UV filter mode.
LIBYUV_API
int I010ToAR30MatrixFilter(const uint16_t* src_y,

16
include/libyuv/row.h
View File

@ -1824,6 +1824,11 @@ void RGBAToUVRow_C(const uint8_t* src_rgb,
uint8_t* dst_u,
uint8_t* dst_v,
int width);
void RGBAToUVJRow_C(const uint8_t* src_rgb,
int src_stride_rgb,
uint8_t* dst_u,
uint8_t* dst_v,
int width);
void RGB24ToUVRow_C(const uint8_t* src_rgb,
int src_stride_rgb,
uint8_t* dst_u,
@ -5608,6 +5613,17 @@ void GaussCol_F32_C(const float* src0,
float* dst,
int width);
void GaussRow_C(const uint32_t* src, uint16_t* dst, int width);
void GaussCol_C(const uint16_t* src0,
const uint16_t* src1,
const uint16_t* src2,
const uint16_t* src3,
const uint16_t* src4,
uint32_t* dst,
int width);
void ClampFloatToZero_SSE2(const float* src_x, float* dst_y, int width);
#ifdef __cplusplus
} // extern "C"
} // namespace libyuv

2
include/libyuv/version.h
View File

@ -11,6 +11,6 @@
#ifndef INCLUDE_LIBYUV_VERSION_H_
#define INCLUDE_LIBYUV_VERSION_H_
#define LIBYUV_VERSION 1840
#define LIBYUV_VERSION 1841
#endif // INCLUDE_LIBYUV_VERSION_H_

70
source/convert.cc
View File

@ -2054,8 +2054,8 @@ int RGB24ToI420(const uint8_t* src_rgb24,
{
#if !defined(HAS_RGB24TOYROW)
// Allocate 2 rows of ARGB.
const int kRowSize = (width * 4 + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (width * 4 + 31) & ~31;
align_buffer_64(row, row_size * 2);
#endif
for (y = 0; y < height - 1; y += 2) {
@ -2065,10 +2065,10 @@ int RGB24ToI420(const uint8_t* src_rgb24,
RGB24ToYRow(src_rgb24 + src_stride_rgb24, dst_y + dst_stride_y, width);
#else
RGB24ToARGBRow(src_rgb24, row, width);
RGB24ToARGBRow(src_rgb24 + src_stride_rgb24, row + kRowSize, width);
ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
RGB24ToARGBRow(src_rgb24 + src_stride_rgb24, row + row_size, width);
ARGBToUVRow(row, row_size, dst_u, dst_v, width);
ARGBToYRow(row, dst_y, width);
ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
ARGBToYRow(row + row_size, dst_y + dst_stride_y, width);
#endif
src_rgb24 += src_stride_rgb24 * 2;
dst_y += dst_stride_y * 2;
@ -2208,8 +2208,8 @@ int RGB24ToJ420(const uint8_t* src_rgb24,
{
#if !defined(HAS_RGB24TOYJROW)
// Allocate 2 rows of ARGB.
const int kRowSize = (width * 4 + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (width * 4 + 31) & ~31;
align_buffer_64(row, row_size * 2);
#endif
for (y = 0; y < height - 1; y += 2) {
@ -2219,10 +2219,10 @@ int RGB24ToJ420(const uint8_t* src_rgb24,
RGB24ToYJRow(src_rgb24 + src_stride_rgb24, dst_y + dst_stride_y, width);
#else
RGB24ToARGBRow(src_rgb24, row, width);
RGB24ToARGBRow(src_rgb24 + src_stride_rgb24, row + kRowSize, width);
ARGBToUVJRow(row, kRowSize, dst_u, dst_v, width);
RGB24ToARGBRow(src_rgb24 + src_stride_rgb24, row + row_size, width);
ARGBToUVJRow(row, row_size, dst_u, dst_v, width);
ARGBToYJRow(row, dst_y, width);
ARGBToYJRow(row + kRowSize, dst_y + dst_stride_y, width);
ARGBToYJRow(row + row_size, dst_y + dst_stride_y, width);
#endif
src_rgb24 += src_stride_rgb24 * 2;
dst_y += dst_stride_y * 2;
@ -2382,8 +2382,8 @@ int RAWToI420(const uint8_t* src_raw,
{
#if !defined(HAS_RAWTOYROW)
// Allocate 2 rows of ARGB.
const int kRowSize = (width * 4 + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (width * 4 + 31) & ~31;
align_buffer_64(row, row_size * 2);
#endif
for (y = 0; y < height - 1; y += 2) {
@ -2393,10 +2393,10 @@ int RAWToI420(const uint8_t* src_raw,
RAWToYRow(src_raw + src_stride_raw, dst_y + dst_stride_y, width);
#else
RAWToARGBRow(src_raw, row, width);
RAWToARGBRow(src_raw + src_stride_raw, row + kRowSize, width);
ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
RAWToARGBRow(src_raw + src_stride_raw, row + row_size, width);
ARGBToUVRow(row, row_size, dst_u, dst_v, width);
ARGBToYRow(row, dst_y, width);
ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
ARGBToYRow(row + row_size, dst_y + dst_stride_y, width);
#endif
src_raw += src_stride_raw * 2;
dst_y += dst_stride_y * 2;
@ -2536,8 +2536,8 @@ int RAWToJ420(const uint8_t* src_raw,
{
#if !defined(HAS_RAWTOYJROW)
// Allocate 2 rows of ARGB.
const int kRowSize = (width * 4 + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (width * 4 + 31) & ~31;
align_buffer_64(row, row_size * 2);
#endif
for (y = 0; y < height - 1; y += 2) {
@ -2547,10 +2547,10 @@ int RAWToJ420(const uint8_t* src_raw,
RAWToYJRow(src_raw + src_stride_raw, dst_y + dst_stride_y, width);
#else
RAWToARGBRow(src_raw, row, width);
RAWToARGBRow(src_raw + src_stride_raw, row + kRowSize, width);
ARGBToUVJRow(row, kRowSize, dst_u, dst_v, width);
RAWToARGBRow(src_raw + src_stride_raw, row + row_size, width);
ARGBToUVJRow(row, row_size, dst_u, dst_v, width);
ARGBToYJRow(row, dst_y, width);
ARGBToYJRow(row + kRowSize, dst_y + dst_stride_y, width);
ARGBToYJRow(row + row_size, dst_y + dst_stride_y, width);
#endif
src_raw += src_stride_raw * 2;
dst_y += dst_stride_y * 2;
@ -2714,8 +2714,8 @@ int RGB565ToI420(const uint8_t* src_rgb565,
#if !(defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
defined(HAS_RGB565TOYROW_LSX) || defined(HAS_RGB565TOYROW_LASX))
// Allocate 2 rows of ARGB.
const int kRowSize = (width * 4 + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (width * 4 + 31) & ~31;
align_buffer_64(row, row_size * 2);
#endif
for (y = 0; y < height - 1; y += 2) {
#if (defined(HAS_RGB565TOYROW_NEON) || defined(HAS_RGB565TOYROW_MSA) || \
@ -2725,10 +2725,10 @@ int RGB565ToI420(const uint8_t* src_rgb565,
RGB565ToYRow(src_rgb565 + src_stride_rgb565, dst_y + dst_stride_y, width);
#else
RGB565ToARGBRow(src_rgb565, row, width);
RGB565ToARGBRow(src_rgb565 + src_stride_rgb565, row + kRowSize, width);
ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
RGB565ToARGBRow(src_rgb565 + src_stride_rgb565, row + row_size, width);
ARGBToUVRow(row, row_size, dst_u, dst_v, width);
ARGBToYRow(row, dst_y, width);
ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
ARGBToYRow(row + row_size, dst_y + dst_stride_y, width);
#endif
src_rgb565 += src_stride_rgb565 * 2;
dst_y += dst_stride_y * 2;
@ -2894,8 +2894,8 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
#if !(defined(HAS_ARGB1555TOYROW_NEON) || defined(HAS_ARGB1555TOYROW_MSA) || \
defined(HAS_ARGB1555TOYROW_LSX) || defined(HAS_ARGB1555TOYROW_LASX))
// Allocate 2 rows of ARGB.
const int kRowSize = (width * 4 + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (width * 4 + 31) & ~31;
align_buffer_64(row, row_size * 2);
#endif
for (y = 0; y < height - 1; y += 2) {
@ -2907,11 +2907,11 @@ int ARGB1555ToI420(const uint8_t* src_argb1555,
width);
#else
ARGB1555ToARGBRow(src_argb1555, row, width);
ARGB1555ToARGBRow(src_argb1555 + src_stride_argb1555, row + kRowSize,
ARGB1555ToARGBRow(src_argb1555 + src_stride_argb1555, row + row_size,
width);
ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
ARGBToUVRow(row, row_size, dst_u, dst_v, width);
ARGBToYRow(row, dst_y, width);
ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
ARGBToYRow(row + row_size, dst_y + dst_stride_y, width);
#endif
src_argb1555 += src_stride_argb1555 * 2;
dst_y += dst_stride_y * 2;
@ -3089,8 +3089,8 @@ int ARGB4444ToI420(const uint8_t* src_argb4444,
{
#if !(defined(HAS_ARGB4444TOYROW_NEON))
// Allocate 2 rows of ARGB.
const int kRowSize = (width * 4 + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (width * 4 + 31) & ~31;
align_buffer_64(row, row_size * 2);
#endif
for (y = 0; y < height - 1; y += 2) {
@ -3101,11 +3101,11 @@ int ARGB4444ToI420(const uint8_t* src_argb4444,
width);
#else
ARGB4444ToARGBRow(src_argb4444, row, width);
ARGB4444ToARGBRow(src_argb4444 + src_stride_argb4444, row + kRowSize,
ARGB4444ToARGBRow(src_argb4444 + src_stride_argb4444, row + row_size,
width);
ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
ARGBToUVRow(row, row_size, dst_u, dst_v, width);
ARGBToYRow(row, dst_y, width);
ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
ARGBToYRow(row + row_size, dst_y + dst_stride_y, width);
#endif
src_argb4444 += src_stride_argb4444 * 2;
dst_y += dst_stride_y * 2;

387
source/convert_argb.cc
View File

@ -7,8 +7,10 @@
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "libyuv/convert_argb.h"
#include "libyuv/convert_from_argb.h"
#include "libyuv/cpu_id.h"
#ifdef HAVE_JPEG
#include "libyuv/mjpeg_decoder.h"
@ -5497,22 +5499,22 @@ static int I420ToARGBMatrixBilinear(const uint8_t* src_y,
#endif
// alloc 4 lines temp
const int kRowSize = (width + 31) & ~31;
align_buffer_64(row, kRowSize * 4);
const int row_size = (width + 31) & ~31;
align_buffer_64(row, row_size * 4);
uint8_t* temp_u_1 = row;
uint8_t* temp_u_2 = row + kRowSize;
uint8_t* temp_v_1 = row + kRowSize * 2;
uint8_t* temp_v_2 = row + kRowSize * 3;
uint8_t* temp_u_2 = row + row_size;
uint8_t* temp_v_1 = row + row_size * 2;
uint8_t* temp_v_2 = row + row_size * 3;
Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, 0, temp_u_1, row_size, width);
Scale2RowUp(src_v, 0, temp_v_1, row_size, width);
I444ToARGBRow(src_y, temp_u_1, temp_v_1, dst_argb, yuvconstants, width);
dst_argb += dst_stride_argb;
src_y += src_stride_y;
for (y = 0; y < height - 2; y += 2) {
Scale2RowUp(src_u, src_stride_u, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, src_stride_v, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, src_stride_u, temp_u_1, row_size, width);
Scale2RowUp(src_v, src_stride_v, temp_v_1, row_size, width);
I444ToARGBRow(src_y, temp_u_1, temp_v_1, dst_argb, yuvconstants, width);
dst_argb += dst_stride_argb;
src_y += src_stride_y;
@ -5524,8 +5526,8 @@ static int I420ToARGBMatrixBilinear(const uint8_t* src_y,
}
if (!(height & 1)) {
Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, 0, temp_u_1, row_size, width);
Scale2RowUp(src_v, 0, temp_v_1, row_size, width);
I444ToARGBRow(src_y, temp_u_1, temp_v_1, dst_argb, yuvconstants, width);
}
@ -5622,10 +5624,10 @@ static int I422ToARGBMatrixLinear(const uint8_t* src_y,
#endif
// alloc 2 lines temp
const int kRowSize = (width + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (width + 31) & ~31;
align_buffer_64(row, row_size * 2);
uint8_t* temp_u = row;
uint8_t* temp_v = row + kRowSize;
uint8_t* temp_v = row + row_size;
for (y = 0; y < height; ++y) {
ScaleRowUp(src_u, temp_u, width);
@ -5641,6 +5643,188 @@ static int I422ToARGBMatrixLinear(const uint8_t* src_y,
return 0;
}
static int I420ToRGB24MatrixBilinear(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,
uint8_t* dst_rgb24,
int dst_stride_rgb24,
const struct YuvConstants* yuvconstants,
int width,
int height) {
int y;
void (*I444ToARGBRow)(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) =
I444ToARGBRow_C;
void (*ARGBToRGB24Row)(const uint8_t* src_argb, uint8_t* dst_rgb, int width) =
ARGBToRGB24Row_C;
void (*Scale2RowUp)(const uint8_t* src_ptr, ptrdiff_t src_stride,
uint8_t* dst_ptr, ptrdiff_t dst_stride, int dst_width) =
ScaleRowUp2_Bilinear_Any_C;
if (!src_y || !src_u || !src_v || !dst_rgb24 || width <= 0 || height == 0) {
return -1;
}
// Negative height means invert the image.
if (height < 0) {
height = -height;
dst_rgb24 = dst_rgb24 + (height - 1) * dst_stride_rgb24;
dst_stride_rgb24 = -dst_stride_rgb24;
}
#if defined(HAS_I444TOARGBROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3)) {
I444ToARGBRow = I444ToARGBRow_Any_SSSE3;
if (IS_ALIGNED(width, 8)) {
I444ToARGBRow = I444ToARGBRow_SSSE3;
}
}
#endif
#if defined(HAS_I444TOARGBROW_AVX2)
if (TestCpuFlag(kCpuHasAVX2)) {
I444ToARGBRow = I444ToARGBRow_Any_AVX2;
if (IS_ALIGNED(width, 16)) {
I444ToARGBRow = I444ToARGBRow_AVX2;
}
}
#endif
#if defined(HAS_I444TOARGBROW_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
I444ToARGBRow = I444ToARGBRow_Any_NEON;
if (IS_ALIGNED(width, 8)) {
I444ToARGBRow = I444ToARGBRow_NEON;
}
}
#endif
#if defined(HAS_I444TOARGBROW_MSA)
if (TestCpuFlag(kCpuHasMSA)) {
I444ToARGBRow = I444ToARGBRow_Any_MSA;
if (IS_ALIGNED(width, 8)) {
I444ToARGBRow = I444ToARGBRow_MSA;
}
}
#endif
#if defined(HAS_I444TOARGBROW_LASX)
if (TestCpuFlag(kCpuHasLASX)) {
I444ToARGBRow = I444ToARGBRow_Any_LASX;
if (IS_ALIGNED(width, 32)) {
I444ToARGBRow = I444ToARGBRow_LASX;
}
}
#endif
#if defined(HAS_ARGBTORGB24ROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3)) {
ARGBToRGB24Row = ARGBToRGB24Row_Any_SSSE3;
if (IS_ALIGNED(width, 16)) {
ARGBToRGB24Row = ARGBToRGB24Row_SSSE3;
}
}
#endif
#if defined(HAS_ARGBTORGB24ROW_AVX2)
if (TestCpuFlag(kCpuHasAVX2)) {
ARGBToRGB24Row = ARGBToRGB24Row_Any_AVX2;
if (IS_ALIGNED(width, 32)) {
ARGBToRGB24Row = ARGBToRGB24Row_AVX2;
}
}
#endif
#if defined(HAS_ARGBTORGB24ROW_AVX512VBMI)
if (TestCpuFlag(kCpuHasAVX512VBMI)) {
ARGBToRGB24Row = ARGBToRGB24Row_Any_AVX512VBMI;
if (IS_ALIGNED(width, 32)) {
ARGBToRGB24Row = ARGBToRGB24Row_AVX512VBMI;
}
}
#endif
#if defined(HAS_ARGBTORGB24ROW_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
ARGBToRGB24Row = ARGBToRGB24Row_Any_NEON;
if (IS_ALIGNED(width, 16)) {
ARGBToRGB24Row = ARGBToRGB24Row_NEON;
}
}
#endif
#if defined(HAS_ARGBTORGB24ROW_MSA)
if (TestCpuFlag(kCpuHasMSA)) {
ARGBToRGB24Row = ARGBToRGB24Row_Any_MSA;
if (IS_ALIGNED(width, 16)) {
ARGBToRGB24Row = ARGBToRGB24Row_MSA;
}
}
#endif
#if defined(HAS_ARGBTORGB24ROW_LASX)
if (TestCpuFlag(kCpuHasLASX)) {
ARGBToRGB24Row = ARGBToRGB24Row_Any_LASX;
if (IS_ALIGNED(width, 32)) {
ARGBToRGB24Row = ARGBToRGB24Row_LASX;
}
}
#endif
// TODO: Fix HAS macros to match function names
#if defined(HAS_SCALEROWUP2_LINEAR_SSE2)
if (TestCpuFlag(kCpuHasSSE2)) {
Scale2RowUp = ScaleRowUp2_Bilinear_Any_SSE2;
}
#endif
#if defined(HAS_SCALEROWUP2_LINEAR_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3)) {
Scale2RowUp = ScaleRowUp2_Bilinear_Any_SSSE3;
}
#endif
#if defined(HAS_SCALEROWUP2_LINEAR_AVX2)
if (TestCpuFlag(kCpuHasAVX2)) {
Scale2RowUp = ScaleRowUp2_Bilinear_Any_AVX2;
}
#endif
#if defined(HAS_SCALEROWUP2_LINEAR_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
Scale2RowUp = ScaleRowUp2_Bilinear_Any_NEON;
}
#endif
// alloc 4 lines temp
const int row_size = (width + 31) & ~31;
align_buffer_64(row, row_size * 8);
uint8_t* temp_u_1 = row;
uint8_t* temp_u_2 = row + row_size;
uint8_t* temp_v_1 = row + row_size * 2;
uint8_t* temp_v_2 = row + row_size * 3;
uint8_t* temp_argb = row + row_size * 4;
Scale2RowUp(src_u, 0, temp_u_1, row_size, width);
Scale2RowUp(src_v, 0, temp_v_1, row_size, width);
I444ToARGBRow(src_y, temp_u_1, temp_v_1, temp_argb, yuvconstants, width);
ARGBToRGB24Row(temp_argb, dst_rgb24, width);
dst_rgb24 += dst_stride_rgb24;
src_y += src_stride_y;
for (y = 0; y < height - 2; y += 2) {
Scale2RowUp(src_u, src_stride_u, temp_u_1, row_size, width);
Scale2RowUp(src_v, src_stride_v, temp_v_1, row_size, width);
I444ToARGBRow(src_y, temp_u_1, temp_v_1, temp_argb, yuvconstants, width);
ARGBToRGB24Row(temp_argb, dst_rgb24, width);
dst_rgb24 += dst_stride_rgb24;
src_y += src_stride_y;
I444ToARGBRow(src_y, temp_u_2, temp_v_2, temp_argb, yuvconstants, width);
ARGBToRGB24Row(temp_argb, dst_rgb24, width);
dst_rgb24 += dst_stride_rgb24;
src_y += src_stride_y;
src_u += src_stride_u;
src_v += src_stride_v;
}
if (!(height & 1)) {
Scale2RowUp(src_u, 0, temp_u_1, row_size, width);
Scale2RowUp(src_v, 0, temp_v_1, row_size, width);
I444ToARGBRow(src_y, temp_u_1, temp_v_1, temp_argb, yuvconstants, width);
ARGBToRGB24Row(temp_argb, dst_rgb24, width);
}
free_aligned_buffer_64(row);
return 0;
}
static int I010ToAR30MatrixBilinear(const uint16_t* src_y,
int src_stride_y,
const uint16_t* src_u,
@ -5705,22 +5889,22 @@ static int I010ToAR30MatrixBilinear(const uint16_t* src_y,
#endif
// alloc 4 lines temp
const int kRowSize = (width + 31) & ~31;
align_buffer_64(row, kRowSize * 4 * sizeof(uint16_t));
const int row_size = (width + 31) & ~31;
align_buffer_64(row, row_size * 4 * sizeof(uint16_t));
uint16_t* temp_u_1 = (uint16_t*)(row);
uint16_t* temp_u_2 = (uint16_t*)(row) + kRowSize;
uint16_t* temp_v_1 = (uint16_t*)(row) + kRowSize * 2;
uint16_t* temp_v_2 = (uint16_t*)(row) + kRowSize * 3;
uint16_t* temp_u_2 = (uint16_t*)(row) + row_size;
uint16_t* temp_v_1 = (uint16_t*)(row) + row_size * 2;
uint16_t* temp_v_2 = (uint16_t*)(row) + row_size * 3;
Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, 0, temp_u_1, row_size, width);
Scale2RowUp(src_v, 0, temp_v_1, row_size, width);
I410ToAR30Row(src_y, temp_u_1, temp_v_1, dst_ar30, yuvconstants, width);
dst_ar30 += dst_stride_ar30;
src_y += src_stride_y;
for (y = 0; y < height - 2; y += 2) {
Scale2RowUp(src_u, src_stride_u, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, src_stride_v, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, src_stride_u, temp_u_1, row_size, width);
Scale2RowUp(src_v, src_stride_v, temp_v_1, row_size, width);
I410ToAR30Row(src_y, temp_u_1, temp_v_1, dst_ar30, yuvconstants, width);
dst_ar30 += dst_stride_ar30;
src_y += src_stride_y;
@ -5732,8 +5916,8 @@ static int I010ToAR30MatrixBilinear(const uint16_t* src_y,
}
if (!(height & 1)) {
Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, 0, temp_u_1, row_size, width);
Scale2RowUp(src_v, 0, temp_v_1, row_size, width);
I410ToAR30Row(src_y, temp_u_1, temp_v_1, dst_ar30, yuvconstants, width);
}
@ -5803,10 +5987,10 @@ static int I210ToAR30MatrixLinear(const uint16_t* src_y,
#endif
// alloc 2 lines temp
const int kRowSize = (width + 31) & ~31;
align_buffer_64(row, kRowSize * 2 * sizeof(uint16_t));
const int row_size = (width + 31) & ~31;
align_buffer_64(row, row_size * 2 * sizeof(uint16_t));
uint16_t* temp_u = (uint16_t*)(row);
uint16_t* temp_v = (uint16_t*)(row) + kRowSize;
uint16_t* temp_v = (uint16_t*)(row) + row_size;
for (y = 0; y < height; ++y) {
ScaleRowUp(src_u, temp_u, width);
@ -5885,22 +6069,22 @@ static int I010ToARGBMatrixBilinear(const uint16_t* src_y,
#endif
// alloc 4 lines temp
const int kRowSize = (width + 31) & ~31;
align_buffer_64(row, kRowSize * 4 * sizeof(uint16_t));
const int row_size = (width + 31) & ~31;
align_buffer_64(row, row_size * 4 * sizeof(uint16_t));
uint16_t* temp_u_1 = (uint16_t*)(row);
uint16_t* temp_u_2 = (uint16_t*)(row) + kRowSize;
uint16_t* temp_v_1 = (uint16_t*)(row) + kRowSize * 2;
uint16_t* temp_v_2 = (uint16_t*)(row) + kRowSize * 3;
uint16_t* temp_u_2 = (uint16_t*)(row) + row_size;
uint16_t* temp_v_1 = (uint16_t*)(row) + row_size * 2;
uint16_t* temp_v_2 = (uint16_t*)(row) + row_size * 3;
Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, 0, temp_u_1, row_size, width);
Scale2RowUp(src_v, 0, temp_v_1, row_size, width);
I410ToARGBRow(src_y, temp_u_1, temp_v_1, dst_argb, yuvconstants, width);
dst_argb += dst_stride_argb;
src_y += src_stride_y;
for (y = 0; y < height - 2; y += 2) {
Scale2RowUp(src_u, src_stride_u, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, src_stride_v, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, src_stride_u, temp_u_1, row_size, width);
Scale2RowUp(src_v, src_stride_v, temp_v_1, row_size, width);
I410ToARGBRow(src_y, temp_u_1, temp_v_1, dst_argb, yuvconstants, width);
dst_argb += dst_stride_argb;
src_y += src_stride_y;
@ -5912,8 +6096,8 @@ static int I010ToARGBMatrixBilinear(const uint16_t* src_y,
}
if (!(height & 1)) {
Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, 0, temp_u_1, row_size, width);
Scale2RowUp(src_v, 0, temp_v_1, row_size, width);
I410ToARGBRow(src_y, temp_u_1, temp_v_1, dst_argb, yuvconstants, width);
}
@ -5982,10 +6166,10 @@ static int I210ToARGBMatrixLinear(const uint16_t* src_y,
#endif
// alloc 2 lines temp
const int kRowSize = (width + 31) & ~31;
align_buffer_64(row, kRowSize * 2 * sizeof(uint16_t));
const int row_size = (width + 31) & ~31;
align_buffer_64(row, row_size * 2 * sizeof(uint16_t));
uint16_t* temp_u = (uint16_t*)(row);
uint16_t* temp_v = (uint16_t*)(row) + kRowSize;
uint16_t* temp_v = (uint16_t*)(row) + row_size;
for (y = 0; y < height; ++y) {
ScaleRowUp(src_u, temp_u, width);
@ -6134,15 +6318,15 @@ static int I420AlphaToARGBMatrixBilinear(
#endif
// alloc 4 lines temp
const int kRowSize = (width + 31) & ~31;
align_buffer_64(row, kRowSize * 4);
const int row_size = (width + 31) & ~31;
align_buffer_64(row, row_size * 4);
uint8_t* temp_u_1 = row;
uint8_t* temp_u_2 = row + kRowSize;
uint8_t* temp_v_1 = row + kRowSize * 2;
uint8_t* temp_v_2 = row + kRowSize * 3;
uint8_t* temp_u_2 = row + row_size;
uint8_t* temp_v_1 = row + row_size * 2;
uint8_t* temp_v_2 = row + row_size * 3;
Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, 0, temp_u_1, row_size, width);
Scale2RowUp(src_v, 0, temp_v_1, row_size, width);
I444AlphaToARGBRow(src_y, temp_u_1, temp_v_1, src_a, dst_argb, yuvconstants,
width);
if (attenuate) {
@ -6153,8 +6337,8 @@ static int I420AlphaToARGBMatrixBilinear(
src_a += src_stride_a;
for (y = 0; y < height - 2; y += 2) {
Scale2RowUp(src_u, src_stride_u, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, src_stride_v, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, src_stride_u, temp_u_1, row_size, width);
Scale2RowUp(src_v, src_stride_v, temp_v_1, row_size, width);
I444AlphaToARGBRow(src_y, temp_u_1, temp_v_1, src_a, dst_argb, yuvconstants,
width);
if (attenuate) {
@ -6176,8 +6360,8 @@ static int I420AlphaToARGBMatrixBilinear(
}
if (!(height & 1)) {
Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, 0, temp_u_1, row_size, width);
Scale2RowUp(src_v, 0, temp_v_1, row_size, width);
I444AlphaToARGBRow(src_y, temp_u_1, temp_v_1, src_a, dst_argb, yuvconstants,
width);
if (attenuate) {
@ -6317,10 +6501,10 @@ static int I422AlphaToARGBMatrixLinear(const uint8_t* src_y,
#endif
// alloc 2 lines temp
const int kRowSize = (width + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (width + 31) & ~31;
align_buffer_64(row, row_size * 2);
uint8_t* temp_u = row;
uint8_t* temp_v = row + kRowSize;
uint8_t* temp_v = row + row_size;
for (y = 0; y < height; ++y) {
ScaleRowUp(src_u, temp_u, width);
@ -6445,15 +6629,15 @@ static int I010AlphaToARGBMatrixBilinear(
#endif
// alloc 4 lines temp
const int kRowSize = (width + 31) & ~31;
align_buffer_64(row, kRowSize * 4 * sizeof(uint16_t));
const int row_size = (width + 31) & ~31;
align_buffer_64(row, row_size * 4 * sizeof(uint16_t));
uint16_t* temp_u_1 = (uint16_t*)(row);
uint16_t* temp_u_2 = (uint16_t*)(row) + kRowSize;
uint16_t* temp_v_1 = (uint16_t*)(row) + kRowSize * 2;
uint16_t* temp_v_2 = (uint16_t*)(row) + kRowSize * 3;
uint16_t* temp_u_2 = (uint16_t*)(row) + row_size;
uint16_t* temp_v_1 = (uint16_t*)(row) + row_size * 2;
uint16_t* temp_v_2 = (uint16_t*)(row) + row_size * 3;
Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, 0, temp_u_1, row_size, width);
Scale2RowUp(src_v, 0, temp_v_1, row_size, width);
I410AlphaToARGBRow(src_y, temp_u_1, temp_v_1, src_a, dst_argb, yuvconstants,
width);
if (attenuate) {
@ -6464,8 +6648,8 @@ static int I010AlphaToARGBMatrixBilinear(
src_a += src_stride_a;
for (y = 0; y < height - 2; y += 2) {
Scale2RowUp(src_u, src_stride_u, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, src_stride_v, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, src_stride_u, temp_u_1, row_size, width);
Scale2RowUp(src_v, src_stride_v, temp_v_1, row_size, width);
I410AlphaToARGBRow(src_y, temp_u_1, temp_v_1, src_a, dst_argb, yuvconstants,
width);
if (attenuate) {
@ -6487,8 +6671,8 @@ static int I010AlphaToARGBMatrixBilinear(
}
if (!(height & 1)) {
Scale2RowUp(src_u, 0, temp_u_1, kRowSize, width);
Scale2RowUp(src_v, 0, temp_v_1, kRowSize, width);
Scale2RowUp(src_u, 0, temp_u_1, row_size, width);
Scale2RowUp(src_v, 0, temp_v_1, row_size, width);
I410AlphaToARGBRow(src_y, temp_u_1, temp_v_1, src_a, dst_argb, yuvconstants,
width);
if (attenuate) {
@ -6600,10 +6784,10 @@ static int I210AlphaToARGBMatrixLinear(const uint16_t* src_y,
#endif
// alloc 2 lines temp
const int kRowSize = (width + 31) & ~31;
align_buffer_64(row, kRowSize * 2 * sizeof(uint16_t));
const int row_size = (width + 31) & ~31;
align_buffer_64(row, row_size * 2 * sizeof(uint16_t));
uint16_t* temp_u = (uint16_t*)(row);
uint16_t* temp_v = (uint16_t*)(row) + kRowSize;
uint16_t* temp_v = (uint16_t*)(row) + row_size;
for (y = 0; y < height; ++y) {
ScaleRowUp(src_u, temp_u, width);
@ -6684,18 +6868,18 @@ static int P010ToARGBMatrixBilinear(const uint16_t* src_y,
#endif
// alloc 2 lines temp
const int kRowSize = (2 * width + 31) & ~31;
align_buffer_64(row, kRowSize * 2 * sizeof(uint16_t));
const int row_size = (2 * width + 31) & ~31;
align_buffer_64(row, row_size * 2 * sizeof(uint16_t));
uint16_t* temp_uv_1 = (uint16_t*)(row);
uint16_t* temp_uv_2 = (uint16_t*)(row) + kRowSize;
uint16_t* temp_uv_2 = (uint16_t*)(row) + row_size;
Scale2RowUp(src_uv, 0, temp_uv_1, kRowSize, width);
Scale2RowUp(src_uv, 0, temp_uv_1, row_size, width);
P410ToARGBRow(src_y, temp_uv_1, dst_argb, yuvconstants, width);
dst_argb += dst_stride_argb;
src_y += src_stride_y;
for (y = 0; y < height - 2; y += 2) {
Scale2RowUp(src_uv, src_stride_uv, temp_uv_1, kRowSize, width);
Scale2RowUp(src_uv, src_stride_uv, temp_uv_1, row_size, width);
P410ToARGBRow(src_y, temp_uv_1, dst_argb, yuvconstants, width);
dst_argb += dst_stride_argb;
src_y += src_stride_y;
@ -6706,7 +6890,7 @@ static int P010ToARGBMatrixBilinear(const uint16_t* src_y,
}
if (!(height & 1)) {
Scale2RowUp(src_uv, 0, temp_uv_1, kRowSize, width);
Scale2RowUp(src_uv, 0, temp_uv_1, row_size, width);
P410ToARGBRow(src_y, temp_uv_1, dst_argb, yuvconstants, width);
}
@ -6773,8 +6957,8 @@ static int P210ToARGBMatrixLinear(const uint16_t* src_y,
}
#endif
const int kRowSize = (2 * width + 31) & ~31;
align_buffer_64(row, kRowSize * sizeof(uint16_t));
const int row_size = (2 * width + 31) & ~31;
align_buffer_64(row, row_size * sizeof(uint16_t));
uint16_t* temp_uv = (uint16_t*)(row);
for (y = 0; y < height; ++y) {
@ -6850,18 +7034,18 @@ static int P010ToAR30MatrixBilinear(const uint16_t* src_y,
#endif
// alloc 2 lines temp
const int kRowSize = (2 * width + 31) & ~31;
align_buffer_64(row, kRowSize * 2 * sizeof(uint16_t));
const int row_size = (2 * width + 31) & ~31;
align_buffer_64(row, row_size * 2 * sizeof(uint16_t));
uint16_t* temp_uv_1 = (uint16_t*)(row);
uint16_t* temp_uv_2 = (uint16_t*)(row) + kRowSize;
uint16_t* temp_uv_2 = (uint16_t*)(row) + row_size;
Scale2RowUp(src_uv, 0, temp_uv_1, kRowSize, width);
Scale2RowUp(src_uv, 0, temp_uv_1, row_size, width);
P410ToAR30Row(src_y, temp_uv_1, dst_ar30, yuvconstants, width);
dst_ar30 += dst_stride_ar30;
src_y += src_stride_y;
for (y = 0; y < height - 2; y += 2) {
Scale2RowUp(src_uv, src_stride_uv, temp_uv_1, kRowSize, width);
Scale2RowUp(src_uv, src_stride_uv, temp_uv_1, row_size, width);
P410ToAR30Row(src_y, temp_uv_1, dst_ar30, yuvconstants, width);
dst_ar30 += dst_stride_ar30;
src_y += src_stride_y;
@ -6872,7 +7056,7 @@ static int P010ToAR30MatrixBilinear(const uint16_t* src_y,
}
if (!(height & 1)) {
Scale2RowUp(src_uv, 0, temp_uv_1, kRowSize, width);
Scale2RowUp(src_uv, 0, temp_uv_1, row_size, width);
P410ToAR30Row(src_y, temp_uv_1, dst_ar30, yuvconstants, width);
}
@ -6939,8 +7123,8 @@ static int P210ToAR30MatrixLinear(const uint16_t* src_y,
}
#endif
const int kRowSize = (2 * width + 31) & ~31;
align_buffer_64(row, kRowSize * sizeof(uint16_t));
const int row_size = (2 * width + 31) & ~31;
align_buffer_64(row, row_size * sizeof(uint16_t));
uint16_t* temp_uv = (uint16_t*)(row);
for (y = 0; y < height; ++y) {
@ -7015,6 +7199,37 @@ int I422ToARGBMatrixFilter(const uint8_t* src_y,
return -1;
}
LIBYUV_API
int I420ToRGB24MatrixFilter(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,
uint8_t* dst_rgb24,
int dst_stride_rgb24,
const struct YuvConstants* yuvconstants,
int width,
int height,
enum FilterMode filter) {
switch (filter) {
case kFilterNone:
return I420ToRGB24Matrix(src_y, src_stride_y, src_u, src_stride_u, src_v,
src_stride_v, dst_rgb24, dst_stride_rgb24,
yuvconstants, width, height);
case kFilterBilinear:
case kFilterBox:
return I420ToRGB24MatrixBilinear(
src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v,
dst_rgb24, dst_stride_rgb24, yuvconstants, width, height);
case kFilterLinear:
// TODO: Implement Linear using Bilinear with Scale2RowUp stride 0
return -1;
}
return -1;
}
LIBYUV_API
int I010ToAR30MatrixFilter(const uint16_t* src_y,
int src_stride_y,

10
source/convert_from_argb.cc
View File

@ -2804,8 +2804,8 @@ int RAWToJNV21(const uint8_t* src_raw,
uint8_t* row_vj = row_uj + ((halfwidth + 31) & ~31);
#if !defined(HAS_RAWTOYJROW)
// Allocate 2 rows of ARGB.
const int kRowSize = (width * 4 + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (width * 4 + 31) & ~31;
align_buffer_64(row, row_size * 2);
#endif
for (y = 0; y < height - 1; y += 2) {
@ -2816,11 +2816,11 @@ int RAWToJNV21(const uint8_t* src_raw,
RAWToYJRow(src_raw + src_stride_raw, dst_y + dst_stride_y, width);
#else
RAWToARGBRow(src_raw, row, width);
RAWToARGBRow(src_raw + src_stride_raw, row + kRowSize, width);
ARGBToUVJRow(row, kRowSize, row_uj, row_vj, width);
RAWToARGBRow(src_raw + src_stride_raw, row + row_size, width);
ARGBToUVJRow(row, row_size, row_uj, row_vj, width);
MergeUVRow_(row_vj, row_uj, dst_vu, halfwidth);
ARGBToYJRow(row, dst_y, width);
ARGBToYJRow(row + kRowSize, dst_y + dst_stride_y, width);
ARGBToYJRow(row + row_size, dst_y + dst_stride_y, width);
#endif
src_raw += src_stride_raw * 2;
dst_y += dst_stride_y * 2;

2
source/cpu_id.cc
View File

@ -115,7 +115,7 @@ void CpuId(int eax, int ecx, int* cpu_info) {
defined(__x86_64__)) && \
!defined(__pnacl__) && !defined(__CLR_VER) && !defined(__native_client__)
// X86 CPUs have xgetbv to detect OS saves high parts of ymm registers.
int GetXCR0() {
static int GetXCR0() {
int xcr0 = 0;
#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 160040219)
xcr0 = (int)_xgetbv(0); // VS2010 SP1 required. NOLINT

24
source/planar_functions.cc
View File

@ -1085,8 +1085,8 @@ void DetileToYUY2(const uint8_t* src_y,
// Detile plane
for (y = 0; y < height; ++y) {
DetileToYUY2(src_y, src_y_tile_stride, src_uv, src_uv_tile_stride,
dst_yuy2, width);
DetileToYUY2(src_y, src_y_tile_stride, src_uv, src_uv_tile_stride, dst_yuy2,
width);
dst_yuy2 += dst_stride_yuy2;
src_y += 16;
@ -1224,7 +1224,7 @@ void MergeRGBPlane(const uint8_t* src_r,
}
LIBYUV_NOINLINE
void SplitARGBPlaneAlpha(const uint8_t* src_argb,
static void SplitARGBPlaneAlpha(const uint8_t* src_argb,
int src_stride_argb,
uint8_t* dst_r,
int dst_stride_r,
@ -1295,7 +1295,7 @@ void SplitARGBPlaneAlpha(const uint8_t* src_argb,
}
LIBYUV_NOINLINE
void SplitARGBPlaneOpaque(const uint8_t* src_argb,
static void SplitARGBPlaneOpaque(const uint8_t* src_argb,
int src_stride_argb,
uint8_t* dst_r,
int dst_stride_r,
@ -1396,7 +1396,7 @@ void SplitARGBPlane(const uint8_t* src_argb,
}
LIBYUV_NOINLINE
void MergeARGBPlaneAlpha(const uint8_t* src_r,
static void MergeARGBPlaneAlpha(const uint8_t* src_r,
int src_stride_r,
const uint8_t* src_g,
int src_stride_g,
@ -1458,7 +1458,7 @@ void MergeARGBPlaneAlpha(const uint8_t* src_r,
}
LIBYUV_NOINLINE
void MergeARGBPlaneOpaque(const uint8_t* src_r,
static void MergeARGBPlaneOpaque(const uint8_t* src_r,
int src_stride_r,
const uint8_t* src_g,
int src_stride_g,
@ -4545,16 +4545,16 @@ static int ARGBSobelize(const uint8_t* src_argb,
#endif
{
// 3 rows with edges before/after.
const int kRowSize = (width + kEdge + 31) & ~31;
align_buffer_64(rows, kRowSize * 2 + (kEdge + kRowSize * 3 + kEdge));
const int row_size = (width + kEdge + 31) & ~31;
align_buffer_64(rows, row_size * 2 + (kEdge + row_size * 3 + kEdge));
uint8_t* row_sobelx = rows;
uint8_t* row_sobely = rows + kRowSize;
uint8_t* row_y = rows + kRowSize * 2;
uint8_t* row_sobely = rows + row_size;
uint8_t* row_y = rows + row_size * 2;
// Convert first row.
uint8_t* row_y0 = row_y + kEdge;
uint8_t* row_y1 = row_y0 + kRowSize;
uint8_t* row_y2 = row_y1 + kRowSize;
uint8_t* row_y1 = row_y0 + row_size;
uint8_t* row_y2 = row_y1 + row_size;
ARGBToYJRow(src_argb, row_y0, width);
row_y0[-1] = row_y0[0];
memset(row_y0 + width, row_y0[width - 1], 16); // Extrude 16 for valgrind.

3
source/rotate_argb.cc
View File

@ -8,11 +8,12 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "libyuv/rotate.h"
#include "libyuv/rotate_argb.h"
#include "libyuv/convert.h"
#include "libyuv/cpu_id.h"
#include "libyuv/planar_functions.h"
#include "libyuv/rotate.h"
#include "libyuv/row.h"
#include "libyuv/scale_row.h" /* for ScaleARGBRowDownEven_ */

12
source/scale.cc
View File

@ -1315,11 +1315,11 @@ void ScalePlaneBilinearUp(int src_width,
const uint8_t* src = src_ptr + yi * (int64_t)src_stride;
// Allocate 2 row buffers.
const int kRowSize = (dst_width + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (dst_width + 31) & ~31;
align_buffer_64(row, row_size * 2);
uint8_t* rowptr = row;
int rowstride = kRowSize;
int rowstride = row_size;
int lasty = yi;
ScaleFilterCols(rowptr, src, dst_width, x, dx);
@ -1766,11 +1766,11 @@ void ScalePlaneBilinearUp_16(int src_width,
const uint16_t* src = src_ptr + yi * (int64_t)src_stride;
// Allocate 2 row buffers.
const int kRowSize = (dst_width + 31) & ~31;
align_buffer_64(row, kRowSize * 4);
const int row_size = (dst_width + 31) & ~31;
align_buffer_64(row, row_size * 4);
uint16_t* rowptr = (uint16_t*)row;
int rowstride = kRowSize;
int rowstride = row_size;
int lasty = yi;
ScaleFilterCols(rowptr, src, dst_width, x, dx);

20
source/scale_argb.cc
View File

@ -155,8 +155,8 @@ static void ScaleARGBDown4Box(int src_width,
int dy) {
int j;
// Allocate 2 rows of ARGB.
const int kRowSize = (dst_width * 2 * 4 + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (dst_width * 2 * 4 + 31) & ~31;
align_buffer_64(row, row_size * 2);
int row_stride = src_stride * (dy >> 16);
void (*ScaleARGBRowDown2)(const uint8_t* src_argb, ptrdiff_t src_stride,
uint8_t* dst_argb, int dst_width) =
@ -187,9 +187,9 @@ static void ScaleARGBDown4Box(int src_width,
for (j = 0; j < dst_height; ++j) {
ScaleARGBRowDown2(src_argb, src_stride, row, dst_width * 2);
ScaleARGBRowDown2(src_argb + src_stride * 2, src_stride, row + kRowSize,
ScaleARGBRowDown2(src_argb + src_stride * 2, src_stride, row + row_size,
dst_width * 2);
ScaleARGBRowDown2(row, kRowSize, dst_argb, dst_width);
ScaleARGBRowDown2(row, row_size, dst_argb, dst_width);
src_argb += row_stride;
dst_argb += dst_stride;
}
@ -548,11 +548,11 @@ static void ScaleARGBBilinearUp(int src_width,
const uint8_t* src = src_argb + yi * (int64_t)src_stride;
// Allocate 2 rows of ARGB.
const int kRowSize = (dst_width * 4 + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (dst_width * 4 + 31) & ~31;
align_buffer_64(row, row_size * 2);
uint8_t* rowptr = row;
int rowstride = kRowSize;
int rowstride = row_size;
int lasty = yi;
ScaleARGBFilterCols(rowptr, src, dst_width, x, dx);
@ -798,14 +798,14 @@ static void ScaleYUVToARGBBilinearUp(int src_width,
const uint8_t* src_row_v = src_v + uv_yi * (int64_t)src_stride_v;
// Allocate 2 rows of ARGB.
const int kRowSize = (dst_width * 4 + 31) & ~31;
align_buffer_64(row, kRowSize * 2);
const int row_size = (dst_width * 4 + 31) & ~31;
align_buffer_64(row, row_size * 2);
// Allocate 1 row of ARGB for source conversion.
align_buffer_64(argb_row, src_width * 4);
uint8_t* rowptr = row;
int rowstride = kRowSize;
int rowstride = row_size;
int lasty = yi;
// TODO(fbarchard): Convert first 2 rows of YUV to ARGB.

14
source/scale_uv.cc
View File

@ -193,8 +193,8 @@ static void ScaleUVDown4Box(int src_width,
int dy) {
int j;
// Allocate 2 rows of UV.
const int kRowSize = (dst_width * 2 * 2 + 15) & ~15;
align_buffer_64(row, kRowSize * 2);
const int row_size = (dst_width * 2 * 2 + 15) & ~15;
align_buffer_64(row, row_size * 2);
int row_stride = src_stride * (dy >> 16);
void (*ScaleUVRowDown2)(const uint8_t* src_uv, ptrdiff_t src_stride,
uint8_t* dst_uv, int dst_width) =
@ -234,9 +234,9 @@ static void ScaleUVDown4Box(int src_width,
for (j = 0; j < dst_height; ++j) {
ScaleUVRowDown2(src_uv, src_stride, row, dst_width * 2);
ScaleUVRowDown2(src_uv + src_stride * 2, src_stride, row + kRowSize,
ScaleUVRowDown2(src_uv + src_stride * 2, src_stride, row + row_size,
dst_width * 2);
ScaleUVRowDown2(row, kRowSize, dst_uv, dst_width);
ScaleUVRowDown2(row, row_size, dst_uv, dst_width);
src_uv += row_stride;
dst_uv += dst_stride;
}
@ -574,11 +574,11 @@ static void ScaleUVBilinearUp(int src_width,
const uint8_t* src = src_uv + yi * (int64_t)src_stride;
// Allocate 2 rows of UV.
const int kRowSize = (dst_width * 2 + 15) & ~15;
align_buffer_64(row, kRowSize * 2);
const int row_size = (dst_width * 2 + 15) & ~15;
align_buffer_64(row, row_size * 2);
uint8_t* rowptr = row;
int rowstride = kRowSize;
int rowstride = row_size;
int lasty = yi;
ScaleUVFilterCols(rowptr, src, dst_width, x, dx);

8
unit_test/convert_test.cc
View File

@ -680,6 +680,9 @@ TESTBIPLANARTOP(MM21, uint8_t, 1, 2, 2, I420, uint8_t, 1, 2, 2, 8, 16, 32)
#define I422ToARGBFilter(a, b, c, d, e, f, g, h, i, j) \
I422ToARGBMatrixFilter(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j, \
kFilterBilinear)
#define I420ToRGB24Filter(a, b, c, d, e, f, g, h, i, j) \
I420ToRGB24MatrixFilter(a, b, c, d, e, f, g, h, &kYuvI601Constants, i, j, \
kFilterBilinear)
#define ALIGNINT(V, ALIGN) (((V) + (ALIGN)-1) / (ALIGN) * (ALIGN))
@ -816,6 +819,7 @@ TESTPLANARTOB(H420, 2, 2, AB30, 4, 4, 1)
#endif
TESTPLANARTOB(I420, 2, 2, ARGBFilter, 4, 4, 1)
TESTPLANARTOB(I422, 2, 1, ARGBFilter, 4, 4, 1)
TESTPLANARTOB(I420, 2, 2, RGB24Filter, 3, 3, 1)
#else
TESTPLANARTOB(I420, 2, 2, ABGR, 4, 4, 1)
TESTPLANARTOB(I420, 2, 2, ARGB, 4, 4, 1)
@ -832,13 +836,13 @@ TESTPLANARTOB(I422, 2, 1, RGB565, 2, 2, 1)
TESTPLANARTOB(I420, 2, 2, I400, 1, 1, 1)
TESTPLANARTOB(I420, 2, 2, UYVY, 2, 4, 1)
TESTPLANARTOB(I420, 2, 2, YUY2, 2, 4, 1)
TESTPLANARTOB(I420, 2, 2, ARGBFilter, 4, 4, 1)
TESTPLANARTOB(I422, 2, 1, ABGR, 4, 4, 1)
TESTPLANARTOB(I422, 2, 1, ARGB, 4, 4, 1)
TESTPLANARTOB(I422, 2, 1, BGRA, 4, 4, 1)
TESTPLANARTOB(I422, 2, 1, RGBA, 4, 4, 1)
TESTPLANARTOB(I422, 2, 1, UYVY, 2, 4, 1)
TESTPLANARTOB(I422, 2, 1, YUY2, 2, 4, 1)
TESTPLANARTOB(I420, 2, 2, ARGBFilter, 4, 4, 1)
TESTPLANARTOB(I422, 2, 1, ARGBFilter, 4, 4, 1)
TESTPLANARTOB(I444, 1, 1, ABGR, 4, 4, 1)
TESTPLANARTOB(I444, 1, 1, ARGB, 4, 4, 1)
@ -1412,7 +1416,7 @@ TESTATOBIPLANAR(AYUV, 1, 4, NV21, 2, 2)
EPP_B, STRIDE_B, HEIGHT_B)
#else
#define TESTATOB(FMT_A, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, FMT_B, TYPE_B, \
EPP_B, STRIDE_B, HEIGHT_B, INPLACE) \
EPP_B, STRIDE_B, HEIGHT_B) \
TESTATOBI(FMT_A, TYPE_A, EPP_A, STRIDE_A, HEIGHT_A, FMT_B, TYPE_B, EPP_B, \
STRIDE_B, HEIGHT_B, benchmark_width_, _Opt, +, 0)
#endif

6
util/yuvconvert.cc
View File

@ -42,7 +42,7 @@ static __inline uint32_t Abs(int32_t v) {
}
// Parse PYUV format. ie name.1920x800_24Hz_P420.yuv
bool ExtractResolutionFromFilename(const char* name,
static bool ExtractResolutionFromFilename(const char* name,
int* width_ptr,
int* height_ptr) {
// Isolate the .width_height. section of the filename by searching for a
@ -59,7 +59,7 @@ bool ExtractResolutionFromFilename(const char* name,
return false;
}
void PrintHelp(const char* program) {
static void PrintHelp(const char* program) {
printf("%s [-options] src_argb.raw dst_yuv.raw\n", program);
printf(
" -s <width> <height> .... specify source resolution. "
@ -78,7 +78,7 @@ void PrintHelp(const char* program) {
exit(0);
}
void ParseOptions(int argc, const char* argv[]) {
static void ParseOptions(int argc, const char* argv[]) {
if (argc <= 1) {
PrintHelp(argv[0]);
}