/src/libwebp/src/dsp/cost_sse2.c
Line | Count | Source (jump to first uncovered line) |
1 | | // Copyright 2015 Google Inc. All Rights Reserved. |
2 | | // |
3 | | // Use of this source code is governed by a BSD-style license |
4 | | // that can be found in the COPYING file in the root of the source |
5 | | // tree. An additional intellectual property rights grant can be found |
6 | | // in the file PATENTS. All contributing project authors may |
7 | | // be found in the AUTHORS file in the root of the source tree. |
8 | | // ----------------------------------------------------------------------------- |
9 | | // |
10 | | // SSE2 version of cost functions |
11 | | // |
12 | | // Author: Skal (pascal.massimino@gmail.com) |
13 | | |
14 | | #include "src/dsp/dsp.h" |
15 | | |
16 | | #if defined(WEBP_USE_SSE2) |
17 | | #include <emmintrin.h> |
18 | | |
19 | | #include "src/enc/cost_enc.h" |
20 | | #include "src/enc/vp8i_enc.h" |
21 | | #include "src/utils/utils.h" |
22 | | |
23 | | //------------------------------------------------------------------------------ |
24 | | |
25 | | static void SetResidualCoeffs_SSE2(const int16_t* const coeffs, |
26 | 0 | VP8Residual* const res) { |
27 | 0 | const __m128i c0 = _mm_loadu_si128((const __m128i*)(coeffs + 0)); |
28 | 0 | const __m128i c1 = _mm_loadu_si128((const __m128i*)(coeffs + 8)); |
29 | | // Use SSE2 to compare 16 values with a single instruction. |
30 | 0 | const __m128i zero = _mm_setzero_si128(); |
31 | 0 | const __m128i m0 = _mm_packs_epi16(c0, c1); |
32 | 0 | const __m128i m1 = _mm_cmpeq_epi8(m0, zero); |
33 | | // Get the comparison results as a bitmask into 16bits. Negate the mask to get |
34 | | // the position of entries that are not equal to zero. We don't need to mask |
35 | | // out least significant bits according to res->first, since coeffs[0] is 0 |
36 | | // if res->first > 0. |
37 | 0 | const uint32_t mask = 0x0000ffffu ^ (uint32_t)_mm_movemask_epi8(m1); |
38 | | // The position of the most significant non-zero bit indicates the position of |
39 | | // the last non-zero value. |
40 | 0 | assert(res->first == 0 || coeffs[0] == 0); |
41 | 0 | res->last = mask ? BitsLog2Floor(mask) : -1; |
42 | 0 | res->coeffs = coeffs; |
43 | 0 | } |
44 | | |
45 | 0 | static int GetResidualCost_SSE2(int ctx0, const VP8Residual* const res) { |
46 | 0 | uint8_t levels[16], ctxs[16]; |
47 | 0 | uint16_t abs_levels[16]; |
48 | 0 | int n = res->first; |
49 | | // should be prob[VP8EncBands[n]], but it's equivalent for n=0 or 1 |
50 | 0 | const int p0 = res->prob[n][ctx0][0]; |
51 | 0 | CostArrayPtr const costs = res->costs; |
52 | 0 | const uint16_t* t = costs[n][ctx0]; |
53 | | // bit_cost(1, p0) is already incorporated in t[] tables, but only if ctx != 0 |
54 | | // (as required by the syntax). For ctx0 == 0, we need to add it here or it'll |
55 | | // be missing during the loop. |
56 | 0 | int cost = (ctx0 == 0) ? VP8BitCost(1, p0) : 0; |
57 | |
|
58 | 0 | if (res->last < 0) { |
59 | 0 | return VP8BitCost(0, p0); |
60 | 0 | } |
61 | | |
62 | 0 | { // precompute clamped levels and contexts, packed to 8b. |
63 | 0 | const __m128i zero = _mm_setzero_si128(); |
64 | 0 | const __m128i kCst2 = _mm_set1_epi8(2); |
65 | 0 | const __m128i kCst67 = _mm_set1_epi8(MAX_VARIABLE_LEVEL); |
66 | 0 | const __m128i c0 = _mm_loadu_si128((const __m128i*)&res->coeffs[0]); |
67 | 0 | const __m128i c1 = _mm_loadu_si128((const __m128i*)&res->coeffs[8]); |
68 | 0 | const __m128i D0 = _mm_sub_epi16(zero, c0); |
69 | 0 | const __m128i D1 = _mm_sub_epi16(zero, c1); |
70 | 0 | const __m128i E0 = _mm_max_epi16(c0, D0); // abs(v), 16b |
71 | 0 | const __m128i E1 = _mm_max_epi16(c1, D1); |
72 | 0 | const __m128i F = _mm_packs_epi16(E0, E1); |
73 | 0 | const __m128i G = _mm_min_epu8(F, kCst2); // context = 0,1,2 |
74 | 0 | const __m128i H = _mm_min_epu8(F, kCst67); // clamp_level in [0..67] |
75 | |
|
76 | 0 | _mm_storeu_si128((__m128i*)&ctxs[0], G); |
77 | 0 | _mm_storeu_si128((__m128i*)&levels[0], H); |
78 | |
|
79 | 0 | _mm_storeu_si128((__m128i*)&abs_levels[0], E0); |
80 | 0 | _mm_storeu_si128((__m128i*)&abs_levels[8], E1); |
81 | 0 | } |
82 | 0 | for (; n < res->last; ++n) { |
83 | 0 | const int ctx = ctxs[n]; |
84 | 0 | const int level = levels[n]; |
85 | 0 | const int flevel = abs_levels[n]; // full level |
86 | 0 | cost += VP8LevelFixedCosts[flevel] + t[level]; // simplified VP8LevelCost() |
87 | 0 | t = costs[n + 1][ctx]; |
88 | 0 | } |
89 | | // Last coefficient is always non-zero |
90 | 0 | { |
91 | 0 | const int level = levels[n]; |
92 | 0 | const int flevel = abs_levels[n]; |
93 | 0 | assert(flevel != 0); |
94 | 0 | cost += VP8LevelFixedCosts[flevel] + t[level]; |
95 | 0 | if (n < 15) { |
96 | 0 | const int b = VP8EncBands[n + 1]; |
97 | 0 | const int ctx = ctxs[n]; |
98 | 0 | const int last_p0 = res->prob[b][ctx][0]; |
99 | 0 | cost += VP8BitCost(0, last_p0); |
100 | 0 | } |
101 | 0 | } |
102 | 0 | return cost; |
103 | 0 | } |
104 | | |
105 | | //------------------------------------------------------------------------------ |
106 | | // Entry point |
107 | | |
108 | | extern void VP8EncDspCostInitSSE2(void); |
109 | | |
110 | 0 | WEBP_TSAN_IGNORE_FUNCTION void VP8EncDspCostInitSSE2(void) { |
111 | 0 | VP8SetResidualCoeffs = SetResidualCoeffs_SSE2; |
112 | 0 | VP8GetResidualCost = GetResidualCost_SSE2; |
113 | 0 | } |
114 | | |
115 | | #else // !WEBP_USE_SSE2 |
116 | | |
117 | | WEBP_DSP_INIT_STUB(VP8EncDspCostInitSSE2) |
118 | | |
119 | | #endif // WEBP_USE_SSE2 |