dany/libwebp
1
0
Fork 0
mirror of https://github.com/webmproject/libwebp.git synced 2024-12-27 06:08:21 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge "Lossess dec: harmonize the function suffixes"

Browse Source
This commit is contained in:
Pascal Massimino 2017-08-08 02:04:10 +00:00 committed by Gerrit Code Review
commit 8c934902cd
5 changed files with 170 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
src/dsp/lossless.c
View File

@ -107,69 +107,69 @@ static WEBP_INLINE uint32_t Select(uint32_t a, uint32_t b, uint32_t c) {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Predictors // Predictors
static uint32_t Predictor0(uint32_t left, const uint32_t* const top) { static uint32_t Predictor0_C(uint32_t left, const uint32_t* const top) {
(void)top; (void)top;
(void)left; (void)left;
return ARGB_BLACK; return ARGB_BLACK;
} }
static uint32_t Predictor1(uint32_t left, const uint32_t* const top) { static uint32_t Predictor1_C(uint32_t left, const uint32_t* const top) {
(void)top; (void)top;
return left; return left;
} }
static uint32_t Predictor2(uint32_t left, const uint32_t* const top) { static uint32_t Predictor2_C(uint32_t left, const uint32_t* const top) {
(void)left; (void)left;
return top[0]; return top[0];
} }
static uint32_t Predictor3(uint32_t left, const uint32_t* const top) { static uint32_t Predictor3_C(uint32_t left, const uint32_t* const top) {
(void)left; (void)left;
return top[1]; return top[1];
} }
static uint32_t Predictor4(uint32_t left, const uint32_t* const top) { static uint32_t Predictor4_C(uint32_t left, const uint32_t* const top) {
(void)left; (void)left;
return top[-1]; return top[-1];
} }
static uint32_t Predictor5(uint32_t left, const uint32_t* const top) { static uint32_t Predictor5_C(uint32_t left, const uint32_t* const top) {
const uint32_t pred = Average3(left, top[0], top[1]); const uint32_t pred = Average3(left, top[0], top[1]);
return pred; return pred;
} }
static uint32_t Predictor6(uint32_t left, const uint32_t* const top) { static uint32_t Predictor6_C(uint32_t left, const uint32_t* const top) {
const uint32_t pred = Average2(left, top[-1]); const uint32_t pred = Average2(left, top[-1]);
return pred; return pred;
} }
static uint32_t Predictor7(uint32_t left, const uint32_t* const top) { static uint32_t Predictor7_C(uint32_t left, const uint32_t* const top) {
const uint32_t pred = Average2(left, top[0]); const uint32_t pred = Average2(left, top[0]);
return pred; return pred;
} }
static uint32_t Predictor8(uint32_t left, const uint32_t* const top) { static uint32_t Predictor8_C(uint32_t left, const uint32_t* const top) {
const uint32_t pred = Average2(top[-1], top[0]); const uint32_t pred = Average2(top[-1], top[0]);
(void)left; (void)left;
return pred; return pred;
} }
static uint32_t Predictor9(uint32_t left, const uint32_t* const top) { static uint32_t Predictor9_C(uint32_t left, const uint32_t* const top) {
const uint32_t pred = Average2(top[0], top[1]); const uint32_t pred = Average2(top[0], top[1]);
(void)left; (void)left;
return pred; return pred;
} }
static uint32_t Predictor10(uint32_t left, const uint32_t* const top) { static uint32_t Predictor10_C(uint32_t left, const uint32_t* const top) {
const uint32_t pred = Average4(left, top[-1], top[0], top[1]); const uint32_t pred = Average4(left, top[-1], top[0], top[1]);
return pred; return pred;
} }
static uint32_t Predictor11(uint32_t left, const uint32_t* const top) { static uint32_t Predictor11_C(uint32_t left, const uint32_t* const top) {
const uint32_t pred = Select(top[0], left, top[-1]); const uint32_t pred = Select(top[0], left, top[-1]);
return pred; return pred;
} }
static uint32_t Predictor12(uint32_t left, const uint32_t* const top) { static uint32_t Predictor12_C(uint32_t left, const uint32_t* const top) {
const uint32_t pred = ClampedAddSubtractFull(left, top[0], top[-1]); const uint32_t pred = ClampedAddSubtractFull(left, top[0], top[-1]);
return pred; return pred;
} }
static uint32_t Predictor13(uint32_t left, const uint32_t* const top) { static uint32_t Predictor13_C(uint32_t left, const uint32_t* const top) {
const uint32_t pred = ClampedAddSubtractHalf(left, top[0], top[-1]); const uint32_t pred = ClampedAddSubtractHalf(left, top[0], top[-1]);
return pred; return pred;
} }
GENERATE_PREDICTOR_ADD(Predictor0, PredictorAdd0) GENERATE_PREDICTOR_ADD(Predictor0_C, PredictorAdd0_C)
static void PredictorAdd1(const uint32_t* in, const uint32_t* upper, static void PredictorAdd1_C(const uint32_t* in, const uint32_t* upper,
int num_pixels, uint32_t* out) { int num_pixels, uint32_t* out) {
int i; int i;
uint32_t left = out[-1]; uint32_t left = out[-1];
for (i = 0; i < num_pixels; ++i) { for (i = 0; i < num_pixels; ++i) {
@ -177,29 +177,29 @@ static void PredictorAdd1(const uint32_t* in, const uint32_t* upper,
} }
(void)upper; (void)upper;
} }
GENERATE_PREDICTOR_ADD(Predictor2, PredictorAdd2) GENERATE_PREDICTOR_ADD(Predictor2_C, PredictorAdd2_C)
GENERATE_PREDICTOR_ADD(Predictor3, PredictorAdd3) GENERATE_PREDICTOR_ADD(Predictor3_C, PredictorAdd3_C)
GENERATE_PREDICTOR_ADD(Predictor4, PredictorAdd4) GENERATE_PREDICTOR_ADD(Predictor4_C, PredictorAdd4_C)
GENERATE_PREDICTOR_ADD(Predictor5, PredictorAdd5) GENERATE_PREDICTOR_ADD(Predictor5_C, PredictorAdd5_C)
GENERATE_PREDICTOR_ADD(Predictor6, PredictorAdd6) GENERATE_PREDICTOR_ADD(Predictor6_C, PredictorAdd6_C)
GENERATE_PREDICTOR_ADD(Predictor7, PredictorAdd7) GENERATE_PREDICTOR_ADD(Predictor7_C, PredictorAdd7_C)
GENERATE_PREDICTOR_ADD(Predictor8, PredictorAdd8) GENERATE_PREDICTOR_ADD(Predictor8_C, PredictorAdd8_C)
GENERATE_PREDICTOR_ADD(Predictor9, PredictorAdd9) GENERATE_PREDICTOR_ADD(Predictor9_C, PredictorAdd9_C)
GENERATE_PREDICTOR_ADD(Predictor10, PredictorAdd10) GENERATE_PREDICTOR_ADD(Predictor10_C, PredictorAdd10_C)
GENERATE_PREDICTOR_ADD(Predictor11, PredictorAdd11) GENERATE_PREDICTOR_ADD(Predictor11_C, PredictorAdd11_C)
GENERATE_PREDICTOR_ADD(Predictor12, PredictorAdd12) GENERATE_PREDICTOR_ADD(Predictor12_C, PredictorAdd12_C)
GENERATE_PREDICTOR_ADD(Predictor13, PredictorAdd13) GENERATE_PREDICTOR_ADD(Predictor13_C, PredictorAdd13_C)
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Inverse prediction. // Inverse prediction.
static void PredictorInverseTransform(const VP8LTransform* const transform, static void PredictorInverseTransform_C(const VP8LTransform* const transform,
int y_start, int y_end, int y_start, int y_end,
const uint32_t* in, uint32_t* out) { const uint32_t* in, uint32_t* out) {
const int width = transform->xsize_; const int width = transform->xsize_;
if (y_start == 0) { // First Row follows the L (mode=1) mode. if (y_start == 0) { // First Row follows the L (mode=1) mode.
PredictorAdd0(in, NULL, 1, out); PredictorAdd0_C(in, NULL, 1, out);
PredictorAdd1(in + 1, NULL, width - 1, out + 1); PredictorAdd1_C(in + 1, NULL, width - 1, out + 1);
in += width; in += width;
out += width; out += width;
++y_start; ++y_start;
@ -217,7 +217,7 @@ static void PredictorInverseTransform(const VP8LTransform* const transform,
const uint32_t* pred_mode_src = pred_mode_base; const uint32_t* pred_mode_src = pred_mode_base;
int x = 1; int x = 1;
// First pixel follows the T (mode=2) mode. // First pixel follows the T (mode=2) mode.
PredictorAdd2(in, out - width, 1, out); PredictorAdd2_C(in, out - width, 1, out);
// .. the rest: // .. the rest:
while (x < width) { while (x < width) {
const VP8LPredictorAddSubFunc pred_func = const VP8LPredictorAddSubFunc pred_func =
@ -284,9 +284,9 @@ void VP8LTransformColorInverse_C(const VP8LMultipliers* const m,
} }
// Color space inverse transform. // Color space inverse transform.
static void ColorSpaceInverseTransform(const VP8LTransform* const transform, static void ColorSpaceInverseTransform_C(const VP8LTransform* const transform,
int y_start, int y_end, int y_start, int y_end,
const uint32_t* src, uint32_t* dst) { const uint32_t* src, uint32_t* dst) {
const int width = transform->xsize_; const int width = transform->xsize_;
const int tile_width = 1 << transform->bits_; const int tile_width = 1 << transform->bits_;
const int mask = tile_width - 1; const int mask = tile_width - 1;
@ -362,10 +362,10 @@ STATIC_DECL void FUNC_NAME(const VP8LTransform* const transform, \
} \ } \
} }
COLOR_INDEX_INVERSE(ColorIndexInverseTransform, MapARGB, static, uint32_t, 32b, COLOR_INDEX_INVERSE(ColorIndexInverseTransform_C, MapARGB_C, static,
VP8GetARGBIndex, VP8GetARGBValue) uint32_t, 32b, VP8GetARGBIndex, VP8GetARGBValue)
COLOR_INDEX_INVERSE(VP8LColorIndexInverseTransformAlpha, MapAlpha, , uint8_t, COLOR_INDEX_INVERSE(VP8LColorIndexInverseTransformAlpha, MapAlpha_C, ,
8b, VP8GetAlphaIndex, VP8GetAlphaValue) uint8_t, 8b, VP8GetAlphaIndex, VP8GetAlphaValue)
#undef COLOR_INDEX_INVERSE #undef COLOR_INDEX_INVERSE
@ -380,7 +380,7 @@ void VP8LInverseTransform(const VP8LTransform* const transform,
VP8LAddGreenToBlueAndRed(in, (row_end - row_start) * width, out); VP8LAddGreenToBlueAndRed(in, (row_end - row_start) * width, out);
break; break;
case PREDICTOR_TRANSFORM: case PREDICTOR_TRANSFORM:
PredictorInverseTransform(transform, row_start, row_end, in, out); PredictorInverseTransform_C(transform, row_start, row_end, in, out);
if (row_end != transform->ysize_) { if (row_end != transform->ysize_) {
// The last predicted row in this iteration will be the top-pred row // The last predicted row in this iteration will be the top-pred row
// for the first row in next iteration. // for the first row in next iteration.
@ -389,7 +389,7 @@ void VP8LInverseTransform(const VP8LTransform* const transform,
} }
break; break;
case CROSS_COLOR_TRANSFORM: case CROSS_COLOR_TRANSFORM:
ColorSpaceInverseTransform(transform, row_start, row_end, in, out); ColorSpaceInverseTransform_C(transform, row_start, row_end, in, out);
break; break;
case COLOR_INDEXING_TRANSFORM: case COLOR_INDEXING_TRANSFORM:
if (in == out && transform->bits_ > 0) { if (in == out && transform->bits_ > 0) {
@ -403,9 +403,9 @@ void VP8LInverseTransform(const VP8LTransform* const transform,
VP8LSubSampleSize(transform->xsize_, transform->bits_); VP8LSubSampleSize(transform->xsize_, transform->bits_);
uint32_t* const src = out + out_stride - in_stride; uint32_t* const src = out + out_stride - in_stride;
memmove(src, out, in_stride * sizeof(*src)); memmove(src, out, in_stride * sizeof(*src));
ColorIndexInverseTransform(transform, row_start, row_end, src, out); ColorIndexInverseTransform_C(transform, row_start, row_end, src, out);
} else { } else {
ColorIndexInverseTransform(transform, row_start, row_end, in, out); ColorIndexInverseTransform_C(transform, row_start, row_end, in, out);
} }
break; break;
} }
@ -578,23 +578,23 @@ extern void VP8LDspInitMSA(void);
static volatile VP8CPUInfo lossless_last_cpuinfo_used = static volatile VP8CPUInfo lossless_last_cpuinfo_used =
(VP8CPUInfo)&lossless_last_cpuinfo_used; (VP8CPUInfo)&lossless_last_cpuinfo_used;
#define COPY_PREDICTOR_ARRAY(IN, OUT) do { \ #define COPY_PREDICTOR_ARRAY(IN, OUT) do { \
(OUT)[0] = IN##0; \ (OUT)[0] = IN##0_C; \
(OUT)[1] = IN##1; \ (OUT)[1] = IN##1_C; \
(OUT)[2] = IN##2; \ (OUT)[2] = IN##2_C; \
(OUT)[3] = IN##3; \ (OUT)[3] = IN##3_C; \
(OUT)[4] = IN##4; \ (OUT)[4] = IN##4_C; \
(OUT)[5] = IN##5; \ (OUT)[5] = IN##5_C; \
(OUT)[6] = IN##6; \ (OUT)[6] = IN##6_C; \
(OUT)[7] = IN##7; \ (OUT)[7] = IN##7_C; \
(OUT)[8] = IN##8; \ (OUT)[8] = IN##8_C; \
(OUT)[9] = IN##9; \ (OUT)[9] = IN##9_C; \
(OUT)[10] = IN##10; \ (OUT)[10] = IN##10_C; \
(OUT)[11] = IN##11; \ (OUT)[11] = IN##11_C; \
(OUT)[12] = IN##12; \ (OUT)[12] = IN##12_C; \
(OUT)[13] = IN##13; \ (OUT)[13] = IN##13_C; \
(OUT)[14] = IN##0; /* <- padding security sentinels*/ \ (OUT)[14] = IN##0_C; /* <- padding security sentinels*/ \
(OUT)[15] = IN##0; \ (OUT)[15] = IN##0_C; \
} while (0); } while (0);
WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInit(void) { WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInit(void) {
@ -615,8 +615,8 @@ WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInit(void) {
VP8LConvertBGRAToRGB565 = VP8LConvertBGRAToRGB565_C; VP8LConvertBGRAToRGB565 = VP8LConvertBGRAToRGB565_C;
VP8LConvertBGRAToBGR = VP8LConvertBGRAToBGR_C; VP8LConvertBGRAToBGR = VP8LConvertBGRAToBGR_C;
VP8LMapColor32b = MapARGB; VP8LMapColor32b = MapARGB_C;
VP8LMapColor8b = MapAlpha; VP8LMapColor8b = MapAlpha_C;
// If defined, use CPUInfo() to overwrite some pointers with faster versions. // If defined, use CPUInfo() to overwrite some pointers with faster versions.
if (VP8GetCPUInfo != NULL) { if (VP8GetCPUInfo != NULL) {

95
src/dsp/lossless_mips_dsp_r2.c
View File

@ -86,8 +86,8 @@ static void FUNC_NAME(const TYPE* src, \
} \ } \
} }
MAP_COLOR_FUNCS(MapARGB, uint32_t, VP8GetARGBIndex, VP8GetARGBValue) MAP_COLOR_FUNCS(MapARGB_MIPSdspR2, uint32_t, VP8GetARGBIndex, VP8GetARGBValue)
MAP_COLOR_FUNCS(MapAlpha, uint8_t, VP8GetAlphaIndex, VP8GetAlphaValue) MAP_COLOR_FUNCS(MapAlpha_MIPSdspR2, uint8_t, VP8GetAlphaIndex, VP8GetAlphaValue)
#undef MAP_COLOR_FUNCS #undef MAP_COLOR_FUNCS
@ -188,48 +188,52 @@ static WEBP_INLINE uint32_t Average4(uint32_t a0, uint32_t a1,
return Average2(Average2(a0, a1), Average2(a2, a3)); return Average2(Average2(a0, a1), Average2(a2, a3));
} }
static uint32_t Predictor5(uint32_t left, const uint32_t* const top) { static uint32_t Predictor5_MIPSdspR2(uint32_t left, const uint32_t* const top) {
return Average3(left, top[0], top[1]); return Average3(left, top[0], top[1]);
} }
static uint32_t Predictor6(uint32_t left, const uint32_t* const top) { static uint32_t Predictor6_MIPSdspR2(uint32_t left, const uint32_t* const top) {
return Average2(left, top[-1]); return Average2(left, top[-1]);
} }
static uint32_t Predictor7(uint32_t left, const uint32_t* const top) { static uint32_t Predictor7_MIPSdspR2(uint32_t left, const uint32_t* const top) {
return Average2(left, top[0]); return Average2(left, top[0]);
} }
static uint32_t Predictor8(uint32_t left, const uint32_t* const top) { static uint32_t Predictor8_MIPSdspR2(uint32_t left, const uint32_t* const top) {
(void)left; (void)left;
return Average2(top[-1], top[0]); return Average2(top[-1], top[0]);
} }
static uint32_t Predictor9(uint32_t left, const uint32_t* const top) { static uint32_t Predictor9_MIPSdspR2(uint32_t left, const uint32_t* const top) {
(void)left; (void)left;
return Average2(top[0], top[1]); return Average2(top[0], top[1]);
} }
static uint32_t Predictor10(uint32_t left, const uint32_t* const top) { static uint32_t Predictor10_MIPSdspR2(uint32_t left,
const uint32_t* const top) {
return Average4(left, top[-1], top[0], top[1]); return Average4(left, top[-1], top[0], top[1]);
} }
static uint32_t Predictor11(uint32_t left, const uint32_t* const top) { static uint32_t Predictor11_MIPSdspR2(uint32_t left,
const uint32_t* const top) {
return Select(top[0], left, top[-1]); return Select(top[0], left, top[-1]);
} }
static uint32_t Predictor12(uint32_t left, const uint32_t* const top) { static uint32_t Predictor12_MIPSdspR2(uint32_t left,
const uint32_t* const top) {
return ClampedAddSubtractFull(left, top[0], top[-1]); return ClampedAddSubtractFull(left, top[0], top[-1]);
} }
static uint32_t Predictor13(uint32_t left, const uint32_t* const top) { static uint32_t Predictor13_MIPSdspR2(uint32_t left,
const uint32_t* const top) {
return ClampedAddSubtractHalf(left, top[0], top[-1]); return ClampedAddSubtractHalf(left, top[0], top[-1]);
} }
// Add green to blue and red channels (i.e. perform the inverse transform of // Add green to blue and red channels (i.e. perform the inverse transform of
// 'subtract green'). // 'subtract green').
static void AddGreenToBlueAndRed(const uint32_t* src, int num_pixels, static void AddGreenToBlueAndRed_MIPSdspR2(const uint32_t* src, int num_pixels,
uint32_t* dst) { uint32_t* dst) {
uint32_t temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7; uint32_t temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
const uint32_t* const p_loop1_end = src + (num_pixels & ~3); const uint32_t* const p_loop1_end = src + (num_pixels & ~3);
const uint32_t* const p_loop2_end = src + num_pixels; const uint32_t* const p_loop2_end = src + num_pixels;
@ -285,9 +289,9 @@ static void AddGreenToBlueAndRed(const uint32_t* src, int num_pixels,
); );
} }
static void TransformColorInverse(const VP8LMultipliers* const m, static void TransformColorInverse_MIPSdspR2(const VP8LMultipliers* const m,
const uint32_t* src, int num_pixels, const uint32_t* src, int num_pixels,
uint32_t* dst) { uint32_t* dst) {
int temp0, temp1, temp2, temp3, temp4, temp5; int temp0, temp1, temp2, temp3, temp4, temp5;
uint32_t argb, argb1, new_red; uint32_t argb, argb1, new_red;
const uint32_t G_to_R = m->green_to_red_; const uint32_t G_to_R = m->green_to_red_;
@ -356,8 +360,8 @@ static void TransformColorInverse(const VP8LMultipliers* const m,
if (num_pixels & 1) VP8LTransformColorInverse_C(m, src, 1, dst); if (num_pixels & 1) VP8LTransformColorInverse_C(m, src, 1, dst);
} }
static void ConvertBGRAToRGB(const uint32_t* src, static void ConvertBGRAToRGB_MIPSdspR2(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
int temp0, temp1, temp2, temp3; int temp0, temp1, temp2, temp3;
const uint32_t* const p_loop1_end = src + (num_pixels & ~3); const uint32_t* const p_loop1_end = src + (num_pixels & ~3);
const uint32_t* const p_loop2_end = src + num_pixels; const uint32_t* const p_loop2_end = src + num_pixels;
@ -408,8 +412,8 @@ static void ConvertBGRAToRGB(const uint32_t* src,
); );
} }
static void ConvertBGRAToRGBA(const uint32_t* src, static void ConvertBGRAToRGBA_MIPSdspR2(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
int temp0, temp1, temp2, temp3; int temp0, temp1, temp2, temp3;
const uint32_t* const p_loop1_end = src + (num_pixels & ~3); const uint32_t* const p_loop1_end = src + (num_pixels & ~3);
const uint32_t* const p_loop2_end = src + num_pixels; const uint32_t* const p_loop2_end = src + num_pixels;
@ -458,8 +462,8 @@ static void ConvertBGRAToRGBA(const uint32_t* src,
); );
} }
static void ConvertBGRAToRGBA4444(const uint32_t* src, static void ConvertBGRAToRGBA4444_MIPSdspR2(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
int temp0, temp1, temp2, temp3, temp4, temp5; int temp0, temp1, temp2, temp3, temp4, temp5;
const uint32_t* const p_loop1_end = src + (num_pixels & ~3); const uint32_t* const p_loop1_end = src + (num_pixels & ~3);
const uint32_t* const p_loop2_end = src + num_pixels; const uint32_t* const p_loop2_end = src + num_pixels;
@ -532,8 +536,8 @@ static void ConvertBGRAToRGBA4444(const uint32_t* src,
); );
} }
static void ConvertBGRAToRGB565(const uint32_t* src, static void ConvertBGRAToRGB565_MIPSdspR2(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
int temp0, temp1, temp2, temp3, temp4, temp5; int temp0, temp1, temp2, temp3, temp4, temp5;
const uint32_t* const p_loop1_end = src + (num_pixels & ~3); const uint32_t* const p_loop1_end = src + (num_pixels & ~3);
const uint32_t* const p_loop2_end = src + num_pixels; const uint32_t* const p_loop2_end = src + num_pixels;
@ -610,8 +614,8 @@ static void ConvertBGRAToRGB565(const uint32_t* src,
); );
} }
static void ConvertBGRAToBGR(const uint32_t* src, static void ConvertBGRAToBGR_MIPSdspR2(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
int temp0, temp1, temp2, temp3; int temp0, temp1, temp2, temp3;
const uint32_t* const p_loop1_end = src + (num_pixels & ~3); const uint32_t* const p_loop1_end = src + (num_pixels & ~3);
const uint32_t* const p_loop2_end = src + num_pixels; const uint32_t* const p_loop2_end = src + num_pixels;
@ -662,24 +666,27 @@ static void ConvertBGRAToBGR(const uint32_t* src,
extern void VP8LDspInitMIPSdspR2(void); extern void VP8LDspInitMIPSdspR2(void);
WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInitMIPSdspR2(void) { WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInitMIPSdspR2(void) {
VP8LMapColor32b = MapARGB; VP8LMapColor32b = MapARGB_MIPSdspR2;
VP8LMapColor8b = MapAlpha; VP8LMapColor8b = MapAlpha_MIPSdspR2;
VP8LPredictors[5] = Predictor5;
VP8LPredictors[6] = Predictor6; VP8LPredictors[5] = Predictor5_MIPSdspR2;
VP8LPredictors[7] = Predictor7; VP8LPredictors[6] = Predictor6_MIPSdspR2;
VP8LPredictors[8] = Predictor8; VP8LPredictors[7] = Predictor7_MIPSdspR2;
VP8LPredictors[9] = Predictor9; VP8LPredictors[8] = Predictor8_MIPSdspR2;
VP8LPredictors[10] = Predictor10; VP8LPredictors[9] = Predictor9_MIPSdspR2;
VP8LPredictors[11] = Predictor11; VP8LPredictors[10] = Predictor10_MIPSdspR2;
VP8LPredictors[12] = Predictor12; VP8LPredictors[11] = Predictor11_MIPSdspR2;
VP8LPredictors[13] = Predictor13; VP8LPredictors[12] = Predictor12_MIPSdspR2;
VP8LAddGreenToBlueAndRed = AddGreenToBlueAndRed; VP8LPredictors[13] = Predictor13_MIPSdspR2;
VP8LTransformColorInverse = TransformColorInverse;
VP8LConvertBGRAToRGB = ConvertBGRAToRGB; VP8LAddGreenToBlueAndRed = AddGreenToBlueAndRed_MIPSdspR2;
VP8LConvertBGRAToRGBA = ConvertBGRAToRGBA; VP8LTransformColorInverse = TransformColorInverse_MIPSdspR2;
VP8LConvertBGRAToRGBA4444 = ConvertBGRAToRGBA4444;
VP8LConvertBGRAToRGB565 = ConvertBGRAToRGB565; VP8LConvertBGRAToRGB = ConvertBGRAToRGB_MIPSdspR2;
VP8LConvertBGRAToBGR = ConvertBGRAToBGR; VP8LConvertBGRAToRGBA = ConvertBGRAToRGBA_MIPSdspR2;
VP8LConvertBGRAToRGBA4444 = ConvertBGRAToRGBA4444_MIPSdspR2;
VP8LConvertBGRAToRGB565 = ConvertBGRAToRGB565_MIPSdspR2;
VP8LConvertBGRAToBGR = ConvertBGRAToBGR_MIPSdspR2;
} }
#else // !WEBP_USE_MIPS_DSP_R2 #else // !WEBP_USE_MIPS_DSP_R2

33
src/dsp/lossless_msa.c
View File

@ -109,8 +109,8 @@
dst = VSHF_UB(src, t0, mask1); \ dst = VSHF_UB(src, t0, mask1); \
} while (0) } while (0)
static void ConvertBGRAToRGBA(const uint32_t* src, static void ConvertBGRAToRGBA_MSA(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
int i; int i;
const uint8_t* ptemp_src = (const uint8_t*)src; const uint8_t* ptemp_src = (const uint8_t*)src;
uint8_t* ptemp_dst = (uint8_t*)dst; uint8_t* ptemp_dst = (uint8_t*)dst;
@ -150,8 +150,8 @@ static void ConvertBGRAToRGBA(const uint32_t* src,
} }
} }
static void ConvertBGRAToBGR(const uint32_t* src, static void ConvertBGRAToBGR_MSA(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
const uint8_t* ptemp_src = (const uint8_t*)src; const uint8_t* ptemp_src = (const uint8_t*)src;
uint8_t* ptemp_dst = (uint8_t*)dst; uint8_t* ptemp_dst = (uint8_t*)dst;
const v16u8 mask0 = { 0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, const v16u8 mask0 = { 0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14,
@ -197,8 +197,8 @@ static void ConvertBGRAToBGR(const uint32_t* src,
} }
} }
static void ConvertBGRAToRGB(const uint32_t* src, static void ConvertBGRAToRGB_MSA(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
const uint8_t* ptemp_src = (const uint8_t*)src; const uint8_t* ptemp_src = (const uint8_t*)src;
uint8_t* ptemp_dst = (uint8_t*)dst; uint8_t* ptemp_dst = (uint8_t*)dst;
const v16u8 mask0 = { 2, 1, 0, 6, 5, 4, 10, 9, 8, 14, 13, 12, const v16u8 mask0 = { 2, 1, 0, 6, 5, 4, 10, 9, 8, 14, 13, 12,
@ -244,8 +244,8 @@ static void ConvertBGRAToRGB(const uint32_t* src,
} }
} }
static void AddGreenToBlueAndRed(const uint32_t* const src, int num_pixels, static void AddGreenToBlueAndRed_MSA(const uint32_t* const src, int num_pixels,
uint32_t* dst) { uint32_t* dst) {
int i; int i;
const uint8_t* in = (const uint8_t*)src; const uint8_t* in = (const uint8_t*)src;
uint8_t* out = (uint8_t*)dst; uint8_t* out = (uint8_t*)dst;
@ -286,9 +286,9 @@ static void AddGreenToBlueAndRed(const uint32_t* const src, int num_pixels,
} }
} }
static void TransformColorInverse(const VP8LMultipliers* const m, static void TransformColorInverse_MSA(const VP8LMultipliers* const m,
const uint32_t* src, int num_pixels, const uint32_t* src, int num_pixels,
uint32_t* dst) { uint32_t* dst) {
v16u8 src0, dst0; v16u8 src0, dst0;
const v16i8 g2br = (v16i8)__msa_fill_w(m->green_to_blue_ | const v16i8 g2br = (v16i8)__msa_fill_w(m->green_to_blue_ |
(m->green_to_red_ << 16)); (m->green_to_red_ << 16));
@ -341,11 +341,12 @@ static void TransformColorInverse(const VP8LMultipliers* const m,
extern void VP8LDspInitMSA(void); extern void VP8LDspInitMSA(void);
WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInitMSA(void) { WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInitMSA(void) {
VP8LConvertBGRAToRGBA = ConvertBGRAToRGBA; VP8LConvertBGRAToRGBA = ConvertBGRAToRGBA_MSA;
VP8LConvertBGRAToBGR = ConvertBGRAToBGR; VP8LConvertBGRAToBGR = ConvertBGRAToBGR_MSA;
VP8LConvertBGRAToRGB = ConvertBGRAToRGB; VP8LConvertBGRAToRGB = ConvertBGRAToRGB_MSA;
VP8LAddGreenToBlueAndRed = AddGreenToBlueAndRed;
VP8LTransformColorInverse = TransformColorInverse; VP8LAddGreenToBlueAndRed = AddGreenToBlueAndRed_MSA;
VP8LTransformColorInverse = TransformColorInverse_MSA;
} }
#else // !WEBP_USE_MSA #else // !WEBP_USE_MSA

45
src/dsp/lossless_neon.c
View File

@ -26,8 +26,8 @@
#if !defined(WORK_AROUND_GCC) #if !defined(WORK_AROUND_GCC)
// gcc 4.6.0 had some trouble (NDK-r9) with this code. We only use it for // gcc 4.6.0 had some trouble (NDK-r9) with this code. We only use it for
// gcc-4.8.x at least. // gcc-4.8.x at least.
static void ConvertBGRAToRGBA(const uint32_t* src, static void ConvertBGRAToRGBA_NEON(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
const uint32_t* const end = src + (num_pixels & ~15); const uint32_t* const end = src + (num_pixels & ~15);
for (; src < end; src += 16) { for (; src < end; src += 16) {
uint8x16x4_t pixel = vld4q_u8((uint8_t*)src); uint8x16x4_t pixel = vld4q_u8((uint8_t*)src);
@ -41,8 +41,8 @@ static void ConvertBGRAToRGBA(const uint32_t* src,
VP8LConvertBGRAToRGBA_C(src, num_pixels & 15, dst); // left-overs VP8LConvertBGRAToRGBA_C(src, num_pixels & 15, dst); // left-overs
} }
static void ConvertBGRAToBGR(const uint32_t* src, static void ConvertBGRAToBGR_NEON(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
const uint32_t* const end = src + (num_pixels & ~15); const uint32_t* const end = src + (num_pixels & ~15);
for (; src < end; src += 16) { for (; src < end; src += 16) {
const uint8x16x4_t pixel = vld4q_u8((uint8_t*)src); const uint8x16x4_t pixel = vld4q_u8((uint8_t*)src);
@ -53,8 +53,8 @@ static void ConvertBGRAToBGR(const uint32_t* src,
VP8LConvertBGRAToBGR_C(src, num_pixels & 15, dst); // left-overs VP8LConvertBGRAToBGR_C(src, num_pixels & 15, dst); // left-overs
} }
static void ConvertBGRAToRGB(const uint32_t* src, static void ConvertBGRAToRGB_NEON(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
const uint32_t* const end = src + (num_pixels & ~15); const uint32_t* const end = src + (num_pixels & ~15);
for (; src < end; src += 16) { for (; src < end; src += 16) {
const uint8x16x4_t pixel = vld4q_u8((uint8_t*)src); const uint8x16x4_t pixel = vld4q_u8((uint8_t*)src);
@ -71,8 +71,8 @@ static void ConvertBGRAToRGB(const uint32_t* src,
static const uint8_t kRGBAShuffle[8] = { 2, 1, 0, 3, 6, 5, 4, 7 }; static const uint8_t kRGBAShuffle[8] = { 2, 1, 0, 3, 6, 5, 4, 7 };
static void ConvertBGRAToRGBA(const uint32_t* src, static void ConvertBGRAToRGBA_NEON(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
const uint32_t* const end = src + (num_pixels & ~1); const uint32_t* const end = src + (num_pixels & ~1);
const uint8x8_t shuffle = vld1_u8(kRGBAShuffle); const uint8x8_t shuffle = vld1_u8(kRGBAShuffle);
for (; src < end; src += 2) { for (; src < end; src += 2) {
@ -89,8 +89,8 @@ static const uint8_t kBGRShuffle[3][8] = {
{ 21, 22, 24, 25, 26, 28, 29, 30 } { 21, 22, 24, 25, 26, 28, 29, 30 }
}; };
static void ConvertBGRAToBGR(const uint32_t* src, static void ConvertBGRAToBGR_NEON(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
const uint32_t* const end = src + (num_pixels & ~7); const uint32_t* const end = src + (num_pixels & ~7);
const uint8x8_t shuffle0 = vld1_u8(kBGRShuffle[0]); const uint8x8_t shuffle0 = vld1_u8(kBGRShuffle[0]);
const uint8x8_t shuffle1 = vld1_u8(kBGRShuffle[1]); const uint8x8_t shuffle1 = vld1_u8(kBGRShuffle[1]);
@ -116,8 +116,8 @@ static const uint8_t kRGBShuffle[3][8] = {
{ 21, 20, 26, 25, 24, 30, 29, 28 } { 21, 20, 26, 25, 24, 30, 29, 28 }
}; };
static void ConvertBGRAToRGB(const uint32_t* src, static void ConvertBGRAToRGB_NEON(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
const uint32_t* const end = src + (num_pixels & ~7); const uint32_t* const end = src + (num_pixels & ~7);
const uint8x8_t shuffle0 = vld1_u8(kRGBShuffle[0]); const uint8x8_t shuffle0 = vld1_u8(kRGBShuffle[0]);
const uint8x8_t shuffle1 = vld1_u8(kRGBShuffle[1]); const uint8x8_t shuffle1 = vld1_u8(kRGBShuffle[1]);
@ -139,7 +139,6 @@ static void ConvertBGRAToRGB(const uint32_t* src,
#endif // !WORK_AROUND_GCC #endif // !WORK_AROUND_GCC
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Predictor Transform // Predictor Transform
@ -522,8 +521,8 @@ static WEBP_INLINE uint8x16_t DoGreenShuffle(const uint8x16_t argb,
} }
#endif // USE_VTBLQ #endif // USE_VTBLQ
static void AddGreenToBlueAndRed(const uint32_t* src, int num_pixels, static void AddGreenToBlueAndRed_NEON(const uint32_t* src, int num_pixels,
uint32_t* dst) { uint32_t* dst) {
const uint32_t* const end = src + (num_pixels & ~3); const uint32_t* const end = src + (num_pixels & ~3);
#ifdef USE_VTBLQ #ifdef USE_VTBLQ
const uint8x16_t shuffle = vld1q_u8(kGreenShuffle); const uint8x16_t shuffle = vld1q_u8(kGreenShuffle);
@ -542,9 +541,9 @@ static void AddGreenToBlueAndRed(const uint32_t* src, int num_pixels,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Color Transform // Color Transform
static void TransformColorInverse(const VP8LMultipliers* const m, static void TransformColorInverse_NEON(const VP8LMultipliers* const m,
const uint32_t* const src, int num_pixels, const uint32_t* const src,
uint32_t* dst) { int num_pixels, uint32_t* dst) {
// sign-extended multiplying constants, pre-shifted by 6. // sign-extended multiplying constants, pre-shifted by 6.
#define CST(X) (((int16_t)(m->X << 8)) >> 6) #define CST(X) (((int16_t)(m->X << 8)) >> 6)
const int16_t rb[8] = { const int16_t rb[8] = {
@ -627,12 +626,12 @@ WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInitNEON(void) {
VP8LPredictorsAdd[12] = PredictorAdd12_NEON; VP8LPredictorsAdd[12] = PredictorAdd12_NEON;
VP8LPredictorsAdd[13] = PredictorAdd13_NEON; VP8LPredictorsAdd[13] = PredictorAdd13_NEON;
VP8LConvertBGRAToRGBA = ConvertBGRAToRGBA; VP8LConvertBGRAToRGBA = ConvertBGRAToRGBA_NEON;
VP8LConvertBGRAToBGR = ConvertBGRAToBGR; VP8LConvertBGRAToBGR = ConvertBGRAToBGR_NEON;
VP8LConvertBGRAToRGB = ConvertBGRAToRGB; VP8LConvertBGRAToRGB = ConvertBGRAToRGB_NEON;
VP8LAddGreenToBlueAndRed = AddGreenToBlueAndRed; VP8LAddGreenToBlueAndRed = AddGreenToBlueAndRed_NEON;
VP8LTransformColorInverse = TransformColorInverse; VP8LTransformColorInverse = TransformColorInverse_NEON;
} }
#else // !WEBP_USE_NEON #else // !WEBP_USE_NEON

30
src/dsp/lossless_sse2.c
View File

@ -484,8 +484,8 @@ static void TransformColorInverse(const VP8LMultipliers* const m,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Color-space conversion functions // Color-space conversion functions
static void ConvertBGRAToRGB(const uint32_t* src, int num_pixels, static void ConvertBGRAToRGB_SSE2(const uint32_t* src, int num_pixels,
uint8_t* dst) { uint8_t* dst) {
const __m128i* in = (const __m128i*)src; const __m128i* in = (const __m128i*)src;
__m128i* out = (__m128i*)dst; __m128i* out = (__m128i*)dst;
@ -520,8 +520,8 @@ static void ConvertBGRAToRGB(const uint32_t* src, int num_pixels,
} }
} }
static void ConvertBGRAToRGBA(const uint32_t* src, static void ConvertBGRAToRGBA_SSE2(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
const __m128i red_blue_mask = _mm_set1_epi32(0x00ff00ffu); const __m128i red_blue_mask = _mm_set1_epi32(0x00ff00ffu);
const __m128i* in = (const __m128i*)src; const __m128i* in = (const __m128i*)src;
__m128i* out = (__m128i*)dst; __m128i* out = (__m128i*)dst;
@ -548,8 +548,8 @@ static void ConvertBGRAToRGBA(const uint32_t* src,
} }
} }
static void ConvertBGRAToRGBA4444(const uint32_t* src, static void ConvertBGRAToRGBA4444_SSE2(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
const __m128i mask_0x0f = _mm_set1_epi8(0x0f); const __m128i mask_0x0f = _mm_set1_epi8(0x0f);
const __m128i mask_0xf0 = _mm_set1_epi8(0xf0); const __m128i mask_0xf0 = _mm_set1_epi8(0xf0);
const __m128i* in = (const __m128i*)src; const __m128i* in = (const __m128i*)src;
@ -584,8 +584,8 @@ static void ConvertBGRAToRGBA4444(const uint32_t* src,
} }
} }
static void ConvertBGRAToRGB565(const uint32_t* src, static void ConvertBGRAToRGB565_SSE2(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
const __m128i mask_0xe0 = _mm_set1_epi8(0xe0); const __m128i mask_0xe0 = _mm_set1_epi8(0xe0);
const __m128i mask_0xf8 = _mm_set1_epi8(0xf8); const __m128i mask_0xf8 = _mm_set1_epi8(0xf8);
const __m128i mask_0x07 = _mm_set1_epi8(0x07); const __m128i mask_0x07 = _mm_set1_epi8(0x07);
@ -625,8 +625,8 @@ static void ConvertBGRAToRGB565(const uint32_t* src,
} }
} }
static void ConvertBGRAToBGR(const uint32_t* src, static void ConvertBGRAToBGR_SSE2(const uint32_t* src,
int num_pixels, uint8_t* dst) { int num_pixels, uint8_t* dst) {
const __m128i mask_l = _mm_set_epi32(0, 0x00ffffff, 0, 0x00ffffff); const __m128i mask_l = _mm_set_epi32(0, 0x00ffffff, 0, 0x00ffffff);
const __m128i mask_h = _mm_set_epi32(0x00ffffff, 0, 0x00ffffff, 0); const __m128i mask_h = _mm_set_epi32(0x00ffffff, 0, 0x00ffffff, 0);
const __m128i* in = (const __m128i*)src; const __m128i* in = (const __m128i*)src;
@ -692,11 +692,11 @@ WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInitSSE2(void) {
VP8LAddGreenToBlueAndRed = AddGreenToBlueAndRed; VP8LAddGreenToBlueAndRed = AddGreenToBlueAndRed;
VP8LTransformColorInverse = TransformColorInverse; VP8LTransformColorInverse = TransformColorInverse;
VP8LConvertBGRAToRGB = ConvertBGRAToRGB; VP8LConvertBGRAToRGB = ConvertBGRAToRGB_SSE2;
VP8LConvertBGRAToRGBA = ConvertBGRAToRGBA; VP8LConvertBGRAToRGBA = ConvertBGRAToRGBA_SSE2;
VP8LConvertBGRAToRGBA4444 = ConvertBGRAToRGBA4444; VP8LConvertBGRAToRGBA4444 = ConvertBGRAToRGBA4444_SSE2;
VP8LConvertBGRAToRGB565 = ConvertBGRAToRGB565; VP8LConvertBGRAToRGB565 = ConvertBGRAToRGB565_SSE2;
VP8LConvertBGRAToBGR = ConvertBGRAToBGR; VP8LConvertBGRAToBGR = ConvertBGRAToBGR_SSE2;
} }
#else // !WEBP_USE_SSE2 #else // !WEBP_USE_SSE2