dany/libwebp
1
0
Fork 0
mirror of https://github.com/webmproject/libwebp.git synced 2025-04-04 16:06:49 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Lossless Enc: harmonize the function suffixes

Browse Source 
BUG=webp:355

Change-Id: I8baf506bd2a27095b956ef22a862b071f60c0d72
This commit is contained in:
skal 2017-08-07 17:06:24 -07:00
parent 24ad2e3c99
commit 1411f02761
7 changed files with 115 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
src/dsp/lossless_enc.c
View File

@ -325,7 +325,7 @@ const uint8_t kPrefixEncodeExtraBitsValue[PREFIX_LOOKUP_IDX_MAX] = {
112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126
}; };
static float FastSLog2Slow(uint32_t v) { static float FastSLog2Slow_C(uint32_t v) {
assert(v >= LOG_LOOKUP_IDX_MAX); assert(v >= LOG_LOOKUP_IDX_MAX);
if (v < APPROX_LOG_WITH_CORRECTION_MAX) { if (v < APPROX_LOG_WITH_CORRECTION_MAX) {
int log_cnt = 0; int log_cnt = 0;
@ -351,7 +351,7 @@ static float FastSLog2Slow(uint32_t v) {
} }
} }
static float FastLog2Slow(uint32_t v) { static float FastLog2Slow_C(uint32_t v) {
assert(v >= LOG_LOOKUP_IDX_MAX); assert(v >= LOG_LOOKUP_IDX_MAX);
if (v < APPROX_LOG_WITH_CORRECTION_MAX) { if (v < APPROX_LOG_WITH_CORRECTION_MAX) {
int log_cnt = 0; int log_cnt = 0;
@ -380,7 +380,7 @@ static float FastLog2Slow(uint32_t v) {
// Methods to calculate Entropy (Shannon). // Methods to calculate Entropy (Shannon).
// Compute the combined Shanon's entropy for distribution {X} and {X+Y} // Compute the combined Shanon's entropy for distribution {X} and {X+Y}
static float CombinedShannonEntropy(const int X[256], const int Y[256]) { static float CombinedShannonEntropy_C(const int X[256], const int Y[256]) {
int i; int i;
double retval = 0.; double retval = 0.;
int sumX = 0, sumXY = 0; int sumX = 0, sumXY = 0;
@ -453,9 +453,9 @@ static WEBP_INLINE void GetEntropyUnrefinedHelper(
*i_prev = i; *i_prev = i;
} }
static void GetEntropyUnrefined(const uint32_t X[], int length, static void GetEntropyUnrefined_C(const uint32_t X[], int length,
VP8LBitEntropy* const bit_entropy, VP8LBitEntropy* const bit_entropy,
VP8LStreaks* const stats) { VP8LStreaks* const stats) {
int i; int i;
int i_prev = 0; int i_prev = 0;
uint32_t x_prev = X[0]; uint32_t x_prev = X[0];
@ -474,10 +474,11 @@ static void GetEntropyUnrefined(const uint32_t X[], int length,
bit_entropy->entropy += VP8LFastSLog2(bit_entropy->sum); bit_entropy->entropy += VP8LFastSLog2(bit_entropy->sum);
} }
static void GetCombinedEntropyUnrefined(const uint32_t X[], const uint32_t Y[], static void GetCombinedEntropyUnrefined_C(const uint32_t X[],
int length, const uint32_t Y[],
VP8LBitEntropy* const bit_entropy, int length,
VP8LStreaks* const stats) { VP8LBitEntropy* const bit_entropy,
VP8LStreaks* const stats) {
int i = 1; int i = 1;
int i_prev = 0; int i_prev = 0;
uint32_t xy_prev = X[0] + Y[0]; uint32_t xy_prev = X[0] + Y[0];
@ -577,8 +578,8 @@ void VP8LCollectColorBlueTransforms_C(const uint32_t* argb, int stride,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static int VectorMismatch(const uint32_t* const array1, static int VectorMismatch_C(const uint32_t* const array1,
const uint32_t* const array2, int length) { const uint32_t* const array2, int length) {
int match_len = 0; int match_len = 0;
while (match_len < length && array1[match_len] == array2[match_len]) { while (match_len < length && array1[match_len] == array2[match_len]) {
@ -610,15 +611,15 @@ void VP8LBundleColorMap_C(const uint8_t* const row, int width, int xbits,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static double ExtraCost(const uint32_t* population, int length) { static double ExtraCost_C(const uint32_t* population, int length) {
int i; int i;
double cost = 0.; double cost = 0.;
for (i = 2; i < length - 2; ++i) cost += (i >> 1) * population[i + 2]; for (i = 2; i < length - 2; ++i) cost += (i >> 1) * population[i + 2];
return cost; return cost;
} }
static double ExtraCostCombined(const uint32_t* X, const uint32_t* Y, static double ExtraCostCombined_C(const uint32_t* X, const uint32_t* Y,
int length) { int length) {
int i; int i;
double cost = 0.; double cost = 0.;
for (i = 2; i < length - 2; ++i) { for (i = 2; i < length - 2; ++i) {
@ -630,9 +631,9 @@ static double ExtraCostCombined(const uint32_t* X, const uint32_t* Y,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static void HistogramAdd(const VP8LHistogram* const a, static void HistogramAdd_C(const VP8LHistogram* const a,
const VP8LHistogram* const b, const VP8LHistogram* const b,
VP8LHistogram* const out) { VP8LHistogram* const out) {
int i; int i;
const int literal_size = VP8LHistogramNumCodes(a->palette_code_bits_); const int literal_size = VP8LHistogramNumCodes(a->palette_code_bits_);
assert(a->palette_code_bits_ == b->palette_code_bits_); assert(a->palette_code_bits_ == b->palette_code_bits_);
@ -876,19 +877,19 @@ WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInit(void) {
VP8LCollectColorBlueTransforms = VP8LCollectColorBlueTransforms_C; VP8LCollectColorBlueTransforms = VP8LCollectColorBlueTransforms_C;
VP8LCollectColorRedTransforms = VP8LCollectColorRedTransforms_C; VP8LCollectColorRedTransforms = VP8LCollectColorRedTransforms_C;
VP8LFastLog2Slow = FastLog2Slow; VP8LFastLog2Slow = FastLog2Slow_C;
VP8LFastSLog2Slow = FastSLog2Slow; VP8LFastSLog2Slow = FastSLog2Slow_C;
VP8LExtraCost = ExtraCost; VP8LExtraCost = ExtraCost_C;
VP8LExtraCostCombined = ExtraCostCombined; VP8LExtraCostCombined = ExtraCostCombined_C;
VP8LCombinedShannonEntropy = CombinedShannonEntropy; VP8LCombinedShannonEntropy = CombinedShannonEntropy_C;
VP8LGetEntropyUnrefined = GetEntropyUnrefined; VP8LGetEntropyUnrefined = GetEntropyUnrefined_C;
VP8LGetCombinedEntropyUnrefined = GetCombinedEntropyUnrefined; VP8LGetCombinedEntropyUnrefined = GetCombinedEntropyUnrefined_C;
VP8LHistogramAdd = HistogramAdd; VP8LHistogramAdd = HistogramAdd_C;
VP8LVectorMismatch = VectorMismatch; VP8LVectorMismatch = VectorMismatch_C;
VP8LBundleColorMap = VP8LBundleColorMap_C; VP8LBundleColorMap = VP8LBundleColorMap_C;
VP8LPredictorsSub[0] = PredictorSub0_C; VP8LPredictorsSub[0] = PredictorSub0_C;

53
src/dsp/lossless_enc_mips32.c
View File

@ -23,7 +23,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
static float FastSLog2Slow(uint32_t v) { static float FastSLog2Slow_MIPS32(uint32_t v) {
assert(v >= LOG_LOOKUP_IDX_MAX); assert(v >= LOG_LOOKUP_IDX_MAX);
if (v < APPROX_LOG_WITH_CORRECTION_MAX) { if (v < APPROX_LOG_WITH_CORRECTION_MAX) {
uint32_t log_cnt, y, correction; uint32_t log_cnt, y, correction;
@ -59,7 +59,7 @@ static float FastSLog2Slow(uint32_t v) {
} }
} }
static float FastLog2Slow(uint32_t v) { static float FastLog2Slow_MIPS32(uint32_t v) {
assert(v >= LOG_LOOKUP_IDX_MAX); assert(v >= LOG_LOOKUP_IDX_MAX);
if (v < APPROX_LOG_WITH_CORRECTION_MAX) { if (v < APPROX_LOG_WITH_CORRECTION_MAX) {
uint32_t log_cnt, y; uint32_t log_cnt, y;
@ -104,7 +104,7 @@ static float FastLog2Slow(uint32_t v) {
// pop += 2; // pop += 2;
// } // }
// return (double)cost; // return (double)cost;
static double ExtraCost(const uint32_t* const population, int length) { static double ExtraCost_MIPS32(const uint32_t* const population, int length) {
int i, temp0, temp1; int i, temp0, temp1;
const uint32_t* pop = &population[4]; const uint32_t* pop = &population[4];
const uint32_t* const LoopEnd = &population[length]; const uint32_t* const LoopEnd = &population[length];
@ -149,8 +149,8 @@ static double ExtraCost(const uint32_t* const population, int length) {
// pY += 2; // pY += 2;
// } // }
// return (double)cost; // return (double)cost;
static double ExtraCostCombined(const uint32_t* const X, static double ExtraCostCombined_MIPS32(const uint32_t* const X,
const uint32_t* const Y, int length) { const uint32_t* const Y, int length) {
int i, temp0, temp1, temp2, temp3; int i, temp0, temp1, temp2, temp3;
const uint32_t* pX = &X[4]; const uint32_t* pX = &X[4];
const uint32_t* pY = &Y[4]; const uint32_t* pY = &Y[4];
@ -241,9 +241,9 @@ static WEBP_INLINE void GetEntropyUnrefinedHelper(
*i_prev = i; *i_prev = i;
} }
static void GetEntropyUnrefined(const uint32_t X[], int length, static void GetEntropyUnrefined_MIPS32(const uint32_t X[], int length,
VP8LBitEntropy* const bit_entropy, VP8LBitEntropy* const bit_entropy,
VP8LStreaks* const stats) { VP8LStreaks* const stats) {
int i; int i;
int i_prev = 0; int i_prev = 0;
uint32_t x_prev = X[0]; uint32_t x_prev = X[0];
@ -262,26 +262,27 @@ static void GetEntropyUnrefined(const uint32_t X[], int length,
bit_entropy->entropy += VP8LFastSLog2(bit_entropy->sum); bit_entropy->entropy += VP8LFastSLog2(bit_entropy->sum);
} }
static void GetCombinedEntropyUnrefined(const uint32_t X[], const uint32_t Y[], static void GetCombinedEntropyUnrefined_MIPS32(const uint32_t X[],
int length, const uint32_t Y[],
VP8LBitEntropy* const bit_entropy, int length,
VP8LStreaks* const stats) { VP8LBitEntropy* const entropy,
VP8LStreaks* const stats) {
int i = 1; int i = 1;
int i_prev = 0; int i_prev = 0;
uint32_t xy_prev = X[0] + Y[0]; uint32_t xy_prev = X[0] + Y[0];
memset(stats, 0, sizeof(*stats)); memset(stats, 0, sizeof(*stats));
VP8LBitEntropyInit(bit_entropy); VP8LBitEntropyInit(entropy);
for (i = 1; i < length; ++i) { for (i = 1; i < length; ++i) {
const uint32_t xy = X[i] + Y[i]; const uint32_t xy = X[i] + Y[i];
if (xy != xy_prev) { if (xy != xy_prev) {
GetEntropyUnrefinedHelper(xy, i, &xy_prev, &i_prev, bit_entropy, stats); GetEntropyUnrefinedHelper(xy, i, &xy_prev, &i_prev, entropy, stats);
} }
} }
GetEntropyUnrefinedHelper(0, i, &xy_prev, &i_prev, bit_entropy, stats); GetEntropyUnrefinedHelper(0, i, &xy_prev, &i_prev, entropy, stats);
bit_entropy->entropy += VP8LFastSLog2(bit_entropy->sum); entropy->entropy += VP8LFastSLog2(entropy->sum);
} }
#define ASM_START \ #define ASM_START \
@ -374,9 +375,9 @@ static void GetCombinedEntropyUnrefined(const uint32_t X[], const uint32_t Y[],
} \ } \
} while (0) } while (0)
static void HistogramAdd(const VP8LHistogram* const a, static void HistogramAdd_MIPS32(const VP8LHistogram* const a,
const VP8LHistogram* const b, const VP8LHistogram* const b,
VP8LHistogram* const out) { VP8LHistogram* const out) {
uint32_t temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7; uint32_t temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
const int extra_cache_size = VP8LHistogramNumCodes(a->palette_code_bits_) const int extra_cache_size = VP8LHistogramNumCodes(a->palette_code_bits_)
- (NUM_LITERAL_CODES + NUM_LENGTH_CODES); - (NUM_LITERAL_CODES + NUM_LENGTH_CODES);
@ -415,13 +416,13 @@ static void HistogramAdd(const VP8LHistogram* const a,
extern void VP8LEncDspInitMIPS32(void); extern void VP8LEncDspInitMIPS32(void);
WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitMIPS32(void) { WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitMIPS32(void) {
VP8LFastSLog2Slow = FastSLog2Slow; VP8LFastSLog2Slow = FastSLog2Slow_MIPS32;
VP8LFastLog2Slow = FastLog2Slow; VP8LFastLog2Slow = FastLog2Slow_MIPS32;
VP8LExtraCost = ExtraCost; VP8LExtraCost = ExtraCost_MIPS32;
VP8LExtraCostCombined = ExtraCostCombined; VP8LExtraCostCombined = ExtraCostCombined_MIPS32;
VP8LGetEntropyUnrefined = GetEntropyUnrefined; VP8LGetEntropyUnrefined = GetEntropyUnrefined_MIPS32;
VP8LGetCombinedEntropyUnrefined = GetCombinedEntropyUnrefined; VP8LGetCombinedEntropyUnrefined = GetCombinedEntropyUnrefined_MIPS32;
VP8LHistogramAdd = HistogramAdd; VP8LHistogramAdd = HistogramAdd_MIPS32;
} }
#else // !WEBP_USE_MIPS32 #else // !WEBP_USE_MIPS32

36
src/dsp/lossless_enc_mips_dsp_r2.c
View File

@ -18,8 +18,8 @@
#include "./lossless.h" #include "./lossless.h"
static void SubtractGreenFromBlueAndRed(uint32_t* argb_data, static void SubtractGreenFromBlueAndRed_MIPSdspR2(uint32_t* argb_data,
int num_pixels) { int num_pixels) {
uint32_t temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7; uint32_t temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
uint32_t* const p_loop1_end = argb_data + (num_pixels & ~3); uint32_t* const p_loop1_end = argb_data + (num_pixels & ~3);
uint32_t* const p_loop2_end = p_loop1_end + (num_pixels & 3); uint32_t* const p_loop2_end = p_loop1_end + (num_pixels & 3);
@ -78,8 +78,8 @@ static WEBP_INLINE uint32_t ColorTransformDelta(int8_t color_pred,
return (uint32_t)((int)(color_pred) * color) >> 5; return (uint32_t)((int)(color_pred) * color) >> 5;
} }
static void TransformColor(const VP8LMultipliers* const m, uint32_t* data, static void TransformColor_MIPSdspR2(const VP8LMultipliers* const m,
int num_pixels) { uint32_t* data, int num_pixels) {
int temp0, temp1, temp2, temp3, temp4, temp5; int temp0, temp1, temp2, temp3, temp4, temp5;
uint32_t argb, argb1, new_red, new_red1; uint32_t argb, argb1, new_red, new_red1;
const uint32_t G_to_R = m->green_to_red_; const uint32_t G_to_R = m->green_to_red_;
@ -171,10 +171,13 @@ static WEBP_INLINE uint8_t TransformColorBlue(uint8_t green_to_blue,
return (new_blue & 0xff); return (new_blue & 0xff);
} }
static void CollectColorBlueTransforms(const uint32_t* argb, int stride, static void CollectColorBlueTransforms_MIPSdspR2(const uint32_t* argb,
int tile_width, int tile_height, int stride,
int green_to_blue, int red_to_blue, int tile_width,
int histo[]) { int tile_height,
int green_to_blue,
int red_to_blue,
int histo[]) {
const int rtb = (red_to_blue << 16) | (red_to_blue & 0xffff); const int rtb = (red_to_blue << 16) | (red_to_blue & 0xffff);
const int gtb = (green_to_blue << 16) | (green_to_blue & 0xffff); const int gtb = (green_to_blue << 16) | (green_to_blue & 0xffff);
const uint32_t mask = 0xff00ffu; const uint32_t mask = 0xff00ffu;
@ -222,9 +225,12 @@ static WEBP_INLINE uint8_t TransformColorRed(uint8_t green_to_red,
return (new_red & 0xff); return (new_red & 0xff);
} }
static void CollectColorRedTransforms(const uint32_t* argb, int stride, static void CollectColorRedTransforms_MIPSdspR2(const uint32_t* argb,
int tile_width, int tile_height, int stride,
int green_to_red, int histo[]) { int tile_width,
int tile_height,
int green_to_red,
int histo[]) {
const int gtr = (green_to_red << 16) | (green_to_red & 0xffff); const int gtr = (green_to_red << 16) | (green_to_red & 0xffff);
while (tile_height-- > 0) { while (tile_height-- > 0) {
int x; int x;
@ -262,10 +268,10 @@ static void CollectColorRedTransforms(const uint32_t* argb, int stride,
extern void VP8LEncDspInitMIPSdspR2(void); extern void VP8LEncDspInitMIPSdspR2(void);
WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitMIPSdspR2(void) { WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitMIPSdspR2(void) {
VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed; VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed_MIPSdspR2;
VP8LTransformColor = TransformColor; VP8LTransformColor = TransformColor_MIPSdspR2;
VP8LCollectColorBlueTransforms = CollectColorBlueTransforms; VP8LCollectColorBlueTransforms = CollectColorBlueTransforms_MIPSdspR2;
VP8LCollectColorRedTransforms = CollectColorRedTransforms; VP8LCollectColorRedTransforms = CollectColorRedTransforms_MIPSdspR2;
} }
#else // !WEBP_USE_MIPS_DSP_R2 #else // !WEBP_USE_MIPS_DSP_R2

11
src/dsp/lossless_enc_msa.c
View File

@ -48,8 +48,8 @@
dst = VSHF_UB(src, t0, mask1); \ dst = VSHF_UB(src, t0, mask1); \
} while (0) } while (0)
static void TransformColor(const VP8LMultipliers* const m, uint32_t* data, static void TransformColor_MSA(const VP8LMultipliers* const m, uint32_t* data,
int num_pixels) { int num_pixels) {
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));
@ -94,7 +94,8 @@ static void TransformColor(const VP8LMultipliers* const m, uint32_t* data,
} }
} }
static void SubtractGreenFromBlueAndRed(uint32_t* argb_data, int num_pixels) { static void SubtractGreenFromBlueAndRed_MSA(uint32_t* argb_data,
int num_pixels) {
int i; int i;
uint8_t* ptemp_data = (uint8_t*)argb_data; uint8_t* ptemp_data = (uint8_t*)argb_data;
v16u8 src0, dst0, tmp0; v16u8 src0, dst0, tmp0;
@ -136,8 +137,8 @@ static void SubtractGreenFromBlueAndRed(uint32_t* argb_data, int num_pixels) {
extern void VP8LEncDspInitMSA(void); extern void VP8LEncDspInitMSA(void);
WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitMSA(void) { WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitMSA(void) {
VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed; VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed_MSA;
VP8LTransformColor = TransformColor; VP8LTransformColor = TransformColor_MSA;
} }
#else // !WEBP_USE_MSA #else // !WEBP_USE_MSA

11
src/dsp/lossless_enc_neon.c
View File

@ -52,7 +52,8 @@ static WEBP_INLINE uint8x16_t DoGreenShuffle(const uint8x16_t argb,
} }
#endif // USE_VTBLQ #endif // USE_VTBLQ
static void SubtractGreenFromBlueAndRed(uint32_t* argb_data, int num_pixels) { static void SubtractGreenFromBlueAndRed_NEON(uint32_t* argb_data,
int num_pixels) {
const uint32_t* const end = argb_data + (num_pixels & ~3); const uint32_t* const end = argb_data + (num_pixels & ~3);
#ifdef USE_VTBLQ #ifdef USE_VTBLQ
const uint8x16_t shuffle = vld1q_u8(kGreenShuffle); const uint8x16_t shuffle = vld1q_u8(kGreenShuffle);
@ -71,8 +72,8 @@ static void SubtractGreenFromBlueAndRed(uint32_t* argb_data, int num_pixels) {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Color Transform // Color Transform
static void TransformColor(const VP8LMultipliers* const m, static void TransformColor_NEON(const VP8LMultipliers* const m,
uint32_t* argb_data, int num_pixels) { uint32_t* argb_data, int num_pixels) {
// 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] = {
@ -132,8 +133,8 @@ static void TransformColor(const VP8LMultipliers* const m,
extern void VP8LEncDspInitNEON(void); extern void VP8LEncDspInitNEON(void);
WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitNEON(void) { WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitNEON(void) {
VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed; VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed_NEON;
VP8LTransformColor = TransformColor; VP8LTransformColor = TransformColor_NEON;
} }
#else // !WEBP_USE_NEON #else // !WEBP_USE_NEON

47
src/dsp/lossless_enc_sse2.c
View File

@ -26,7 +26,8 @@
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Subtract-Green Transform // Subtract-Green Transform
static void SubtractGreenFromBlueAndRed(uint32_t* argb_data, int num_pixels) { static void SubtractGreenFromBlueAndRed_SSE2(uint32_t* argb_data,
int num_pixels) {
int i; int i;
for (i = 0; i + 4 <= num_pixels; i += 4) { for (i = 0; i + 4 <= num_pixels; i += 4) {
const __m128i in = _mm_loadu_si128((__m128i*)&argb_data[i]); // argb const __m128i in = _mm_loadu_si128((__m128i*)&argb_data[i]); // argb
@ -45,8 +46,8 @@ static void SubtractGreenFromBlueAndRed(uint32_t* argb_data, int num_pixels) {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Color Transform // Color Transform
static void TransformColor(const VP8LMultipliers* const m, static void TransformColor_SSE2(const VP8LMultipliers* const m,
uint32_t* argb_data, int num_pixels) { uint32_t* argb_data, int num_pixels) {
const __m128i mults_rb = _mm_set_epi16( const __m128i mults_rb = _mm_set_epi16(
CST_5b(m->green_to_red_), CST_5b(m->green_to_blue_), CST_5b(m->green_to_red_), CST_5b(m->green_to_blue_),
CST_5b(m->green_to_red_), CST_5b(m->green_to_blue_), CST_5b(m->green_to_red_), CST_5b(m->green_to_blue_),
@ -80,10 +81,10 @@ static void TransformColor(const VP8LMultipliers* const m,
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
#define SPAN 8 #define SPAN 8
static void CollectColorBlueTransforms(const uint32_t* argb, int stride, static void CollectColorBlueTransforms_SSE2(const uint32_t* argb, int stride,
int tile_width, int tile_height, int tile_width, int tile_height,
int green_to_blue, int red_to_blue, int green_to_blue, int red_to_blue,
int histo[]) { int histo[]) {
const __m128i mults_r = _mm_set_epi16( const __m128i mults_r = _mm_set_epi16(
CST_5b(red_to_blue), 0, CST_5b(red_to_blue), 0, CST_5b(red_to_blue), 0, CST_5b(red_to_blue), 0,
CST_5b(red_to_blue), 0, CST_5b(red_to_blue), 0); CST_5b(red_to_blue), 0, CST_5b(red_to_blue), 0);
@ -131,9 +132,9 @@ static void CollectColorBlueTransforms(const uint32_t* argb, int stride,
} }
} }
static void CollectColorRedTransforms(const uint32_t* argb, int stride, static void CollectColorRedTransforms_SSE2(const uint32_t* argb, int stride,
int tile_width, int tile_height, int tile_width, int tile_height,
int green_to_red, int histo[]) { int green_to_red, int histo[]) {
const __m128i mults_g = _mm_set_epi16( const __m128i mults_g = _mm_set_epi16(
0, CST_5b(green_to_red), 0, CST_5b(green_to_red), 0, CST_5b(green_to_red), 0, CST_5b(green_to_red),
0, CST_5b(green_to_red), 0, CST_5b(green_to_red)); 0, CST_5b(green_to_red), 0, CST_5b(green_to_red));
@ -231,9 +232,9 @@ static void AddVectorEq(const uint32_t* a, uint32_t* out, int size) {
// Note we are adding uint32_t's as *signed* int32's (using _mm_add_epi32). But // Note we are adding uint32_t's as *signed* int32's (using _mm_add_epi32). But
// that's ok since the histogram values are less than 1<<28 (max picture size). // that's ok since the histogram values are less than 1<<28 (max picture size).
static void HistogramAdd(const VP8LHistogram* const a, static void HistogramAdd_SSE2(const VP8LHistogram* const a,
const VP8LHistogram* const b, const VP8LHistogram* const b,
VP8LHistogram* const out) { VP8LHistogram* const out) {
int i; int i;
const int literal_size = VP8LHistogramNumCodes(a->palette_code_bits_); const int literal_size = VP8LHistogramNumCodes(a->palette_code_bits_);
assert(a->palette_code_bits_ == b->palette_code_bits_); assert(a->palette_code_bits_ == b->palette_code_bits_);
@ -276,7 +277,7 @@ static void HistogramAdd(const VP8LHistogram* const a,
} \ } \
} while (0) } while (0)
static float CombinedShannonEntropy(const int X[256], const int Y[256]) { static float CombinedShannonEntropy_SSE2(const int X[256], const int Y[256]) {
int i; int i;
double retval = 0.; double retval = 0.;
int sumX, sumXY; int sumX, sumXY;
@ -332,8 +333,8 @@ static float CombinedShannonEntropy(const int X[256], const int Y[256]) {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
static int VectorMismatch(const uint32_t* const array1, static int VectorMismatch_SSE2(const uint32_t* const array1,
const uint32_t* const array2, int length) { const uint32_t* const array2, int length) {
int match_len; int match_len;
if (length >= 12) { if (length >= 12) {
@ -677,13 +678,13 @@ static void PredictorSub13_SSE2(const uint32_t* in, const uint32_t* upper,
extern void VP8LEncDspInitSSE2(void); extern void VP8LEncDspInitSSE2(void);
WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitSSE2(void) { WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitSSE2(void) {
VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed; VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed_SSE2;
VP8LTransformColor = TransformColor; VP8LTransformColor = TransformColor_SSE2;
VP8LCollectColorBlueTransforms = CollectColorBlueTransforms; VP8LCollectColorBlueTransforms = CollectColorBlueTransforms_SSE2;
VP8LCollectColorRedTransforms = CollectColorRedTransforms; VP8LCollectColorRedTransforms = CollectColorRedTransforms_SSE2;
VP8LHistogramAdd = HistogramAdd; VP8LHistogramAdd = HistogramAdd_SSE2;
VP8LCombinedShannonEntropy = CombinedShannonEntropy; VP8LCombinedShannonEntropy = CombinedShannonEntropy_SSE2;
VP8LVectorMismatch = VectorMismatch; VP8LVectorMismatch = VectorMismatch_SSE2;
VP8LBundleColorMap = BundleColorMap_SSE2; VP8LBundleColorMap = BundleColorMap_SSE2;
VP8LPredictorsSub[0] = PredictorSub0_SSE2; VP8LPredictorsSub[0] = PredictorSub0_SSE2;

5
src/dsp/lossless_enc_sse41.c
View File

@ -21,7 +21,8 @@
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Subtract-Green Transform // Subtract-Green Transform
static void SubtractGreenFromBlueAndRed(uint32_t* argb_data, int num_pixels) { static void SubtractGreenFromBlueAndRed_SSE41(uint32_t* argb_data,
int num_pixels) {
int i; int i;
const __m128i kCstShuffle = _mm_set_epi8(-1, 13, -1, 13, -1, 9, -1, 9, const __m128i kCstShuffle = _mm_set_epi8(-1, 13, -1, 13, -1, 9, -1, 9,
-1, 5, -1, 5, -1, 1, -1, 1); -1, 5, -1, 5, -1, 1, -1, 1);
@ -43,7 +44,7 @@ static void SubtractGreenFromBlueAndRed(uint32_t* argb_data, int num_pixels) {
extern void VP8LEncDspInitSSE41(void); extern void VP8LEncDspInitSSE41(void);
WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitSSE41(void) { WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitSSE41(void) {
VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed; VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed_SSE41;
} }
#else // !WEBP_USE_SSE41 #else // !WEBP_USE_SSE41