?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cc: Added inline to Tile::IsReadyToDraw
[chromium-blink-merge.git] / third_party / libwebp / dsp / enc_neon.c
blobeb256e681da11fa3d4351f80d4dd30412ea4ae0e
1 // Copyright 2012 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 // ARM NEON version of speed-critical encoding functions.
11 //
12 // adapted from libvpx (http://www.webmproject.org/code/)
13
14 #include "./dsp.h"
15
16 #if defined(__cplusplus) || defined(c_plusplus)
17 extern "C" {
18 #endif
19
20 #if defined(WEBP_USE_NEON)
21
22 #include "../enc/vp8enci.h"
23
24 //------------------------------------------------------------------------------
25 // Transforms (Paragraph 14.4)
26
27 // Inverse transform.
28 // This code is pretty much the same as TransformOneNEON in the decoder, except
29 // for subtraction to *ref. See the comments there for algorithmic explanations.
30 static void ITransformOne(const uint8_t* ref,
31 const int16_t* in, uint8_t* dst) {
32 const int kBPS = BPS;
33 const int16_t kC1C2[] = { 20091, 17734, 0, 0 }; // kC1 / (kC2 >> 1) / 0 / 0
34
35 __asm__ volatile (
36 "vld1.16 {q1, q2}, [%[in]] \n"
37 "vld1.16 {d0}, [%[kC1C2]] \n"
38
39 // d2: in[0]
40 // d3: in[8]
41 // d4: in[4]
42 // d5: in[12]
43 "vswp d3, d4 \n"
44
45 // q8 = {in[4], in[12]} * kC1 * 2 >> 16
46 // q9 = {in[4], in[12]} * kC2 >> 16
47 "vqdmulh.s16 q8, q2, d0[0] \n"
48 "vqdmulh.s16 q9, q2, d0[1] \n"
49
50 // d22 = a = in[0] + in[8]
51 // d23 = b = in[0] - in[8]
52 "vqadd.s16 d22, d2, d3 \n"
53 "vqsub.s16 d23, d2, d3 \n"
54
55 // q8 = in[4]/[12] * kC1 >> 16
56 "vshr.s16 q8, q8, #1 \n"
57
58 // Add {in[4], in[12]} back after the multiplication.
59 "vqadd.s16 q8, q2, q8 \n"
60
61 // d20 = c = in[4]*kC2 - in[12]*kC1
62 // d21 = d = in[4]*kC1 + in[12]*kC2
63 "vqsub.s16 d20, d18, d17 \n"
64 "vqadd.s16 d21, d19, d16 \n"
65
66 // d2 = tmp[0] = a + d
67 // d3 = tmp[1] = b + c
68 // d4 = tmp[2] = b - c
69 // d5 = tmp[3] = a - d
70 "vqadd.s16 d2, d22, d21 \n"
71 "vqadd.s16 d3, d23, d20 \n"
72 "vqsub.s16 d4, d23, d20 \n"
73 "vqsub.s16 d5, d22, d21 \n"
74
75 "vzip.16 q1, q2 \n"
76 "vzip.16 q1, q2 \n"
77
78 "vswp d3, d4 \n"
79
80 // q8 = {tmp[4], tmp[12]} * kC1 * 2 >> 16
81 // q9 = {tmp[4], tmp[12]} * kC2 >> 16
82 "vqdmulh.s16 q8, q2, d0[0] \n"
83 "vqdmulh.s16 q9, q2, d0[1] \n"
84
85 // d22 = a = tmp[0] + tmp[8]
86 // d23 = b = tmp[0] - tmp[8]
87 "vqadd.s16 d22, d2, d3 \n"
88 "vqsub.s16 d23, d2, d3 \n"
89
90 "vshr.s16 q8, q8, #1 \n"
91 "vqadd.s16 q8, q2, q8 \n"
92
93 // d20 = c = in[4]*kC2 - in[12]*kC1
94 // d21 = d = in[4]*kC1 + in[12]*kC2
95 "vqsub.s16 d20, d18, d17 \n"
96 "vqadd.s16 d21, d19, d16 \n"
97
98 // d2 = tmp[0] = a + d
99 // d3 = tmp[1] = b + c
100 // d4 = tmp[2] = b - c
101 // d5 = tmp[3] = a - d
102 "vqadd.s16 d2, d22, d21 \n"
103 "vqadd.s16 d3, d23, d20 \n"
104 "vqsub.s16 d4, d23, d20 \n"
105 "vqsub.s16 d5, d22, d21 \n"
106
107 "vld1.32 d6[0], [%[ref]], %[kBPS] \n"
108 "vld1.32 d6[1], [%[ref]], %[kBPS] \n"
109 "vld1.32 d7[0], [%[ref]], %[kBPS] \n"
110 "vld1.32 d7[1], [%[ref]], %[kBPS] \n"
111
112 "sub %[ref], %[ref], %[kBPS], lsl #2 \n"
113
114 // (val) + 4 >> 3
115 "vrshr.s16 d2, d2, #3 \n"
116 "vrshr.s16 d3, d3, #3 \n"
117 "vrshr.s16 d4, d4, #3 \n"
118 "vrshr.s16 d5, d5, #3 \n"
119
120 "vzip.16 q1, q2 \n"
121 "vzip.16 q1, q2 \n"
122
123 // Must accumulate before saturating
124 "vmovl.u8 q8, d6 \n"
125 "vmovl.u8 q9, d7 \n"
126
127 "vqadd.s16 q1, q1, q8 \n"
128 "vqadd.s16 q2, q2, q9 \n"
129
130 "vqmovun.s16 d0, q1 \n"
131 "vqmovun.s16 d1, q2 \n"
132
133 "vst1.32 d0[0], [%[dst]], %[kBPS] \n"
134 "vst1.32 d0[1], [%[dst]], %[kBPS] \n"
135 "vst1.32 d1[0], [%[dst]], %[kBPS] \n"
136 "vst1.32 d1[1], [%[dst]] \n"
137
138 : [in] "+r"(in), [dst] "+r"(dst) // modified registers
139 : [kBPS] "r"(kBPS), [kC1C2] "r"(kC1C2), [ref] "r"(ref) // constants
140 : "memory", "q0", "q1", "q2", "q8", "q9", "q10", "q11" // clobbered
141 );
142 }
143
144 static void ITransform(const uint8_t* ref,
145 const int16_t* in, uint8_t* dst, int do_two) {
146 ITransformOne(ref, in, dst);
147 if (do_two) {
148 ITransformOne(ref + 4, in + 16, dst + 4);
149 }
150 }
151
152 // Same code as dec_neon.c
153 static void ITransformWHT(const int16_t* in, int16_t* out) {
154 const int kStep = 32; // The store is only incrementing the pointer as if we
155 // had stored a single byte.
156 __asm__ volatile (
157 // part 1
158 // load data into q0, q1
159 "vld1.16 {q0, q1}, [%[in]] \n"
160
161 "vaddl.s16 q2, d0, d3 \n" // a0 = in[0] + in[12]
162 "vaddl.s16 q3, d1, d2 \n" // a1 = in[4] + in[8]
163 "vsubl.s16 q4, d1, d2 \n" // a2 = in[4] - in[8]
164 "vsubl.s16 q5, d0, d3 \n" // a3 = in[0] - in[12]
165
166 "vadd.s32 q0, q2, q3 \n" // tmp[0] = a0 + a1
167 "vsub.s32 q2, q2, q3 \n" // tmp[8] = a0 - a1
168 "vadd.s32 q1, q5, q4 \n" // tmp[4] = a3 + a2
169 "vsub.s32 q3, q5, q4 \n" // tmp[12] = a3 - a2
170
171 // Transpose
172 // q0 = tmp[0, 4, 8, 12], q1 = tmp[2, 6, 10, 14]
173 // q2 = tmp[1, 5, 9, 13], q3 = tmp[3, 7, 11, 15]
174 "vswp d1, d4 \n" // vtrn.64 q0, q2
175 "vswp d3, d6 \n" // vtrn.64 q1, q3
176 "vtrn.32 q0, q1 \n"
177 "vtrn.32 q2, q3 \n"
178
179 "vmov.s32 q4, #3 \n" // dc = 3
180 "vadd.s32 q0, q0, q4 \n" // dc = tmp[0] + 3
181 "vadd.s32 q6, q0, q3 \n" // a0 = dc + tmp[3]
182 "vadd.s32 q7, q1, q2 \n" // a1 = tmp[1] + tmp[2]
183 "vsub.s32 q8, q1, q2 \n" // a2 = tmp[1] - tmp[2]
184 "vsub.s32 q9, q0, q3 \n" // a3 = dc - tmp[3]
185
186 "vadd.s32 q0, q6, q7 \n"
187 "vshrn.s32 d0, q0, #3 \n" // (a0 + a1) >> 3
188 "vadd.s32 q1, q9, q8 \n"
189 "vshrn.s32 d1, q1, #3 \n" // (a3 + a2) >> 3
190 "vsub.s32 q2, q6, q7 \n"
191 "vshrn.s32 d2, q2, #3 \n" // (a0 - a1) >> 3
192 "vsub.s32 q3, q9, q8 \n"
193 "vshrn.s32 d3, q3, #3 \n" // (a3 - a2) >> 3
194
195 // set the results to output
196 "vst1.16 d0[0], [%[out]], %[kStep] \n"
197 "vst1.16 d1[0], [%[out]], %[kStep] \n"
198 "vst1.16 d2[0], [%[out]], %[kStep] \n"
199 "vst1.16 d3[0], [%[out]], %[kStep] \n"
200 "vst1.16 d0[1], [%[out]], %[kStep] \n"
201 "vst1.16 d1[1], [%[out]], %[kStep] \n"
202 "vst1.16 d2[1], [%[out]], %[kStep] \n"
203 "vst1.16 d3[1], [%[out]], %[kStep] \n"
204 "vst1.16 d0[2], [%[out]], %[kStep] \n"
205 "vst1.16 d1[2], [%[out]], %[kStep] \n"
206 "vst1.16 d2[2], [%[out]], %[kStep] \n"
207 "vst1.16 d3[2], [%[out]], %[kStep] \n"
208 "vst1.16 d0[3], [%[out]], %[kStep] \n"
209 "vst1.16 d1[3], [%[out]], %[kStep] \n"
210 "vst1.16 d2[3], [%[out]], %[kStep] \n"
211 "vst1.16 d3[3], [%[out]], %[kStep] \n"
212
213 : [out] "+r"(out) // modified registers
214 : [in] "r"(in), [kStep] "r"(kStep) // constants
215 : "memory", "q0", "q1", "q2", "q3", "q4",
216 "q5", "q6", "q7", "q8", "q9" // clobbered
217 );
218 }
219
220 // Forward transform.
221
222 // adapted from vp8/encoder/arm/neon/shortfdct_neon.asm
223 static const int16_t kCoeff16[] = {
224 5352, 5352, 5352, 5352, 2217, 2217, 2217, 2217
225 };
226 static const int32_t kCoeff32[] = {
227 1812, 1812, 1812, 1812,
228 937, 937, 937, 937,
229 12000, 12000, 12000, 12000,
230 51000, 51000, 51000, 51000
231 };
232
233 static void FTransform(const uint8_t* src, const uint8_t* ref,
234 int16_t* out) {
235 const int kBPS = BPS;
236 const uint8_t* src_ptr = src;
237 const uint8_t* ref_ptr = ref;
238 const int16_t* coeff16 = kCoeff16;
239 const int32_t* coeff32 = kCoeff32;
240
241 __asm__ volatile (
242 // load src into q4, q5 in high half
243 "vld1.8 {d8}, [%[src_ptr]], %[kBPS] \n"
244 "vld1.8 {d10}, [%[src_ptr]], %[kBPS] \n"
245 "vld1.8 {d9}, [%[src_ptr]], %[kBPS] \n"
246 "vld1.8 {d11}, [%[src_ptr]] \n"
247
248 // load ref into q6, q7 in high half
249 "vld1.8 {d12}, [%[ref_ptr]], %[kBPS] \n"
250 "vld1.8 {d14}, [%[ref_ptr]], %[kBPS] \n"
251 "vld1.8 {d13}, [%[ref_ptr]], %[kBPS] \n"
252 "vld1.8 {d15}, [%[ref_ptr]] \n"
253
254 // Pack the high values in to q4 and q6
255 "vtrn.32 q4, q5 \n"
256 "vtrn.32 q6, q7 \n"
257
258 // d[0-3] = src - ref
259 "vsubl.u8 q0, d8, d12 \n"
260 "vsubl.u8 q1, d9, d13 \n"
261
262 // load coeff16 into q8(d16=5352, d17=2217)
263 "vld1.16 {q8}, [%[coeff16]] \n"
264
265 // load coeff32 high half into q9 = 1812, q10 = 937
266 "vld1.32 {q9, q10}, [%[coeff32]]! \n"
267
268 // load coeff32 low half into q11=12000, q12=51000
269 "vld1.32 {q11,q12}, [%[coeff32]] \n"
270
271 // part 1
272 // Transpose. Register dN is the same as dN in C
273 "vtrn.32 d0, d2 \n"
274 "vtrn.32 d1, d3 \n"
275 "vtrn.16 d0, d1 \n"
276 "vtrn.16 d2, d3 \n"
277
278 "vadd.s16 d4, d0, d3 \n" // a0 = d0 + d3
279 "vadd.s16 d5, d1, d2 \n" // a1 = d1 + d2
280 "vsub.s16 d6, d1, d2 \n" // a2 = d1 - d2
281 "vsub.s16 d7, d0, d3 \n" // a3 = d0 - d3
282
283 "vadd.s16 d0, d4, d5 \n" // a0 + a1
284 "vshl.s16 d0, d0, #3 \n" // temp[0+i*4] = (a0+a1) << 3
285 "vsub.s16 d2, d4, d5 \n" // a0 - a1
286 "vshl.s16 d2, d2, #3 \n" // (temp[2+i*4] = (a0-a1) << 3
287
288 "vmlal.s16 q9, d7, d16 \n" // a3*5352 + 1812
289 "vmlal.s16 q10, d7, d17 \n" // a3*2217 + 937
290 "vmlal.s16 q9, d6, d17 \n" // a2*2217 + a3*5352 + 1812
291 "vmlsl.s16 q10, d6, d16 \n" // a3*2217 + 937 - a2*5352
292
293 // temp[1+i*4] = (d2*2217 + d3*5352 + 1812) >> 9
294 // temp[3+i*4] = (d3*2217 + 937 - d2*5352) >> 9
295 "vshrn.s32 d1, q9, #9 \n"
296 "vshrn.s32 d3, q10, #9 \n"
297
298 // part 2
299 // transpose d0=ip[0], d1=ip[4], d2=ip[8], d3=ip[12]
300 "vtrn.32 d0, d2 \n"
301 "vtrn.32 d1, d3 \n"
302 "vtrn.16 d0, d1 \n"
303 "vtrn.16 d2, d3 \n"
304
305 "vmov.s16 d26, #7 \n"
306
307 "vadd.s16 d4, d0, d3 \n" // a1 = ip[0] + ip[12]
308 "vadd.s16 d5, d1, d2 \n" // b1 = ip[4] + ip[8]
309 "vsub.s16 d6, d1, d2 \n" // c1 = ip[4] - ip[8]
310 "vadd.s16 d4, d4, d26 \n" // a1 + 7
311 "vsub.s16 d7, d0, d3 \n" // d1 = ip[0] - ip[12]
312
313 "vadd.s16 d0, d4, d5 \n" // op[0] = a1 + b1 + 7
314 "vsub.s16 d2, d4, d5 \n" // op[8] = a1 - b1 + 7
315
316 "vmlal.s16 q11, d7, d16 \n" // d1*5352 + 12000
317 "vmlal.s16 q12, d7, d17 \n" // d1*2217 + 51000
318
319 "vceq.s16 d4, d7, #0 \n"
320
321 "vshr.s16 d0, d0, #4 \n"
322 "vshr.s16 d2, d2, #4 \n"
323
324 "vmlal.s16 q11, d6, d17 \n" // c1*2217 + d1*5352 + 12000
325 "vmlsl.s16 q12, d6, d16 \n" // d1*2217 - c1*5352 + 51000
326
327 "vmvn d4, d4 \n" // !(d1 == 0)
328 // op[4] = (c1*2217 + d1*5352 + 12000)>>16
329 "vshrn.s32 d1, q11, #16 \n"
330 // op[4] += (d1!=0)
331 "vsub.s16 d1, d1, d4 \n"
332 // op[12]= (d1*2217 - c1*5352 + 51000)>>16
333 "vshrn.s32 d3, q12, #16 \n"
334
335 // set result to out array
336 "vst1.16 {q0, q1}, [%[out]] \n"
337 : [src_ptr] "+r"(src_ptr), [ref_ptr] "+r"(ref_ptr),
338 [coeff32] "+r"(coeff32) // modified registers
339 : [kBPS] "r"(kBPS), [coeff16] "r"(coeff16),
340 [out] "r"(out) // constants
341 : "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", "q8", "q9",
342 "q10", "q11", "q12", "q13" // clobbered
343 );
344 }
345
346 static void FTransformWHT(const int16_t* in, int16_t* out) {
347 const int kStep = 32;
348 __asm__ volatile (
349 // d0 = in[0 * 16] , d1 = in[1 * 16]
350 // d2 = in[2 * 16] , d3 = in[3 * 16]
351 "vld1.16 d0[0], [%[in]], %[kStep] \n"
352 "vld1.16 d1[0], [%[in]], %[kStep] \n"
353 "vld1.16 d2[0], [%[in]], %[kStep] \n"
354 "vld1.16 d3[0], [%[in]], %[kStep] \n"
355 "vld1.16 d0[1], [%[in]], %[kStep] \n"
356 "vld1.16 d1[1], [%[in]], %[kStep] \n"
357 "vld1.16 d2[1], [%[in]], %[kStep] \n"
358 "vld1.16 d3[1], [%[in]], %[kStep] \n"
359 "vld1.16 d0[2], [%[in]], %[kStep] \n"
360 "vld1.16 d1[2], [%[in]], %[kStep] \n"
361 "vld1.16 d2[2], [%[in]], %[kStep] \n"
362 "vld1.16 d3[2], [%[in]], %[kStep] \n"
363 "vld1.16 d0[3], [%[in]], %[kStep] \n"
364 "vld1.16 d1[3], [%[in]], %[kStep] \n"
365 "vld1.16 d2[3], [%[in]], %[kStep] \n"
366 "vld1.16 d3[3], [%[in]], %[kStep] \n"
367
368 "vaddl.s16 q2, d0, d2 \n" // a0=(in[0*16]+in[2*16])
369 "vaddl.s16 q3, d1, d3 \n" // a1=(in[1*16]+in[3*16])
370 "vsubl.s16 q4, d1, d3 \n" // a2=(in[1*16]-in[3*16])
371 "vsubl.s16 q5, d0, d2 \n" // a3=(in[0*16]-in[2*16])
372
373 "vqadd.s32 q6, q2, q3 \n" // a0 + a1
374 "vqadd.s32 q7, q5, q4 \n" // a3 + a2
375 "vqsub.s32 q8, q5, q4 \n" // a3 - a2
376 "vqsub.s32 q9, q2, q3 \n" // a0 - a1
377
378 // Transpose
379 // q6 = tmp[0, 1, 2, 3] ; q7 = tmp[ 4, 5, 6, 7]
380 // q8 = tmp[8, 9, 10, 11] ; q9 = tmp[12, 13, 14, 15]
381 "vswp d13, d16 \n" // vtrn.64 q0, q2
382 "vswp d15, d18 \n" // vtrn.64 q1, q3
383 "vtrn.32 q6, q7 \n"
384 "vtrn.32 q8, q9 \n"
385
386 "vqadd.s32 q0, q6, q8 \n" // a0 = tmp[0] + tmp[8]
387 "vqadd.s32 q1, q7, q9 \n" // a1 = tmp[4] + tmp[12]
388 "vqsub.s32 q2, q7, q9 \n" // a2 = tmp[4] - tmp[12]
389 "vqsub.s32 q3, q6, q8 \n" // a3 = tmp[0] - tmp[8]
390
391 "vqadd.s32 q4, q0, q1 \n" // b0 = a0 + a1
392 "vqadd.s32 q5, q3, q2 \n" // b1 = a3 + a2
393 "vqsub.s32 q6, q3, q2 \n" // b2 = a3 - a2
394 "vqsub.s32 q7, q0, q1 \n" // b3 = a0 - a1
395
396 "vshrn.s32 d18, q4, #1 \n" // b0 >> 1
397 "vshrn.s32 d19, q5, #1 \n" // b1 >> 1
398 "vshrn.s32 d20, q6, #1 \n" // b2 >> 1
399 "vshrn.s32 d21, q7, #1 \n" // b3 >> 1
400
401 "vst1.16 {q9, q10}, [%[out]] \n"
402
403 : [in] "+r"(in)
404 : [kStep] "r"(kStep), [out] "r"(out)
405 : "memory", "q0", "q1", "q2", "q3", "q4", "q5",
406 "q6", "q7", "q8", "q9", "q10" // clobbered
407 ) ;
408 }
409
410 //------------------------------------------------------------------------------
411 // Texture distortion
412 //
413 // We try to match the spectral content (weighted) between source and
414 // reconstructed samples.
415
416 // Hadamard transform
417 // Returns the weighted sum of the absolute value of transformed coefficients.
418 // This uses a TTransform helper function in C
419 static int Disto4x4(const uint8_t* const a, const uint8_t* const b,
420 const uint16_t* const w) {
421 const int kBPS = BPS;
422 const uint8_t* A = a;
423 const uint8_t* B = b;
424 const uint16_t* W = w;
425 int sum;
426 __asm__ volatile (
427 "vld1.32 d0[0], [%[a]], %[kBPS] \n"
428 "vld1.32 d0[1], [%[a]], %[kBPS] \n"
429 "vld1.32 d2[0], [%[a]], %[kBPS] \n"
430 "vld1.32 d2[1], [%[a]] \n"
431
432 "vld1.32 d1[0], [%[b]], %[kBPS] \n"
433 "vld1.32 d1[1], [%[b]], %[kBPS] \n"
434 "vld1.32 d3[0], [%[b]], %[kBPS] \n"
435 "vld1.32 d3[1], [%[b]] \n"
436
437 // a d0/d2, b d1/d3
438 // d0/d1: 01 01 01 01
439 // d2/d3: 23 23 23 23
440 // But: it goes 01 45 23 67
441 // Notice the middle values are transposed
442 "vtrn.16 q0, q1 \n"
443
444 // {a0, a1} = {in[0] + in[2], in[1] + in[3]}
445 "vaddl.u8 q2, d0, d2 \n"
446 "vaddl.u8 q10, d1, d3 \n"
447 // {a3, a2} = {in[0] - in[2], in[1] - in[3]}
448 "vsubl.u8 q3, d0, d2 \n"
449 "vsubl.u8 q11, d1, d3 \n"
450
451 // tmp[0] = a0 + a1
452 "vpaddl.s16 q0, q2 \n"
453 "vpaddl.s16 q8, q10 \n"
454
455 // tmp[1] = a3 + a2
456 "vpaddl.s16 q1, q3 \n"
457 "vpaddl.s16 q9, q11 \n"
458
459 // No pair subtract
460 // q2 = {a0, a3}
461 // q3 = {a1, a2}
462 "vtrn.16 q2, q3 \n"
463 "vtrn.16 q10, q11 \n"
464
465 // {tmp[3], tmp[2]} = {a0 - a1, a3 - a2}
466 "vsubl.s16 q12, d4, d6 \n"
467 "vsubl.s16 q13, d5, d7 \n"
468 "vsubl.s16 q14, d20, d22 \n"
469 "vsubl.s16 q15, d21, d23 \n"
470
471 // separate tmp[3] and tmp[2]
472 // q12 = tmp[3]
473 // q13 = tmp[2]
474 "vtrn.32 q12, q13 \n"
475 "vtrn.32 q14, q15 \n"
476
477 // Transpose tmp for a
478 "vswp d1, d26 \n" // vtrn.64
479 "vswp d3, d24 \n" // vtrn.64
480 "vtrn.32 q0, q1 \n"
481 "vtrn.32 q13, q12 \n"
482
483 // Transpose tmp for b
484 "vswp d17, d30 \n" // vtrn.64
485 "vswp d19, d28 \n" // vtrn.64
486 "vtrn.32 q8, q9 \n"
487 "vtrn.32 q15, q14 \n"
488
489 // The first Q register is a, the second b.
490 // q0/8 tmp[0-3]
491 // q13/15 tmp[4-7]
492 // q1/9 tmp[8-11]
493 // q12/14 tmp[12-15]
494
495 // These are still in 01 45 23 67 order. We fix it easily in the addition
496 // case but the subtraction propegates them.
497 "vswp d3, d27 \n"
498 "vswp d19, d31 \n"
499
500 // a0 = tmp[0] + tmp[8]
501 "vadd.s32 q2, q0, q1 \n"
502 "vadd.s32 q3, q8, q9 \n"
503
504 // a1 = tmp[4] + tmp[12]
505 "vadd.s32 q10, q13, q12 \n"
506 "vadd.s32 q11, q15, q14 \n"
507
508 // a2 = tmp[4] - tmp[12]
509 "vsub.s32 q13, q13, q12 \n"
510 "vsub.s32 q15, q15, q14 \n"
511
512 // a3 = tmp[0] - tmp[8]
513 "vsub.s32 q0, q0, q1 \n"
514 "vsub.s32 q8, q8, q9 \n"
515
516 // b0 = a0 + a1
517 "vadd.s32 q1, q2, q10 \n"
518 "vadd.s32 q9, q3, q11 \n"
519
520 // b1 = a3 + a2
521 "vadd.s32 q12, q0, q13 \n"
522 "vadd.s32 q14, q8, q15 \n"
523
524 // b2 = a3 - a2
525 "vsub.s32 q0, q0, q13 \n"
526 "vsub.s32 q8, q8, q15 \n"
527
528 // b3 = a0 - a1
529 "vsub.s32 q2, q2, q10 \n"
530 "vsub.s32 q3, q3, q11 \n"
531
532 "vld1.64 {q10, q11}, [%[w]] \n"
533
534 // abs(b0)
535 "vabs.s32 q1, q1 \n"
536 "vabs.s32 q9, q9 \n"
537 // abs(b1)
538 "vabs.s32 q12, q12 \n"
539 "vabs.s32 q14, q14 \n"
540 // abs(b2)
541 "vabs.s32 q0, q0 \n"
542 "vabs.s32 q8, q8 \n"
543 // abs(b3)
544 "vabs.s32 q2, q2 \n"
545 "vabs.s32 q3, q3 \n"
546
547 // expand w before using.
548 "vmovl.u16 q13, d20 \n"
549 "vmovl.u16 q15, d21 \n"
550
551 // w[0] * abs(b0)
552 "vmul.u32 q1, q1, q13 \n"
553 "vmul.u32 q9, q9, q13 \n"
554
555 // w[4] * abs(b1)
556 "vmla.u32 q1, q12, q15 \n"
557 "vmla.u32 q9, q14, q15 \n"
558
559 // expand w before using.
560 "vmovl.u16 q13, d22 \n"
561 "vmovl.u16 q15, d23 \n"
562
563 // w[8] * abs(b1)
564 "vmla.u32 q1, q0, q13 \n"
565 "vmla.u32 q9, q8, q13 \n"
566
567 // w[12] * abs(b1)
568 "vmla.u32 q1, q2, q15 \n"
569 "vmla.u32 q9, q3, q15 \n"
570
571 // Sum the arrays
572 "vpaddl.u32 q1, q1 \n"
573 "vpaddl.u32 q9, q9 \n"
574 "vadd.u64 d2, d3 \n"
575 "vadd.u64 d18, d19 \n"
576
577 // Hadamard transform needs 4 bits of extra precision (2 bits in each
578 // direction) for dynamic raw. Weights w[] are 16bits at max, so the maximum
579 // precision for coeff is 8bit of input + 4bits of Hadamard transform +
580 // 16bits for w[] + 2 bits of abs() summation.
581 //
582 // This uses a maximum of 31 bits (signed). Discarding the top 32 bits is
583 // A-OK.
584
585 // sum2 - sum1
586 "vsub.u32 d0, d2, d18 \n"
587 // abs(sum2 - sum1)
588 "vabs.s32 d0, d0 \n"
589 // abs(sum2 - sum1) >> 5
590 "vshr.u32 d0, #5 \n"
591
592 // It would be better to move the value straight into r0 but I'm not
593 // entirely sure how this works with inline assembly.
594 "vmov.32 %[sum], d0[0] \n"
595
596 : [sum] "=r"(sum), [a] "+r"(A), [b] "+r"(B), [w] "+r"(W)
597 : [kBPS] "r"(kBPS)
598 : "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", "q8", "q9",
599 "q10", "q11", "q12", "q13", "q14", "q15" // clobbered
600 ) ;
601
602 return sum;
603 }
604
605 static int Disto16x16(const uint8_t* const a, const uint8_t* const b,
606 const uint16_t* const w) {
607 int D = 0;
608 int x, y;
609 for (y = 0; y < 16 * BPS; y += 4 * BPS) {
610 for (x = 0; x < 16; x += 4) {
611 D += Disto4x4(a + x + y, b + x + y, w);
612 }
613 }
614 return D;
615 }
616
617 #endif // WEBP_USE_NEON
618
619 //------------------------------------------------------------------------------
620 // Entry point
621
622 extern void VP8EncDspInitNEON(void);
623
624 void VP8EncDspInitNEON(void) {
625 #if defined(WEBP_USE_NEON)
626 VP8ITransform = ITransform;
627 VP8FTransform = FTransform;
628
629 VP8ITransformWHT = ITransformWHT;
630 VP8FTransformWHT = FTransformWHT;
631
632 VP8TDisto4x4 = Disto4x4;
633 VP8TDisto16x16 = Disto16x16;
634 #endif // WEBP_USE_NEON
635 }
636
637 #if defined(__cplusplus) || defined(c_plusplus)
638 } // extern "C"
639 #endif