mirror of
https://chromium.googlesource.com/libyuv/libyuv
synced 2025-12-06 16:56:55 +08:00
706fc412ad
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
339 lines
12 KiB
C++
339 lines
12 KiB
C++
/*
|
|
* 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<uint32*>(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"
|