1 /*
2  * Copyright (c) 2017, Alliance for Open Media. All rights reserved
3  *
4  * This source code is subject to the terms of the BSD 2 Clause License and
5  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6  * was not distributed with this source code in the LICENSE file, you can
7  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8  * Media Patent License 1.0 was not distributed with this source code in the
9  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10  */
11 
12 #include <assert.h>
13 #include <smmintrin.h>
14 
15 #include "config/aom_config.h"
16 #include "config/av1_rtcd.h"
17 
av1_filter_intra_edge_sse4_1(uint8_t * p,int sz,int strength)18 void av1_filter_intra_edge_sse4_1(uint8_t *p, int sz, int strength) {
19   if (!strength) return;
20 
21   DECLARE_ALIGNED(16, static const int8_t, kern[3][16]) = {
22     { 4, 8, 4, 0, 4, 8, 4, 0, 4, 8, 4, 0, 4, 8, 4, 0 },  // strength 1: 4,8,4
23     { 5, 6, 5, 0, 5, 6, 5, 0, 5, 6, 5, 0, 5, 6, 5, 0 },  // strength 2: 5,6,5
24     { 2, 4, 4, 4, 2, 0, 0, 0, 2, 4, 4, 4, 2, 0, 0, 0 }  // strength 3: 2,4,4,4,2
25   };
26 
27   DECLARE_ALIGNED(16, static const int8_t, v_const[5][16]) = {
28     { 0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6 },
29     { 4, 5, 6, 7, 5, 6, 7, 8, 6, 7, 8, 9, 7, 8, 9, 10 },
30     { 0, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 8 },
31     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
32   };
33 
34   // Extend the first and last samples to simplify the loop for the 5-tap case
35   p[-1] = p[0];
36   __m128i last = _mm_set1_epi8(p[sz - 1]);
37   _mm_storeu_si128((__m128i *)&p[sz], last);
38 
39   // Adjust input pointer for filter support area
40   uint8_t *in = (strength == 3) ? p - 1 : p;
41 
42   // Avoid modifying first sample
43   uint8_t *out = p + 1;
44   int len = sz - 1;
45 
46   const int use_3tap_filter = (strength < 3);
47 
48   if (use_3tap_filter) {
49     __m128i coef0 = _mm_lddqu_si128((__m128i const *)kern[strength - 1]);
50     __m128i shuf0 = _mm_lddqu_si128((__m128i const *)v_const[0]);
51     __m128i shuf1 = _mm_lddqu_si128((__m128i const *)v_const[1]);
52     __m128i iden = _mm_lddqu_si128((__m128i *)v_const[3]);
53     __m128i in0 = _mm_lddqu_si128((__m128i *)in);
54     while (len > 0) {
55       int n_out = (len < 8) ? len : 8;
56       __m128i d0 = _mm_shuffle_epi8(in0, shuf0);
57       __m128i d1 = _mm_shuffle_epi8(in0, shuf1);
58       d0 = _mm_maddubs_epi16(d0, coef0);
59       d1 = _mm_maddubs_epi16(d1, coef0);
60       d0 = _mm_hadd_epi16(d0, d1);
61       __m128i eight = _mm_set1_epi16(8);
62       d0 = _mm_add_epi16(d0, eight);
63       d0 = _mm_srai_epi16(d0, 4);
64       d0 = _mm_packus_epi16(d0, d0);
65       __m128i out0 = _mm_lddqu_si128((__m128i *)out);
66       __m128i n0 = _mm_set1_epi8(n_out);
67       __m128i mask = _mm_cmpgt_epi8(n0, iden);
68       out0 = _mm_blendv_epi8(out0, d0, mask);
69       _mm_storel_epi64((__m128i *)out, out0);
70       __m128i in1 = _mm_lddqu_si128((__m128i *)(in + 16));
71       in0 = _mm_alignr_epi8(in1, in0, 8);
72       in += 8;
73       out += 8;
74       len -= n_out;
75     }
76   } else {  // 5-tap filter
77     __m128i coef0 = _mm_lddqu_si128((__m128i const *)kern[strength - 1]);
78     __m128i two = _mm_set1_epi8(2);
79     __m128i shuf_a = _mm_lddqu_si128((__m128i const *)v_const[2]);
80     __m128i shuf_b = _mm_add_epi8(shuf_a, two);
81     __m128i shuf_c = _mm_add_epi8(shuf_b, two);
82     __m128i shuf_d = _mm_add_epi8(shuf_c, two);
83     __m128i iden = _mm_lddqu_si128((__m128i *)v_const[3]);
84     __m128i in0 = _mm_lddqu_si128((__m128i *)in);
85     while (len > 0) {
86       int n_out = (len < 8) ? len : 8;
87       __m128i d0 = _mm_shuffle_epi8(in0, shuf_a);
88       __m128i d1 = _mm_shuffle_epi8(in0, shuf_b);
89       __m128i d2 = _mm_shuffle_epi8(in0, shuf_c);
90       __m128i d3 = _mm_shuffle_epi8(in0, shuf_d);
91       d0 = _mm_maddubs_epi16(d0, coef0);
92       d1 = _mm_maddubs_epi16(d1, coef0);
93       d2 = _mm_maddubs_epi16(d2, coef0);
94       d3 = _mm_maddubs_epi16(d3, coef0);
95       d0 = _mm_hadd_epi16(d0, d1);
96       d2 = _mm_hadd_epi16(d2, d3);
97       d0 = _mm_hadd_epi16(d0, d2);
98       __m128i eight = _mm_set1_epi16(8);
99       d0 = _mm_add_epi16(d0, eight);
100       d0 = _mm_srai_epi16(d0, 4);
101       d0 = _mm_packus_epi16(d0, d0);
102       __m128i out0 = _mm_lddqu_si128((__m128i *)out);
103       __m128i n0 = _mm_set1_epi8(n_out);
104       __m128i mask = _mm_cmpgt_epi8(n0, iden);
105       out0 = _mm_blendv_epi8(out0, d0, mask);
106       _mm_storel_epi64((__m128i *)out, out0);
107       __m128i in1 = _mm_lddqu_si128((__m128i *)(in + 16));
108       in0 = _mm_alignr_epi8(in1, in0, 8);
109       in += 8;
110       out += 8;
111       len -= n_out;
112     }
113   }
114 }
115 
av1_filter_intra_edge_high_sse4_1(uint16_t * p,int sz,int strength)116 void av1_filter_intra_edge_high_sse4_1(uint16_t *p, int sz, int strength) {
117   if (!strength) return;
118 
119   DECLARE_ALIGNED(16, static const int16_t, kern[3][8]) = {
120     { 4, 8, 4, 8, 4, 8, 4, 8 },  // strength 1: 4,8,4
121     { 5, 6, 5, 6, 5, 6, 5, 6 },  // strength 2: 5,6,5
122     { 2, 4, 2, 4, 2, 4, 2, 4 }   // strength 3: 2,4,4,4,2
123   };
124 
125   DECLARE_ALIGNED(16, static const int16_t,
126                   v_const[1][8]) = { { 0, 1, 2, 3, 4, 5, 6, 7 } };
127 
128   // Extend the first and last samples to simplify the loop for the 5-tap case
129   p[-1] = p[0];
130   __m128i last = _mm_set1_epi16(p[sz - 1]);
131   _mm_storeu_si128((__m128i *)&p[sz], last);
132 
133   // Adjust input pointer for filter support area
134   uint16_t *in = (strength == 3) ? p - 1 : p;
135 
136   // Avoid modifying first sample
137   uint16_t *out = p + 1;
138   int len = sz - 1;
139 
140   const int use_3tap_filter = (strength < 3);
141 
142   if (use_3tap_filter) {
143     __m128i coef0 = _mm_lddqu_si128((__m128i const *)kern[strength - 1]);
144     __m128i iden = _mm_lddqu_si128((__m128i *)v_const[0]);
145     __m128i in0 = _mm_lddqu_si128((__m128i *)&in[0]);
146     __m128i in8 = _mm_lddqu_si128((__m128i *)&in[8]);
147     while (len > 0) {
148       int n_out = (len < 8) ? len : 8;
149       __m128i in1 = _mm_alignr_epi8(in8, in0, 2);
150       __m128i in2 = _mm_alignr_epi8(in8, in0, 4);
151       __m128i in02 = _mm_add_epi16(in0, in2);
152       __m128i d0 = _mm_unpacklo_epi16(in02, in1);
153       __m128i d1 = _mm_unpackhi_epi16(in02, in1);
154       d0 = _mm_mullo_epi16(d0, coef0);
155       d1 = _mm_mullo_epi16(d1, coef0);
156       d0 = _mm_hadd_epi16(d0, d1);
157       __m128i eight = _mm_set1_epi16(8);
158       d0 = _mm_add_epi16(d0, eight);
159       d0 = _mm_srli_epi16(d0, 4);
160       __m128i out0 = _mm_lddqu_si128((__m128i *)out);
161       __m128i n0 = _mm_set1_epi16(n_out);
162       __m128i mask = _mm_cmpgt_epi16(n0, iden);
163       out0 = _mm_blendv_epi8(out0, d0, mask);
164       _mm_storeu_si128((__m128i *)out, out0);
165       in += 8;
166       in0 = in8;
167       in8 = _mm_lddqu_si128((__m128i *)&in[8]);
168       out += 8;
169       len -= n_out;
170     }
171   } else {  // 5-tap filter
172     __m128i coef0 = _mm_lddqu_si128((__m128i const *)kern[strength - 1]);
173     __m128i iden = _mm_lddqu_si128((__m128i *)v_const[0]);
174     __m128i in0 = _mm_lddqu_si128((__m128i *)&in[0]);
175     __m128i in8 = _mm_lddqu_si128((__m128i *)&in[8]);
176     while (len > 0) {
177       int n_out = (len < 8) ? len : 8;
178       __m128i in1 = _mm_alignr_epi8(in8, in0, 2);
179       __m128i in2 = _mm_alignr_epi8(in8, in0, 4);
180       __m128i in3 = _mm_alignr_epi8(in8, in0, 6);
181       __m128i in4 = _mm_alignr_epi8(in8, in0, 8);
182       __m128i in04 = _mm_add_epi16(in0, in4);
183       __m128i in123 = _mm_add_epi16(in1, in2);
184       in123 = _mm_add_epi16(in123, in3);
185       __m128i d0 = _mm_unpacklo_epi16(in04, in123);
186       __m128i d1 = _mm_unpackhi_epi16(in04, in123);
187       d0 = _mm_mullo_epi16(d0, coef0);
188       d1 = _mm_mullo_epi16(d1, coef0);
189       d0 = _mm_hadd_epi16(d0, d1);
190       __m128i eight = _mm_set1_epi16(8);
191       d0 = _mm_add_epi16(d0, eight);
192       d0 = _mm_srli_epi16(d0, 4);
193       __m128i out0 = _mm_lddqu_si128((__m128i *)out);
194       __m128i n0 = _mm_set1_epi16(n_out);
195       __m128i mask = _mm_cmpgt_epi16(n0, iden);
196       out0 = _mm_blendv_epi8(out0, d0, mask);
197       _mm_storeu_si128((__m128i *)out, out0);
198       in += 8;
199       in0 = in8;
200       in8 = _mm_lddqu_si128((__m128i *)&in[8]);
201       out += 8;
202       len -= n_out;
203     }
204   }
205 }
206 
av1_upsample_intra_edge_sse4_1(uint8_t * p,int sz)207 void av1_upsample_intra_edge_sse4_1(uint8_t *p, int sz) {
208   // interpolate half-sample positions
209   assert(sz <= 24);
210 
211   DECLARE_ALIGNED(16, static const int8_t, kernel[1][16]) = {
212     { -1, 9, 9, -1, -1, 9, 9, -1, -1, 9, 9, -1, -1, 9, 9, -1 }
213   };
214 
215   DECLARE_ALIGNED(
216       16, static const int8_t,
217       v_const[2][16]) = { { 0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6 },
218                           { 4, 5, 6, 7, 5, 6, 7, 8, 6, 7, 8, 9, 7, 8, 9, 10 } };
219 
220   // Extend first/last samples (upper-left p[-1], last p[sz-1])
221   // to support 4-tap filter
222   p[-2] = p[-1];
223   p[sz] = p[sz - 1];
224 
225   uint8_t *in = &p[-2];
226   uint8_t *out = &p[-2];
227 
228   int n = sz + 1;  // Input length including upper-left sample
229 
230   __m128i in0 = _mm_lddqu_si128((__m128i *)&in[0]);
231   __m128i in16 = _mm_lddqu_si128((__m128i *)&in[16]);
232 
233   __m128i coef0 = _mm_lddqu_si128((__m128i *)kernel[0]);
234   __m128i shuf0 = _mm_lddqu_si128((__m128i *)v_const[0]);
235   __m128i shuf1 = _mm_lddqu_si128((__m128i *)v_const[1]);
236 
237   while (n > 0) {
238     __m128i in8 = _mm_alignr_epi8(in16, in0, 8);
239     __m128i d0 = _mm_shuffle_epi8(in0, shuf0);
240     __m128i d1 = _mm_shuffle_epi8(in0, shuf1);
241     __m128i d2 = _mm_shuffle_epi8(in8, shuf0);
242     __m128i d3 = _mm_shuffle_epi8(in8, shuf1);
243     d0 = _mm_maddubs_epi16(d0, coef0);
244     d1 = _mm_maddubs_epi16(d1, coef0);
245     d2 = _mm_maddubs_epi16(d2, coef0);
246     d3 = _mm_maddubs_epi16(d3, coef0);
247     d0 = _mm_hadd_epi16(d0, d1);
248     d2 = _mm_hadd_epi16(d2, d3);
249     __m128i eight = _mm_set1_epi16(8);
250     d0 = _mm_add_epi16(d0, eight);
251     d2 = _mm_add_epi16(d2, eight);
252     d0 = _mm_srai_epi16(d0, 4);
253     d2 = _mm_srai_epi16(d2, 4);
254     d0 = _mm_packus_epi16(d0, d2);
255     __m128i in1 = _mm_alignr_epi8(in16, in0, 1);
256     __m128i out0 = _mm_unpacklo_epi8(in1, d0);
257     __m128i out1 = _mm_unpackhi_epi8(in1, d0);
258     _mm_storeu_si128((__m128i *)&out[0], out0);
259     _mm_storeu_si128((__m128i *)&out[16], out1);
260     in0 = in16;
261     in16 = _mm_setzero_si128();
262     out += 32;
263     n -= 16;
264   }
265 }
266 
av1_upsample_intra_edge_high_sse4_1(uint16_t * p,int sz,int bd)267 void av1_upsample_intra_edge_high_sse4_1(uint16_t *p, int sz, int bd) {
268   // interpolate half-sample positions
269   assert(sz <= 24);
270 
271   DECLARE_ALIGNED(16, static const int16_t,
272                   kernel[1][8]) = { { -1, 9, -1, 9, -1, 9, -1, 9 } };
273 
274   // Extend first/last samples (upper-left p[-1], last p[sz-1])
275   // to support 4-tap filter
276   p[-2] = p[-1];
277   p[sz] = p[sz - 1];
278 
279   uint16_t *in = &p[-2];
280   uint16_t *out = in;
281   int n = sz + 1;
282 
283   __m128i in0 = _mm_lddqu_si128((__m128i *)&in[0]);
284   __m128i in8 = _mm_lddqu_si128((__m128i *)&in[8]);
285   __m128i in16 = _mm_lddqu_si128((__m128i *)&in[16]);
286   __m128i in24 = _mm_lddqu_si128((__m128i *)&in[24]);
287 
288   while (n > 0) {
289     __m128i in1 = _mm_alignr_epi8(in8, in0, 2);
290     __m128i in2 = _mm_alignr_epi8(in8, in0, 4);
291     __m128i in3 = _mm_alignr_epi8(in8, in0, 6);
292     __m128i sum0 = _mm_add_epi16(in0, in3);
293     __m128i sum1 = _mm_add_epi16(in1, in2);
294     __m128i d0 = _mm_unpacklo_epi16(sum0, sum1);
295     __m128i d1 = _mm_unpackhi_epi16(sum0, sum1);
296     __m128i coef0 = _mm_lddqu_si128((__m128i *)kernel[0]);
297     d0 = _mm_madd_epi16(d0, coef0);
298     d1 = _mm_madd_epi16(d1, coef0);
299     __m128i eight = _mm_set1_epi32(8);
300     d0 = _mm_add_epi32(d0, eight);
301     d1 = _mm_add_epi32(d1, eight);
302     d0 = _mm_srai_epi32(d0, 4);
303     d1 = _mm_srai_epi32(d1, 4);
304     d0 = _mm_packus_epi32(d0, d1);
305     __m128i max0 = _mm_set1_epi16((1 << bd) - 1);
306     d0 = _mm_min_epi16(d0, max0);
307     __m128i out0 = _mm_unpacklo_epi16(in1, d0);
308     __m128i out1 = _mm_unpackhi_epi16(in1, d0);
309     _mm_storeu_si128((__m128i *)&out[0], out0);
310     _mm_storeu_si128((__m128i *)&out[8], out1);
311     in0 = in8;
312     in8 = in16;
313     in16 = in24;
314     in24 = _mm_setzero_si128();
315     out += 16;
316     n -= 8;
317   }
318 }
319