dany/libwebp
1
0
Fork 0
mirror of https://github.com/webmproject/libwebp.git synced 2025-02-13 15:32:53 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge "filters: harmonize the suffixes naming to _SSE2(), _C(), etc."

Browse Source
This commit is contained in:
Pascal Massimino 2017-08-01 01:55:48 +00:00 committed by Gerrit Code Review
commit 7295fde2e6
4 changed files with 193 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
src/dsp/filters.c
View File

@ -28,7 +28,7 @@
assert(row >= 0 && num_rows > 0 && row + num_rows <= height); \ assert(row >= 0 && num_rows > 0 && row + num_rows <= height); \
(void)height; // Silence unused warning. (void)height; // Silence unused warning.
static WEBP_INLINE void PredictLine(const uint8_t* src, const uint8_t* pred, static WEBP_INLINE void PredictLine_C(const uint8_t* src, const uint8_t* pred,
uint8_t* dst, int length, int inverse) { uint8_t* dst, int length, int inverse) {
int i; int i;
if (inverse) { if (inverse) {
@ -41,7 +41,7 @@ static WEBP_INLINE void PredictLine(const uint8_t* src, const uint8_t* pred,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Horizontal filter. // Horizontal filter.
static WEBP_INLINE void DoHorizontalFilter(const uint8_t* in, static WEBP_INLINE void DoHorizontalFilter_C(const uint8_t* in,
int width, int height, int stride, int width, int height, int stride,
int row, int num_rows, int row, int num_rows,
int inverse, uint8_t* out) { int inverse, uint8_t* out) {
@ -56,7 +56,7 @@ static WEBP_INLINE void DoHorizontalFilter(const uint8_t* in,
if (row == 0) { if (row == 0) {
// Leftmost pixel is the same as input for topmost scanline. // Leftmost pixel is the same as input for topmost scanline.
out[0] = in[0]; out[0] = in[0];
PredictLine(in + 1, preds, out + 1, width - 1, inverse); PredictLine_C(in + 1, preds, out + 1, width - 1, inverse);
row = 1; row = 1;
preds += stride; preds += stride;
in += stride; in += stride;
@ -66,8 +66,8 @@ static WEBP_INLINE void DoHorizontalFilter(const uint8_t* in,
// Filter line-by-line. // Filter line-by-line.
while (row < last_row) { while (row < last_row) {
// Leftmost pixel is predicted from above. // Leftmost pixel is predicted from above.
PredictLine(in, preds - stride, out, 1, inverse); PredictLine_C(in, preds - stride, out, 1, inverse);
PredictLine(in + 1, preds, out + 1, width - 1, inverse); PredictLine_C(in + 1, preds, out + 1, width - 1, inverse);
++row; ++row;
preds += stride; preds += stride;
in += stride; in += stride;
@ -78,7 +78,7 @@ static WEBP_INLINE void DoHorizontalFilter(const uint8_t* in,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Vertical filter. // Vertical filter.
static WEBP_INLINE void DoVerticalFilter(const uint8_t* in, static WEBP_INLINE void DoVerticalFilter_C(const uint8_t* in,
int width, int height, int stride, int width, int height, int stride,
int row, int num_rows, int row, int num_rows,
int inverse, uint8_t* out) { int inverse, uint8_t* out) {
@ -94,7 +94,7 @@ static WEBP_INLINE void DoVerticalFilter(const uint8_t* in,
// Very first top-left pixel is copied. // Very first top-left pixel is copied.
out[0] = in[0]; out[0] = in[0];
// Rest of top scan-line is left-predicted. // Rest of top scan-line is left-predicted.
PredictLine(in + 1, preds, out + 1, width - 1, inverse); PredictLine_C(in + 1, preds, out + 1, width - 1, inverse);
row = 1; row = 1;
in += stride; in += stride;
out += stride; out += stride;
@ -105,7 +105,7 @@ static WEBP_INLINE void DoVerticalFilter(const uint8_t* in,
// Filter line-by-line. // Filter line-by-line.
while (row < last_row) { while (row < last_row) {
PredictLine(in, preds, out, width, inverse); PredictLine_C(in, preds, out, width, inverse);
++row; ++row;
preds += stride; preds += stride;
in += stride; in += stride;
@ -116,12 +116,12 @@ static WEBP_INLINE void DoVerticalFilter(const uint8_t* in,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Gradient filter. // Gradient filter.
static WEBP_INLINE int GradientPredictor(uint8_t a, uint8_t b, uint8_t c) { static WEBP_INLINE int GradientPredictor_C(uint8_t a, uint8_t b, uint8_t c) {
const int g = a + b - c; const int g = a + b - c;
return ((g & ~0xff) == 0) ? g : (g < 0) ? 0 : 255; // clip to 8bit return ((g & ~0xff) == 0) ? g : (g < 0) ? 0 : 255; // clip to 8bit
} }
static WEBP_INLINE void DoGradientFilter(const uint8_t* in, static WEBP_INLINE void DoGradientFilter_C(const uint8_t* in,
int width, int height, int stride, int width, int height, int stride,
int row, int num_rows, int row, int num_rows,
int inverse, uint8_t* out) { int inverse, uint8_t* out) {
@ -136,7 +136,7 @@ static WEBP_INLINE void DoGradientFilter(const uint8_t* in,
// left prediction for top scan-line // left prediction for top scan-line
if (row == 0) { if (row == 0) {
out[0] = in[0]; out[0] = in[0];
PredictLine(in + 1, preds, out + 1, width - 1, inverse); PredictLine_C(in + 1, preds, out + 1, width - 1, inverse);
row = 1; row = 1;
preds += stride; preds += stride;
in += stride; in += stride;
@ -147,9 +147,9 @@ static WEBP_INLINE void DoGradientFilter(const uint8_t* in,
while (row < last_row) { while (row < last_row) {
int w; int w;
// leftmost pixel: predict from above. // leftmost pixel: predict from above.
PredictLine(in, preds - stride, out, 1, inverse); PredictLine_C(in, preds - stride, out, 1, inverse);
for (w = 1; w < width; ++w) { for (w = 1; w < width; ++w) {
const int pred = GradientPredictor(preds[w - 1], const int pred = GradientPredictor_C(preds[w - 1],
preds[w - stride], preds[w - stride],
preds[w - stride - 1]); preds[w - stride - 1]);
out[w] = in[w] + (inverse ? pred : -pred); out[w] = in[w] + (inverse ? pred : -pred);
@ -165,26 +165,26 @@ static WEBP_INLINE void DoGradientFilter(const uint8_t* in,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static void HorizontalFilter(const uint8_t* data, int width, int height, static void HorizontalFilter_C(const uint8_t* data, int width, int height,
int stride, uint8_t* filtered_data) { int stride, uint8_t* filtered_data) {
DoHorizontalFilter(data, width, height, stride, 0, height, 0, filtered_data); DoHorizontalFilter_C(data, width, height, stride, 0, height, 0,
filtered_data);
} }
static void VerticalFilter(const uint8_t* data, int width, int height, static void VerticalFilter_C(const uint8_t* data, int width, int height,
int stride, uint8_t* filtered_data) { int stride, uint8_t* filtered_data) {
DoVerticalFilter(data, width, height, stride, 0, height, 0, filtered_data); DoVerticalFilter_C(data, width, height, stride, 0, height, 0, filtered_data);
} }
static void GradientFilter_C(const uint8_t* data, int width, int height,
static void GradientFilter(const uint8_t* data, int width, int height,
int stride, uint8_t* filtered_data) { int stride, uint8_t* filtered_data) {
DoGradientFilter(data, width, height, stride, 0, height, 0, filtered_data); DoGradientFilter_C(data, width, height, stride, 0, height, 0, filtered_data);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static void HorizontalUnfilter(const uint8_t* prev, const uint8_t* in, static void HorizontalUnfilter_C(const uint8_t* prev, const uint8_t* in,
uint8_t* out, int width) { uint8_t* out, int width) {
uint8_t pred = (prev == NULL) ? 0 : prev[0]; uint8_t pred = (prev == NULL) ? 0 : prev[0];
int i; int i;
@ -194,26 +194,26 @@ static void HorizontalUnfilter(const uint8_t* prev, const uint8_t* in,
} }
} }
static void VerticalUnfilter(const uint8_t* prev, const uint8_t* in, static void VerticalUnfilter_C(const uint8_t* prev, const uint8_t* in,
uint8_t* out, int width) { uint8_t* out, int width) {
if (prev == NULL) { if (prev == NULL) {
HorizontalUnfilter(NULL, in, out, width); HorizontalUnfilter_C(NULL, in, out, width);
} else { } else {
int i; int i;
for (i = 0; i < width; ++i) out[i] = prev[i] + in[i]; for (i = 0; i < width; ++i) out[i] = prev[i] + in[i];
} }
} }
static void GradientUnfilter(const uint8_t* prev, const uint8_t* in, static void GradientUnfilter_C(const uint8_t* prev, const uint8_t* in,
uint8_t* out, int width) { uint8_t* out, int width) {
if (prev == NULL) { if (prev == NULL) {
HorizontalUnfilter(NULL, in, out, width); HorizontalUnfilter_C(NULL, in, out, width);
} else { } else {
uint8_t top = prev[0], top_left = top, left = top; uint8_t top = prev[0], top_left = top, left = top;
int i; int i;
for (i = 0; i < width; ++i) { for (i = 0; i < width; ++i) {
top = prev[i]; // need to read this first, in case prev==out top = prev[i]; // need to read this first, in case prev==out
left = in[i] + GradientPredictor(left, top, top_left); left = in[i] + GradientPredictor_C(left, top, top_left);
top_left = top; top_left = top;
out[i] = left; out[i] = left;
} }
@ -238,14 +238,14 @@ WEBP_TSAN_IGNORE_FUNCTION void VP8FiltersInit(void) {
if (filters_last_cpuinfo_used == VP8GetCPUInfo) return; if (filters_last_cpuinfo_used == VP8GetCPUInfo) return;
WebPUnfilters[WEBP_FILTER_NONE] = NULL; WebPUnfilters[WEBP_FILTER_NONE] = NULL;
WebPUnfilters[WEBP_FILTER_HORIZONTAL] = HorizontalUnfilter; WebPUnfilters[WEBP_FILTER_HORIZONTAL] = HorizontalUnfilter_C;
WebPUnfilters[WEBP_FILTER_VERTICAL] = VerticalUnfilter; WebPUnfilters[WEBP_FILTER_VERTICAL] = VerticalUnfilter_C;
WebPUnfilters[WEBP_FILTER_GRADIENT] = GradientUnfilter; WebPUnfilters[WEBP_FILTER_GRADIENT] = GradientUnfilter_C;
WebPFilters[WEBP_FILTER_NONE] = NULL; WebPFilters[WEBP_FILTER_NONE] = NULL;
WebPFilters[WEBP_FILTER_HORIZONTAL] = HorizontalFilter; WebPFilters[WEBP_FILTER_HORIZONTAL] = HorizontalFilter_C;
WebPFilters[WEBP_FILTER_VERTICAL] = VerticalFilter; WebPFilters[WEBP_FILTER_VERTICAL] = VerticalFilter_C;
WebPFilters[WEBP_FILTER_GRADIENT] = GradientFilter; WebPFilters[WEBP_FILTER_GRADIENT] = GradientFilter_C;
if (VP8GetCPUInfo != NULL) { if (VP8GetCPUInfo != NULL) {
#if defined(WEBP_USE_SSE2) #if defined(WEBP_USE_SSE2)

67
src/dsp/filters_mips_dsp_r2.c
View File

@ -101,7 +101,7 @@
); \ ); \
} while (0) } while (0)
static WEBP_INLINE void PredictLine(const uint8_t* src, uint8_t* dst, static WEBP_INLINE void PredictLine_MIPSdspR2(const uint8_t* src, uint8_t* dst,
int length) { int length) {
DO_PREDICT_LINE(src, dst, length, 0); DO_PREDICT_LINE(src, dst, length, 0);
} }
@ -192,8 +192,9 @@ static WEBP_INLINE void PredictLine(const uint8_t* src, uint8_t* dst,
} \ } \
} while (0) } while (0)
static WEBP_INLINE void DoHorizontalFilter(const uint8_t* in, static WEBP_INLINE void DoHorizontalFilter_MIPSdspR2(const uint8_t* in,
int width, int height, int stride, int width, int height,
int stride,
int row, int num_rows, int row, int num_rows,
uint8_t* out) { uint8_t* out) {
const uint8_t* preds; const uint8_t* preds;
@ -207,7 +208,7 @@ static WEBP_INLINE void DoHorizontalFilter(const uint8_t* in,
if (row == 0) { if (row == 0) {
// Leftmost pixel is the same as input for topmost scanline. // Leftmost pixel is the same as input for topmost scanline.
out[0] = in[0]; out[0] = in[0];
PredictLine(in + 1, out + 1, width - 1); PredictLine_MIPSdspR2(in + 1, out + 1, width - 1);
row = 1; row = 1;
preds += stride; preds += stride;
in += stride; in += stride;
@ -219,9 +220,11 @@ static WEBP_INLINE void DoHorizontalFilter(const uint8_t* in,
} }
#undef FILTER_LINE_BY_LINE #undef FILTER_LINE_BY_LINE
static void HorizontalFilter(const uint8_t* data, int width, int height, static void HorizontalFilter_MIPSdspR2(const uint8_t* data,
int width, int height,
int stride, uint8_t* filtered_data) { int stride, uint8_t* filtered_data) {
DoHorizontalFilter(data, width, height, stride, 0, height, filtered_data); DoHorizontalFilter_MIPSdspR2(data, width, height, stride, 0, height,
filtered_data);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -237,9 +240,11 @@ static void HorizontalFilter(const uint8_t* data, int width, int height,
} \ } \
} while (0) } while (0)
static WEBP_INLINE void DoVerticalFilter(const uint8_t* in, static WEBP_INLINE void DoVerticalFilter_MIPSdspR2(const uint8_t* in,
int width, int height, int stride, int width, int height,
int row, int num_rows, uint8_t* out) { int stride,
int row, int num_rows,
uint8_t* out) {
const uint8_t* preds; const uint8_t* preds;
const size_t start_offset = row * stride; const size_t start_offset = row * stride;
const int last_row = row + num_rows; const int last_row = row + num_rows;
@ -252,7 +257,7 @@ static WEBP_INLINE void DoVerticalFilter(const uint8_t* in,
// Very first top-left pixel is copied. // Very first top-left pixel is copied.
out[0] = in[0]; out[0] = in[0];
// Rest of top scan-line is left-predicted. // Rest of top scan-line is left-predicted.
PredictLine(in + 1, out + 1, width - 1); PredictLine_MIPSdspR2(in + 1, out + 1, width - 1);
row = 1; row = 1;
in += stride; in += stride;
out += stride; out += stride;
@ -266,15 +271,16 @@ static WEBP_INLINE void DoVerticalFilter(const uint8_t* in,
} }
#undef FILTER_LINE_BY_LINE #undef FILTER_LINE_BY_LINE
static void VerticalFilter(const uint8_t* data, int width, int height, static void VerticalFilter_MIPSdspR2(const uint8_t* data, int width, int height,
int stride, uint8_t* filtered_data) { int stride, uint8_t* filtered_data) {
DoVerticalFilter(data, width, height, stride, 0, height, filtered_data); DoVerticalFilter_MIPSdspR2(data, width, height, stride, 0, height,
filtered_data);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Gradient filter. // Gradient filter.
static WEBP_INLINE int GradientPredictor(uint8_t a, uint8_t b, uint8_t c) { static int GradientPredictor_MIPSdspR2(uint8_t a, uint8_t b, uint8_t c) {
int temp0; int temp0;
__asm__ volatile ( __asm__ volatile (
"addu %[temp0], %[a], %[b] \n\t" "addu %[temp0], %[a], %[b] \n\t"
@ -293,7 +299,7 @@ static WEBP_INLINE int GradientPredictor(uint8_t a, uint8_t b, uint8_t c) {
int w; \ int w; \
PREDICT_LINE_ONE_PASS(in, PREDS - stride, out); \ PREDICT_LINE_ONE_PASS(in, PREDS - stride, out); \
for (w = 1; w < width; ++w) { \ for (w = 1; w < width; ++w) { \
const int pred = GradientPredictor(PREDS[w - 1], \ const int pred = GradientPredictor_MIPSdspR2(PREDS[w - 1], \
PREDS[w - stride], \ PREDS[w - stride], \
PREDS[w - stride - 1]); \ PREDS[w - stride - 1]); \
out[w] = in[w] OPERATION pred; \ out[w] = in[w] OPERATION pred; \
@ -304,7 +310,7 @@ static WEBP_INLINE int GradientPredictor(uint8_t a, uint8_t b, uint8_t c) {
} \ } \
} while (0) } while (0)
static WEBP_INLINE void DoGradientFilter(const uint8_t* in, static void DoGradientFilter_MIPSdspR2(const uint8_t* in,
int width, int height, int stride, int width, int height, int stride,
int row, int num_rows, uint8_t* out) { int row, int num_rows, uint8_t* out) {
const uint8_t* preds; const uint8_t* preds;
@ -318,7 +324,7 @@ static WEBP_INLINE void DoGradientFilter(const uint8_t* in,
// left prediction for top scan-line // left prediction for top scan-line
if (row == 0) { if (row == 0) {
out[0] = in[0]; out[0] = in[0];
PredictLine(in + 1, out + 1, width - 1); PredictLine_MIPSdspR2(in + 1, out + 1, width - 1);
row = 1; row = 1;
preds += stride; preds += stride;
in += stride; in += stride;
@ -330,38 +336,39 @@ static WEBP_INLINE void DoGradientFilter(const uint8_t* in,
} }
#undef FILTER_LINE_BY_LINE #undef FILTER_LINE_BY_LINE
static void GradientFilter(const uint8_t* data, int width, int height, static void GradientFilter_MIPSdspR2(const uint8_t* data, int width, int height,
int stride, uint8_t* filtered_data) { int stride, uint8_t* filtered_data) {
DoGradientFilter(data, width, height, stride, 0, height, filtered_data); DoGradientFilter_MIPSdspR2(data, width, height, stride, 0, height,
filtered_data);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static void HorizontalUnfilter(const uint8_t* prev, const uint8_t* in, static void HorizontalUnfilter_MIPSdspR2(const uint8_t* prev, const uint8_t* in,
uint8_t* out, int width) { uint8_t* out, int width) {
out[0] = in[0] + (prev == NULL ? 0 : prev[0]); out[0] = in[0] + (prev == NULL ? 0 : prev[0]);
DO_PREDICT_LINE(in + 1, out + 1, width - 1, 1); DO_PREDICT_LINE(in + 1, out + 1, width - 1, 1);
} }
static void VerticalUnfilter(const uint8_t* prev, const uint8_t* in, static void VerticalUnfilter_MIPSdspR2(const uint8_t* prev, const uint8_t* in,
uint8_t* out, int width) { uint8_t* out, int width) {
if (prev == NULL) { if (prev == NULL) {
HorizontalUnfilter(NULL, in, out, width); HorizontalUnfilter_MIPSdspR2(NULL, in, out, width);
} else { } else {
DO_PREDICT_LINE_VERTICAL(in, prev, out, width, 1); DO_PREDICT_LINE_VERTICAL(in, prev, out, width, 1);
} }
} }
static void GradientUnfilter(const uint8_t* prev, const uint8_t* in, static void GradientUnfilter_MIPSdspR2(const uint8_t* prev, const uint8_t* in,
uint8_t* out, int width) { uint8_t* out, int width) {
if (prev == NULL) { if (prev == NULL) {
HorizontalUnfilter(NULL, in, out, width); HorizontalUnfilter_MIPSdspR2(NULL, in, out, width);
} else { } else {
uint8_t top = prev[0], top_left = top, left = top; uint8_t top = prev[0], top_left = top, left = top;
int i; int i;
for (i = 0; i < width; ++i) { for (i = 0; i < width; ++i) {
top = prev[i]; // need to read this first, in case prev==dst top = prev[i]; // need to read this first, in case prev==dst
left = in[i] + GradientPredictor(left, top, top_left); left = in[i] + GradientPredictor_MIPSdspR2(left, top, top_left);
top_left = top; top_left = top;
out[i] = left; out[i] = left;
} }
@ -379,13 +386,13 @@ static void GradientUnfilter(const uint8_t* prev, const uint8_t* in,
extern void VP8FiltersInitMIPSdspR2(void); extern void VP8FiltersInitMIPSdspR2(void);
WEBP_TSAN_IGNORE_FUNCTION void VP8FiltersInitMIPSdspR2(void) { WEBP_TSAN_IGNORE_FUNCTION void VP8FiltersInitMIPSdspR2(void) {
WebPUnfilters[WEBP_FILTER_HORIZONTAL] = HorizontalUnfilter; WebPUnfilters[WEBP_FILTER_HORIZONTAL] = HorizontalUnfilter_MIPSdspR2;
WebPUnfilters[WEBP_FILTER_VERTICAL] = VerticalUnfilter; WebPUnfilters[WEBP_FILTER_VERTICAL] = VerticalUnfilter_MIPSdspR2;
WebPUnfilters[WEBP_FILTER_GRADIENT] = GradientUnfilter; WebPUnfilters[WEBP_FILTER_GRADIENT] = GradientUnfilter_MIPSdspR2;
WebPFilters[WEBP_FILTER_HORIZONTAL] = HorizontalFilter; WebPFilters[WEBP_FILTER_HORIZONTAL] = HorizontalFilter_MIPSdspR2;
WebPFilters[WEBP_FILTER_VERTICAL] = VerticalFilter; WebPFilters[WEBP_FILTER_VERTICAL] = VerticalFilter_MIPSdspR2;
WebPFilters[WEBP_FILTER_GRADIENT] = GradientFilter; WebPFilters[WEBP_FILTER_GRADIENT] = GradientFilter_MIPSdspR2;
} }
#else // !WEBP_USE_MIPS_DSP_R2 #else // !WEBP_USE_MIPS_DSP_R2

12
src/dsp/filters_msa.c
View File

@ -66,7 +66,7 @@ static WEBP_INLINE void PredictLineInverse0(const uint8_t* src,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Horrizontal filter // Horrizontal filter
static void HorizontalFilter(const uint8_t* data, int width, int height, static void HorizontalFilter_MSA(const uint8_t* data, int width, int height,
int stride, uint8_t* filtered_data) { int stride, uint8_t* filtered_data) {
const uint8_t* preds = data; const uint8_t* preds = data;
const uint8_t* in = data; const uint8_t* in = data;
@ -129,7 +129,7 @@ static WEBP_INLINE void PredictLineGradient(const uint8_t* pinput,
} }
static void GradientFilter(const uint8_t* data, int width, int height, static void GradientFilter_MSA(const uint8_t* data, int width, int height,
int stride, uint8_t* filtered_data) { int stride, uint8_t* filtered_data) {
const uint8_t* in = data; const uint8_t* in = data;
const uint8_t* preds = data; const uint8_t* preds = data;
@ -157,7 +157,7 @@ static void GradientFilter(const uint8_t* data, int width, int height,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Vertical filter // Vertical filter
static void VerticalFilter(const uint8_t* data, int width, int height, static void VerticalFilter_MSA(const uint8_t* data, int width, int height,
int stride, uint8_t* filtered_data) { int stride, uint8_t* filtered_data) {
const uint8_t* in = data; const uint8_t* in = data;
const uint8_t* preds = data; const uint8_t* preds = data;
@ -190,9 +190,9 @@ static void VerticalFilter(const uint8_t* data, int width, int height,
extern void VP8FiltersInitMSA(void); extern void VP8FiltersInitMSA(void);
WEBP_TSAN_IGNORE_FUNCTION void VP8FiltersInitMSA(void) { WEBP_TSAN_IGNORE_FUNCTION void VP8FiltersInitMSA(void) {
WebPFilters[WEBP_FILTER_HORIZONTAL] = HorizontalFilter; WebPFilters[WEBP_FILTER_HORIZONTAL] = HorizontalFilter_MSA;
WebPFilters[WEBP_FILTER_VERTICAL] = VerticalFilter; WebPFilters[WEBP_FILTER_VERTICAL] = VerticalFilter_MSA;
WebPFilters[WEBP_FILTER_GRADIENT] = GradientFilter; WebPFilters[WEBP_FILTER_GRADIENT] = GradientFilter_MSA;
} }
#else // !WEBP_USE_MSA #else // !WEBP_USE_MSA

75
src/dsp/filters_sse2.c
View File

@ -32,7 +32,7 @@
assert(row >= 0 && num_rows > 0 && row + num_rows <= height); \ assert(row >= 0 && num_rows > 0 && row + num_rows <= height); \
(void)height; // Silence unused warning. (void)height; // Silence unused warning.
static void PredictLineTop(const uint8_t* src, const uint8_t* pred, static void PredictLineTop_SSE2(const uint8_t* src, const uint8_t* pred,
uint8_t* dst, int length) { uint8_t* dst, int length) {
int i; int i;
const int max_pos = length & ~31; const int max_pos = length & ~31;
@ -51,7 +51,7 @@ static void PredictLineTop(const uint8_t* src, const uint8_t* pred,
} }
// Special case for left-based prediction (when preds==dst-1 or preds==src-1). // Special case for left-based prediction (when preds==dst-1 or preds==src-1).
static void PredictLineLeft(const uint8_t* src, uint8_t* dst, int length) { static void PredictLineLeft_SSE2(const uint8_t* src, uint8_t* dst, int length) {
int i; int i;
const int max_pos = length & ~31; const int max_pos = length & ~31;
assert(length >= 0); assert(length >= 0);
@ -71,8 +71,9 @@ static void PredictLineLeft(const uint8_t* src, uint8_t* dst, int length) {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Horizontal filter. // Horizontal filter.
static WEBP_INLINE void DoHorizontalFilter(const uint8_t* in, static WEBP_INLINE void DoHorizontalFilter_SSE2(const uint8_t* in,
int width, int height, int stride, int width, int height,
int stride,
int row, int num_rows, int row, int num_rows,
uint8_t* out) { uint8_t* out) {
const size_t start_offset = row * stride; const size_t start_offset = row * stride;
@ -84,7 +85,7 @@ static WEBP_INLINE void DoHorizontalFilter(const uint8_t* in,
if (row == 0) { if (row == 0) {
// Leftmost pixel is the same as input for topmost scanline. // Leftmost pixel is the same as input for topmost scanline.
out[0] = in[0]; out[0] = in[0];
PredictLineLeft(in + 1, out + 1, width - 1); PredictLineLeft_SSE2(in + 1, out + 1, width - 1);
row = 1; row = 1;
in += stride; in += stride;
out += stride; out += stride;
@ -94,7 +95,7 @@ static WEBP_INLINE void DoHorizontalFilter(const uint8_t* in,
while (row < last_row) { while (row < last_row) {
// Leftmost pixel is predicted from above. // Leftmost pixel is predicted from above.
out[0] = in[0] - in[-stride]; out[0] = in[0] - in[-stride];
PredictLineLeft(in + 1, out + 1, width - 1); PredictLineLeft_SSE2(in + 1, out + 1, width - 1);
++row; ++row;
in += stride; in += stride;
out += stride; out += stride;
@ -104,9 +105,10 @@ static WEBP_INLINE void DoHorizontalFilter(const uint8_t* in,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Vertical filter. // Vertical filter.
static WEBP_INLINE void DoVerticalFilter(const uint8_t* in, static WEBP_INLINE void DoVerticalFilter_SSE2(const uint8_t* in,
int width, int height, int stride, int width, int height, int stride,
int row, int num_rows, uint8_t* out) { int row, int num_rows,
uint8_t* out) {
const size_t start_offset = row * stride; const size_t start_offset = row * stride;
const int last_row = row + num_rows; const int last_row = row + num_rows;
SANITY_CHECK(in, out); SANITY_CHECK(in, out);
@ -117,7 +119,7 @@ static WEBP_INLINE void DoVerticalFilter(const uint8_t* in,
// Very first top-left pixel is copied. // Very first top-left pixel is copied.
out[0] = in[0]; out[0] = in[0];
// Rest of top scan-line is left-predicted. // Rest of top scan-line is left-predicted.
PredictLineLeft(in + 1, out + 1, width - 1); PredictLineLeft_SSE2(in + 1, out + 1, width - 1);
row = 1; row = 1;
in += stride; in += stride;
out += stride; out += stride;
@ -125,7 +127,7 @@ static WEBP_INLINE void DoVerticalFilter(const uint8_t* in,
// Filter line-by-line. // Filter line-by-line.
while (row < last_row) { while (row < last_row) {
PredictLineTop(in, in - stride, out, width); PredictLineTop_SSE2(in, in - stride, out, width);
++row; ++row;
in += stride; in += stride;
out += stride; out += stride;
@ -135,12 +137,12 @@ static WEBP_INLINE void DoVerticalFilter(const uint8_t* in,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Gradient filter. // Gradient filter.
static WEBP_INLINE int GradientPredictorC(uint8_t a, uint8_t b, uint8_t c) { static WEBP_INLINE int GradientPredictor_SSE2(uint8_t a, uint8_t b, uint8_t c) {
const int g = a + b - c; const int g = a + b - c;
return ((g & ~0xff) == 0) ? g : (g < 0) ? 0 : 255; // clip to 8bit return ((g & ~0xff) == 0) ? g : (g < 0) ? 0 : 255; // clip to 8bit
} }
static void GradientPredictDirect(const uint8_t* const row, static void GradientPredictDirect_SSE2(const uint8_t* const row,
const uint8_t* const top, const uint8_t* const top,
uint8_t* const out, int length) { uint8_t* const out, int length) {
const int max_pos = length & ~7; const int max_pos = length & ~7;
@ -161,11 +163,11 @@ static void GradientPredictDirect(const uint8_t* const row,
_mm_storel_epi64((__m128i*)(out + i), H); _mm_storel_epi64((__m128i*)(out + i), H);
} }
for (; i < length; ++i) { for (; i < length; ++i) {
out[i] = row[i] - GradientPredictorC(row[i - 1], top[i], top[i - 1]); out[i] = row[i] - GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
} }
} }
static WEBP_INLINE void DoGradientFilter(const uint8_t* in, static WEBP_INLINE void DoGradientFilter_SSE2(const uint8_t* in,
int width, int height, int stride, int width, int height, int stride,
int row, int num_rows, int row, int num_rows,
uint8_t* out) { uint8_t* out) {
@ -178,7 +180,7 @@ static WEBP_INLINE void DoGradientFilter(const uint8_t* in,
// left prediction for top scan-line // left prediction for top scan-line
if (row == 0) { if (row == 0) {
out[0] = in[0]; out[0] = in[0];
PredictLineLeft(in + 1, out + 1, width - 1); PredictLineLeft_SSE2(in + 1, out + 1, width - 1);
row = 1; row = 1;
in += stride; in += stride;
out += stride; out += stride;
@ -187,7 +189,7 @@ static WEBP_INLINE void DoGradientFilter(const uint8_t* in,
// Filter line-by-line. // Filter line-by-line.
while (row < last_row) { while (row < last_row) {
out[0] = in[0] - in[-stride]; out[0] = in[0] - in[-stride];
GradientPredictDirect(in + 1, in + 1 - stride, out + 1, width - 1); GradientPredictDirect_SSE2(in + 1, in + 1 - stride, out + 1, width - 1);
++row; ++row;
in += stride; in += stride;
out += stride; out += stride;
@ -198,25 +200,26 @@ static WEBP_INLINE void DoGradientFilter(const uint8_t* in,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static void HorizontalFilter(const uint8_t* data, int width, int height, static void HorizontalFilter_SSE2(const uint8_t* data, int width, int height,
int stride, uint8_t* filtered_data) { int stride, uint8_t* filtered_data) {
DoHorizontalFilter(data, width, height, stride, 0, height, filtered_data); DoHorizontalFilter_SSE2(data, width, height, stride, 0, height,
filtered_data);
} }
static void VerticalFilter(const uint8_t* data, int width, int height, static void VerticalFilter_SSE2(const uint8_t* data, int width, int height,
int stride, uint8_t* filtered_data) { int stride, uint8_t* filtered_data) {
DoVerticalFilter(data, width, height, stride, 0, height, filtered_data); DoVerticalFilter_SSE2(data, width, height, stride, 0, height, filtered_data);
} }
static void GradientFilter(const uint8_t* data, int width, int height, static void GradientFilter_SSE2(const uint8_t* data, int width, int height,
int stride, uint8_t* filtered_data) { int stride, uint8_t* filtered_data) {
DoGradientFilter(data, width, height, stride, 0, height, filtered_data); DoGradientFilter_SSE2(data, width, height, stride, 0, height, filtered_data);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Inverse transforms // Inverse transforms
static void HorizontalUnfilter(const uint8_t* prev, const uint8_t* in, static void HorizontalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
uint8_t* out, int width) { uint8_t* out, int width) {
int i; int i;
__m128i last; __m128i last;
@ -238,10 +241,10 @@ static void HorizontalUnfilter(const uint8_t* prev, const uint8_t* in,
for (; i < width; ++i) out[i] = in[i] + out[i - 1]; for (; i < width; ++i) out[i] = in[i] + out[i - 1];
} }
static void VerticalUnfilter(const uint8_t* prev, const uint8_t* in, static void VerticalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
uint8_t* out, int width) { uint8_t* out, int width) {
if (prev == NULL) { if (prev == NULL) {
HorizontalUnfilter(NULL, in, out, width); HorizontalUnfilter_SSE2(NULL, in, out, width);
} else { } else {
int i; int i;
const int max_pos = width & ~31; const int max_pos = width & ~31;
@ -260,7 +263,7 @@ static void VerticalUnfilter(const uint8_t* prev, const uint8_t* in,
} }
} }
static void GradientPredictInverse(const uint8_t* const in, static void GradientPredictInverse_SSE2(const uint8_t* const in,
const uint8_t* const top, const uint8_t* const top,
uint8_t* const row, int length) { uint8_t* const row, int length) {
if (length > 0) { if (length > 0) {
@ -293,18 +296,18 @@ static void GradientPredictInverse(const uint8_t* const in,
_mm_storel_epi64((__m128i*)&row[i], out); _mm_storel_epi64((__m128i*)&row[i], out);
} }
for (; i < length; ++i) { for (; i < length; ++i) {
row[i] = in[i] + GradientPredictorC(row[i - 1], top[i], top[i - 1]); row[i] = in[i] + GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
} }
} }
} }
static void GradientUnfilter(const uint8_t* prev, const uint8_t* in, static void GradientUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
uint8_t* out, int width) { uint8_t* out, int width) {
if (prev == NULL) { if (prev == NULL) {
HorizontalUnfilter(NULL, in, out, width); HorizontalUnfilter_SSE2(NULL, in, out, width);
} else { } else {
out[0] = in[0] + prev[0]; // predict from above out[0] = in[0] + prev[0]; // predict from above
GradientPredictInverse(in + 1, prev + 1, out + 1, width - 1); GradientPredictInverse_SSE2(in + 1, prev + 1, out + 1, width - 1);
} }
} }
@ -314,13 +317,13 @@ static void GradientUnfilter(const uint8_t* prev, const uint8_t* in,
extern void VP8FiltersInitSSE2(void); extern void VP8FiltersInitSSE2(void);
WEBP_TSAN_IGNORE_FUNCTION void VP8FiltersInitSSE2(void) { WEBP_TSAN_IGNORE_FUNCTION void VP8FiltersInitSSE2(void) {
WebPUnfilters[WEBP_FILTER_HORIZONTAL] = HorizontalUnfilter; WebPUnfilters[WEBP_FILTER_HORIZONTAL] = HorizontalUnfilter_SSE2;
WebPUnfilters[WEBP_FILTER_VERTICAL] = VerticalUnfilter; WebPUnfilters[WEBP_FILTER_VERTICAL] = VerticalUnfilter_SSE2;
WebPUnfilters[WEBP_FILTER_GRADIENT] = GradientUnfilter; WebPUnfilters[WEBP_FILTER_GRADIENT] = GradientUnfilter_SSE2;
WebPFilters[WEBP_FILTER_HORIZONTAL] = HorizontalFilter; WebPFilters[WEBP_FILTER_HORIZONTAL] = HorizontalFilter_SSE2;
WebPFilters[WEBP_FILTER_VERTICAL] = VerticalFilter; WebPFilters[WEBP_FILTER_VERTICAL] = VerticalFilter_SSE2;
WebPFilters[WEBP_FILTER_GRADIENT] = GradientFilter; WebPFilters[WEBP_FILTER_GRADIENT] = GradientFilter_SSE2;
} }
#else // !WEBP_USE_SSE2 #else // !WEBP_USE_SSE2