From 706fc412ad24faad94463e58f204c3fe73cbe433 Mon Sep 17 00:00:00 2001 From: "fbarchard@google.com" Date: Thu, 10 Nov 2011 20:13:57 +0000 Subject: [PATCH] move code from table to common BUG=none TEST=none Review URL: http://webrtc-codereview.appspot.com/269009 git-svn-id: http://libyuv.googlecode.com/svn/trunk@69 16f28f9a-4ce2-e073-06de-1de4eb20be90 --- libyuv.gyp | 1 + source/row_common.cc | 338 +++++++++++++++++++++++++++++++++++++++++++ source/row_table.cc | 323 ----------------------------------------- 3 files changed, 339 insertions(+), 323 deletions(-) create mode 100644 source/row_common.cc diff --git a/libyuv.gyp b/libyuv.gyp index 93d3eef87..9d482078f 100644 --- a/libyuv.gyp +++ b/libyuv.gyp @@ -42,6 +42,7 @@ 'source/format_conversion.cc', 'source/planar_functions.cc', 'source/rotate.cc', + 'source/row_common.cc', 'source/row_table.cc', 'source/scale.cc', 'source/video_common.cc', diff --git a/source/row_common.cc b/source/row_common.cc new file mode 100644 index 000000000..74a303238 --- /dev/null +++ b/source/row_common.cc @@ -0,0 +1,338 @@ +/* + * Copyright (c) 2011 The LibYuv 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 "row.h" + +extern "C" { + +void ABGRToARGBRow_C(const uint8* src_abgr, uint8* dst_argb, int pix) { + for (int x = 0; x < pix; ++x) { + // To support in-place conversion. + uint8 r = src_abgr[0]; + uint8 g = src_abgr[1]; + uint8 b = src_abgr[2]; + uint8 a = src_abgr[3]; + dst_argb[0] = b; + dst_argb[1] = g; + dst_argb[2] = r; + dst_argb[3] = a; + dst_argb += 4; + src_abgr += 4; + } +} + +void BGRAToARGBRow_C(const uint8* src_bgra, uint8* dst_argb, int pix) { + for (int x = 0; x < pix; ++x) { + // To support in-place conversion. + uint8 a = src_bgra[0]; + uint8 r = src_bgra[1]; + uint8 g = src_bgra[2]; + uint8 b = src_bgra[3]; + dst_argb[0] = b; + dst_argb[1] = g; + dst_argb[2] = r; + dst_argb[3] = a; + dst_argb += 4; + src_bgra += 4; + } +} + +void RAWToARGBRow_C(const uint8* src_raw, uint8* dst_argb, int pix) { + for (int x = 0; x < pix; ++x) { + uint8 r = src_raw[0]; + uint8 g = src_raw[1]; + uint8 b = src_raw[2]; + dst_argb[0] = b; + dst_argb[1] = g; + dst_argb[2] = r; + dst_argb[3] = 255u; + dst_argb += 4; + src_raw += 3; + } +} + +void BG24ToARGBRow_C(const uint8* src_bg24, uint8* dst_argb, int pix) { + for (int x = 0; x < pix; ++x) { + uint8 b = src_bg24[0]; + uint8 g = src_bg24[1]; + uint8 r = src_bg24[2]; + dst_argb[0] = b; + dst_argb[1] = g; + dst_argb[2] = r; + dst_argb[3] = 255u; + dst_argb[3] = 255u; + dst_argb += 4; + src_bg24 += 3; + } +} + +// C versions do the same +void RGB24ToYRow_C(const uint8* src_argb, uint8* dst_y, int pix) { + SIMD_ALIGNED(uint8 row[kMaxStride]); + BG24ToARGBRow_C(src_argb, row, pix); + ARGBToYRow_C(row, dst_y, pix); +} + +void RAWToYRow_C(const uint8* src_argb, uint8* dst_y, int pix) { + SIMD_ALIGNED(uint8 row[kMaxStride]); + RAWToARGBRow_C(src_argb, row, pix); + ARGBToYRow_C(row, dst_y, pix); +} + +void RGB24ToUVRow_C(const uint8* src_argb, int src_stride_argb, + uint8* dst_u, uint8* dst_v, int pix) { + SIMD_ALIGNED(uint8 row[kMaxStride * 2]); + BG24ToARGBRow_C(src_argb, row, pix); + BG24ToARGBRow_C(src_argb + src_stride_argb, row + kMaxStride, pix); + ARGBToUVRow_C(row, kMaxStride, dst_u, dst_v, pix); +} + +void RAWToUVRow_C(const uint8* src_argb, int src_stride_argb, + uint8* dst_u, uint8* dst_v, int pix) { + SIMD_ALIGNED(uint8 row[kMaxStride * 2]); + RAWToARGBRow_C(src_argb, row, pix); + RAWToARGBRow_C(src_argb + src_stride_argb, row + kMaxStride, pix); + ARGBToUVRow_C(row, kMaxStride, dst_u, dst_v, pix); +} + +static inline int RGBToY(uint8 r, uint8 g, uint8 b) { + return (( 66 * r + 129 * g + 25 * b + 128) >> 8) + 16; +} + +static inline int RGBToU(uint8 r, uint8 g, uint8 b) { + return ((-38 * r - 74 * g + 112 * b + 128) >> 8) + 128; +} +static inline int RGBToV(uint8 r, uint8 g, uint8 b) { + return ((112 * r - 94 * g - 18 * b + 128) >> 8) + 128; +} + +#define MAKEROWY(NAME,R,G,B) \ +void NAME ## ToYRow_C(const uint8* src_argb0, uint8* dst_y, int width) { \ + for (int x = 0; x < width; ++x) { \ + dst_y[0] = RGBToY(src_argb0[R], src_argb0[G], src_argb0[B]); \ + src_argb0 += 4; \ + dst_y += 1; \ + } \ +} \ +void NAME ## ToUVRow_C(const uint8* src_rgb0, int src_stride_rgb, \ + uint8* dst_u, uint8* dst_v, int width) { \ + const uint8* src_rgb1 = src_rgb0 + src_stride_rgb; \ + for (int x = 0; x < width - 1; x += 2) { \ + uint8 ab = (src_rgb0[B] + src_rgb0[B + 4] + \ + src_rgb1[B] + src_rgb1[B + 4]) >> 2; \ + uint8 ag = (src_rgb0[G] + src_rgb0[G + 4] + \ + src_rgb1[G] + src_rgb1[G + 4]) >> 2; \ + uint8 ar = (src_rgb0[R] + src_rgb0[R + 4] + \ + src_rgb1[R] + src_rgb1[R + 4]) >> 2; \ + dst_u[0] = RGBToU(ar, ag, ab); \ + dst_v[0] = RGBToV(ar, ag, ab); \ + src_rgb0 += 8; \ + src_rgb1 += 8; \ + dst_u += 1; \ + dst_v += 1; \ + } \ + if (width & 1) { \ + uint8 ab = (src_rgb0[B] + src_rgb1[B]) >> 1; \ + uint8 ag = (src_rgb0[G] + src_rgb1[G]) >> 1; \ + uint8 ar = (src_rgb0[R] + src_rgb1[R]) >> 1; \ + dst_u[0] = RGBToU(ar, ag, ab); \ + dst_v[0] = RGBToV(ar, ag, ab); \ + } \ +} + +MAKEROWY(ARGB,2,1,0) +MAKEROWY(BGRA,1,2,3) +MAKEROWY(ABGR,0,1,2) + +#if defined(HAS_RAWTOYROW_SSSE3) + +void RGB24ToYRow_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) { + SIMD_ALIGNED(uint8 row[kMaxStride]); + BG24ToARGBRow_SSSE3(src_argb, row, pix); + ARGBToYRow_SSSE3(row, dst_y, pix); +} + +void RAWToYRow_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) { + SIMD_ALIGNED(uint8 row[kMaxStride]); + RAWToARGBRow_SSSE3(src_argb, row, pix); + ARGBToYRow_SSSE3(row, dst_y, pix); +} + +#endif + +#if defined(HAS_RAWTOUVROW_SSSE3) +#if defined(HAS_ARGBTOUVROW_SSSE3) +void RGB24ToUVRow_SSSE3(const uint8* src_argb, int src_stride_argb, + uint8* dst_u, uint8* dst_v, int pix) { + SIMD_ALIGNED(uint8 row[kMaxStride * 2]); + BG24ToARGBRow_SSSE3(src_argb, row, pix); + BG24ToARGBRow_SSSE3(src_argb + src_stride_argb, row + kMaxStride, pix); + ARGBToUVRow_SSSE3(row, kMaxStride, dst_u, dst_v, pix); +} + +void RAWToUVRow_SSSE3(const uint8* src_argb, int src_stride_argb, + uint8* dst_u, uint8* dst_v, int pix) { + SIMD_ALIGNED(uint8 row[kMaxStride * 2]); + RAWToARGBRow_SSSE3(src_argb, row, pix); + RAWToARGBRow_SSSE3(src_argb + src_stride_argb, row + kMaxStride, pix); + ARGBToUVRow_SSSE3(row, kMaxStride, dst_u, dst_v, pix); +} + +#else + +void RGB24ToUVRow_SSSE3(const uint8* src_argb, int src_stride_argb, + uint8* dst_u, uint8* dst_v, int pix) { + SIMD_ALIGNED(uint8 row[kMaxStride * 2]); + BG24ToARGBRow_SSSE3(src_argb, row, pix); + BG24ToARGBRow_SSSE3(src_argb + src_stride_argb, row + kMaxStride, pix); + ARGBToUVRow_C(row, kMaxStride, dst_u, dst_v, pix); +} + +void RAWToUVRow_SSSE3(const uint8* src_argb, int src_stride_argb, + uint8* dst_u, uint8* dst_v, int pix) { + SIMD_ALIGNED(uint8 row[kMaxStride * 2]); + RAWToARGBRow_SSSE3(src_argb, row, pix); + RAWToARGBRow_SSSE3(src_argb + src_stride_argb, row + kMaxStride, pix); + ARGBToUVRow_C(row, kMaxStride, dst_u, dst_v, pix); +} + +#endif +#endif + +void I400ToARGBRow_C(const uint8* src_y, uint8* dst_argb, int pix) { + // Copy a Y to RGB. + for (int x = 0; x < pix; ++x) { + uint8 y = src_y[0]; + dst_argb[2] = dst_argb[1] = dst_argb[0] = y; + dst_argb[3] = 255u; + dst_argb += 4; + ++src_y; + } +} + +// C reference code that mimic the YUV assembly. +#define packuswb(x) ((x) < 0 ? 0 : ((x) > 255 ? 255 : (x))) +#define paddsw(x, y) (((x) + (y)) < -32768 ? -32768 : \ + (((x) + (y)) > 32767 ? 32767 : ((x) + (y)))) + +static inline void YuvPixel(uint8 y, + uint8 u, + uint8 v, + uint8* rgb_buf, + int ashift, + int rshift, + int gshift, + int bshift) { + + int b = kCoefficientsRgbY[256+u][0]; + int g = kCoefficientsRgbY[256+u][1]; + int r = kCoefficientsRgbY[256+u][2]; + int a = kCoefficientsRgbY[256+u][3]; + + b = paddsw(b, kCoefficientsRgbY[512+v][0]); + g = paddsw(g, kCoefficientsRgbY[512+v][1]); + r = paddsw(r, kCoefficientsRgbY[512+v][2]); + a = paddsw(a, kCoefficientsRgbY[512+v][3]); + + b = paddsw(b, kCoefficientsRgbY[y][0]); + g = paddsw(g, kCoefficientsRgbY[y][1]); + r = paddsw(r, kCoefficientsRgbY[y][2]); + a = paddsw(a, kCoefficientsRgbY[y][3]); + + b >>= 6; + g >>= 6; + r >>= 6; + a >>= 6; + + *reinterpret_cast(rgb_buf) = (packuswb(b) << bshift) | + (packuswb(g) << gshift) | + (packuswb(r) << rshift) | + (packuswb(a) << ashift); +} + +void FastConvertYUVToARGBRow_C(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { + for (int x = 0; x < width - 1; x += 2) { + YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf + 0, 24, 16, 8, 0); + YuvPixel(y_buf[1], u_buf[0], v_buf[0], rgb_buf + 4, 24, 16, 8, 0); + y_buf += 2; + u_buf += 1; + v_buf += 1; + rgb_buf += 8; // Advance 2 pixels. + } + if (width & 1) { + YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf + 0, 24, 16, 8, 0); + } +} + +void FastConvertYUVToBGRARow_C(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { + for (int x = 0; x < width - 1; x += 2) { + YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf + 0, 0, 8, 16, 24); + YuvPixel(y_buf[1], u_buf[0], v_buf[0], rgb_buf + 4, 0, 8, 16, 24); + y_buf += 2; + u_buf += 1; + v_buf += 1; + rgb_buf += 8; // Advance 2 pixels. + } + if (width & 1) { + YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf, 0, 8, 16, 24); + } +} + +void FastConvertYUVToABGRRow_C(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { + for (int x = 0; x < width - 1; x += 2) { + YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf + 0, 24, 0, 8, 16); + YuvPixel(y_buf[1], u_buf[0], v_buf[0], rgb_buf + 4, 24, 0, 8, 16); + y_buf += 2; + u_buf += 1; + v_buf += 1; + rgb_buf += 8; // Advance 2 pixels. + } + if (width & 1) { + YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf + 0, 24, 0, 8, 16); + } +} + +void FastConvertYUV444ToARGBRow_C(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { + for (int x = 0; x < width; ++x) { + YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf, 24, 16, 8, 0); + y_buf += 1; + u_buf += 1; + v_buf += 1; + rgb_buf += 4; // Advance 1 pixel. + } +} + +void FastConvertYToARGBRow_C(const uint8* y_buf, + uint8* rgb_buf, + int width) { + for (int x = 0; x < width; ++x) { + YuvPixel(y_buf[0], 128, 128, rgb_buf, 24, 16, 8, 0); + y_buf += 1; + rgb_buf += 4; // Advance 1 pixel. + } +} + +} // extern "C" diff --git a/source/row_table.cc b/source/row_table.cc index 4d191ac2f..2c0e4e424 100644 --- a/source/row_table.cc +++ b/source/row_table.cc @@ -290,327 +290,4 @@ MAKETABLE(kCoefficientsBgraY) MAKETABLE(kCoefficientsAbgrY) -void ABGRToARGBRow_C(const uint8* src_abgr, uint8* dst_argb, int pix) { - for (int x = 0; x < pix; ++x) { - // To support in-place conversion. - uint8 r = src_abgr[0]; - uint8 g = src_abgr[1]; - uint8 b = src_abgr[2]; - uint8 a = src_abgr[3]; - dst_argb[0] = b; - dst_argb[1] = g; - dst_argb[2] = r; - dst_argb[3] = a; - dst_argb += 4; - src_abgr += 4; - } -} - -void BGRAToARGBRow_C(const uint8* src_bgra, uint8* dst_argb, int pix) { - for (int x = 0; x < pix; ++x) { - // To support in-place conversion. - uint8 a = src_bgra[0]; - uint8 r = src_bgra[1]; - uint8 g = src_bgra[2]; - uint8 b = src_bgra[3]; - dst_argb[0] = b; - dst_argb[1] = g; - dst_argb[2] = r; - dst_argb[3] = a; - dst_argb += 4; - src_bgra += 4; - } -} - -void RAWToARGBRow_C(const uint8* src_raw, uint8* dst_argb, int pix) { - for (int x = 0; x < pix; ++x) { - uint8 r = src_raw[0]; - uint8 g = src_raw[1]; - uint8 b = src_raw[2]; - dst_argb[0] = b; - dst_argb[1] = g; - dst_argb[2] = r; - dst_argb[3] = 255u; - dst_argb += 4; - src_raw += 3; - } -} - -void BG24ToARGBRow_C(const uint8* src_bg24, uint8* dst_argb, int pix) { - for (int x = 0; x < pix; ++x) { - uint8 b = src_bg24[0]; - uint8 g = src_bg24[1]; - uint8 r = src_bg24[2]; - dst_argb[0] = b; - dst_argb[1] = g; - dst_argb[2] = r; - dst_argb[3] = 255u; - dst_argb[3] = 255u; - dst_argb += 4; - src_bg24 += 3; - } -} - -// C versions do the same -void RGB24ToYRow_C(const uint8* src_argb, uint8* dst_y, int pix) { - SIMD_ALIGNED(uint8 row[kMaxStride]); - BG24ToARGBRow_C(src_argb, row, pix); - ARGBToYRow_C(row, dst_y, pix); -} - -void RAWToYRow_C(const uint8* src_argb, uint8* dst_y, int pix) { - SIMD_ALIGNED(uint8 row[kMaxStride]); - RAWToARGBRow_C(src_argb, row, pix); - ARGBToYRow_C(row, dst_y, pix); -} - -void RGB24ToUVRow_C(const uint8* src_argb, int src_stride_argb, - uint8* dst_u, uint8* dst_v, int pix) { - SIMD_ALIGNED(uint8 row[kMaxStride * 2]); - BG24ToARGBRow_C(src_argb, row, pix); - BG24ToARGBRow_C(src_argb + src_stride_argb, row + kMaxStride, pix); - ARGBToUVRow_C(row, kMaxStride, dst_u, dst_v, pix); -} - -void RAWToUVRow_C(const uint8* src_argb, int src_stride_argb, - uint8* dst_u, uint8* dst_v, int pix) { - SIMD_ALIGNED(uint8 row[kMaxStride * 2]); - RAWToARGBRow_C(src_argb, row, pix); - RAWToARGBRow_C(src_argb + src_stride_argb, row + kMaxStride, pix); - ARGBToUVRow_C(row, kMaxStride, dst_u, dst_v, pix); -} - -static inline int RGBToY(uint8 r, uint8 g, uint8 b) { - return (( 66 * r + 129 * g + 25 * b + 128) >> 8) + 16; -} - -static inline int RGBToU(uint8 r, uint8 g, uint8 b) { - return ((-38 * r - 74 * g + 112 * b + 128) >> 8) + 128; -} -static inline int RGBToV(uint8 r, uint8 g, uint8 b) { - return ((112 * r - 94 * g - 18 * b + 128) >> 8) + 128; -} - -#define MAKEROWY(NAME,R,G,B) \ -void NAME ## ToYRow_C(const uint8* src_argb0, uint8* dst_y, int width) { \ - for (int x = 0; x < width; ++x) { \ - dst_y[0] = RGBToY(src_argb0[R], src_argb0[G], src_argb0[B]); \ - src_argb0 += 4; \ - dst_y += 1; \ - } \ -} \ -void NAME ## ToUVRow_C(const uint8* src_rgb0, int src_stride_rgb, \ - uint8* dst_u, uint8* dst_v, int width) { \ - const uint8* src_rgb1 = src_rgb0 + src_stride_rgb; \ - for (int x = 0; x < width - 1; x += 2) { \ - uint8 ab = (src_rgb0[B] + src_rgb0[B + 4] + \ - src_rgb1[B] + src_rgb1[B + 4]) >> 2; \ - uint8 ag = (src_rgb0[G] + src_rgb0[G + 4] + \ - src_rgb1[G] + src_rgb1[G + 4]) >> 2; \ - uint8 ar = (src_rgb0[R] + src_rgb0[R + 4] + \ - src_rgb1[R] + src_rgb1[R + 4]) >> 2; \ - dst_u[0] = RGBToU(ar, ag, ab); \ - dst_v[0] = RGBToV(ar, ag, ab); \ - src_rgb0 += 8; \ - src_rgb1 += 8; \ - dst_u += 1; \ - dst_v += 1; \ - } \ - if (width & 1) { \ - uint8 ab = (src_rgb0[B] + src_rgb1[B]) >> 1; \ - uint8 ag = (src_rgb0[G] + src_rgb1[G]) >> 1; \ - uint8 ar = (src_rgb0[R] + src_rgb1[R]) >> 1; \ - dst_u[0] = RGBToU(ar, ag, ab); \ - dst_v[0] = RGBToV(ar, ag, ab); \ - } \ -} - -MAKEROWY(ARGB,2,1,0) -MAKEROWY(BGRA,1,2,3) -MAKEROWY(ABGR,0,1,2) - -#if defined(HAS_RAWTOYROW_SSSE3) - -void RGB24ToYRow_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) { - SIMD_ALIGNED(uint8 row[kMaxStride]); - BG24ToARGBRow_SSSE3(src_argb, row, pix); - ARGBToYRow_SSSE3(row, dst_y, pix); -} - -void RAWToYRow_SSSE3(const uint8* src_argb, uint8* dst_y, int pix) { - SIMD_ALIGNED(uint8 row[kMaxStride]); - RAWToARGBRow_SSSE3(src_argb, row, pix); - ARGBToYRow_SSSE3(row, dst_y, pix); -} - -#endif - -#if defined(HAS_RAWTOUVROW_SSSE3) -#if defined(HAS_ARGBTOUVROW_SSSE3) -void RGB24ToUVRow_SSSE3(const uint8* src_argb, int src_stride_argb, - uint8* dst_u, uint8* dst_v, int pix) { - SIMD_ALIGNED(uint8 row[kMaxStride * 2]); - BG24ToARGBRow_SSSE3(src_argb, row, pix); - BG24ToARGBRow_SSSE3(src_argb + src_stride_argb, row + kMaxStride, pix); - ARGBToUVRow_SSSE3(row, kMaxStride, dst_u, dst_v, pix); -} - -void RAWToUVRow_SSSE3(const uint8* src_argb, int src_stride_argb, - uint8* dst_u, uint8* dst_v, int pix) { - SIMD_ALIGNED(uint8 row[kMaxStride * 2]); - RAWToARGBRow_SSSE3(src_argb, row, pix); - RAWToARGBRow_SSSE3(src_argb + src_stride_argb, row + kMaxStride, pix); - ARGBToUVRow_SSSE3(row, kMaxStride, dst_u, dst_v, pix); -} - -#else - -void RGB24ToUVRow_SSSE3(const uint8* src_argb, int src_stride_argb, - uint8* dst_u, uint8* dst_v, int pix) { - SIMD_ALIGNED(uint8 row[kMaxStride * 2]); - BG24ToARGBRow_SSSE3(src_argb, row, pix); - BG24ToARGBRow_SSSE3(src_argb + src_stride_argb, row + kMaxStride, pix); - ARGBToUVRow_C(row, kMaxStride, dst_u, dst_v, pix); -} - -void RAWToUVRow_SSSE3(const uint8* src_argb, int src_stride_argb, - uint8* dst_u, uint8* dst_v, int pix) { - SIMD_ALIGNED(uint8 row[kMaxStride * 2]); - RAWToARGBRow_SSSE3(src_argb, row, pix); - RAWToARGBRow_SSSE3(src_argb + src_stride_argb, row + kMaxStride, pix); - ARGBToUVRow_C(row, kMaxStride, dst_u, dst_v, pix); -} - -#endif -#endif - -void I400ToARGBRow_C(const uint8* src_y, uint8* dst_argb, int pix) { - // Copy a Y to RGB. - for (int x = 0; x < pix; ++x) { - uint8 y = src_y[0]; - dst_argb[2] = dst_argb[1] = dst_argb[0] = y; - dst_argb[3] = 255u; - dst_argb += 4; - ++src_y; - } -} - -// C reference code that mimic the YUV assembly. -#define packuswb(x) ((x) < 0 ? 0 : ((x) > 255 ? 255 : (x))) -#define paddsw(x, y) (((x) + (y)) < -32768 ? -32768 : \ - (((x) + (y)) > 32767 ? 32767 : ((x) + (y)))) - -static inline void YuvPixel(uint8 y, - uint8 u, - uint8 v, - uint8* rgb_buf, - int ashift, - int rshift, - int gshift, - int bshift) { - - int b = kCoefficientsRgbY[256+u][0]; - int g = kCoefficientsRgbY[256+u][1]; - int r = kCoefficientsRgbY[256+u][2]; - int a = kCoefficientsRgbY[256+u][3]; - - b = paddsw(b, kCoefficientsRgbY[512+v][0]); - g = paddsw(g, kCoefficientsRgbY[512+v][1]); - r = paddsw(r, kCoefficientsRgbY[512+v][2]); - a = paddsw(a, kCoefficientsRgbY[512+v][3]); - - b = paddsw(b, kCoefficientsRgbY[y][0]); - g = paddsw(g, kCoefficientsRgbY[y][1]); - r = paddsw(r, kCoefficientsRgbY[y][2]); - a = paddsw(a, kCoefficientsRgbY[y][3]); - - b >>= 6; - g >>= 6; - r >>= 6; - a >>= 6; - - *reinterpret_cast(rgb_buf) = (packuswb(b) << bshift) | - (packuswb(g) << gshift) | - (packuswb(r) << rshift) | - (packuswb(a) << ashift); -} - -void FastConvertYUVToARGBRow_C(const uint8* y_buf, - const uint8* u_buf, - const uint8* v_buf, - uint8* rgb_buf, - int width) { - for (int x = 0; x < width - 1; x += 2) { - YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf + 0, 24, 16, 8, 0); - YuvPixel(y_buf[1], u_buf[0], v_buf[0], rgb_buf + 4, 24, 16, 8, 0); - y_buf += 2; - u_buf += 1; - v_buf += 1; - rgb_buf += 8; // Advance 2 pixels. - } - if (width & 1) { - YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf + 0, 24, 16, 8, 0); - } -} - -void FastConvertYUVToBGRARow_C(const uint8* y_buf, - const uint8* u_buf, - const uint8* v_buf, - uint8* rgb_buf, - int width) { - for (int x = 0; x < width - 1; x += 2) { - YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf + 0, 0, 8, 16, 24); - YuvPixel(y_buf[1], u_buf[0], v_buf[0], rgb_buf + 4, 0, 8, 16, 24); - y_buf += 2; - u_buf += 1; - v_buf += 1; - rgb_buf += 8; // Advance 2 pixels. - } - if (width & 1) { - YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf, 0, 8, 16, 24); - } -} - -void FastConvertYUVToABGRRow_C(const uint8* y_buf, - const uint8* u_buf, - const uint8* v_buf, - uint8* rgb_buf, - int width) { - for (int x = 0; x < width - 1; x += 2) { - YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf + 0, 24, 0, 8, 16); - YuvPixel(y_buf[1], u_buf[0], v_buf[0], rgb_buf + 4, 24, 0, 8, 16); - y_buf += 2; - u_buf += 1; - v_buf += 1; - rgb_buf += 8; // Advance 2 pixels. - } - if (width & 1) { - YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf + 0, 24, 0, 8, 16); - } -} - -void FastConvertYUV444ToARGBRow_C(const uint8* y_buf, - const uint8* u_buf, - const uint8* v_buf, - uint8* rgb_buf, - int width) { - for (int x = 0; x < width; ++x) { - YuvPixel(y_buf[0], u_buf[0], v_buf[0], rgb_buf, 24, 16, 8, 0); - y_buf += 1; - u_buf += 1; - v_buf += 1; - rgb_buf += 4; // Advance 1 pixel. - } -} - -void FastConvertYToARGBRow_C(const uint8* y_buf, - uint8* rgb_buf, - int width) { - for (int x = 0; x < width; ++x) { - YuvPixel(y_buf[0], 128, 128, rgb_buf, 24, 16, 8, 0); - y_buf += 1; - rgb_buf += 4; // Advance 1 pixel. - } -} - } // extern "C"