mirror of
https://chromium.googlesource.com/libyuv/libyuv
synced 2025-12-06 16:56:55 +08:00
f7a5048f54
BUG=none TEST=builds Review URL: http://webrtc-codereview.appspot.com/268008 git-svn-id: http://libyuv.googlecode.com/svn/trunk@73 16f28f9a-4ce2-e073-06de-1de4eb20be90
434 lines
13 KiB
C++
434 lines
13 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 <assert.h>
|
|
|
|
#include "libyuv/cpu_id.h"
|
|
#include "video_common.h"
|
|
#include "row.h"
|
|
|
|
namespace libyuv {
|
|
|
|
// Note: to do this with Neon vld4.8 would load ARGB values into 4 registers
|
|
// and vst would select which 2 components to write. The low level would need
|
|
// to be ARGBToBG, ARGBToGB, ARGBToRG, ARGBToGR
|
|
|
|
#if defined(WIN32) && !defined(COVERAGE_ENABLED)
|
|
#define HAS_ARGBTOBAYERROW_SSSE3
|
|
__declspec(naked)
|
|
static void ARGBToBayerRow_SSSE3(const uint8* src_argb,
|
|
uint8* dst_bayer, uint32 selector, int pix) {
|
|
__asm {
|
|
mov eax, [esp + 4] // src_argb
|
|
mov edx, [esp + 8] // dst_bayer
|
|
movd xmm5, [esp + 12] // selector
|
|
mov ecx, [esp + 16] // pix
|
|
pshufd xmm5, xmm5, 0
|
|
|
|
wloop:
|
|
movdqa xmm0, [eax]
|
|
lea eax, [eax + 16]
|
|
pshufb xmm0, xmm5
|
|
movd [edx], xmm0
|
|
lea edx, [edx + 4]
|
|
sub ecx, 4
|
|
ja wloop
|
|
ret
|
|
}
|
|
}
|
|
|
|
#elif (defined(__x86_64__) || defined(__i386__)) && \
|
|
!defined(COVERAGE_ENABLED) && !defined(TARGET_IPHONE_SIMULATOR)
|
|
|
|
#define HAS_ARGBTOBAYERROW_SSSE3
|
|
static void ARGBToBayerRow_SSSE3(const uint8* src_argb, uint8* dst_bayer,
|
|
uint32 selector, int pix) {
|
|
asm volatile (
|
|
"movd %3,%%xmm5 \n"
|
|
"pshufd $0x0,%%xmm5,%%xmm5 \n"
|
|
"1: \n"
|
|
"movdqa (%0),%%xmm0 \n"
|
|
"lea 0x10(%0),%0 \n"
|
|
"pshufb %%xmm5,%%xmm0 \n"
|
|
"movd %%xmm0,(%1) \n"
|
|
"lea 0x4(%1),%1 \n"
|
|
"sub $0x4,%2 \n"
|
|
"ja 1b \n"
|
|
: "+r"(src_argb), // %0
|
|
"+r"(dst_bayer), // %1
|
|
"+r"(pix) // %2
|
|
: "g"(selector) // %3
|
|
: "memory", "cc"
|
|
#if defined(__SSE2__)
|
|
, "xmm0", "xmm5"
|
|
#endif
|
|
|
|
);
|
|
}
|
|
#endif
|
|
|
|
static void ARGBToBayerRow_C(const uint8* src_argb,
|
|
uint8* dst_bayer, uint32 selector, int pix) {
|
|
int index0 = selector & 0xff;
|
|
int index1 = (selector >> 8) & 0xff;
|
|
// Copy a row of Bayer.
|
|
for (int x = 0; x < pix - 1; x += 2) {
|
|
dst_bayer[0] = src_argb[index0];
|
|
dst_bayer[1] = src_argb[index1];
|
|
src_argb += 8;
|
|
dst_bayer += 2;
|
|
}
|
|
if (pix & 1) {
|
|
dst_bayer[0] = src_argb[index0];
|
|
}
|
|
}
|
|
|
|
// generate a selector mask useful for pshufb
|
|
static uint32 GenerateSelector(int select0, int select1) {
|
|
return static_cast<uint32>(select0) |
|
|
static_cast<uint32>((select1 + 4) << 8) |
|
|
static_cast<uint32>((select0 + 8) << 16) |
|
|
static_cast<uint32>((select1 + 12) << 24);
|
|
}
|
|
|
|
// Converts 32 bit ARGB to any Bayer RGB format.
|
|
int ARGBToBayerRGB(const uint8* src_rgb, int src_stride_rgb,
|
|
uint8* dst_bayer, int dst_stride_bayer,
|
|
uint32 dst_fourcc_bayer,
|
|
int width, int height) {
|
|
if (height < 0) {
|
|
height = -height;
|
|
src_rgb = src_rgb + (height - 1) * src_stride_rgb;
|
|
src_stride_rgb = -src_stride_rgb;
|
|
}
|
|
void (*ARGBToBayerRow)(const uint8* src_argb,
|
|
uint8* dst_bayer, uint32 selector, int pix);
|
|
#if defined(HAS_ARGBTOBAYERROW_SSSE3)
|
|
if (libyuv::TestCpuFlag(libyuv::kCpuHasSSSE3) &&
|
|
(width % 4 == 0) &&
|
|
IS_ALIGNED(src_rgb, 16) && (src_stride_rgb % 16 == 0) &&
|
|
IS_ALIGNED(dst_bayer, 4) && (dst_stride_bayer % 4 == 0)) {
|
|
ARGBToBayerRow = ARGBToBayerRow_SSSE3;
|
|
} else
|
|
#endif
|
|
{
|
|
ARGBToBayerRow = ARGBToBayerRow_C;
|
|
}
|
|
|
|
int blue_index = 0;
|
|
int green_index = 1;
|
|
int red_index = 2;
|
|
|
|
// Now build a lookup table containing the indices for the four pixels in each
|
|
// 2x2 Bayer grid.
|
|
uint32 index_map[2];
|
|
switch (dst_fourcc_bayer) {
|
|
default:
|
|
assert(false);
|
|
case FOURCC_RGGB:
|
|
index_map[0] = GenerateSelector(red_index, green_index);
|
|
index_map[1] = GenerateSelector(green_index, blue_index);
|
|
break;
|
|
case FOURCC_BGGR:
|
|
index_map[0] = GenerateSelector(blue_index, green_index);
|
|
index_map[1] = GenerateSelector(green_index, red_index);
|
|
break;
|
|
case FOURCC_GRBG:
|
|
index_map[0] = GenerateSelector(green_index, red_index);
|
|
index_map[1] = GenerateSelector(blue_index, green_index);
|
|
break;
|
|
case FOURCC_GBRG:
|
|
index_map[0] = GenerateSelector(green_index, blue_index);
|
|
index_map[1] = GenerateSelector(red_index, green_index);
|
|
break;
|
|
}
|
|
|
|
// Now convert.
|
|
for (int y = 0; y < height; ++y) {
|
|
ARGBToBayerRow(src_rgb, dst_bayer, index_map[y & 1], width);
|
|
src_rgb += src_stride_rgb;
|
|
dst_bayer += dst_stride_bayer;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#define AVG(a,b) (((a) + (b)) >> 1)
|
|
|
|
static void BayerRowBG(const uint8* src_bayer0, int src_stride_bayer,
|
|
uint8* dst_rgb, int pix) {
|
|
const uint8* src_bayer1 = src_bayer0 + src_stride_bayer;
|
|
uint8 g = src_bayer0[1];
|
|
uint8 r = src_bayer1[1];
|
|
for (int x = 0; x < pix - 2; x += 2) {
|
|
dst_rgb[0] = src_bayer0[0];
|
|
dst_rgb[1] = AVG(g, src_bayer0[1]);
|
|
dst_rgb[2] = AVG(r, src_bayer1[1]);
|
|
dst_rgb[3] = 255U;
|
|
dst_rgb[4] = AVG(src_bayer0[0], src_bayer0[2]);
|
|
dst_rgb[5] = src_bayer0[1];
|
|
dst_rgb[6] = src_bayer1[1];
|
|
dst_rgb[7] = 255U;
|
|
g = src_bayer0[1];
|
|
r = src_bayer1[1];
|
|
src_bayer0 += 2;
|
|
src_bayer1 += 2;
|
|
dst_rgb += 8;
|
|
}
|
|
dst_rgb[0] = src_bayer0[0];
|
|
dst_rgb[1] = AVG(g, src_bayer0[1]);
|
|
dst_rgb[2] = AVG(r, src_bayer1[1]);
|
|
dst_rgb[3] = 255U;
|
|
if (!(pix & 1)) {
|
|
dst_rgb[4] = src_bayer0[0];
|
|
dst_rgb[5] = src_bayer0[1];
|
|
dst_rgb[6] = src_bayer1[1];
|
|
dst_rgb[7] = 255U;
|
|
}
|
|
}
|
|
|
|
static void BayerRowRG(const uint8* src_bayer0, int src_stride_bayer,
|
|
uint8* dst_rgb, int pix) {
|
|
const uint8* src_bayer1 = src_bayer0 + src_stride_bayer;
|
|
uint8 g = src_bayer0[1];
|
|
uint8 b = src_bayer1[1];
|
|
for (int x = 0; x < pix - 2; x += 2) {
|
|
dst_rgb[0] = AVG(b, src_bayer1[1]);
|
|
dst_rgb[1] = AVG(g, src_bayer0[1]);
|
|
dst_rgb[2] = src_bayer0[0];
|
|
dst_rgb[3] = 255U;
|
|
dst_rgb[4] = src_bayer1[1];
|
|
dst_rgb[5] = src_bayer0[1];
|
|
dst_rgb[6] = AVG(src_bayer0[0], src_bayer0[2]);
|
|
dst_rgb[7] = 255U;
|
|
g = src_bayer0[1];
|
|
b = src_bayer1[1];
|
|
src_bayer0 += 2;
|
|
src_bayer1 += 2;
|
|
dst_rgb += 8;
|
|
}
|
|
dst_rgb[0] = AVG(b, src_bayer1[1]);
|
|
dst_rgb[1] = AVG(g, src_bayer0[1]);
|
|
dst_rgb[2] = src_bayer0[0];
|
|
dst_rgb[3] = 255U;
|
|
if (!(pix & 1)) {
|
|
dst_rgb[4] = src_bayer1[1];
|
|
dst_rgb[5] = src_bayer0[1];
|
|
dst_rgb[6] = src_bayer0[0];
|
|
dst_rgb[7] = 255U;
|
|
}
|
|
}
|
|
|
|
static void BayerRowGB(const uint8* src_bayer0, int src_stride_bayer,
|
|
uint8* dst_rgb, int pix) {
|
|
const uint8* src_bayer1 = src_bayer0 + src_stride_bayer;
|
|
uint8 b = src_bayer0[1];
|
|
for (int x = 0; x < pix - 2; x += 2) {
|
|
dst_rgb[0] = AVG(b, src_bayer0[1]);
|
|
dst_rgb[1] = src_bayer0[0];
|
|
dst_rgb[2] = src_bayer1[0];
|
|
dst_rgb[3] = 255U;
|
|
dst_rgb[4] = src_bayer0[1];
|
|
dst_rgb[5] = AVG(src_bayer0[0], src_bayer0[2]);
|
|
dst_rgb[6] = AVG(src_bayer1[0], src_bayer1[2]);
|
|
dst_rgb[7] = 255U;
|
|
b = src_bayer0[1];
|
|
src_bayer0 += 2;
|
|
src_bayer1 += 2;
|
|
dst_rgb += 8;
|
|
}
|
|
dst_rgb[0] = AVG(b, src_bayer0[1]);
|
|
dst_rgb[1] = src_bayer0[0];
|
|
dst_rgb[2] = src_bayer1[0];
|
|
dst_rgb[3] = 255U;
|
|
if (!(pix & 1)) {
|
|
dst_rgb[4] = src_bayer0[1];
|
|
dst_rgb[5] = src_bayer0[0];
|
|
dst_rgb[6] = src_bayer1[0];
|
|
dst_rgb[7] = 255U;
|
|
}
|
|
}
|
|
|
|
static void BayerRowGR(const uint8* src_bayer0, int src_stride_bayer,
|
|
uint8* dst_rgb, int pix) {
|
|
const uint8* src_bayer1 = src_bayer0 + src_stride_bayer;
|
|
uint8 r = src_bayer0[1];
|
|
for (int x = 0; x < pix - 2; x += 2) {
|
|
dst_rgb[0] = src_bayer1[0];
|
|
dst_rgb[1] = src_bayer0[0];
|
|
dst_rgb[2] = AVG(r, src_bayer0[1]);
|
|
dst_rgb[3] = 255U;
|
|
dst_rgb[4] = AVG(src_bayer1[0], src_bayer1[2]);
|
|
dst_rgb[5] = AVG(src_bayer0[0], src_bayer0[2]);
|
|
dst_rgb[6] = src_bayer0[1];
|
|
dst_rgb[7] = 255U;
|
|
r = src_bayer0[1];
|
|
src_bayer0 += 2;
|
|
src_bayer1 += 2;
|
|
dst_rgb += 8;
|
|
}
|
|
dst_rgb[0] = src_bayer1[0];
|
|
dst_rgb[1] = src_bayer0[0];
|
|
dst_rgb[2] = AVG(r, src_bayer0[1]);
|
|
dst_rgb[3] = 255U;
|
|
if (!(pix & 1)) {
|
|
dst_rgb[4] = src_bayer1[0];
|
|
dst_rgb[5] = src_bayer0[0];
|
|
dst_rgb[6] = src_bayer0[1];
|
|
dst_rgb[7] = 255U;
|
|
}
|
|
}
|
|
|
|
// Converts any Bayer RGB format to ARGB.
|
|
int BayerRGBToARGB(const uint8* src_bayer, int src_stride_bayer,
|
|
uint32 src_fourcc_bayer,
|
|
uint8* dst_rgb, int dst_stride_rgb,
|
|
int width, int height) {
|
|
if (height < 0) {
|
|
height = -height;
|
|
dst_rgb = dst_rgb + (height - 1) * dst_stride_rgb;
|
|
dst_stride_rgb = -dst_stride_rgb;
|
|
}
|
|
void (*BayerRow0)(const uint8* src_bayer, int src_stride_bayer,
|
|
uint8* dst_rgb, int pix);
|
|
void (*BayerRow1)(const uint8* src_bayer, int src_stride_bayer,
|
|
uint8* dst_rgb, int pix);
|
|
|
|
switch (src_fourcc_bayer) {
|
|
default:
|
|
assert(false);
|
|
case FOURCC_RGGB:
|
|
BayerRow0 = BayerRowRG;
|
|
BayerRow1 = BayerRowGB;
|
|
break;
|
|
case FOURCC_BGGR:
|
|
BayerRow0 = BayerRowBG;
|
|
BayerRow1 = BayerRowGR;
|
|
break;
|
|
case FOURCC_GRBG:
|
|
BayerRow0 = BayerRowGR;
|
|
BayerRow1 = BayerRowBG;
|
|
break;
|
|
case FOURCC_GBRG:
|
|
BayerRow0 = BayerRowGB;
|
|
BayerRow1 = BayerRowRG;
|
|
break;
|
|
}
|
|
|
|
for (int y = 0; y < height - 1; y += 2) {
|
|
BayerRow0(src_bayer, src_stride_bayer, dst_rgb, width);
|
|
BayerRow1(src_bayer + src_stride_bayer, -src_stride_bayer,
|
|
dst_rgb + dst_stride_rgb, width);
|
|
src_bayer += src_stride_bayer * 2;
|
|
dst_rgb += dst_stride_rgb * 2;
|
|
}
|
|
if (height & 1) {
|
|
BayerRow0(src_bayer, -src_stride_bayer, dst_rgb, width);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Converts any Bayer RGB format to ARGB.
|
|
int BayerRGBToI420(const uint8* src_bayer, int src_stride_bayer,
|
|
uint32 src_fourcc_bayer,
|
|
uint8* dst_y, int dst_stride_y,
|
|
uint8* dst_u, int dst_stride_u,
|
|
uint8* dst_v, int dst_stride_v,
|
|
int width, int height) {
|
|
if (width * 4 > kMaxStride) {
|
|
return -1;
|
|
}
|
|
// Negative height means invert the image.
|
|
if (height < 0) {
|
|
height = -height;
|
|
int halfheight = (height + 1) >> 1;
|
|
dst_y = dst_y + (height - 1) * dst_stride_y;
|
|
dst_u = dst_u + (halfheight - 1) * dst_stride_u;
|
|
dst_v = dst_v + (halfheight - 1) * dst_stride_v;
|
|
dst_stride_y = -dst_stride_y;
|
|
dst_stride_u = -dst_stride_u;
|
|
dst_stride_v = -dst_stride_v;
|
|
}
|
|
void (*BayerRow0)(const uint8* src_bayer, int src_stride_bayer,
|
|
uint8* dst_rgb, int pix);
|
|
void (*BayerRow1)(const uint8* src_bayer, int src_stride_bayer,
|
|
uint8* dst_rgb, int pix);
|
|
void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int pix);
|
|
void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb,
|
|
uint8* dst_u, uint8* dst_v, int width);
|
|
SIMD_ALIGNED(uint8 row[kMaxStride * 2]);
|
|
|
|
#if defined(HAS_ARGBTOYROW_SSSE3)
|
|
if (libyuv::TestCpuFlag(libyuv::kCpuHasSSSE3) &&
|
|
(width % 16 == 0) &&
|
|
IS_ALIGNED(row, 16) && (kMaxStride % 16 == 0) &&
|
|
IS_ALIGNED(dst_y, 16) && (dst_stride_y % 16 == 0)) {
|
|
ARGBToYRow = ARGBToYRow_SSSE3;
|
|
} else
|
|
#endif
|
|
{
|
|
ARGBToYRow = ARGBToYRow_C;
|
|
}
|
|
#if defined(HAS_ARGBTOUVROW_SSSE3)
|
|
if (libyuv::TestCpuFlag(libyuv::kCpuHasSSSE3) &&
|
|
(width % 16 == 0) &&
|
|
IS_ALIGNED(row, 16) && (kMaxStride % 16 == 0) &&
|
|
IS_ALIGNED(dst_u, 8) && (dst_stride_u % 8 == 0) &&
|
|
IS_ALIGNED(dst_v, 8) && (dst_stride_v % 8 == 0)) {
|
|
ARGBToUVRow = ARGBToUVRow_SSSE3;
|
|
} else
|
|
#endif
|
|
{
|
|
ARGBToUVRow = ARGBToUVRow_C;
|
|
}
|
|
|
|
switch (src_fourcc_bayer) {
|
|
default:
|
|
assert(false);
|
|
case FOURCC_RGGB:
|
|
BayerRow0 = BayerRowRG;
|
|
BayerRow1 = BayerRowGB;
|
|
break;
|
|
case FOURCC_BGGR:
|
|
BayerRow0 = BayerRowBG;
|
|
BayerRow1 = BayerRowGR;
|
|
break;
|
|
case FOURCC_GRBG:
|
|
BayerRow0 = BayerRowGR;
|
|
BayerRow1 = BayerRowBG;
|
|
break;
|
|
case FOURCC_GBRG:
|
|
BayerRow0 = BayerRowGB;
|
|
BayerRow1 = BayerRowRG;
|
|
break;
|
|
}
|
|
|
|
for (int y = 0; y < height - 1; y += 2) {
|
|
BayerRow0(src_bayer, src_stride_bayer, row, width);
|
|
BayerRow1(src_bayer + src_stride_bayer, -src_stride_bayer,
|
|
row + kMaxStride, width);
|
|
ARGBToUVRow(row, kMaxStride, dst_u, dst_v, width);
|
|
ARGBToYRow(row, dst_y, width);
|
|
ARGBToYRow(row + kMaxStride, dst_y + dst_stride_y, width);
|
|
src_bayer += src_stride_bayer * 2;
|
|
dst_y += dst_stride_y * 2;
|
|
dst_u += dst_stride_u;
|
|
dst_v += dst_stride_v;
|
|
}
|
|
// TODO(fbarchard): Make sure this filters properly
|
|
if (height & 1) {
|
|
BayerRow0(src_bayer, src_stride_bayer, row, width);
|
|
ARGBToUVRow(row, 0, dst_u, dst_v, width);
|
|
ARGBToYRow(row, dst_y, width);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
} // namespace libyuv
|