History

quantize avx: copy 32x32 implementation

Ensure avx and ssse3 stay in sync by testing them against each other.

Johann committed 9 years ago

Commit f60d1dc1 parent 1787e7d5 files · +223 −512Browse files

Unified · Split

5 files
  1. test/vp9_quantize_test.cc +8 −10
  2. vpx_dsp/vpx_dsp.mk +0 −3
  3. vpx_dsp/vpx_dsp_rtcd_defs.pl +1 −1
  4. vpx_dsp/x86/quantize_avx.c +214 −1
  5. vpx_dsp/x86/quantize_avx_x86_64.asm +0 −497
test/vp9_quantize_test.cc+8−10
@@ -392,16 +392,14 @@ INSTANTIATE_TEST_CASE_P( · 391 unmodified lines
392392 // TODO(johannkoenig): AVX optimizations do not yet pass the 32x32 test or
393393 // highbitdepth configurations.
394394 #if HAVE_AVX && !CONFIG_VP9_HIGHBITDEPTH
395−INSTANTIATE_TEST_CASE_P(AVX, VP9QuantizeTest,
396− ::testing::Values(make_tuple(&vpx_quantize_b_avx,
397− &vpx_quantize_b_c,
398− VPX_BITS_8, 16)));
399−#if ARCH_X86_64
400−INSTANTIATE_TEST_CASE_P(DISABLED_AVX, VP9QuantizeTest,
401− ::testing::Values(make_tuple(&vpx_quantize_b_32x32_avx,
402− &vpx_quantize_b_32x32_c,
403− VPX_BITS_8, 32)));
404−#endif // ARCH_X86_64
395+INSTANTIATE_TEST_CASE_P(
396+ AVX, VP9QuantizeTest,
397+ ::testing::Values(make_tuple(&vpx_quantize_b_avx, &vpx_quantize_b_c,
398+ VPX_BITS_8, 16),
399+ // Even though SSSE3 and AVX do not match the reference
400+ // code, we can keep them in sync with each other.
401+ make_tuple(&vpx_quantize_b_32x32_avx,
402+ &vpx_quantize_b_32x32_ssse3, VPX_BITS_8, 32)));
405403 #endif // HAVE_AVX && !CONFIG_VP9_HIGHBITDEPTH
406404
407405 // TODO(webm:1448): dqcoeff is not handled correctly in HBD builds.
vpx_dsp/vpx_dsp.mk+0−3
@@ -282,9 +282,6 @@ DSP_SRCS-$(HAVE_NEON) += arm/quantize_neon.c · 281 unmodified lines
282282 ifeq ($(CONFIG_VP9_HIGHBITDEPTH),yes)
283283 DSP_SRCS-$(HAVE_SSE2) += x86/highbd_quantize_intrin_sse2.c
284284 endif
285−ifeq ($(ARCH_X86_64),yes)
286−DSP_SRCS-$(HAVE_AVX) += x86/quantize_avx_x86_64.asm
287−endif
288285
289286 # avg
290287 DSP_SRCS-yes += avg.c
vpx_dsp/vpx_dsp_rtcd_defs.pl+1−1
@@ -673,7 +673,7 @@ if (vpx_config("CONFIG_VP9_ENCODER") eq "yes") { · 672 unmodified lines
673673 specialize qw/vpx_quantize_b neon sse2 ssse3 avx/;
674674
675675 add_proto qw/void vpx_quantize_b_32x32/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
676− specialize qw/vpx_quantize_b_32x32 neon ssse3/, "$avx_x86_64";
676+ specialize qw/vpx_quantize_b_32x32 neon ssse3 avx/;
677677
678678 if (vpx_config("CONFIG_VP9_HIGHBITDEPTH") eq "yes") {
679679 add_proto qw/void vpx_highbd_quantize_b/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan";
vpx_dsp/x86/quantize_avx.c+214−1
@@ -46,7 +46,7 @@ void vpx_quantize_b_avx(const tran_low_t *coeff_ptr, intptr_t n_coeffs, · 45 unmodified lines
4646
4747 // Setup global values.
4848 zbin = _mm_load_si128((const __m128i *)zbin_ptr);
49− // x86 has no "greater *or equal* comparison. Subtract 1 from zbin so
49+ // x86 has no "greater *or equal*" comparison. Subtract 1 from zbin so
5050 // it is a strict "greater" comparison.
5151 zbin = _mm_sub_epi16(zbin, _mm_set1_epi16(1));
5252 round = _mm_load_si128((const __m128i *)round_ptr);
@@ -200,3 +200,216 @@ void vpx_quantize_b_avx(const tran_low_t *coeff_ptr, intptr_t n_coeffs, · 147 unmodified lines
200200 *eob_ptr = _mm_extract_epi16(eob, 1);
201201 }
202202 }
203+
204+void vpx_quantize_b_32x32_avx(
205+ const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block,
206+ const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr,
207+ const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr,
208+ tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr,
209+ const int16_t *scan_ptr, const int16_t *iscan_ptr) {
210+ const __m128i zero = _mm_setzero_si128();
211+ const __m128i one = _mm_set1_epi16(1);
212+ const __m256i big_zero = _mm256_setzero_si256();
213+ int index;
214+
215+ __m128i zbin, round, quant, dequant, shift;
216+ __m128i coeff0, coeff1;
217+ __m128i qcoeff0, qcoeff1;
218+ __m128i cmp_mask0, cmp_mask1;
219+ __m128i all_zero;
220+ __m128i qtmp0, qtmp1;
221+ __m128i zero_coeff0, zero_coeff1, iscan0, iscan1;
222+ __m128i eob = zero, eob0, eob1;
223+
224+ (void)scan_ptr;
225+ (void)n_coeffs;
226+ (void)skip_block;
227+ assert(!skip_block);
228+
229+ *eob_ptr = 0;
230+
231+ // Setup global values.
232+ // The 32x32 halves zbin and round.
233+ zbin = _mm_load_si128((const __m128i *)zbin_ptr);
234+ // Shift with rounding.
235+ zbin = _mm_add_epi16(zbin, one);
236+ zbin = _mm_srli_epi16(zbin, 1);
237+ // x86 has no "greater *or equal*" comparison. Subtract 1 from zbin so
238+ // it is a strict "greater" comparison.
239+ zbin = _mm_sub_epi16(zbin, one);
240+
241+ round = _mm_load_si128((const __m128i *)round_ptr);
242+ round = _mm_add_epi16(round, one);
243+ round = _mm_srli_epi16(round, 1);
244+
245+ quant = _mm_load_si128((const __m128i *)quant_ptr);
246+ dequant = _mm_load_si128((const __m128i *)dequant_ptr);
247+ shift = _mm_load_si128((const __m128i *)quant_shift_ptr);
248+ shift = _mm_slli_epi16(shift, 1);
249+
250+ // Do DC and first 15 AC.
251+ coeff0 = load_tran_low(coeff_ptr);
252+ coeff1 = load_tran_low(coeff_ptr + 8);
253+
254+ qcoeff0 = _mm_abs_epi16(coeff0);
255+ qcoeff1 = _mm_abs_epi16(coeff1);
256+
257+ cmp_mask0 = _mm_cmpgt_epi16(qcoeff0, zbin);
258+ zbin = _mm_unpackhi_epi64(zbin, zbin); // Switch DC to AC
259+ cmp_mask1 = _mm_cmpgt_epi16(qcoeff1, zbin);
260+
261+ all_zero = _mm_or_si128(cmp_mask0, cmp_mask1);
262+ if (_mm_test_all_zeros(all_zero, all_zero)) {
263+ _mm256_store_si256((__m256i *)(qcoeff_ptr), big_zero);
264+ _mm256_store_si256((__m256i *)(dqcoeff_ptr), big_zero);
265+#if CONFIG_VP9_HIGHBITDEPTH
266+ _mm256_store_si256((__m256i *)(qcoeff_ptr + 8), big_zero);
267+ _mm256_store_si256((__m256i *)(dqcoeff_ptr + 8), big_zero);
268+#endif // CONFIG_VP9_HIGHBITDEPTH
269+
270+ round = _mm_unpackhi_epi64(round, round);
271+ quant = _mm_unpackhi_epi64(quant, quant);
272+ shift = _mm_unpackhi_epi64(shift, shift);
273+ dequant = _mm_unpackhi_epi64(dequant, dequant);
274+ } else {
275+ qcoeff0 = _mm_adds_epi16(qcoeff0, round);
276+ round = _mm_unpackhi_epi64(round, round);
277+ qcoeff1 = _mm_adds_epi16(qcoeff1, round);
278+
279+ qtmp0 = _mm_mulhi_epi16(qcoeff0, quant);
280+ quant = _mm_unpackhi_epi64(quant, quant);
281+ qtmp1 = _mm_mulhi_epi16(qcoeff1, quant);
282+
283+ qtmp0 = _mm_add_epi16(qtmp0, qcoeff0);
284+ qtmp1 = _mm_add_epi16(qtmp1, qcoeff1);
285+
286+ qcoeff0 = _mm_mulhi_epi16(qtmp0, shift);
287+ shift = _mm_unpackhi_epi64(shift, shift);
288+ qcoeff1 = _mm_mulhi_epi16(qtmp1, shift);
289+
290+ // Reinsert signs
291+ qcoeff0 = _mm_sign_epi16(qcoeff0, coeff0);
292+ qcoeff1 = _mm_sign_epi16(qcoeff1, coeff1);
293+
294+ // Mask out zbin threshold coeffs
295+ qcoeff0 = _mm_and_si128(qcoeff0, cmp_mask0);
296+ qcoeff1 = _mm_and_si128(qcoeff1, cmp_mask1);
297+
298+ store_tran_low(qcoeff0, qcoeff_ptr);
299+ store_tran_low(qcoeff1, qcoeff_ptr + 8);
300+
301+ // Un-sign to bias rounding like C.
302+ // dequant is almost always negative, so this is probably the backwards way
303+ // to handle the sign. However, it matches the previous assembly.
304+ coeff0 = _mm_abs_epi16(qcoeff0);
305+ coeff1 = _mm_abs_epi16(qcoeff1);
306+
307+ coeff0 = _mm_mullo_epi16(coeff0, dequant);
308+ dequant = _mm_unpackhi_epi64(dequant, dequant);
309+ coeff1 = _mm_mullo_epi16(coeff1, dequant);
310+
311+ // "Divide" by 2.
312+ coeff0 = _mm_srli_epi16(coeff0, 1);
313+ coeff1 = _mm_srli_epi16(coeff1, 1);
314+
315+ coeff0 = _mm_sign_epi16(coeff0, qcoeff0);
316+ coeff1 = _mm_sign_epi16(coeff1, qcoeff1);
317+
318+ store_tran_low(coeff0, dqcoeff_ptr);
319+ store_tran_low(coeff1, dqcoeff_ptr + 8);
320+
321+ // Scan for eob.
322+ zero_coeff0 = _mm_cmpeq_epi16(coeff0, zero);
323+ zero_coeff1 = _mm_cmpeq_epi16(coeff1, zero);
324+ iscan0 = _mm_load_si128((const __m128i *)(iscan_ptr));
325+ iscan1 = _mm_load_si128((const __m128i *)(iscan_ptr + 8));
326+ // Add one to convert from indices to counts
327+ iscan0 = _mm_sub_epi16(iscan0, cmp_mask0);
328+ iscan1 = _mm_sub_epi16(iscan1, cmp_mask1);
329+ eob = _mm_andnot_si128(zero_coeff0, iscan0);
330+ eob1 = _mm_andnot_si128(zero_coeff1, iscan1);
331+ eob = _mm_max_epi16(eob, eob1);
332+ }
333+
334+ // AC only loop.
335+ for (index = 16; index < 32 * 32; index += 16) {
336+ coeff0 = load_tran_low(coeff_ptr + index);
337+ coeff1 = load_tran_low(coeff_ptr + index + 8);
338+
339+ qcoeff0 = _mm_abs_epi16(coeff0);
340+ qcoeff1 = _mm_abs_epi16(coeff1);
341+
342+ cmp_mask0 = _mm_cmpgt_epi16(qcoeff0, zbin);
343+ cmp_mask1 = _mm_cmpgt_epi16(qcoeff1, zbin);
344+
345+ all_zero = _mm_or_si128(cmp_mask0, cmp_mask1);
346+ if (_mm_test_all_zeros(all_zero, all_zero)) {
347+ _mm256_store_si256((__m256i *)(qcoeff_ptr + index), big_zero);
348+ _mm256_store_si256((__m256i *)(dqcoeff_ptr + index), big_zero);
349+#if CONFIG_VP9_HIGHBITDEPTH
350+ _mm256_store_si256((__m256i *)(qcoeff_ptr + index + 8), big_zero);
351+ _mm256_store_si256((__m256i *)(dqcoeff_ptr + index + 8), big_zero);
352+#endif // CONFIG_VP9_HIGHBITDEPTH
353+ continue;
354+ }
355+
356+ qcoeff0 = _mm_adds_epi16(qcoeff0, round);
357+ qcoeff1 = _mm_adds_epi16(qcoeff1, round);
358+
359+ qtmp0 = _mm_mulhi_epi16(qcoeff0, quant);
360+ qtmp1 = _mm_mulhi_epi16(qcoeff1, quant);
361+
362+ qtmp0 = _mm_add_epi16(qtmp0, qcoeff0);
363+ qtmp1 = _mm_add_epi16(qtmp1, qcoeff1);
364+
365+ qcoeff0 = _mm_mulhi_epi16(qtmp0, shift);
366+ qcoeff1 = _mm_mulhi_epi16(qtmp1, shift);
367+
368+ qcoeff0 = _mm_sign_epi16(qcoeff0, coeff0);
369+ qcoeff1 = _mm_sign_epi16(qcoeff1, coeff1);
370+
371+ qcoeff0 = _mm_and_si128(qcoeff0, cmp_mask0);
372+ qcoeff1 = _mm_and_si128(qcoeff1, cmp_mask1);
373+
374+ store_tran_low(qcoeff0, qcoeff_ptr + index);
375+ store_tran_low(qcoeff1, qcoeff_ptr + index + 8);
376+
377+ coeff0 = _mm_abs_epi16(qcoeff0);
378+ coeff1 = _mm_abs_epi16(qcoeff1);
379+
380+ coeff0 = _mm_mullo_epi16(coeff0, dequant);
381+ coeff1 = _mm_mullo_epi16(coeff1, dequant);
382+
383+ coeff0 = _mm_srli_epi16(coeff0, 1);
384+ coeff1 = _mm_srli_epi16(coeff1, 1);
385+
386+ coeff0 = _mm_sign_epi16(coeff0, qcoeff0);
387+ coeff1 = _mm_sign_epi16(coeff1, qcoeff1);
388+
389+ store_tran_low(coeff0, dqcoeff_ptr + index);
390+ store_tran_low(coeff1, dqcoeff_ptr + index + 8);
391+
392+ zero_coeff0 = _mm_cmpeq_epi16(coeff0, zero);
393+ zero_coeff1 = _mm_cmpeq_epi16(coeff1, zero);
394+ iscan0 = _mm_load_si128((const __m128i *)(iscan_ptr + index));
395+ iscan1 = _mm_load_si128((const __m128i *)(iscan_ptr + index + 8));
396+ iscan0 = _mm_sub_epi16(iscan0, cmp_mask0);
397+ iscan1 = _mm_sub_epi16(iscan1, cmp_mask1);
398+ eob0 = _mm_andnot_si128(zero_coeff0, iscan0);
399+ eob1 = _mm_andnot_si128(zero_coeff1, iscan1);
400+ eob0 = _mm_max_epi16(eob0, eob1);
401+ eob = _mm_max_epi16(eob, eob0);
402+ }
403+
404+ // Accumulate eob.
405+ {
406+ __m128i eob_shuffled;
407+ eob_shuffled = _mm_shuffle_epi32(eob, 0xe);
408+ eob = _mm_max_epi16(eob, eob_shuffled);
409+ eob_shuffled = _mm_shufflelo_epi16(eob, 0xe);
410+ eob = _mm_max_epi16(eob, eob_shuffled);
411+ eob_shuffled = _mm_shufflelo_epi16(eob, 0x1);
412+ eob = _mm_max_epi16(eob, eob_shuffled);
413+ *eob_ptr = _mm_extract_epi16(eob, 1);
414+ }
415+}
vpx_dsp/x86/quantize_avx_x86_64.asm+0−497
@@ -1,497 +0,0 @@
1−;
2−; Copyright (c) 2015 The WebM project authors. All Rights Reserved.
3−;
4−; Use of this source code is governed by a BSD-style license
5−; that can be found in the LICENSE file in the root of the source
6−; tree. An additional intellectual property rights grant can be found
7−; in the file PATENTS. All contributing project authors may
8−; be found in the AUTHORS file in the root of the source tree.
9−;
10−
11−%include "third_party/x86inc/x86inc.asm"
12−
13−SECTION .text
14−
15−%macro QUANTIZE_FN 2
16−cglobal quantize_%1, 0, %2, 15, coeff, ncoeff, skip, zbin, round, quant, \
17− shift, qcoeff, dqcoeff, dequant, \
18− eob, scan, iscan
19−
20− vzeroupper
21−
22−%ifnidn %1, b_32x32
23−
24− ; Special case for ncoeff == 16, as it is frequent and we can save on
25− ; not setting up a loop.
26− cmp ncoeffmp, 16
27− jne .generic
28−
29− ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
30− ;; Special case of ncoeff == 16
31− ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
32−
33−.single:
34−
35− movifnidn coeffq, coeffmp
36− movifnidn zbinq, zbinmp
37− mova m0, [zbinq] ; m0 = zbin
38−
39− ; Get DC and first 15 AC coeffs - in this special case, that is all.
40−%if CONFIG_VP9_HIGHBITDEPTH
41− ; coeff stored as 32bit numbers but we process them as 16 bit numbers
42− mova m9, [coeffq]
43− packssdw m9, [coeffq+16] ; m9 = c[i]
44− mova m10, [coeffq+32]
45− packssdw m10, [coeffq+48] ; m10 = c[i]
46−%else
47− mova m9, [coeffq] ; m9 = c[i]
48− mova m10, [coeffq+16] ; m10 = c[i]
49−%endif
50−
51− mov r0, eobmp ; Output pointer
52− mov r1, qcoeffmp ; Output pointer
53− mov r2, dqcoeffmp ; Output pointer
54−
55− pxor m5, m5 ; m5 = dedicated zero
56−
57− pcmpeqw m4, m4 ; All word lanes -1
58− paddw m0, m4 ; m0 = zbin - 1
59−
60− pabsw m6, m9 ; m6 = abs(m9)
61− pabsw m11, m10 ; m11 = abs(m10)
62− pcmpgtw m7, m6, m0 ; m7 = c[i] >= zbin
63− punpckhqdq m0, m0
64− pcmpgtw m12, m11, m0 ; m12 = c[i] >= zbin
65−
66− ; Check if all coeffs are less than zbin. If yes, we just write zeros
67− ; to the outputs and we are done.
68− por m14, m7, m12
69− ptest m14, m14
70− jnz .single_nonzero
71−
72−%if CONFIG_VP9_HIGHBITDEPTH
73− mova [r1 ], ymm5
74− mova [r1+32], ymm5
75− mova [r2 ], ymm5
76− mova [r2+32], ymm5
77−%else
78− mova [r1], ymm5
79− mova [r2], ymm5
80−%endif
81− mov [r0], word 0
82−
83− vzeroupper
84− RET
85−
86−.single_nonzero:
87−
88− ; Actual quantization of size 16 block - setup pointers, rounders, etc.
89− movifnidn r4, roundmp
90− movifnidn r5, quantmp
91− mov r3, dequantmp
92− mov r6, shiftmp
93− mova m1, [r4] ; m1 = round
94− mova m2, [r5] ; m2 = quant
95− mova m3, [r3] ; m3 = dequant
96− mova m4, [r6] ; m4 = shift
97−
98− mov r3, iscanmp
99−
100− DEFINE_ARGS eob, qcoeff, dqcoeff, iscan
101−
102− ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
103−
104− paddsw m6, m1 ; m6 += round
105− punpckhqdq m1, m1
106− paddsw m11, m1 ; m11 += round
107− pmulhw m8, m6, m2 ; m8 = m6*q>>16
108− punpckhqdq m2, m2
109− pmulhw m13, m11, m2 ; m13 = m11*q>>16
110− paddw m8, m6 ; m8 += m6
111− paddw m13, m11 ; m13 += m11
112− pmulhw m8, m4 ; m8 = m8*qsh>>16
113− punpckhqdq m4, m4
114− pmulhw m13, m4 ; m13 = m13*qsh>>16
115− psignw m8, m9 ; m8 = reinsert sign
116− psignw m13, m10 ; m13 = reinsert sign
117− pand m8, m7
118− pand m13, m12
119−
120−%if CONFIG_VP9_HIGHBITDEPTH
121− ; Store 16bit numbers as 32bit numbers in array pointed to by qcoeff
122− pcmpgtw m6, m5, m8
123− punpckhwd m6, m8, m6
124− pmovsxwd m11, m8
125− mova [qcoeffq ], m11
126− mova [qcoeffq+16], m6
127− pcmpgtw m6, m5, m13
128− punpckhwd m6, m13, m6
129− pmovsxwd m11, m13
130− mova [qcoeffq+32], m11
131− mova [qcoeffq+48], m6
132−%else
133− mova [qcoeffq ], m8
134− mova [qcoeffq+16], m13
135−%endif
136−
137− pmullw m8, m3 ; dqc[i] = qc[i] * q
138− punpckhqdq m3, m3
139− pmullw m13, m3 ; dqc[i] = qc[i] * q
140−
141−%if CONFIG_VP9_HIGHBITDEPTH
142− ; Store 16bit numbers as 32bit numbers in array pointed to by qcoeff
143− pcmpgtw m6, m5, m8
144− punpckhwd m6, m8, m6
145− pmovsxwd m11, m8
146− mova [dqcoeffq ], m11
147− mova [dqcoeffq+16], m6
148− pcmpgtw m6, m5, m13
149− punpckhwd m6, m13, m6
150− pmovsxwd m11, m13
151− mova [dqcoeffq+32], m11
152− mova [dqcoeffq+48], m6
153−%else
154− mova [dqcoeffq ], m8
155− mova [dqcoeffq+16], m13
156−%endif
157−
158− mova m6, [iscanq] ; m6 = scan[i]
159− mova m11, [iscanq+16] ; m11 = scan[i]
160−
161− pcmpeqw m8, m8, m5 ; m8 = c[i] == 0
162− pcmpeqw m13, m13, m5 ; m13 = c[i] == 0
163− psubw m6, m6, m7 ; m6 = scan[i] + 1
164− psubw m11, m11, m12 ; m11 = scan[i] + 1
165− pandn m8, m8, m6 ; m8 = max(eob)
166− pandn m13, m13, m11 ; m13 = max(eob)
167− pmaxsw m8, m8, m13
168−
169− ; Horizontally accumulate/max eobs and write into [eob] memory pointer
170− pshufd m7, m8, 0xe
171− pmaxsw m8, m7
172− pshuflw m7, m8, 0xe
173− pmaxsw m8, m7
174− pshuflw m7, m8, 0x1
175− pmaxsw m8, m7
176− movq rax, m8
177− mov [eobq], ax
178−
179− vzeroupper
180− RET
181−
182− ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
183− ;; Generic case of ncoeff != 16
184− ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
185−
186−.generic:
187−
188−%endif ; %ifnidn %1, b_32x32
189−
190−DEFINE_ARGS coeff, ncoeff, skip, zbin, round, quant, shift, \
191− qcoeff, dqcoeff, dequant, eob, scan, iscan
192−
193− ; Actual quantization loop - setup pointers, rounders, etc.
194− movifnidn coeffq, coeffmp
195− movifnidn ncoeffq, ncoeffmp
196− mov r2, dequantmp
197− movifnidn zbinq, zbinmp
198− movifnidn roundq, roundmp
199− movifnidn quantq, quantmp
200− mova m0, [zbinq] ; m0 = zbin
201− mova m1, [roundq] ; m1 = round
202− mova m2, [quantq] ; m2 = quant
203− mova m3, [r2] ; m3 = dequant
204− pcmpeqw m4, m4 ; All lanes -1
205−%ifidn %1, b_32x32
206− psubw m0, m4
207− psubw m1, m4
208− psrlw m0, 1 ; m0 = (m0 + 1) / 2
209− psrlw m1, 1 ; m1 = (m1 + 1) / 2
210−%endif
211− paddw m0, m4 ; m0 = m0 + 1
212−
213− mov r2, shiftmp
214− mov r3, qcoeffmp
215− mova m4, [r2] ; m4 = shift
216− mov r4, dqcoeffmp
217− mov r5, iscanmp
218−%ifidn %1, b_32x32
219− psllw m4, 1
220−%endif
221− pxor m5, m5 ; m5 = dedicated zero
222−
223− DEFINE_ARGS coeff, ncoeff, d1, qcoeff, dqcoeff, iscan, d2, d3, d4, d5, eob
224−
225−%if CONFIG_VP9_HIGHBITDEPTH
226− lea coeffq, [ coeffq+ncoeffq*4]
227− lea qcoeffq, [ qcoeffq+ncoeffq*4]
228− lea dqcoeffq, [dqcoeffq+ncoeffq*4]
229−%else
230− lea coeffq, [ coeffq+ncoeffq*2]
231− lea qcoeffq, [ qcoeffq+ncoeffq*2]
232− lea dqcoeffq, [dqcoeffq+ncoeffq*2]
233−%endif
234− lea iscanq, [ iscanq+ncoeffq*2]
235− neg ncoeffq
236−
237− ; get DC and first 15 AC coeffs
238−%if CONFIG_VP9_HIGHBITDEPTH
239− ; coeff stored as 32bit numbers & require 16bit numbers
240− mova m9, [coeffq+ncoeffq*4+ 0]
241− packssdw m9, [coeffq+ncoeffq*4+16]
242− mova m10, [coeffq+ncoeffq*4+32]
243− packssdw m10, [coeffq+ncoeffq*4+48]
244−%else
245− mova m9, [coeffq+ncoeffq*2+ 0] ; m9 = c[i]
246− mova m10, [coeffq+ncoeffq*2+16] ; m10 = c[i]
247−%endif
248−
249− pabsw m6, m9 ; m6 = abs(m9)
250− pabsw m11, m10 ; m11 = abs(m10)
251− pcmpgtw m7, m6, m0 ; m7 = c[i] >= zbin
252− punpckhqdq m0, m0
253− pcmpgtw m12, m11, m0 ; m12 = c[i] >= zbin
254−
255− ; Check if all coeffs are less than zbin. If yes, skip forward quickly.
256− por m14, m7, m12
257− ptest m14, m14
258− jnz .first_nonzero
259−
260−%if CONFIG_VP9_HIGHBITDEPTH
261− mova [qcoeffq+ncoeffq*4 ], ymm5
262− mova [qcoeffq+ncoeffq*4+32], ymm5
263− mova [dqcoeffq+ncoeffq*4 ], ymm5
264− mova [dqcoeffq+ncoeffq*4+32], ymm5
265−%else
266− mova [qcoeffq+ncoeffq*2], ymm5
267− mova [dqcoeffq+ncoeffq*2], ymm5
268−%endif
269−
270− add ncoeffq, mmsize
271−
272− punpckhqdq m1, m1
273− punpckhqdq m2, m2
274− punpckhqdq m3, m3
275− punpckhqdq m4, m4
276− pxor m8, m8
277−
278− jmp .ac_only_loop
279−
280−.first_nonzero:
281−
282− paddsw m6, m1 ; m6 += round
283− punpckhqdq m1, m1
284− paddsw m11, m1 ; m11 += round
285− pmulhw m8, m6, m2 ; m8 = m6*q>>16
286− punpckhqdq m2, m2
287− pmulhw m13, m11, m2 ; m13 = m11*q>>16
288− paddw m8, m6 ; m8 += m6
289− paddw m13, m11 ; m13 += m11
290− pmulhw m8, m4 ; m8 = m8*qsh>>16
291− punpckhqdq m4, m4
292− pmulhw m13, m4 ; m13 = m13*qsh>>16
293− psignw m8, m9 ; m8 = reinsert sign
294− psignw m13, m10 ; m13 = reinsert sign
295− pand m8, m7
296− pand m13, m12
297−
298−%if CONFIG_VP9_HIGHBITDEPTH
299− ; store 16bit numbers as 32bit numbers in array pointed to by qcoeff
300− pcmpgtw m6, m5, m8
301− punpckhwd m6, m8, m6
302− pmovsxwd m11, m8
303− mova [qcoeffq+ncoeffq*4+ 0], m11
304− mova [qcoeffq+ncoeffq*4+16], m6
305− pcmpgtw m6, m5, m13
306− punpckhwd m6, m13, m6
307− pmovsxwd m11, m13
308− mova [qcoeffq+ncoeffq*4+32], m11
309− mova [qcoeffq+ncoeffq*4+48], m6
310−%else
311− mova [qcoeffq+ncoeffq*2+ 0], m8
312− mova [qcoeffq+ncoeffq*2+16], m13
313−%endif
314−
315−%ifidn %1, b_32x32
316− pabsw m8, m8
317− pabsw m13, m13
318−%endif
319− pmullw m8, m3 ; dqc[i] = qc[i] * q
320− punpckhqdq m3, m3
321− pmullw m13, m3 ; dqc[i] = qc[i] * q
322−%ifidn %1, b_32x32
323− psrlw m8, 1
324− psrlw m13, 1
325− psignw m8, m9
326− psignw m13, m10
327−%endif
328−
329−%if CONFIG_VP9_HIGHBITDEPTH
330− ; store 16bit numbers as 32bit numbers in array pointed to by qcoeff
331− pcmpgtw m6, m5, m8
332− punpckhwd m6, m8, m6
333− pmovsxwd m11, m8
334− mova [dqcoeffq+ncoeffq*4+ 0], m11
335− mova [dqcoeffq+ncoeffq*4+16], m6
336− pcmpgtw m6, m5, m13
337− punpckhwd m6, m13, m6
338− pmovsxwd m11, m13
339− mova [dqcoeffq+ncoeffq*4+32], m11
340− mova [dqcoeffq+ncoeffq*4+48], m6
341−%else
342− mova [dqcoeffq+ncoeffq*2+ 0], m8
343− mova [dqcoeffq+ncoeffq*2+16], m13
344−%endif
345−
346− pcmpeqw m8, m5 ; m8 = c[i] == 0
347− pcmpeqw m13, m5 ; m13 = c[i] == 0
348− mova m6, [iscanq+ncoeffq*2] ; m6 = scan[i]
349− mova m11, [iscanq+ncoeffq*2+16] ; m11 = scan[i]
350− psubw m6, m7 ; m6 = scan[i] + 1
351− psubw m11, m12 ; m11 = scan[i] + 1
352− pandn m8, m6 ; m8 = max(eob)
353− pandn m13, m11 ; m13 = max(eob)
354− pmaxsw m8, m13
355− add ncoeffq, mmsize
356−
357−.ac_only_loop:
358−
359−%if CONFIG_VP9_HIGHBITDEPTH
360− ; pack coeff from 32bit to 16bit array
361− mova m9, [coeffq+ncoeffq*4+ 0]
362− packssdw m9, [coeffq+ncoeffq*4+16]
363− mova m10, [coeffq+ncoeffq*4+32]
364− packssdw m10, [coeffq+ncoeffq*4+48]
365−%else
366− mova m9, [coeffq+ncoeffq*2+ 0] ; m9 = c[i]
367− mova m10, [coeffq+ncoeffq*2+16] ; m10 = c[i]
368−%endif
369−
370− pabsw m6, m9 ; m6 = abs(m9)
371− pabsw m11, m10 ; m11 = abs(m10)
372− pcmpgtw m7, m6, m0 ; m7 = c[i] >= zbin
373− pcmpgtw m12, m11, m0 ; m12 = c[i] >= zbin
374−
375− ; Check if all coeffs are less than zbin. If yes, skip this itertion.
376− ; And just write zeros as the result would be.
377− por m14, m7, m12
378− ptest m14, m14
379− jnz .rest_nonzero
380−
381−%if CONFIG_VP9_HIGHBITDEPTH
382− mova [qcoeffq+ncoeffq*4+ 0], ymm5
383− mova [qcoeffq+ncoeffq*4+32], ymm5
384− mova [dqcoeffq+ncoeffq*4+ 0], ymm5
385− mova [dqcoeffq+ncoeffq*4+32], ymm5
386−%else
387− mova [qcoeffq+ncoeffq*2+ 0], ymm5
388− mova [dqcoeffq+ncoeffq*2+ 0], ymm5
389−%endif
390− add ncoeffq, mmsize
391− jnz .ac_only_loop
392−
393− ; Horizontally accumulate/max eobs and write into [eob] memory pointer
394− mov r2, eobmp
395− pshufd m7, m8, 0xe
396− pmaxsw m8, m7
397− pshuflw m7, m8, 0xe
398− pmaxsw m8, m7
399− pshuflw m7, m8, 0x1
400− pmaxsw m8, m7
401− movq rax, m8
402− mov [r2], ax
403− vzeroupper
404− RET
405−
406−.rest_nonzero:
407− paddsw m6, m1 ; m6 += round
408− paddsw m11, m1 ; m11 += round
409− pmulhw m14, m6, m2 ; m14 = m6*q>>16
410− pmulhw m13, m11, m2 ; m13 = m11*q>>16
411− paddw m14, m6 ; m14 += m6
412− paddw m13, m11 ; m13 += m11
413− pmulhw m14, m4 ; m14 = m14*qsh>>16
414− pmulhw m13, m4 ; m13 = m13*qsh>>16
415− psignw m14, m9 ; m14 = reinsert sign
416− psignw m13, m10 ; m13 = reinsert sign
417− pand m14, m7
418− pand m13, m12
419−
420−%if CONFIG_VP9_HIGHBITDEPTH
421− ; store 16bit numbers as 32bit numbers in array pointed to by qcoeff
422− pcmpgtw m6, m5, m14
423− punpckhwd m6, m14, m6
424− pmovsxwd m11, m14
425− mova [qcoeffq+ncoeffq*4+ 0], m11
426− mova [qcoeffq+ncoeffq*4+16], m6
427− pcmpgtw m6, m5, m13
428− punpckhwd m6, m13, m6
429− pmovsxwd m11, m13
430− mova [qcoeffq+ncoeffq*4+32], m11
431− mova [qcoeffq+ncoeffq*4+48], m6
432−%else
433− mova [qcoeffq+ncoeffq*2+ 0], m14
434− mova [qcoeffq+ncoeffq*2+16], m13
435−%endif
436−
437−%ifidn %1, b_32x32
438− pabsw m14, m14
439− pabsw m13, m13
440−%endif
441− pmullw m14, m3 ; dqc[i] = qc[i] * q
442− pmullw m13, m3 ; dqc[i] = qc[i] * q
443−%ifidn %1, b_32x32
444− psrlw m14, 1
445− psrlw m13, 1
446− psignw m14, m9
447− psignw m13, m10
448−%endif
449−
450−%if CONFIG_VP9_HIGHBITDEPTH
451− ; store 16bit numbers as 32bit numbers in array pointed to by qcoeff
452− pcmpgtw m6, m5, m14
453− punpckhwd m6, m14, m6
454− pmovsxwd m11, m14
455− mova [dqcoeffq+ncoeffq*4+ 0], m11
456− mova [dqcoeffq+ncoeffq*4+16], m6
457− pcmpgtw m6, m5, m13
458− punpckhwd m6, m13, m6
459− pmovsxwd m11, m13
460− mova [dqcoeffq+ncoeffq*4+32], m11
461− mova [dqcoeffq+ncoeffq*4+48], m6
462−%else
463− mova [dqcoeffq+ncoeffq*2+ 0], m14
464− mova [dqcoeffq+ncoeffq*2+16], m13
465−%endif
466−
467− pcmpeqw m14, m5 ; m14 = c[i] == 0
468− pcmpeqw m13, m5 ; m13 = c[i] == 0
469− mova m6, [iscanq+ncoeffq*2+ 0] ; m6 = scan[i]
470− mova m11, [iscanq+ncoeffq*2+16] ; m11 = scan[i]
471− psubw m6, m7 ; m6 = scan[i] + 1
472− psubw m11, m12 ; m11 = scan[i] + 1
473− pandn m14, m6 ; m14 = max(eob)
474− pandn m13, m11 ; m13 = max(eob)
475− pmaxsw m8, m14
476− pmaxsw m8, m13
477− add ncoeffq, mmsize
478− jnz .ac_only_loop
479−
480− ; Horizontally accumulate/max eobs and write into [eob] memory pointer
481− mov r2, eobmp
482− pshufd m7, m8, 0xe
483− pmaxsw m8, m7
484− pshuflw m7, m8, 0xe
485− pmaxsw m8, m7
486− pshuflw m7, m8, 0x1
487− pmaxsw m8, m7
488− movq rax, m8
489− mov [r2], ax
490− vzeroupper
491− RET
492−%endmacro
493−
494−INIT_XMM avx
495−QUANTIZE_FN b_32x32, 7
496−
497−END

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t