/* * Copyright (c) 2016 The WebM project authors. All Rights Reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree.
#include <arm_neon.h>
#include "./vpx_config.h"
#include "./vpx_dsp_rtcd.h"
#include "sum_neon.h"
#include "vpx/vpx_integer.h"
//------------------------------------------------------------------------------
// DC 4x4
static INLINE uint16_t dc_sum_4(
const uint16_t *ref) {
const uint16x4_t ref_u16 = vld1_u16(ref);
return horizontal_add_uint16x4(ref_u16);
}
static INLINE void dc_store_4x4(uint16_t *dst, ptrdiff_t stride,
const uint16x4_t dc) {
int i;
for (i =
0 ; i <
4 ; ++i, dst += stride) {
vst1_u16(dst, dc);
}
}
void vpx_highbd_dc_predictor_4x4_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x4_t a = vld1_u16(above);
const uint16x4_t l = vld1_u16(left);
const uint16_t sum = horizontal_add_uint16x4(vadd_u16(a, l));
const uint16x4_t dc = vrshr_n_u16(vdup_n_u16(sum),
3 );
(
void )bd;
dc_store_4x4(dst, stride, dc);
}
void vpx_highbd_dc_left_predictor_4x4_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16_t sum = dc_sum_4(left);
const uint16x4_t dc = vrshr_n_u16(vdup_n_u16(sum),
2 );
(
void )above;
(
void )bd;
dc_store_4x4(dst, stride, dc);
}
void vpx_highbd_dc_top_predictor_4x4_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16_t sum = dc_sum_4(above);
const uint16x4_t dc = vrshr_n_u16(vdup_n_u16(sum),
2 );
(
void )left;
(
void )bd;
dc_store_4x4(dst, stride, dc);
}
void vpx_highbd_dc_128_predictor_4x4_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x4_t dc = vdup_n_u16(
1 << (bd -
1 ));
(
void )above;
(
void )left;
dc_store_4x4(dst, stride, dc);
}
//------------------------------------------------------------------------------
// DC 8x8
static INLINE uint16_t dc_sum_8(
const uint16_t *ref) {
const uint16x8_t ref_u16 = vld1q_u16(ref);
return horizontal_add_uint16x8(ref_u16);
}
static INLINE void dc_store_8x8(uint16_t *dst, ptrdiff_t stride,
const uint16x8_t dc) {
int i;
for (i =
0 ; i <
8 ; ++i, dst += stride) {
vst1q_u16(dst, dc);
}
}
void vpx_highbd_dc_predictor_8x8_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t above_u16 = vld1q_u16(above);
const uint16x8_t left_u16 = vld1q_u16(left);
const uint16x8_t p0 = vaddq_u16(above_u16, left_u16);
const uint16_t sum = horizontal_add_uint16x8(p0);
const uint16x8_t dc = vrshrq_n_u16(vdupq_n_u16(sum),
4 );
(
void )bd;
dc_store_8x8(dst, stride, dc);
}
void vpx_highbd_dc_left_predictor_8x8_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16_t sum = dc_sum_8(left);
const uint16x8_t dc = vrshrq_n_u16(vdupq_n_u16(sum),
3 );
(
void )above;
(
void )bd;
dc_store_8x8(dst, stride, dc);
}
void vpx_highbd_dc_top_predictor_8x8_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16_t sum = dc_sum_8(above);
const uint16x8_t dc = vrshrq_n_u16(vdupq_n_u16(sum),
3 );
(
void )left;
(
void )bd;
dc_store_8x8(dst, stride, dc);
}
void vpx_highbd_dc_128_predictor_8x8_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t dc = vdupq_n_u16(
1 << (bd -
1 ));
(
void )above;
(
void )left;
dc_store_8x8(dst, stride, dc);
}
//------------------------------------------------------------------------------
// DC 16x16
static INLINE uint16_t dc_sum_16(
const uint16_t *ref) {
const uint16x8_t ref_u16_0 = vld1q_u16(ref +
0 );
const uint16x8_t ref_u16_1 = vld1q_u16(ref +
8 );
const uint16x8_t p0 = vaddq_u16(ref_u16_0, ref_u16_1);
return horizontal_add_uint16x8(p0);
}
static INLINE void dc_store_16x16(uint16_t *dst, ptrdiff_t stride,
const uint16x8_t dc) {
int i;
for (i =
0 ; i <
16 ; ++i, dst += stride) {
vst1q_u16(dst +
0 , dc);
vst1q_u16(dst +
8 , dc);
}
}
void vpx_highbd_dc_predictor_16x16_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t a0 = vld1q_u16(above +
0 );
const uint16x8_t a1 = vld1q_u16(above +
8 );
const uint16x8_t l0 = vld1q_u16(left +
0 );
const uint16x8_t l1 = vld1q_u16(left +
8 );
const uint16x8_t pa = vaddq_u16(a0, a1);
const uint16x8_t pl = vaddq_u16(l0, l1);
const uint16x8_t pal0 = vaddq_u16(pa, pl);
const uint32_t sum = horizontal_add_uint16x8(pal0);
const uint16x8_t dc = vdupq_lane_u16(vrshrn_n_u32(vdupq_n_u32(sum),
5 ),
0 );
(
void )bd;
dc_store_16x16(dst, stride, dc);
}
void vpx_highbd_dc_left_predictor_16x16_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16_t sum = dc_sum_16(left);
const uint16x8_t dc = vrshrq_n_u16(vdupq_n_u16(sum),
4 );
(
void )above;
(
void )bd;
dc_store_16x16(dst, stride, dc);
}
void vpx_highbd_dc_top_predictor_16x16_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16_t sum = dc_sum_16(above);
const uint16x8_t dc = vrshrq_n_u16(vdupq_n_u16(sum),
4 );
(
void )left;
(
void )bd;
dc_store_16x16(dst, stride, dc);
}
void vpx_highbd_dc_128_predictor_16x16_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t dc = vdupq_n_u16(
1 << (bd -
1 ));
(
void )above;
(
void )left;
dc_store_16x16(dst, stride, dc);
}
//------------------------------------------------------------------------------
// DC 32x32
static INLINE uint32_t dc_sum_32(
const uint16_t *ref) {
const uint16x8_t r0 = vld1q_u16(ref +
0 );
const uint16x8_t r1 = vld1q_u16(ref +
8 );
const uint16x8_t r2 = vld1q_u16(ref +
16 );
const uint16x8_t r3 = vld1q_u16(ref +
24 );
const uint16x8_t p0 = vaddq_u16(r0, r1);
const uint16x8_t p1 = vaddq_u16(r2, r3);
const uint16x8_t p2 = vaddq_u16(p0, p1);
return horizontal_add_uint16x8(p2);
}
static INLINE void dc_store_32x32(uint16_t *dst, ptrdiff_t stride,
const uint16x8_t dc) {
int i;
for (i =
0 ; i <
32 ; ++i) {
vst1q_u16(dst +
0 , dc);
vst1q_u16(dst +
8 , dc);
vst1q_u16(dst +
16 , dc);
vst1q_u16(dst +
24 , dc);
dst += stride;
}
}
void vpx_highbd_dc_predictor_32x32_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t a0 = vld1q_u16(above +
0 );
const uint16x8_t a1 = vld1q_u16(above +
8 );
const uint16x8_t a2 = vld1q_u16(above +
16 );
const uint16x8_t a3 = vld1q_u16(above +
24 );
const uint16x8_t l0 = vld1q_u16(left +
0 );
const uint16x8_t l1 = vld1q_u16(left +
8 );
const uint16x8_t l2 = vld1q_u16(left +
16 );
const uint16x8_t l3 = vld1q_u16(left +
24 );
const uint16x8_t pa0 = vaddq_u16(a0, a1);
const uint16x8_t pa1 = vaddq_u16(a2, a3);
const uint16x8_t pl0 = vaddq_u16(l0, l1);
const uint16x8_t pl1 = vaddq_u16(l2, l3);
const uint16x8_t pa = vaddq_u16(pa0, pa1);
const uint16x8_t pl = vaddq_u16(pl0, pl1);
const uint16x8_t pal0 = vaddq_u16(pa, pl);
const uint32_t sum = horizontal_add_uint16x8(pal0);
const uint16x8_t dc = vdupq_lane_u16(vrshrn_n_u32(vdupq_n_u32(sum),
6 ),
0 );
(
void )bd;
dc_store_32x32(dst, stride, dc);
}
void vpx_highbd_dc_left_predictor_32x32_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint32_t sum = dc_sum_32(left);
const uint16x8_t dc = vdupq_lane_u16(vrshrn_n_u32(vdupq_n_u32(sum),
5 ),
0 );
(
void )above;
(
void )bd;
dc_store_32x32(dst, stride, dc);
}
void vpx_highbd_dc_top_predictor_32x32_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint32_t sum = dc_sum_32(above);
const uint16x8_t dc = vdupq_lane_u16(vrshrn_n_u32(vdupq_n_u32(sum),
5 ),
0 );
(
void )left;
(
void )bd;
dc_store_32x32(dst, stride, dc);
}
void vpx_highbd_dc_128_predictor_32x32_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t dc = vdupq_n_u16(
1 << (bd -
1 ));
(
void )above;
(
void )left;
dc_store_32x32(dst, stride, dc);
}
// -----------------------------------------------------------------------------
void vpx_highbd_d45_predictor_4x4_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x8_t a0, a1, a2, d0;
uint16_t a7;
(
void )left;
(
void )bd;
a0 = vld1q_u16(above);
a7 = above[
7 ];
// [ above[1], ..., above[6], x, x ]
a1 = vextq_u16(a0, a0,
1 );
// [ above[2], ..., above[7], x, x ]
a2 = vextq_u16(a0, a0,
2 );
// d0[0] = AVG3(above[0], above[1], above[2]);
// ...
// d0[5] = AVG3(above[5], above[6], above[7]);
// d0[6] = x (don't care)
// d0[7] = x (don't care)
d0 = vrhaddq_u16(vhaddq_u16(a0, a2), a1);
// We want:
// stride=0 [ d0[0], d0[1], d0[2], d0[3] ]
// stride=1 [ d0[1], d0[2], d0[3], d0[4] ]
// stride=2 [ d0[2], d0[3], d0[4], d0[5] ]
// stride=2 [ d0[3], d0[4], d0[5], above[7] ]
vst1_u16(dst +
0 * stride, vget_low_u16(d0));
vst1_u16(dst +
1 * stride, vget_low_u16(vextq_u16(d0, d0,
1 )));
vst1_u16(dst +
2 * stride, vget_low_u16(vextq_u16(d0, d0,
2 )));
vst1_u16(dst +
3 * stride, vget_low_u16(vextq_u16(d0, d0,
3 )));
// We stored d0[6] above, so fixup into above[7].
dst[
3 * stride +
3 ] = a7;
}
void vpx_highbd_d45_predictor_8x8_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x8_t ax0, a0, a1, a7, d0;
(
void )left;
(
void )bd;
a0 = vld1q_u16(above +
0 );
a1 = vld1q_u16(above +
1 );
a7 = vld1q_dup_u16(above +
7 );
// We want to calculate the AVG3 result in lanes 1-7 inclusive so we can
// shift in above[7] later, so shift a0 across by one to get the right
// inputs:
// [ x, above[0], ... , above[6] ]
ax0 = vextq_u16(a0, a0,
7 );
// d0[0] = x (don't care)
// d0[1] = AVG3(above[0], above[1], above[2]);
// ...
// d0[7] = AVG3(above[6], above[7], above[8]);
d0 = vrhaddq_u16(vhaddq_u16(ax0, a1), a0);
// Undo the earlier ext, incrementally shift in duplicates of above[7].
vst1q_u16(dst +
0 * stride, vextq_u16(d0, a7,
1 ));
vst1q_u16(dst +
1 * stride, vextq_u16(d0, a7,
2 ));
vst1q_u16(dst +
2 * stride, vextq_u16(d0, a7,
3 ));
vst1q_u16(dst +
3 * stride, vextq_u16(d0, a7,
4 ));
vst1q_u16(dst +
4 * stride, vextq_u16(d0, a7,
5 ));
vst1q_u16(dst +
5 * stride, vextq_u16(d0, a7,
6 ));
vst1q_u16(dst +
6 * stride, vextq_u16(d0, a7,
7 ));
vst1q_u16(dst +
7 * stride, a7);
}
void vpx_highbd_d45_predictor_16x16_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x8_t ax0, a0, a1, a7, a8, a9, a15, d0[
2 ];
(
void )left;
(
void )bd;
a0 = vld1q_u16(above +
0 );
a1 = vld1q_u16(above +
1 );
a7 = vld1q_u16(above +
7 );
a8 = vld1q_u16(above +
8 );
a9 = vld1q_u16(above +
9 );
a15 = vld1q_dup_u16(above +
15 );
// [ x, above[0], ... , above[6] ]
ax0 = vextq_u16(a0, a0,
7 );
// We have one unused lane here to leave room to shift in above[15] in the
// last lane:
// d0[0][1] = x (don't care)
// d0[0][1] = AVG3(above[0], above[1], above[2]);
// ...
// d0[0][7] = AVG3(above[6], above[7], above[8]);
// d0[1][0] = AVG3(above[7], above[8], above[9]);
// ...
// d0[1][7] = AVG3(above[14], above[15], above[16]);
d0[
0 ] = vrhaddq_u16(vhaddq_u16(ax0, a1), a0);
d0[
1 ] = vrhaddq_u16(vhaddq_u16(a7, a9), a8);
// Incrementally shift in duplicates of above[15].
vst1q_u16(dst +
0 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
1 ));
vst1q_u16(dst +
0 * stride +
8 , vextq_u16(d0[
1 ], a15,
1 ));
vst1q_u16(dst +
1 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
2 ));
vst1q_u16(dst +
1 * stride +
8 , vextq_u16(d0[
1 ], a15,
2 ));
vst1q_u16(dst +
2 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
3 ));
vst1q_u16(dst +
2 * stride +
8 , vextq_u16(d0[
1 ], a15,
3 ));
vst1q_u16(dst +
3 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
4 ));
vst1q_u16(dst +
3 * stride +
8 , vextq_u16(d0[
1 ], a15,
4 ));
vst1q_u16(dst +
4 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
5 ));
vst1q_u16(dst +
4 * stride +
8 , vextq_u16(d0[
1 ], a15,
5 ));
vst1q_u16(dst +
5 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
6 ));
vst1q_u16(dst +
5 * stride +
8 , vextq_u16(d0[
1 ], a15,
6 ));
vst1q_u16(dst +
6 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
7 ));
vst1q_u16(dst +
6 * stride +
8 , vextq_u16(d0[
1 ], a15,
7 ));
vst1q_u16(dst +
7 * stride +
0 , d0[
1 ]);
vst1q_u16(dst +
7 * stride +
8 , a15);
vst1q_u16(dst +
8 * stride +
0 , vextq_u16(d0[
1 ], a15,
1 ));
vst1q_u16(dst +
8 * stride +
8 , a15);
vst1q_u16(dst +
9 * stride +
0 , vextq_u16(d0[
1 ], a15,
2 ));
vst1q_u16(dst +
9 * stride +
8 , a15);
vst1q_u16(dst +
10 * stride +
0 , vextq_u16(d0[
1 ], a15,
3 ));
vst1q_u16(dst +
10 * stride +
8 , a15);
vst1q_u16(dst +
11 * stride +
0 , vextq_u16(d0[
1 ], a15,
4 ));
vst1q_u16(dst +
11 * stride +
8 , a15);
vst1q_u16(dst +
12 * stride +
0 , vextq_u16(d0[
1 ], a15,
5 ));
vst1q_u16(dst +
12 * stride +
8 , a15);
vst1q_u16(dst +
13 * stride +
0 , vextq_u16(d0[
1 ], a15,
6 ));
vst1q_u16(dst +
13 * stride +
8 , a15);
vst1q_u16(dst +
14 * stride +
0 , vextq_u16(d0[
1 ], a15,
7 ));
vst1q_u16(dst +
14 * stride +
8 , a15);
vst1q_u16(dst +
15 * stride +
0 , a15);
vst1q_u16(dst +
15 * stride +
8 , a15);
}
void vpx_highbd_d45_predictor_32x32_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x8_t ax0, a0, a1, a7, a8, a9, a15, a16, a17, a23, a24, a25, a31, d0[
4 ];
int i;
(
void )left;
(
void )bd;
a0 = vld1q_u16(above +
0 );
a1 = vld1q_u16(above +
1 );
a7 = vld1q_u16(above +
7 );
a8 = vld1q_u16(above +
8 );
a9 = vld1q_u16(above +
9 );
a15 = vld1q_u16(above +
15 );
a16 = vld1q_u16(above +
16 );
a17 = vld1q_u16(above +
17 );
a23 = vld1q_u16(above +
23 );
a24 = vld1q_u16(above +
24 );
a25 = vld1q_u16(above +
25 );
a31 = vld1q_dup_u16(above +
31 );
// [ x, above[0], ... , above[6] ]
ax0 = vextq_u16(a0, a0,
7 );
d0[
0 ] = vrhaddq_u16(vhaddq_u16(ax0, a1), a0);
d0[
1 ] = vrhaddq_u16(vhaddq_u16(a7, a9), a8);
d0[
2 ] = vrhaddq_u16(vhaddq_u16(a15, a17), a16);
d0[
3 ] = vrhaddq_u16(vhaddq_u16(a23, a25), a24);
for (i =
0 ; i <
32 ; ++i) {
d0[
0 ] = vextq_u16(d0[
0 ], d0[
1 ],
1 );
d0[
1 ] = vextq_u16(d0[
1 ], d0[
2 ],
1 );
d0[
2 ] = vextq_u16(d0[
2 ], d0[
3 ],
1 );
d0[
3 ] = vextq_u16(d0[
3 ], a31,
1 );
vst1q_u16(dst +
0 , d0[
0 ]);
vst1q_u16(dst +
8 , d0[
1 ]);
vst1q_u16(dst +
16 , d0[
2 ]);
vst1q_u16(dst +
24 , d0[
3 ]);
dst += stride;
}
}
// -----------------------------------------------------------------------------
void vpx_highbd_d63_predictor_4x4_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x4_t a0, a1, a2, a3, d0, d1, d2, d3;
(
void )left;
(
void )bd;
a0 = vld1_u16(above +
0 );
a1 = vld1_u16(above +
1 );
a2 = vld1_u16(above +
2 );
a3 = vld1_u16(above +
3 );
d0 = vrhadd_u16(a0, a1);
d1 = vrhadd_u16(vhadd_u16(a0, a2), a1);
d2 = vrhadd_u16(a1, a2);
d3 = vrhadd_u16(vhadd_u16(a1, a3), a2);
// Note that here we are performing a full avg calculation for the final
// elements rather than storing a duplicate of above[3], which differs
// (correctly) from the general scheme employed by the bs={8,16,32}
// implementations in order to match the original C implementation.
vst1_u16(dst +
0 * stride, d0);
vst1_u16(dst +
1 * stride, d1);
vst1_u16(dst +
2 * stride, d2);
vst1_u16(dst +
3 * stride, d3);
}
void vpx_highbd_d63_predictor_8x8_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x8_t a0, a1, a2, a7, d0, d1, d0_ext, d1_ext;
(
void )left;
(
void )bd;
a0 = vld1q_u16(above +
0 );
a1 = vld1q_u16(above +
1 );
a2 = vld1q_u16(above +
2 );
a7 = vld1q_dup_u16(above +
7 );
d0 = vrhaddq_u16(a0, a1);
d1 = vrhaddq_u16(vhaddq_u16(a0, a2), a1);
// We want to store:
// stride=0 [ d0[0], d0[1], d0[2], d0[3], d0[4], d0[5], d0[6], d0[7] ]
// stride=1 [ d1[0], d1[1], d1[2], d1[3], d1[4], d1[5], d1[6], d1[7] ]
// stride=2 [ d0[1], d0[2], d0[3], d0[4], d0[5], d0[6], a[7], a[7] ]
// stride=3 [ d1[1], d1[2], d1[3], d1[4], d1[5], d1[6], a[7], a[7] ]
// stride=4 [ d0[2], d0[3], d0[4], d0[5], d0[6], a[7], a[7], a[7] ]
// stride=5 [ d1[2], d1[3], d1[4], d1[5], d1[6], a[7], a[7], a[7] ]
// stride=6 [ d0[3], d0[4], d0[5], d0[6], a[7], a[7], a[7], a[7] ]
// stride=7 [ d1[3], d1[4], d1[5], d1[6], a[7], a[7], a[7], a[7] ]
// Note in particular that d0[7] and d1[7] are only ever referenced in the
// stride=0 and stride=1 cases respectively, and in later strides are
// replaced by a copy of above[7]. These are equivalent if for i>7,
// above[i]==above[7], however that is not always the case.
// Strip out d0[7] and d1[7] so that we can replace it with an additional
// copy of above[7], the first vector here doesn't matter so just reuse
// d0/d1.
d0_ext = vextq_u16(d0, d0,
7 );
d1_ext = vextq_u16(d1, d1,
7 );
// Shuffle in duplicates of above[7] and store.
vst1q_u16(dst +
0 * stride, d0);
vst1q_u16(dst +
1 * stride, d1);
vst1q_u16(dst +
2 * stride, vextq_u16(d0_ext, a7,
2 ));
vst1q_u16(dst +
3 * stride, vextq_u16(d1_ext, a7,
2 ));
vst1q_u16(dst +
4 * stride, vextq_u16(d0_ext, a7,
3 ));
vst1q_u16(dst +
5 * stride, vextq_u16(d1_ext, a7,
3 ));
vst1q_u16(dst +
6 * stride, vextq_u16(d0_ext, a7,
4 ));
vst1q_u16(dst +
7 * stride, vextq_u16(d1_ext, a7,
4 ));
}
void vpx_highbd_d63_predictor_16x16_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
// See vpx_highbd_d63_predictor_8x8_neon for details on the implementation.
uint16x8_t a0, a1, a2, a8, a9, a10, a15, d0[
2 ], d1[
2 ], d0_ext, d1_ext;
(
void )left;
(
void )bd;
a0 = vld1q_u16(above +
0 );
a1 = vld1q_u16(above +
1 );
a2 = vld1q_u16(above +
2 );
a8 = vld1q_u16(above +
8 );
a9 = vld1q_u16(above +
9 );
a10 = vld1q_u16(above +
10 );
a15 = vld1q_dup_u16(above +
15 );
d0[
0 ] = vrhaddq_u16(a0, a1);
d0[
1 ] = vrhaddq_u16(a8, a9);
d1[
0 ] = vrhaddq_u16(vhaddq_u16(a0, a2), a1);
d1[
1 ] = vrhaddq_u16(vhaddq_u16(a8, a10), a9);
// Strip out the final element of d0/d1 so that we can replace it with an
// additional copy of above[7], the first vector here doesn't matter so just
// reuse the same vector.
d0_ext = vextq_u16(d0[
1 ], d0[
1 ],
7 );
d1_ext = vextq_u16(d1[
1 ], d1[
1 ],
7 );
// Shuffle in duplicates of above[7] and store. Note that cases involving
// {d0,d1}_ext require an extra shift to undo the shifting out of the final
// element from above.
vst1q_u16(dst +
0 * stride +
0 , d0[
0 ]);
vst1q_u16(dst +
0 * stride +
8 , d0[
1 ]);
vst1q_u16(dst +
1 * stride +
0 , d1[
0 ]);
vst1q_u16(dst +
1 * stride +
8 , d1[
1 ]);
vst1q_u16(dst +
2 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
1 ));
vst1q_u16(dst +
2 * stride +
8 , vextq_u16(d0_ext, a15,
2 ));
vst1q_u16(dst +
3 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
1 ));
vst1q_u16(dst +
3 * stride +
8 , vextq_u16(d1_ext, a15,
2 ));
vst1q_u16(dst +
4 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
2 ));
vst1q_u16(dst +
4 * stride +
8 , vextq_u16(d0_ext, a15,
3 ));
vst1q_u16(dst +
5 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
2 ));
vst1q_u16(dst +
5 * stride +
8 , vextq_u16(d1_ext, a15,
3 ));
vst1q_u16(dst +
6 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
3 ));
vst1q_u16(dst +
6 * stride +
8 , vextq_u16(d0_ext, a15,
4 ));
vst1q_u16(dst +
7 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
3 ));
vst1q_u16(dst +
7 * stride +
8 , vextq_u16(d1_ext, a15,
4 ));
vst1q_u16(dst +
8 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
4 ));
vst1q_u16(dst +
8 * stride +
8 , vextq_u16(d0_ext, a15,
5 ));
vst1q_u16(dst +
9 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
4 ));
vst1q_u16(dst +
9 * stride +
8 , vextq_u16(d1_ext, a15,
5 ));
vst1q_u16(dst +
10 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
5 ));
vst1q_u16(dst +
10 * stride +
8 , vextq_u16(d0_ext, a15,
6 ));
vst1q_u16(dst +
11 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
5 ));
vst1q_u16(dst +
11 * stride +
8 , vextq_u16(d1_ext, a15,
6 ));
vst1q_u16(dst +
12 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
6 ));
vst1q_u16(dst +
12 * stride +
8 , vextq_u16(d0_ext, a15,
7 ));
vst1q_u16(dst +
13 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
6 ));
vst1q_u16(dst +
13 * stride +
8 , vextq_u16(d1_ext, a15,
7 ));
vst1q_u16(dst +
14 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
7 ));
vst1q_u16(dst +
14 * stride +
8 , a15);
vst1q_u16(dst +
15 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
7 ));
vst1q_u16(dst +
15 * stride +
8 , a15);
}
void vpx_highbd_d63_predictor_32x32_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
// See vpx_highbd_d63_predictor_8x8_neon for details on the implementation.
uint16x8_t a0, a1, a2, a8, a9, a10, a16, a17, a18, a24, a25, a26, a31, d0[
4 ],
d1[
4 ], d0_ext, d1_ext;
(
void )left;
(
void )bd;
a0 = vld1q_u16(above +
0 );
a1 = vld1q_u16(above +
1 );
a2 = vld1q_u16(above +
2 );
a8 = vld1q_u16(above +
8 );
a9 = vld1q_u16(above +
9 );
a10 = vld1q_u16(above +
10 );
a16 = vld1q_u16(above +
16 );
a17 = vld1q_u16(above +
17 );
a18 = vld1q_u16(above +
18 );
a24 = vld1q_u16(above +
24 );
a25 = vld1q_u16(above +
25 );
a26 = vld1q_u16(above +
26 );
a31 = vld1q_dup_u16(above +
31 );
d0[
0 ] = vrhaddq_u16(a0, a1);
d0[
1 ] = vrhaddq_u16(a8, a9);
d0[
2 ] = vrhaddq_u16(a16, a17);
d0[
3 ] = vrhaddq_u16(a24, a25);
d1[
0 ] = vrhaddq_u16(vhaddq_u16(a0, a2), a1);
d1[
1 ] = vrhaddq_u16(vhaddq_u16(a8, a10), a9);
d1[
2 ] = vrhaddq_u16(vhaddq_u16(a16, a18), a17);
d1[
3 ] = vrhaddq_u16(vhaddq_u16(a24, a26), a25);
// Strip out the final element of d0/d1 so that we can replace it with an
// additional copy of above[7], the first vector here doesn't matter so just
// reuse the same vector.
d0_ext = vextq_u16(d0[
3 ], d0[
3 ],
7 );
d1_ext = vextq_u16(d1[
3 ], d1[
3 ],
7 );
// Shuffle in duplicates of above[7] and store. Note that cases involving
// {d0,d1}_ext require an extra shift to undo the shifting out of the final
// element from above.
vst1q_u16(dst +
0 * stride +
0 , d0[
0 ]);
vst1q_u16(dst +
0 * stride +
8 , d0[
1 ]);
vst1q_u16(dst +
0 * stride +
16 , d0[
2 ]);
vst1q_u16(dst +
0 * stride +
24 , d0[
3 ]);
vst1q_u16(dst +
1 * stride +
0 , d1[
0 ]);
vst1q_u16(dst +
1 * stride +
8 , d1[
1 ]);
vst1q_u16(dst +
1 * stride +
16 , d1[
2 ]);
vst1q_u16(dst +
1 * stride +
24 , d1[
3 ]);
vst1q_u16(dst +
2 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
1 ));
vst1q_u16(dst +
2 * stride +
8 , vextq_u16(d0[
1 ], d0[
2 ],
1 ));
vst1q_u16(dst +
2 * stride +
16 , vextq_u16(d0[
2 ], d0[
3 ],
1 ));
vst1q_u16(dst +
2 * stride +
24 , vextq_u16(d0_ext, a31,
2 ));
vst1q_u16(dst +
3 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
1 ));
vst1q_u16(dst +
3 * stride +
8 , vextq_u16(d1[
1 ], d1[
2 ],
1 ));
vst1q_u16(dst +
3 * stride +
16 , vextq_u16(d1[
2 ], d1[
3 ],
1 ));
vst1q_u16(dst +
3 * stride +
24 , vextq_u16(d1_ext, a31,
2 ));
vst1q_u16(dst +
4 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
2 ));
vst1q_u16(dst +
4 * stride +
8 , vextq_u16(d0[
1 ], d0[
2 ],
2 ));
vst1q_u16(dst +
4 * stride +
16 , vextq_u16(d0[
2 ], d0[
3 ],
2 ));
vst1q_u16(dst +
4 * stride +
24 , vextq_u16(d0_ext, a31,
3 ));
vst1q_u16(dst +
5 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
2 ));
vst1q_u16(dst +
5 * stride +
8 , vextq_u16(d1[
1 ], d1[
2 ],
2 ));
vst1q_u16(dst +
5 * stride +
16 , vextq_u16(d1[
2 ], d1[
3 ],
2 ));
vst1q_u16(dst +
5 * stride +
24 , vextq_u16(d1_ext, a31,
3 ));
vst1q_u16(dst +
6 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
3 ));
vst1q_u16(dst +
6 * stride +
8 , vextq_u16(d0[
1 ], d0[
2 ],
3 ));
vst1q_u16(dst +
6 * stride +
16 , vextq_u16(d0[
2 ], d0[
3 ],
3 ));
vst1q_u16(dst +
6 * stride +
24 , vextq_u16(d0_ext, a31,
4 ));
vst1q_u16(dst +
7 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
3 ));
vst1q_u16(dst +
7 * stride +
8 , vextq_u16(d1[
1 ], d1[
2 ],
3 ));
vst1q_u16(dst +
7 * stride +
16 , vextq_u16(d1[
2 ], d1[
3 ],
3 ));
vst1q_u16(dst +
7 * stride +
24 , vextq_u16(d1_ext, a31,
4 ));
vst1q_u16(dst +
8 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
4 ));
vst1q_u16(dst +
8 * stride +
8 , vextq_u16(d0[
1 ], d0[
2 ],
4 ));
vst1q_u16(dst +
8 * stride +
16 , vextq_u16(d0[
2 ], d0[
3 ],
4 ));
vst1q_u16(dst +
8 * stride +
24 , vextq_u16(d0_ext, a31,
5 ));
vst1q_u16(dst +
9 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
4 ));
vst1q_u16(dst +
9 * stride +
8 , vextq_u16(d1[
1 ], d1[
2 ],
4 ));
vst1q_u16(dst +
9 * stride +
16 , vextq_u16(d1[
2 ], d1[
3 ],
4 ));
vst1q_u16(dst +
9 * stride +
24 , vextq_u16(d1_ext, a31,
5 ));
vst1q_u16(dst +
10 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
5 ));
vst1q_u16(dst +
10 * stride +
8 , vextq_u16(d0[
1 ], d0[
2 ],
5 ));
vst1q_u16(dst +
10 * stride +
16 , vextq_u16(d0[
2 ], d0[
3 ],
5 ));
vst1q_u16(dst +
10 * stride +
24 , vextq_u16(d0_ext, a31,
6 ));
vst1q_u16(dst +
11 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
5 ));
vst1q_u16(dst +
11 * stride +
8 , vextq_u16(d1[
1 ], d1[
2 ],
5 ));
vst1q_u16(dst +
11 * stride +
16 , vextq_u16(d1[
2 ], d1[
3 ],
5 ));
vst1q_u16(dst +
11 * stride +
24 , vextq_u16(d1_ext, a31,
6 ));
vst1q_u16(dst +
12 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
6 ));
vst1q_u16(dst +
12 * stride +
8 , vextq_u16(d0[
1 ], d0[
2 ],
6 ));
vst1q_u16(dst +
12 * stride +
16 , vextq_u16(d0[
2 ], d0[
3 ],
6 ));
vst1q_u16(dst +
12 * stride +
24 , vextq_u16(d0_ext, a31,
7 ));
vst1q_u16(dst +
13 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
6 ));
vst1q_u16(dst +
13 * stride +
8 , vextq_u16(d1[
1 ], d1[
2 ],
6 ));
vst1q_u16(dst +
13 * stride +
16 , vextq_u16(d1[
2 ], d1[
3 ],
6 ));
vst1q_u16(dst +
13 * stride +
24 , vextq_u16(d1_ext, a31,
7 ));
vst1q_u16(dst +
14 * stride +
0 , vextq_u16(d0[
0 ], d0[
1 ],
7 ));
vst1q_u16(dst +
14 * stride +
8 , vextq_u16(d0[
1 ], d0[
2 ],
7 ));
vst1q_u16(dst +
14 * stride +
16 , vextq_u16(d0[
2 ], d0[
3 ],
7 ));
vst1q_u16(dst +
14 * stride +
24 , a31);
vst1q_u16(dst +
15 * stride +
0 , vextq_u16(d1[
0 ], d1[
1 ],
7 ));
vst1q_u16(dst +
15 * stride +
8 , vextq_u16(d1[
1 ], d1[
2 ],
7 ));
vst1q_u16(dst +
15 * stride +
16 , vextq_u16(d1[
2 ], d1[
3 ],
7 ));
vst1q_u16(dst +
15 * stride +
24 , a31);
vst1q_u16(dst +
16 * stride +
0 , d0[
1 ]);
vst1q_u16(dst +
16 * stride +
8 , d0[
2 ]);
vst1q_u16(dst +
16 * stride +
16 , vextq_u16(d0_ext, a31,
1 ));
vst1q_u16(dst +
16 * stride +
24 , a31);
vst1q_u16(dst +
17 * stride +
0 , d1[
1 ]);
vst1q_u16(dst +
17 * stride +
8 , d1[
2 ]);
vst1q_u16(dst +
17 * stride +
16 , vextq_u16(d1_ext, a31,
1 ));
vst1q_u16(dst +
17 * stride +
24 , a31);
vst1q_u16(dst +
18 * stride +
0 , vextq_u16(d0[
1 ], d0[
2 ],
1 ));
vst1q_u16(dst +
18 * stride +
8 , vextq_u16(d0[
2 ], d0[
3 ],
1 ));
vst1q_u16(dst +
18 * stride +
16 , vextq_u16(d0_ext, a31,
2 ));
vst1q_u16(dst +
18 * stride +
24 , a31);
vst1q_u16(dst +
19 * stride +
0 , vextq_u16(d1[
1 ], d1[
2 ],
1 ));
vst1q_u16(dst +
19 * stride +
8 , vextq_u16(d1[
2 ], d1[
3 ],
1 ));
vst1q_u16(dst +
19 * stride +
16 , vextq_u16(d1_ext, a31,
2 ));
vst1q_u16(dst +
19 * stride +
24 , a31);
vst1q_u16(dst +
20 * stride +
0 , vextq_u16(d0[
1 ], d0[
2 ],
2 ));
vst1q_u16(dst +
20 * stride +
8 , vextq_u16(d0[
2 ], d0[
3 ],
2 ));
vst1q_u16(dst +
20 * stride +
16 , vextq_u16(d0_ext, a31,
3 ));
vst1q_u16(dst +
20 * stride +
24 , a31);
vst1q_u16(dst +
21 * stride +
0 , vextq_u16(d1[
1 ], d1[
2 ],
2 ));
vst1q_u16(dst +
21 * stride +
8 , vextq_u16(d1[
2 ], d1[
3 ],
2 ));
vst1q_u16(dst +
21 * stride +
16 , vextq_u16(d1_ext, a31,
3 ));
vst1q_u16(dst +
21 * stride +
24 , a31);
vst1q_u16(dst +
22 * stride +
0 , vextq_u16(d0[
1 ], d0[
2 ],
3 ));
vst1q_u16(dst +
22 * stride +
8 , vextq_u16(d0[
2 ], d0[
3 ],
3 ));
vst1q_u16(dst +
22 * stride +
16 , vextq_u16(d0_ext, a31,
4 ));
vst1q_u16(dst +
22 * stride +
24 , a31);
vst1q_u16(dst +
23 * stride +
0 , vextq_u16(d1[
1 ], d1[
2 ],
3 ));
vst1q_u16(dst +
23 * stride +
8 , vextq_u16(d1[
2 ], d1[
3 ],
3 ));
vst1q_u16(dst +
23 * stride +
16 , vextq_u16(d1_ext, a31,
4 ));
vst1q_u16(dst +
23 * stride +
24 , a31);
vst1q_u16(dst +
24 * stride +
0 , vextq_u16(d0[
1 ], d0[
2 ],
4 ));
vst1q_u16(dst +
24 * stride +
8 , vextq_u16(d0[
2 ], d0[
3 ],
4 ));
vst1q_u16(dst +
24 * stride +
16 , vextq_u16(d0_ext, a31,
5 ));
vst1q_u16(dst +
24 * stride +
24 , a31);
vst1q_u16(dst +
25 * stride +
0 , vextq_u16(d1[
1 ], d1[
2 ],
4 ));
vst1q_u16(dst +
25 * stride +
8 , vextq_u16(d1[
2 ], d1[
3 ],
4 ));
vst1q_u16(dst +
25 * stride +
16 , vextq_u16(d1_ext, a31,
5 ));
vst1q_u16(dst +
25 * stride +
24 , a31);
vst1q_u16(dst +
26 * stride +
0 , vextq_u16(d0[
1 ], d0[
2 ],
5 ));
vst1q_u16(dst +
26 * stride +
8 , vextq_u16(d0[
2 ], d0[
3 ],
5 ));
vst1q_u16(dst +
26 * stride +
16 , vextq_u16(d0_ext, a31,
6 ));
vst1q_u16(dst +
26 * stride +
24 , a31);
vst1q_u16(dst +
27 * stride +
0 , vextq_u16(d1[
1 ], d1[
2 ],
5 ));
vst1q_u16(dst +
27 * stride +
8 , vextq_u16(d1[
2 ], d1[
3 ],
5 ));
vst1q_u16(dst +
27 * stride +
16 , vextq_u16(d1_ext, a31,
6 ));
vst1q_u16(dst +
27 * stride +
24 , a31);
vst1q_u16(dst +
28 * stride +
0 , vextq_u16(d0[
1 ], d0[
2 ],
6 ));
vst1q_u16(dst +
28 * stride +
8 , vextq_u16(d0[
2 ], d0[
3 ],
6 ));
vst1q_u16(dst +
28 * stride +
16 , vextq_u16(d0_ext, a31,
7 ));
vst1q_u16(dst +
28 * stride +
24 , a31);
vst1q_u16(dst +
29 * stride +
0 , vextq_u16(d1[
1 ], d1[
2 ],
6 ));
vst1q_u16(dst +
29 * stride +
8 , vextq_u16(d1[
2 ], d1[
3 ],
6 ));
vst1q_u16(dst +
29 * stride +
16 , vextq_u16(d1_ext, a31,
7 ));
vst1q_u16(dst +
29 * stride +
24 , a31);
vst1q_u16(dst +
30 * stride +
0 , vextq_u16(d0[
1 ], d0[
2 ],
7 ));
vst1q_u16(dst +
30 * stride +
8 , vextq_u16(d0[
2 ], d0[
3 ],
7 ));
vst1q_u16(dst +
30 * stride +
16 , a31);
vst1q_u16(dst +
30 * stride +
24 , a31);
vst1q_u16(dst +
31 * stride +
0 , vextq_u16(d1[
1 ], d1[
2 ],
7 ));
vst1q_u16(dst +
31 * stride +
8 , vextq_u16(d1[
2 ], d1[
3 ],
7 ));
vst1q_u16(dst +
31 * stride +
16 , a31);
vst1q_u16(dst +
31 * stride +
24 , a31);
}
// -----------------------------------------------------------------------------
void vpx_highbd_d117_predictor_4x4_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x4_t az, a0, l0az, l0, l1, azl0, col0, col0_even, col0_odd, d0, d1;
(
void )bd;
az = vld1_u16(above -
1 );
a0 = vld1_u16(above +
0 );
// [ left[0], above[-1], above[0], above[1] ]
l0az = vext_u16(vld1_dup_u16(left), az,
3 );
l0 = vld1_u16(left +
0 );
// The last lane here is unused, reading left[4] could cause a buffer
// over-read, so just fill with a duplicate of left[0] to avoid needing to
// materialize a zero:
// [ left[1], left[2], left[3], x ]
l1 = vext_u16(l0, l0,
1 );
// [ above[-1], left[0], left[1], left[2] ]
azl0 = vext_u16(vld1_dup_u16(above -
1 ), l0,
3 );
d0 = vrhadd_u16(az, a0);
d1 = vrhadd_u16(vhadd_u16(l0az, a0), az);
col0 = vrhadd_u16(vhadd_u16(azl0, l1), l0);
col0_even = vdup_lane_u16(col0,
0 );
col0_odd = vdup_lane_u16(col0,
1 );
vst1_u16(dst +
0 * stride, d0);
vst1_u16(dst +
1 * stride, d1);
vst1_u16(dst +
2 * stride, vext_u16(col0_even, d0,
3 ));
vst1_u16(dst +
3 * stride, vext_u16(col0_odd, d1,
3 ));
}
void vpx_highbd_d117_predictor_8x8_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x8_t az, a0, l0az, l0, l1, azl0, col0, col0_even, col0_odd, d0, d1;
(
void )bd;
az = vld1q_u16(above -
1 );
a0 = vld1q_u16(above +
0 );
// [ left[0], above[-1], ..., left[5] ]
l0az = vextq_u16(vld1q_dup_u16(left), az,
7 );
l0 = vld1q_u16(left +
0 );
// The last lane here is unused, reading left[8] could cause a buffer
// over-read, so just fill with a duplicate of left[0] to avoid needing to
// materialize a zero:
// [ left[1], ... , left[7], x ]
l1 = vextq_u16(l0, l0,
1 );
// [ above[-1], left[0], ..., left[6] ]
azl0 = vextq_u16(vld1q_dup_u16(above -
1 ), l0,
7 );
// d0[0] = AVG2(above[-1], above[0])
// ...
// d0[7] = AVG2(above[6], above[7])
d0 = vrhaddq_u16(az, a0);
// d1[0] = AVG3(left[0], above[-1], above[0])
// d1[1] = AVG3(above[-1], above[0], above[1])
// ...
// d1[7] = AVG3(above[5], above[6], above[7])
d1 = vrhaddq_u16(vhaddq_u16(l0az, a0), az);
// The ext instruction shifts elements in from the end of the vector rather
// than the start, so reverse the vector to put the elements to be shifted in
// at the end:
// col0[7] = AVG3(above[-1], left[0], left[1])
// col0[6] = AVG3(left[0], left[1], left[2])
// ...
// col0[0] = AVG3(left[6], left[7], left[8])
col0 = vrhaddq_u16(vhaddq_u16(azl0, l1), l0);
col0 = vrev64q_u16(vextq_u16(col0, col0,
4 ));
// We don't care about the first parameter to this uzp since we only ever use
// the high three elements, we just use col0 again since it is already
// available:
// col0_even = [ x, x, x, x, x, col0[3], col0[5], col0[7] ]
// col0_odd = [ x, x, x, x, x, col0[2], col0[4], col0[6] ]
col0_even = vuzpq_u16(col0, col0).val[
1 ];
col0_odd = vuzpq_u16(col0, col0).val[
0 ];
// Incrementally shift more elements from col0 into d0/1:
// stride=0 [ d0[0], d0[1], d0[2], d0[3], d0[4], d0[5], d0[6], d0[7] ]
// stride=1 [ d1[0], d1[1], d1[2], d1[3], d1[4], d1[5], d1[6], d1[7] ]
// stride=2 [ col0[7], d0[0], d0[1], d0[2], d0[3], d0[4], d0[5], d0[6] ]
// stride=3 [ col0[6], d1[0], d1[1], d1[2], d1[3], d1[4], d1[5], d1[6] ]
// stride=4 [ col0[5], col0[7], d0[0], d0[1], d0[2], d0[3], d0[4], d0[5] ]
// stride=5 [ col0[4], col0[6], d1[0], d1[1], d1[2], d1[3], d1[4], d1[5] ]
// stride=6 [ col0[3], col0[5], col0[7], d0[0], d0[1], d0[2], d0[3], d0[4] ]
// stride=7 [ col0[2], col0[4], col0[6], d1[0], d1[1], d1[2], d1[3], d1[4] ]
vst1q_u16(dst +
0 * stride, d0);
vst1q_u16(dst +
1 * stride, d1);
vst1q_u16(dst +
2 * stride, vextq_u16(col0_even, d0,
7 ));
vst1q_u16(dst +
3 * stride, vextq_u16(col0_odd, d1,
7 ));
vst1q_u16(dst +
4 * stride, vextq_u16(col0_even, d0,
6 ));
vst1q_u16(dst +
5 * stride, vextq_u16(col0_odd, d1,
6 ));
vst1q_u16(dst +
6 * stride, vextq_u16(col0_even, d0,
5 ));
vst1q_u16(dst +
7 * stride, vextq_u16(col0_odd, d1,
5 ));
}
void vpx_highbd_d117_predictor_16x16_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x8_t az, a0, a6, a7, a8, l0az, l0, l1, l7, l8, l9, azl0, col0_lo,
col0_hi, col0_even, col0_odd, d0_lo, d0_hi, d1_lo, d1_hi;
(
void )bd;
az = vld1q_u16(above -
1 );
a0 = vld1q_u16(above +
0 );
a6 = vld1q_u16(above +
6 );
a7 = vld1q_u16(above +
7 );
a8 = vld1q_u16(above +
8 );
// [ left[0], above[-1], ..., left[5] ]
l0az = vextq_u16(vld1q_dup_u16(left), az,
7 );
l0 = vld1q_u16(left +
0 );
l1 = vld1q_u16(left +
1 );
l7 = vld1q_u16(left +
7 );
l8 = vld1q_u16(left +
8 );
// The last lane here is unused, reading left[16] could cause a buffer
// over-read, so just fill with a duplicate of left[8] to avoid needing to
// materialize a zero:
// [ left[9], ... , left[15], x ]
l9 = vextq_u16(l8, l8,
1 );
// [ above[-1], left[0], ..., left[6] ]
azl0 = vextq_u16(vld1q_dup_u16(above -
1 ), l0,
7 );
d0_lo = vrhaddq_u16(az, a0);
d0_hi = vrhaddq_u16(a7, a8);
d1_lo = vrhaddq_u16(vhaddq_u16(l0az, a0), az);
d1_hi = vrhaddq_u16(vhaddq_u16(a6, a8), a7);
col0_lo = vrhaddq_u16(vhaddq_u16(azl0, l1), l0);
col0_hi = vrhaddq_u16(vhaddq_u16(l7, l9), l8);
// Reverse within each vector, then swap the array indices in the uzp to
// complete the reversal across all 16 elements.
col0_lo = vrev64q_u16(vextq_u16(col0_lo, col0_lo,
4 ));
col0_hi = vrev64q_u16(vextq_u16(col0_hi, col0_hi,
4 ));
col0_even = vuzpq_u16(col0_hi, col0_lo).val[
1 ];
col0_odd = vuzpq_u16(col0_hi, col0_lo).val[
0 ];
vst1q_u16(dst +
0 * stride +
0 , d0_lo);
vst1q_u16(dst +
0 * stride +
8 , d0_hi);
vst1q_u16(dst +
1 * stride +
0 , d1_lo);
vst1q_u16(dst +
1 * stride +
8 , d1_hi);
vst1q_u16(dst +
2 * stride +
0 , vextq_u16(col0_even, d0_lo,
7 ));
vst1q_u16(dst +
2 * stride +
8 , vextq_u16(d0_lo, d0_hi,
7 ));
vst1q_u16(dst +
3 * stride +
0 , vextq_u16(col0_odd, d1_lo,
7 ));
vst1q_u16(dst +
3 * stride +
8 , vextq_u16(d1_lo, d1_hi,
7 ));
vst1q_u16(dst +
4 * stride +
0 , vextq_u16(col0_even, d0_lo,
6 ));
vst1q_u16(dst +
4 * stride +
8 , vextq_u16(d0_lo, d0_hi,
6 ));
vst1q_u16(dst +
5 * stride +
0 , vextq_u16(col0_odd, d1_lo,
6 ));
vst1q_u16(dst +
5 * stride +
8 , vextq_u16(d1_lo, d1_hi,
6 ));
vst1q_u16(dst +
6 * stride +
0 , vextq_u16(col0_even, d0_lo,
5 ));
vst1q_u16(dst +
6 * stride +
8 , vextq_u16(d0_lo, d0_hi,
5 ));
vst1q_u16(dst +
7 * stride +
0 , vextq_u16(col0_odd, d1_lo,
5 ));
vst1q_u16(dst +
7 * stride +
8 , vextq_u16(d1_lo, d1_hi,
5 ));
vst1q_u16(dst +
8 * stride +
0 , vextq_u16(col0_even, d0_lo,
4 ));
vst1q_u16(dst +
8 * stride +
8 , vextq_u16(d0_lo, d0_hi,
4 ));
vst1q_u16(dst +
9 * stride +
0 , vextq_u16(col0_odd, d1_lo,
4 ));
vst1q_u16(dst +
9 * stride +
8 , vextq_u16(d1_lo, d1_hi,
4 ));
vst1q_u16(dst +
10 * stride +
0 , vextq_u16(col0_even, d0_lo,
3 ));
vst1q_u16(dst +
10 * stride +
8 , vextq_u16(d0_lo, d0_hi,
3 ));
vst1q_u16(dst +
11 * stride +
0 , vextq_u16(col0_odd, d1_lo,
3 ));
vst1q_u16(dst +
11 * stride +
8 , vextq_u16(d1_lo, d1_hi,
3 ));
vst1q_u16(dst +
12 * stride +
0 , vextq_u16(col0_even, d0_lo,
2 ));
vst1q_u16(dst +
12 * stride +
8 , vextq_u16(d0_lo, d0_hi,
2 ));
vst1q_u16(dst +
13 * stride +
0 , vextq_u16(col0_odd, d1_lo,
2 ));
vst1q_u16(dst +
13 * stride +
8 , vextq_u16(d1_lo, d1_hi,
2 ));
vst1q_u16(dst +
14 * stride +
0 , vextq_u16(col0_even, d0_lo,
1 ));
vst1q_u16(dst +
14 * stride +
8 , vextq_u16(d0_lo, d0_hi,
1 ));
vst1q_u16(dst +
15 * stride +
0 , vextq_u16(col0_odd, d1_lo,
1 ));
vst1q_u16(dst +
15 * stride +
8 , vextq_u16(d1_lo, d1_hi,
1 ));
}
void vpx_highbd_d117_predictor_32x32_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x8_t az, a0, a6, a7, a8, a14, a15, a16, a22, a23, a24, l0az, l0, l1, l7,
l8, l9, l15, l16, l17, l23, l24, l25, azl0, d0[
4 ], d1[
4 ], col0[
4 ],
col0_even[
2 ], col0_odd[
2 ];
(
void )bd;
az = vld1q_u16(above -
1 );
a0 = vld1q_u16(above +
0 );
a6 = vld1q_u16(above +
6 );
a7 = vld1q_u16(above +
7 );
a8 = vld1q_u16(above +
8 );
a14 = vld1q_u16(above +
14 );
a15 = vld1q_u16(above +
15 );
a16 = vld1q_u16(above +
16 );
a22 = vld1q_u16(above +
22 );
a23 = vld1q_u16(above +
23 );
a24 = vld1q_u16(above +
24 );
// [ left[0], above[-1], ..., left[5] ]
l0az = vextq_u16(vld1q_dup_u16(left), az,
7 );
l0 = vld1q_u16(left +
0 );
l1 = vld1q_u16(left +
1 );
l7 = vld1q_u16(left +
7 );
l8 = vld1q_u16(left +
8 );
l9 = vld1q_u16(left +
9 );
l15 = vld1q_u16(left +
15 );
l16 = vld1q_u16(left +
16 );
l17 = vld1q_u16(left +
17 );
l23 = vld1q_u16(left +
23 );
l24 = vld1q_u16(left +
24 );
l25 = vld1q_u16(left +
25 );
// The last lane here is unused, reading left[32] could cause a buffer
// over-read, so just fill with a duplicate of left[24] to avoid needing to
// materialize a zero:
// [ left[25], ... , left[31], x ]
l25 = vextq_u16(l24, l24,
1 );
// [ above[-1], left[0], ..., left[6] ]
azl0 = vextq_u16(vld1q_dup_u16(above -
1 ), l0,
7 );
d0[
0 ] = vrhaddq_u16(az, a0);
d0[
1 ] = vrhaddq_u16(a7, a8);
d0[
2 ] = vrhaddq_u16(a15, a16);
d0[
3 ] = vrhaddq_u16(a23, a24);
d1[
0 ] = vrhaddq_u16(vhaddq_u16(l0az, a0), az);
d1[
1 ] = vrhaddq_u16(vhaddq_u16(a6, a8), a7);
d1[
2 ] = vrhaddq_u16(vhaddq_u16(a14, a16), a15);
d1[
3 ] = vrhaddq_u16(vhaddq_u16(a22, a24), a23);
col0[
0 ] = vrhaddq_u16(vhaddq_u16(azl0, l1), l0);
col0[
1 ] = vrhaddq_u16(vhaddq_u16(l7, l9), l8);
col0[
2 ] = vrhaddq_u16(vhaddq_u16(l15, l17), l16);
col0[
3 ] = vrhaddq_u16(vhaddq_u16(l23, l25), l24);
// Reverse within each vector, then swap the array indices in both the uzp
// and the col0_{even,odd} assignment to complete the reversal across all
// 32-elements.
col0[
0 ] = vrev64q_u16(vextq_u16(col0[
0 ], col0[
0 ],
4 ));
col0[
1 ] = vrev64q_u16(vextq_u16(col0[
1 ], col0[
1 ],
4 ));
col0[
2 ] = vrev64q_u16(vextq_u16(col0[
2 ], col0[
2 ],
4 ));
col0[
3 ] = vrev64q_u16(vextq_u16(col0[
3 ], col0[
3 ],
4 ));
col0_even[
1 ] = vuzpq_u16(col0[
1 ], col0[
0 ]).val[
1 ];
col0_even[
0 ] = vuzpq_u16(col0[
3 ], col0[
2 ]).val[
1 ];
col0_odd[
1 ] = vuzpq_u16(col0[
1 ], col0[
0 ]).val[
0 ];
col0_odd[
0 ] = vuzpq_u16(col0[
3 ], col0[
2 ]).val[
0 ];
vst1q_u16(dst +
0 * stride +
0 , d0[
0 ]);
vst1q_u16(dst +
0 * stride +
8 , d0[
1 ]);
vst1q_u16(dst +
0 * stride +
16 , d0[
2 ]);
vst1q_u16(dst +
0 * stride +
24 , d0[
3 ]);
vst1q_u16(dst +
1 * stride +
0 , d1[
0 ]);
vst1q_u16(dst +
1 * stride +
8 , d1[
1 ]);
vst1q_u16(dst +
1 * stride +
16 , d1[
2 ]);
vst1q_u16(dst +
1 * stride +
24 , d1[
3 ]);
vst1q_u16(dst +
2 * stride +
0 , vextq_u16(col0_even[
1 ], d0[
0 ],
7 ));
vst1q_u16(dst +
2 * stride +
8 , vextq_u16(d0[
0 ], d0[
1 ],
7 ));
vst1q_u16(dst +
2 * stride +
16 , vextq_u16(d0[
1 ], d0[
2 ],
7 ));
vst1q_u16(dst +
2 * stride +
24 , vextq_u16(d0[
2 ], d0[
3 ],
7 ));
vst1q_u16(dst +
3 * stride +
0 , vextq_u16(col0_odd[
1 ], d1[
0 ],
7 ));
vst1q_u16(dst +
3 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
7 ));
vst1q_u16(dst +
3 * stride +
16 , vextq_u16(d1[
1 ], d1[
2 ],
7 ));
vst1q_u16(dst +
3 * stride +
24 , vextq_u16(d1[
2 ], d1[
3 ],
7 ));
vst1q_u16(dst +
4 * stride +
0 , vextq_u16(col0_even[
1 ], d0[
0 ],
6 ));
vst1q_u16(dst +
4 * stride +
8 , vextq_u16(d0[
0 ], d0[
1 ],
6 ));
vst1q_u16(dst +
4 * stride +
16 , vextq_u16(d0[
1 ], d0[
2 ],
6 ));
vst1q_u16(dst +
4 * stride +
24 , vextq_u16(d0[
2 ], d0[
3 ],
6 ));
vst1q_u16(dst +
5 * stride +
0 , vextq_u16(col0_odd[
1 ], d1[
0 ],
6 ));
vst1q_u16(dst +
5 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
6 ));
vst1q_u16(dst +
5 * stride +
16 , vextq_u16(d1[
1 ], d1[
2 ],
6 ));
vst1q_u16(dst +
5 * stride +
24 , vextq_u16(d1[
2 ], d1[
3 ],
6 ));
vst1q_u16(dst +
6 * stride +
0 , vextq_u16(col0_even[
1 ], d0[
0 ],
5 ));
vst1q_u16(dst +
6 * stride +
8 , vextq_u16(d0[
0 ], d0[
1 ],
5 ));
vst1q_u16(dst +
6 * stride +
16 , vextq_u16(d0[
1 ], d0[
2 ],
5 ));
vst1q_u16(dst +
6 * stride +
24 , vextq_u16(d0[
2 ], d0[
3 ],
5 ));
vst1q_u16(dst +
7 * stride +
0 , vextq_u16(col0_odd[
1 ], d1[
0 ],
5 ));
vst1q_u16(dst +
7 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
5 ));
vst1q_u16(dst +
7 * stride +
16 , vextq_u16(d1[
1 ], d1[
2 ],
5 ));
vst1q_u16(dst +
7 * stride +
24 , vextq_u16(d1[
2 ], d1[
3 ],
5 ));
vst1q_u16(dst +
8 * stride +
0 , vextq_u16(col0_even[
1 ], d0[
0 ],
4 ));
vst1q_u16(dst +
8 * stride +
8 , vextq_u16(d0[
0 ], d0[
1 ],
4 ));
vst1q_u16(dst +
8 * stride +
16 , vextq_u16(d0[
1 ], d0[
2 ],
4 ));
vst1q_u16(dst +
8 * stride +
24 , vextq_u16(d0[
2 ], d0[
3 ],
4 ));
vst1q_u16(dst +
9 * stride +
0 , vextq_u16(col0_odd[
1 ], d1[
0 ],
4 ));
vst1q_u16(dst +
9 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
4 ));
vst1q_u16(dst +
9 * stride +
16 , vextq_u16(d1[
1 ], d1[
2 ],
4 ));
vst1q_u16(dst +
9 * stride +
24 , vextq_u16(d1[
2 ], d1[
3 ],
4 ));
vst1q_u16(dst +
10 * stride +
0 , vextq_u16(col0_even[
1 ], d0[
0 ],
3 ));
vst1q_u16(dst +
10 * stride +
8 , vextq_u16(d0[
0 ], d0[
1 ],
3 ));
vst1q_u16(dst +
10 * stride +
16 , vextq_u16(d0[
1 ], d0[
2 ],
3 ));
vst1q_u16(dst +
10 * stride +
24 , vextq_u16(d0[
2 ], d0[
3 ],
3 ));
vst1q_u16(dst +
11 * stride +
0 , vextq_u16(col0_odd[
1 ], d1[
0 ],
3 ));
vst1q_u16(dst +
11 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
3 ));
vst1q_u16(dst +
11 * stride +
16 , vextq_u16(d1[
1 ], d1[
2 ],
3 ));
vst1q_u16(dst +
11 * stride +
24 , vextq_u16(d1[
2 ], d1[
3 ],
3 ));
vst1q_u16(dst +
12 * stride +
0 , vextq_u16(col0_even[
1 ], d0[
0 ],
2 ));
vst1q_u16(dst +
12 * stride +
8 , vextq_u16(d0[
0 ], d0[
1 ],
2 ));
vst1q_u16(dst +
12 * stride +
16 , vextq_u16(d0[
1 ], d0[
2 ],
2 ));
vst1q_u16(dst +
12 * stride +
24 , vextq_u16(d0[
2 ], d0[
3 ],
2 ));
vst1q_u16(dst +
13 * stride +
0 , vextq_u16(col0_odd[
1 ], d1[
0 ],
2 ));
vst1q_u16(dst +
13 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
2 ));
vst1q_u16(dst +
13 * stride +
16 , vextq_u16(d1[
1 ], d1[
2 ],
2 ));
vst1q_u16(dst +
13 * stride +
24 , vextq_u16(d1[
2 ], d1[
3 ],
2 ));
vst1q_u16(dst +
14 * stride +
0 , vextq_u16(col0_even[
1 ], d0[
0 ],
1 ));
vst1q_u16(dst +
14 * stride +
8 , vextq_u16(d0[
0 ], d0[
1 ],
1 ));
vst1q_u16(dst +
14 * stride +
16 , vextq_u16(d0[
1 ], d0[
2 ],
1 ));
vst1q_u16(dst +
14 * stride +
24 , vextq_u16(d0[
2 ], d0[
3 ],
1 ));
vst1q_u16(dst +
15 * stride +
0 , vextq_u16(col0_odd[
1 ], d1[
0 ],
1 ));
vst1q_u16(dst +
15 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
1 ));
vst1q_u16(dst +
15 * stride +
16 , vextq_u16(d1[
1 ], d1[
2 ],
1 ));
vst1q_u16(dst +
15 * stride +
24 , vextq_u16(d1[
2 ], d1[
3 ],
1 ));
vst1q_u16(dst +
16 * stride +
0 , col0_even[
1 ]);
vst1q_u16(dst +
16 * stride +
8 , d0[
0 ]);
vst1q_u16(dst +
16 * stride +
16 , d0[
1 ]);
vst1q_u16(dst +
16 * stride +
24 , d0[
2 ]);
vst1q_u16(dst +
17 * stride +
0 , col0_odd[
1 ]);
vst1q_u16(dst +
17 * stride +
8 , d1[
0 ]);
vst1q_u16(dst +
17 * stride +
16 , d1[
1 ]);
vst1q_u16(dst +
17 * stride +
24 , d1[
2 ]);
vst1q_u16(dst +
18 * stride +
0 , vextq_u16(col0_even[
0 ], col0_even[
1 ],
7 ));
vst1q_u16(dst +
18 * stride +
8 , vextq_u16(col0_even[
1 ], d0[
0 ],
7 ));
vst1q_u16(dst +
18 * stride +
16 , vextq_u16(d0[
0 ], d0[
1 ],
7 ));
vst1q_u16(dst +
18 * stride +
24 , vextq_u16(d0[
1 ], d0[
2 ],
7 ));
vst1q_u16(dst +
19 * stride +
0 , vextq_u16(col0_odd[
0 ], col0_odd[
1 ],
7 ));
vst1q_u16(dst +
19 * stride +
8 , vextq_u16(col0_odd[
1 ], d1[
0 ],
7 ));
vst1q_u16(dst +
19 * stride +
16 , vextq_u16(d1[
0 ], d1[
1 ],
7 ));
vst1q_u16(dst +
19 * stride +
24 , vextq_u16(d1[
1 ], d1[
2 ],
7 ));
vst1q_u16(dst +
20 * stride +
0 , vextq_u16(col0_even[
0 ], col0_even[
1 ],
6 ));
vst1q_u16(dst +
20 * stride +
8 , vextq_u16(col0_even[
1 ], d0[
0 ],
6 ));
vst1q_u16(dst +
20 * stride +
16 , vextq_u16(d0[
0 ], d0[
1 ],
6 ));
vst1q_u16(dst +
20 * stride +
24 , vextq_u16(d0[
1 ], d0[
2 ],
6 ));
vst1q_u16(dst +
21 * stride +
0 , vextq_u16(col0_odd[
0 ], col0_odd[
1 ],
6 ));
vst1q_u16(dst +
21 * stride +
8 , vextq_u16(col0_odd[
1 ], d1[
0 ],
6 ));
vst1q_u16(dst +
21 * stride +
16 , vextq_u16(d1[
0 ], d1[
1 ],
6 ));
vst1q_u16(dst +
21 * stride +
24 , vextq_u16(d1[
1 ], d1[
2 ],
6 ));
vst1q_u16(dst +
22 * stride +
0 , vextq_u16(col0_even[
0 ], col0_even[
1 ],
5 ));
vst1q_u16(dst +
22 * stride +
8 , vextq_u16(col0_even[
1 ], d0[
0 ],
5 ));
vst1q_u16(dst +
22 * stride +
16 , vextq_u16(d0[
0 ], d0[
1 ],
5 ));
vst1q_u16(dst +
22 * stride +
24 , vextq_u16(d0[
1 ], d0[
2 ],
5 ));
vst1q_u16(dst +
23 * stride +
0 , vextq_u16(col0_odd[
0 ], col0_odd[
1 ],
5 ));
vst1q_u16(dst +
23 * stride +
8 , vextq_u16(col0_odd[
1 ], d1[
0 ],
5 ));
vst1q_u16(dst +
23 * stride +
16 , vextq_u16(d1[
0 ], d1[
1 ],
5 ));
vst1q_u16(dst +
23 * stride +
24 , vextq_u16(d1[
1 ], d1[
2 ],
5 ));
vst1q_u16(dst +
24 * stride +
0 , vextq_u16(col0_even[
0 ], col0_even[
1 ],
4 ));
vst1q_u16(dst +
24 * stride +
8 , vextq_u16(col0_even[
1 ], d0[
0 ],
4 ));
vst1q_u16(dst +
24 * stride +
16 , vextq_u16(d0[
0 ], d0[
1 ],
4 ));
vst1q_u16(dst +
24 * stride +
24 , vextq_u16(d0[
1 ], d0[
2 ],
4 ));
vst1q_u16(dst +
25 * stride +
0 , vextq_u16(col0_odd[
0 ], col0_odd[
1 ],
4 ));
vst1q_u16(dst +
25 * stride +
8 , vextq_u16(col0_odd[
1 ], d1[
0 ],
4 ));
vst1q_u16(dst +
25 * stride +
16 , vextq_u16(d1[
0 ], d1[
1 ],
4 ));
vst1q_u16(dst +
25 * stride +
24 , vextq_u16(d1[
1 ], d1[
2 ],
4 ));
vst1q_u16(dst +
26 * stride +
0 , vextq_u16(col0_even[
0 ], col0_even[
1 ],
3 ));
vst1q_u16(dst +
26 * stride +
8 , vextq_u16(col0_even[
1 ], d0[
0 ],
3 ));
vst1q_u16(dst +
26 * stride +
16 , vextq_u16(d0[
0 ], d0[
1 ],
3 ));
vst1q_u16(dst +
26 * stride +
24 , vextq_u16(d0[
1 ], d0[
2 ],
3 ));
vst1q_u16(dst +
27 * stride +
0 , vextq_u16(col0_odd[
0 ], col0_odd[
1 ],
3 ));
vst1q_u16(dst +
27 * stride +
8 , vextq_u16(col0_odd[
1 ], d1[
0 ],
3 ));
vst1q_u16(dst +
27 * stride +
16 , vextq_u16(d1[
0 ], d1[
1 ],
3 ));
vst1q_u16(dst +
27 * stride +
24 , vextq_u16(d1[
1 ], d1[
2 ],
3 ));
vst1q_u16(dst +
28 * stride +
0 , vextq_u16(col0_even[
0 ], col0_even[
1 ],
2 ));
vst1q_u16(dst +
28 * stride +
8 , vextq_u16(col0_even[
1 ], d0[
0 ],
2 ));
vst1q_u16(dst +
28 * stride +
16 , vextq_u16(d0[
0 ], d0[
1 ],
2 ));
vst1q_u16(dst +
28 * stride +
24 , vextq_u16(d0[
1 ], d0[
2 ],
2 ));
vst1q_u16(dst +
29 * stride +
0 , vextq_u16(col0_odd[
0 ], col0_odd[
1 ],
2 ));
vst1q_u16(dst +
29 * stride +
8 , vextq_u16(col0_odd[
1 ], d1[
0 ],
2 ));
vst1q_u16(dst +
29 * stride +
16 , vextq_u16(d1[
0 ], d1[
1 ],
2 ));
vst1q_u16(dst +
29 * stride +
24 , vextq_u16(d1[
1 ], d1[
2 ],
2 ));
vst1q_u16(dst +
30 * stride +
0 , vextq_u16(col0_even[
0 ], col0_even[
1 ],
1 ));
vst1q_u16(dst +
30 * stride +
8 , vextq_u16(col0_even[
1 ], d0[
0 ],
1 ));
vst1q_u16(dst +
30 * stride +
16 , vextq_u16(d0[
0 ], d0[
1 ],
1 ));
vst1q_u16(dst +
30 * stride +
24 , vextq_u16(d0[
1 ], d0[
2 ],
1 ));
vst1q_u16(dst +
31 * stride +
0 , vextq_u16(col0_odd[
0 ], col0_odd[
1 ],
1 ));
vst1q_u16(dst +
31 * stride +
8 , vextq_u16(col0_odd[
1 ], d1[
0 ],
1 ));
vst1q_u16(dst +
31 * stride +
16 , vextq_u16(d1[
0 ], d1[
1 ],
1 ));
vst1q_u16(dst +
31 * stride +
24 , vextq_u16(d1[
1 ], d1[
2 ],
1 ));
}
// -----------------------------------------------------------------------------
void vpx_highbd_d153_predictor_4x4_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
// See vpx_highbd_d153_predictor_8x8_neon for details on the implementation.
uint16x4_t az, a0, l0az, l0, l1, azl0, d0, d1, d2, d20_lo, d20_hi;
(
void )bd;
az = vld1_u16(above -
1 );
a0 = vld1_u16(above +
0 );
// [ left[0], above[-1], above[0], above[1] ]
l0az = vext_u16(vld1_dup_u16(left), az,
3 );
l0 = vld1_u16(left);
// The last lane here is unused, reading left[4] could cause a buffer
// over-read, so just fill with a duplicate of left[0] to avoid needing to
// materialize a zero:
// [ left[1], left[2], left[3], x ]
l1 = vext_u16(l0, l0,
1 );
// [ above[-1], left[0], left[1], left[2] ]
azl0 = vext_u16(vld1_dup_u16(above -
1 ), l0,
3 );
d0 = vrhadd_u16(azl0, l0);
d1 = vrhadd_u16(vhadd_u16(l0az, a0), az);
d2 = vrhadd_u16(vhadd_u16(azl0, l1), l0);
d20_lo = vzip_u16(vrev64_u16(d2), vrev64_u16(d0)).val[
0 ];
d20_hi = vzip_u16(vrev64_u16(d2), vrev64_u16(d0)).val[
1 ];
// Incrementally shift more elements from d0/d2 reversed into d1:
// stride=0 [ d0[0], d1[0], d1[1], d1[2] ]
// stride=1 [ d0[1], d2[0], d0[0], d1[0] ]
// stride=2 [ d0[2], d2[1], d0[1], d2[0] ]
// stride=3 [ d0[3], d2[2], d0[2], d2[1] ]
vst1_u16(dst +
0 * stride, vext_u16(d20_hi, d1,
3 ));
vst1_u16(dst +
1 * stride, vext_u16(d20_hi, d1,
1 ));
vst1_u16(dst +
2 * stride, vext_u16(d20_lo, d20_hi,
3 ));
vst1_u16(dst +
3 * stride, vext_u16(d20_lo, d20_hi,
1 ));
}
void vpx_highbd_d153_predictor_8x8_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x8_t az, a0, l0az, l0, l1, azl0, d0, d1, d2, d0_rev, d2_rev, d20_lo,
d20_hi;
(
void )bd;
az = vld1q_u16(above -
1 );
a0 = vld1q_u16(above +
0 );
// [ left[0], above[-1], ... , above[5] ]
l0az = vextq_u16(vld1q_dup_u16(left), az,
7 );
l0 = vld1q_u16(left);
// The last lane here is unused, reading left[8] could cause a buffer
// over-read, so just fill with a duplicate of left[0] to avoid needing to
// materialize a zero:
// [ left[1], ... , left[7], x ]
l1 = vextq_u16(l0, l0,
1 );
// [ above[-1], left[0], ... , left[6] ]
azl0 = vextq_u16(vld1q_dup_u16(above -
1 ), l0,
7 );
// d0[0] = AVG2(above[-1], left[0])
// d0[1] = AVG2(left[0], left[1])
// ...
// d0[7] = AVG2(left[6], left[7])
d0 = vrhaddq_u16(azl0, l0);
// d1[0] = AVG3(left[0], above[-1], above[0])
// d1[1] = AVG3(above[-1], above[0], above[1])
// ...
// d1[7] = AVG3(above[5], above[6], above[7])
d1 = vrhaddq_u16(vhaddq_u16(l0az, a0), az);
// d2[0] = AVG3(above[-1], left[0], left[1])
// d2[1] = AVG3(left[0], left[1], left[2])
// ...
// d2[7] = AVG3(left[6], left[7], left[8])
d2 = vrhaddq_u16(vhaddq_u16(azl0, l1), l0);
// The ext instruction shifts elements in from the end of the vector rather
// than the start, so reverse the vectors to put the elements to be shifted
// in at the end:
d0_rev = vrev64q_u16(vextq_u16(d0, d0,
4 ));
d2_rev = vrev64q_u16(vextq_u16(d2, d2,
4 ));
d20_lo = vzipq_u16(d2_rev, d0_rev).val[
0 ];
d20_hi = vzipq_u16(d2_rev, d0_rev).val[
1 ];
// Incrementally shift more elements from d0/d2 reversed into d1:
// stride=0 [ d0[0], d1[0], d1[1], d1[2], d1[3], d1[4], d1[5], d1[6] ]
// stride=1 [ d0[1], d2[0], d0[0], d1[0], d1[1], d1[2], d1[3], d1[4] ]
// stride=2 [ d0[2], d2[1], d0[1], d2[0], d0[0], d1[0], d1[1], d1[2] ]
// stride=3 [ d0[3], d2[2], d0[2], d2[1], d0[1], d2[0], d0[0], d1[0] ]
// stride=4 [ d0[4], d2[3], d0[3], d2[2], d0[2], d2[1], d0[1], d2[0] ]
// stride=5 [ d0[5], d2[4], d0[4], d2[3], d0[3], d2[2], d0[2], d2[1] ]
// stride=6 [ d0[6], d2[5], d0[5], d2[4], d0[4], d2[3], d0[3], d2[2] ]
// stride=7 [ d0[7], d2[6], d0[6], d2[5], d0[5], d2[4], d0[4], d2[3] ]
vst1q_u16(dst +
0 * stride, vextq_u16(d20_hi, d1,
7 ));
vst1q_u16(dst +
1 * stride, vextq_u16(d20_hi, d1,
5 ));
vst1q_u16(dst +
2 * stride, vextq_u16(d20_hi, d1,
3 ));
vst1q_u16(dst +
3 * stride, vextq_u16(d20_hi, d1,
1 ));
vst1q_u16(dst +
4 * stride, vextq_u16(d20_lo, d20_hi,
7 ));
vst1q_u16(dst +
5 * stride, vextq_u16(d20_lo, d20_hi,
5 ));
vst1q_u16(dst +
6 * stride, vextq_u16(d20_lo, d20_hi,
3 ));
vst1q_u16(dst +
7 * stride, vextq_u16(d20_lo, d20_hi,
1 ));
}
void vpx_highbd_d153_predictor_16x16_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
// See vpx_highbd_d153_predictor_8x8_neon for details on the implementation.
uint16x8_t az, a0, a6, a7, a8, l0az, l0, l1, l7, l8, l9, azl0, d0[
2 ], d1[
2 ],
d2[
2 ], d20[
4 ];
(
void )bd;
az = vld1q_u16(above -
1 );
a0 = vld1q_u16(above +
0 );
a6 = vld1q_u16(above +
6 );
a7 = vld1q_u16(above +
7 );
a8 = vld1q_u16(above +
8 );
// [ left[0], above[-1], ... , above[13] ]
l0az = vextq_u16(vld1q_dup_u16(left), az,
7 );
l0 = vld1q_u16(left +
0 );
l1 = vld1q_u16(left +
1 );
l7 = vld1q_u16(left +
7 );
l8 = vld1q_u16(left +
8 );
// The last lane here is unused, reading left[16] could cause a buffer
// over-read, so just fill with a duplicate of left[8] to avoid needing to
// materialize a zero:
// [ left[9], ... , left[15], x ]
l9 = vextq_u16(l8, l8,
1 );
// [ above[-1], left[0], ... , left[14] ]
azl0 = vextq_u16(vld1q_dup_u16(above -
1 ), l0,
7 );
d0[
0 ] = vrhaddq_u16(azl0, l0);
d0[
1 ] = vrhaddq_u16(l7, l8);
d1[
0 ] = vrhaddq_u16(vhaddq_u16(l0az, a0), az);
d1[
1 ] = vrhaddq_u16(vhaddq_u16(a6, a8), a7);
d2[
0 ] = vrhaddq_u16(vhaddq_u16(azl0, l1), l0);
d2[
1 ] = vrhaddq_u16(vhaddq_u16(l7, l9), l8);
d0[
0 ] = vrev64q_u16(vextq_u16(d0[
0 ], d0[
0 ],
4 ));
d0[
1 ] = vrev64q_u16(vextq_u16(d0[
1 ], d0[
1 ],
4 ));
d2[
0 ] = vrev64q_u16(vextq_u16(d2[
0 ], d2[
0 ],
4 ));
d2[
1 ] = vrev64q_u16(vextq_u16(d2[
1 ], d2[
1 ],
4 ));
d20[
0 ] = vzipq_u16(d2[
1 ], d0[
1 ]).val[
0 ];
d20[
1 ] = vzipq_u16(d2[
1 ], d0[
1 ]).val[
1 ];
d20[
2 ] = vzipq_u16(d2[
0 ], d0[
0 ]).val[
0 ];
d20[
3 ] = vzipq_u16(d2[
0 ], d0[
0 ]).val[
1 ];
vst1q_u16(dst +
0 * stride +
0 , vextq_u16(d20[
3 ], d1[
0 ],
7 ));
vst1q_u16(dst +
0 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
7 ));
vst1q_u16(dst +
1 * stride +
0 , vextq_u16(d20[
3 ], d1[
0 ],
5 ));
vst1q_u16(dst +
1 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
5 ));
vst1q_u16(dst +
2 * stride +
0 , vextq_u16(d20[
3 ], d1[
0 ],
3 ));
vst1q_u16(dst +
2 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
3 ));
vst1q_u16(dst +
3 * stride +
0 , vextq_u16(d20[
3 ], d1[
0 ],
1 ));
vst1q_u16(dst +
3 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
1 ));
vst1q_u16(dst +
4 * stride +
0 , vextq_u16(d20[
2 ], d20[
3 ],
7 ));
vst1q_u16(dst +
4 * stride +
8 , vextq_u16(d20[
3 ], d1[
0 ],
7 ));
vst1q_u16(dst +
5 * stride +
0 , vextq_u16(d20[
2 ], d20[
3 ],
5 ));
vst1q_u16(dst +
5 * stride +
8 , vextq_u16(d20[
3 ], d1[
0 ],
5 ));
vst1q_u16(dst +
6 * stride +
0 , vextq_u16(d20[
2 ], d20[
3 ],
3 ));
vst1q_u16(dst +
6 * stride +
8 , vextq_u16(d20[
3 ], d1[
0 ],
3 ));
vst1q_u16(dst +
7 * stride +
0 , vextq_u16(d20[
2 ], d20[
3 ],
1 ));
vst1q_u16(dst +
7 * stride +
8 , vextq_u16(d20[
3 ], d1[
0 ],
1 ));
vst1q_u16(dst +
8 * stride +
0 , vextq_u16(d20[
1 ], d20[
2 ],
7 ));
vst1q_u16(dst +
8 * stride +
8 , vextq_u16(d20[
2 ], d20[
3 ],
7 ));
vst1q_u16(dst +
9 * stride +
0 , vextq_u16(d20[
1 ], d20[
2 ],
5 ));
vst1q_u16(dst +
9 * stride +
8 , vextq_u16(d20[
2 ], d20[
3 ],
5 ));
vst1q_u16(dst +
10 * stride +
0 , vextq_u16(d20[
1 ], d20[
2 ],
3 ));
vst1q_u16(dst +
10 * stride +
8 , vextq_u16(d20[
2 ], d20[
3 ],
3 ));
vst1q_u16(dst +
11 * stride +
0 , vextq_u16(d20[
1 ], d20[
2 ],
1 ));
vst1q_u16(dst +
11 * stride +
8 , vextq_u16(d20[
2 ], d20[
3 ],
1 ));
vst1q_u16(dst +
12 * stride +
0 , vextq_u16(d20[
0 ], d20[
1 ],
7 ));
vst1q_u16(dst +
12 * stride +
8 , vextq_u16(d20[
1 ], d20[
2 ],
7 ));
vst1q_u16(dst +
13 * stride +
0 , vextq_u16(d20[
0 ], d20[
1 ],
5 ));
vst1q_u16(dst +
13 * stride +
8 , vextq_u16(d20[
1 ], d20[
2 ],
5 ));
vst1q_u16(dst +
14 * stride +
0 , vextq_u16(d20[
0 ], d20[
1 ],
3 ));
vst1q_u16(dst +
14 * stride +
8 , vextq_u16(d20[
1 ], d20[
2 ],
3 ));
vst1q_u16(dst +
15 * stride +
0 , vextq_u16(d20[
0 ], d20[
1 ],
1 ));
vst1q_u16(dst +
15 * stride +
8 , vextq_u16(d20[
1 ], d20[
2 ],
1 ));
}
void vpx_highbd_d153_predictor_32x32_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
// See vpx_highbd_d153_predictor_8x8_neon for details on the implementation.
uint16x8_t az, a0, a6, a7, a8, a14, a15, a16, a22, a23, a24, l0az, l0, l1, l7,
l8, l9, l15, l16, l17, l23, l24, l25, azl0, d0[
4 ], d1[
4 ], d2[
4 ], d20[
8 ];
(
void )bd;
az = vld1q_u16(above -
1 );
a0 = vld1q_u16(above +
0 );
a6 = vld1q_u16(above +
6 );
a7 = vld1q_u16(above +
7 );
a8 = vld1q_u16(above +
8 );
a14 = vld1q_u16(above +
14 );
a15 = vld1q_u16(above +
15 );
a16 = vld1q_u16(above +
16 );
a22 = vld1q_u16(above +
22 );
a23 = vld1q_u16(above +
23 );
a24 = vld1q_u16(above +
24 );
// [ left[0], above[-1], ... , above[13] ]
l0az = vextq_u16(vld1q_dup_u16(left), az,
7 );
l0 = vld1q_u16(left +
0 );
l1 = vld1q_u16(left +
1 );
l7 = vld1q_u16(left +
7 );
l8 = vld1q_u16(left +
8 );
l9 = vld1q_u16(left +
9 );
l15 = vld1q_u16(left +
15 );
l16 = vld1q_u16(left +
16 );
l17 = vld1q_u16(left +
17 );
l23 = vld1q_u16(left +
23 );
l24 = vld1q_u16(left +
24 );
// The last lane here is unused, reading left[32] could cause a buffer
// over-read, so just fill with a duplicate of left[24] to avoid needing to
// materialize a zero:
// [ left[25], ... , left[31], x ]
l25 = vextq_u16(l24, l24,
1 );
// [ above[-1], left[0], ... , left[14] ]
azl0 = vextq_u16(vld1q_dup_u16(above -
1 ), l0,
7 );
d0[
0 ] = vrhaddq_u16(azl0, l0);
d0[
1 ] = vrhaddq_u16(l7, l8);
d0[
2 ] = vrhaddq_u16(l15, l16);
d0[
3 ] = vrhaddq_u16(l23, l24);
d1[
0 ] = vrhaddq_u16(vhaddq_u16(l0az, a0), az);
d1[
1 ] = vrhaddq_u16(vhaddq_u16(a6, a8), a7);
d1[
2 ] = vrhaddq_u16(vhaddq_u16(a14, a16), a15);
d1[
3 ] = vrhaddq_u16(vhaddq_u16(a22, a24), a23);
d2[
0 ] = vrhaddq_u16(vhaddq_u16(azl0, l1), l0);
d2[
1 ] = vrhaddq_u16(vhaddq_u16(l7, l9), l8);
d2[
2 ] = vrhaddq_u16(vhaddq_u16(l15, l17), l16);
d2[
3 ] = vrhaddq_u16(vhaddq_u16(l23, l25), l24);
d0[
0 ] = vrev64q_u16(vextq_u16(d0[
0 ], d0[
0 ],
4 ));
d0[
1 ] = vrev64q_u16(vextq_u16(d0[
1 ], d0[
1 ],
4 ));
d0[
2 ] = vrev64q_u16(vextq_u16(d0[
2 ], d0[
2 ],
4 ));
d0[
3 ] = vrev64q_u16(vextq_u16(d0[
3 ], d0[
3 ],
4 ));
d2[
0 ] = vrev64q_u16(vextq_u16(d2[
0 ], d2[
0 ],
4 ));
d2[
1 ] = vrev64q_u16(vextq_u16(d2[
1 ], d2[
1 ],
4 ));
d2[
2 ] = vrev64q_u16(vextq_u16(d2[
2 ], d2[
2 ],
4 ));
d2[
3 ] = vrev64q_u16(vextq_u16(d2[
3 ], d2[
3 ],
4 ));
d20[
0 ] = vzipq_u16(d2[
3 ], d0[
3 ]).val[
0 ];
d20[
1 ] = vzipq_u16(d2[
3 ], d0[
3 ]).val[
1 ];
d20[
2 ] = vzipq_u16(d2[
2 ], d0[
2 ]).val[
0 ];
d20[
3 ] = vzipq_u16(d2[
2 ], d0[
2 ]).val[
1 ];
d20[
4 ] = vzipq_u16(d2[
1 ], d0[
1 ]).val[
0 ];
d20[
5 ] = vzipq_u16(d2[
1 ], d0[
1 ]).val[
1 ];
d20[
6 ] = vzipq_u16(d2[
0 ], d0[
0 ]).val[
0 ];
d20[
7 ] = vzipq_u16(d2[
0 ], d0[
0 ]).val[
1 ];
vst1q_u16(dst +
0 * stride +
0 , vextq_u16(d20[
7 ], d1[
0 ],
7 ));
vst1q_u16(dst +
0 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
7 ));
vst1q_u16(dst +
0 * stride +
16 , vextq_u16(d1[
1 ], d1[
2 ],
7 ));
vst1q_u16(dst +
0 * stride +
24 , vextq_u16(d1[
2 ], d1[
3 ],
7 ));
vst1q_u16(dst +
1 * stride +
0 , vextq_u16(d20[
7 ], d1[
0 ],
5 ));
vst1q_u16(dst +
1 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
5 ));
vst1q_u16(dst +
1 * stride +
16 , vextq_u16(d1[
1 ], d1[
2 ],
5 ));
vst1q_u16(dst +
1 * stride +
24 , vextq_u16(d1[
2 ], d1[
3 ],
5 ));
vst1q_u16(dst +
2 * stride +
0 , vextq_u16(d20[
7 ], d1[
0 ],
3 ));
vst1q_u16(dst +
2 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
3 ));
vst1q_u16(dst +
2 * stride +
16 , vextq_u16(d1[
1 ], d1[
2 ],
3 ));
vst1q_u16(dst +
2 * stride +
24 , vextq_u16(d1[
2 ], d1[
3 ],
3 ));
vst1q_u16(dst +
3 * stride +
0 , vextq_u16(d20[
7 ], d1[
0 ],
1 ));
vst1q_u16(dst +
3 * stride +
8 , vextq_u16(d1[
0 ], d1[
1 ],
1 ));
vst1q_u16(dst +
3 * stride +
16 , vextq_u16(d1[
1 ], d1[
2 ],
1 ));
vst1q_u16(dst +
3 * stride +
24 , vextq_u16(d1[
2 ], d1[
3 ],
1 ));
vst1q_u16(dst +
4 * stride +
0 , vextq_u16(d20[
6 ], d20[
7 ],
7 ));
vst1q_u16(dst +
4 * stride +
8 , vextq_u16(d20[
7 ], d1[
0 ],
7 ));
vst1q_u16(dst +
4 * stride +
16 , vextq_u16(d1[
0 ], d1[
1 ],
7 ));
vst1q_u16(dst +
4 * stride +
24 , vextq_u16(d1[
1 ], d1[
2 ],
7 ));
vst1q_u16(dst +
5 * stride +
0 , vextq_u16(d20[
6 ], d20[
7 ],
5 ));
vst1q_u16(dst +
5 * stride +
8 , vextq_u16(d20[
7 ], d1[
0 ],
5 ));
vst1q_u16(dst +
5 * stride +
16 , vextq_u16(d1[
0 ], d1[
1 ],
5 ));
vst1q_u16(dst +
5 * stride +
24 , vextq_u16(d1[
1 ], d1[
2 ],
5 ));
vst1q_u16(dst +
6 * stride +
0 , vextq_u16(d20[
6 ], d20[
7 ],
3 ));
vst1q_u16(dst +
6 * stride +
8 , vextq_u16(d20[
7 ], d1[
0 ],
3 ));
vst1q_u16(dst +
6 * stride +
16 , vextq_u16(d1[
0 ], d1[
1 ],
3 ));
vst1q_u16(dst +
6 * stride +
24 , vextq_u16(d1[
1 ], d1[
2 ],
3 ));
vst1q_u16(dst +
7 * stride +
0 , vextq_u16(d20[
6 ], d20[
7 ],
1 ));
vst1q_u16(dst +
7 * stride +
8 , vextq_u16(d20[
7 ], d1[
0 ],
1 ));
vst1q_u16(dst +
7 * stride +
16 , vextq_u16(d1[
0 ], d1[
1 ],
1 ));
vst1q_u16(dst +
7 * stride +
24 , vextq_u16(d1[
1 ], d1[
2 ],
1 ));
vst1q_u16(dst +
8 * stride +
0 , vextq_u16(d20[
5 ], d20[
6 ],
7 ));
vst1q_u16(dst +
8 * stride +
8 , vextq_u16(d20[
6 ], d20[
7 ],
7 ));
vst1q_u16(dst +
8 * stride +
16 , vextq_u16(d20[
7 ], d1[
0 ],
7 ));
vst1q_u16(dst +
8 * stride +
24 , vextq_u16(d1[
0 ], d1[
1 ],
7 ));
vst1q_u16(dst +
9 * stride +
0 , vextq_u16(d20[
5 ], d20[
6 ],
5 ));
vst1q_u16(dst +
9 * stride +
8 , vextq_u16(d20[
6 ], d20[
7 ],
5 ));
vst1q_u16(dst +
9 * stride +
16 , vextq_u16(d20[
7 ], d1[
0 ],
5 ));
vst1q_u16(dst +
9 * stride +
24 , vextq_u16(d1[
0 ], d1[
1 ],
5 ));
vst1q_u16(dst +
10 * stride +
0 , vextq_u16(d20[
5 ], d20[
6 ],
3 ));
vst1q_u16(dst +
10 * stride +
8 , vextq_u16(d20[
6 ], d20[
7 ],
3 ));
vst1q_u16(dst +
10 * stride +
16 , vextq_u16(d20[
7 ], d1[
0 ],
3 ));
vst1q_u16(dst +
10 * stride +
24 , vextq_u16(d1[
0 ], d1[
1 ],
3 ));
vst1q_u16(dst +
11 * stride +
0 , vextq_u16(d20[
5 ], d20[
6 ],
1 ));
vst1q_u16(dst +
11 * stride +
8 , vextq_u16(d20[
6 ], d20[
7 ],
1 ));
vst1q_u16(dst +
11 * stride +
16 , vextq_u16(d20[
7 ], d1[
0 ],
1 ));
vst1q_u16(dst +
11 * stride +
24 , vextq_u16(d1[
0 ], d1[
1 ],
1 ));
vst1q_u16(dst +
12 * stride +
0 , vextq_u16(d20[
4 ], d20[
5 ],
7 ));
vst1q_u16(dst +
12 * stride +
8 , vextq_u16(d20[
5 ], d20[
6 ],
7 ));
vst1q_u16(dst +
12 * stride +
16 , vextq_u16(d20[
6 ], d20[
7 ],
7 ));
vst1q_u16(dst +
12 * stride +
24 , vextq_u16(d20[
7 ], d1[
0 ],
7 ));
vst1q_u16(dst +
13 * stride +
0 , vextq_u16(d20[
4 ], d20[
5 ],
5 ));
vst1q_u16(dst +
13 * stride +
8 , vextq_u16(d20[
5 ], d20[
6 ],
5 ));
vst1q_u16(dst +
13 * stride +
16 , vextq_u16(d20[
6 ], d20[
7 ],
5 ));
vst1q_u16(dst +
13 * stride +
24 , vextq_u16(d20[
7 ], d1[
0 ],
5 ));
vst1q_u16(dst +
14 * stride +
0 , vextq_u16(d20[
4 ], d20[
5 ],
3 ));
vst1q_u16(dst +
14 * stride +
8 , vextq_u16(d20[
5 ], d20[
6 ],
3 ));
vst1q_u16(dst +
14 * stride +
16 , vextq_u16(d20[
6 ], d20[
7 ],
3 ));
vst1q_u16(dst +
14 * stride +
24 , vextq_u16(d20[
7 ], d1[
0 ],
3 ));
vst1q_u16(dst +
15 * stride +
0 , vextq_u16(d20[
4 ], d20[
5 ],
1 ));
vst1q_u16(dst +
15 * stride +
8 , vextq_u16(d20[
5 ], d20[
6 ],
1 ));
vst1q_u16(dst +
15 * stride +
16 , vextq_u16(d20[
6 ], d20[
7 ],
1 ));
vst1q_u16(dst +
15 * stride +
24 , vextq_u16(d20[
7 ], d1[
0 ],
1 ));
vst1q_u16(dst +
16 * stride +
0 , vextq_u16(d20[
3 ], d20[
4 ],
7 ));
vst1q_u16(dst +
16 * stride +
8 , vextq_u16(d20[
4 ], d20[
5 ],
7 ));
vst1q_u16(dst +
16 * stride +
16 , vextq_u16(d20[
5 ], d20[
6 ],
7 ));
vst1q_u16(dst +
16 * stride +
24 , vextq_u16(d20[
6 ], d20[
7 ],
7 ));
vst1q_u16(dst +
17 * stride +
0 , vextq_u16(d20[
3 ], d20[
4 ],
5 ));
vst1q_u16(dst +
17 * stride +
8 , vextq_u16(d20[
4 ], d20[
5 ],
5 ));
vst1q_u16(dst +
17 * stride +
16 , vextq_u16(d20[
5 ], d20[
6 ],
5 ));
vst1q_u16(dst +
17 * stride +
24 , vextq_u16(d20[
6 ], d20[
7 ],
5 ));
vst1q_u16(dst +
18 * stride +
0 , vextq_u16(d20[
3 ], d20[
4 ],
3 ));
vst1q_u16(dst +
18 * stride +
8 , vextq_u16(d20[
4 ], d20[
5 ],
3 ));
vst1q_u16(dst +
18 * stride +
16 , vextq_u16(d20[
5 ], d20[
6 ],
3 ));
vst1q_u16(dst +
18 * stride +
24 , vextq_u16(d20[
6 ], d20[
7 ],
3 ));
vst1q_u16(dst +
19 * stride +
0 , vextq_u16(d20[
3 ], d20[
4 ],
1 ));
vst1q_u16(dst +
19 * stride +
8 , vextq_u16(d20[
4 ], d20[
5 ],
1 ));
vst1q_u16(dst +
19 * stride +
16 , vextq_u16(d20[
5 ], d20[
6 ],
1 ));
vst1q_u16(dst +
19 * stride +
24 , vextq_u16(d20[
6 ], d20[
7 ],
1 ));
vst1q_u16(dst +
20 * stride +
0 , vextq_u16(d20[
2 ], d20[
3 ],
7 ));
vst1q_u16(dst +
20 * stride +
8 , vextq_u16(d20[
3 ], d20[
4 ],
7 ));
vst1q_u16(dst +
20 * stride +
16 , vextq_u16(d20[
4 ], d20[
5 ],
7 ));
vst1q_u16(dst +
20 * stride +
24 , vextq_u16(d20[
5 ], d20[
6 ],
7 ));
vst1q_u16(dst +
21 * stride +
0 , vextq_u16(d20[
2 ], d20[
3 ],
5 ));
vst1q_u16(dst +
21 * stride +
8 , vextq_u16(d20[
3 ], d20[
4 ],
5 ));
vst1q_u16(dst +
21 * stride +
16 , vextq_u16(d20[
4 ], d20[
5 ],
5 ));
vst1q_u16(dst +
21 * stride +
24 , vextq_u16(d20[
5 ], d20[
6 ],
5 ));
vst1q_u16(dst +
22 * stride +
0 , vextq_u16(d20[
2 ], d20[
3 ],
3 ));
vst1q_u16(dst +
22 * stride +
8 , vextq_u16(d20[
3 ], d20[
4 ],
3 ));
vst1q_u16(dst +
22 * stride +
16 , vextq_u16(d20[
4 ], d20[
5 ],
3 ));
vst1q_u16(dst +
22 * stride +
24 , vextq_u16(d20[
5 ], d20[
6 ],
3 ));
vst1q_u16(dst +
23 * stride +
0 , vextq_u16(d20[
2 ], d20[
3 ],
1 ));
vst1q_u16(dst +
23 * stride +
8 , vextq_u16(d20[
3 ], d20[
4 ],
1 ));
vst1q_u16(dst +
23 * stride +
16 , vextq_u16(d20[
4 ], d20[
5 ],
1 ));
vst1q_u16(dst +
23 * stride +
24 , vextq_u16(d20[
5 ], d20[
6 ],
1 ));
vst1q_u16(dst +
24 * stride +
0 , vextq_u16(d20[
1 ], d20[
2 ],
7 ));
vst1q_u16(dst +
24 * stride +
8 , vextq_u16(d20[
2 ], d20[
3 ],
7 ));
vst1q_u16(dst +
24 * stride +
16 , vextq_u16(d20[
3 ], d20[
4 ],
7 ));
vst1q_u16(dst +
24 * stride +
24 , vextq_u16(d20[
4 ], d20[
5 ],
7 ));
vst1q_u16(dst +
25 * stride +
0 , vextq_u16(d20[
1 ], d20[
2 ],
5 ));
vst1q_u16(dst +
25 * stride +
8 , vextq_u16(d20[
2 ], d20[
3 ],
5 ));
vst1q_u16(dst +
25 * stride +
16 , vextq_u16(d20[
3 ], d20[
4 ],
5 ));
vst1q_u16(dst +
25 * stride +
24 , vextq_u16(d20[
4 ], d20[
5 ],
5 ));
vst1q_u16(dst +
26 * stride +
0 , vextq_u16(d20[
1 ], d20[
2 ],
3 ));
vst1q_u16(dst +
26 * stride +
8 , vextq_u16(d20[
2 ], d20[
3 ],
3 ));
vst1q_u16(dst +
26 * stride +
16 , vextq_u16(d20[
3 ], d20[
4 ],
3 ));
vst1q_u16(dst +
26 * stride +
24 , vextq_u16(d20[
4 ], d20[
5 ],
3 ));
vst1q_u16(dst +
27 * stride +
0 , vextq_u16(d20[
1 ], d20[
2 ],
1 ));
vst1q_u16(dst +
27 * stride +
8 , vextq_u16(d20[
2 ], d20[
3 ],
1 ));
vst1q_u16(dst +
27 * stride +
16 , vextq_u16(d20[
3 ], d20[
4 ],
1 ));
vst1q_u16(dst +
27 * stride +
24 , vextq_u16(d20[
4 ], d20[
5 ],
1 ));
vst1q_u16(dst +
28 * stride +
0 , vextq_u16(d20[
0 ], d20[
1 ],
7 ));
vst1q_u16(dst +
28 * stride +
8 , vextq_u16(d20[
1 ], d20[
2 ],
7 ));
vst1q_u16(dst +
28 * stride +
16 , vextq_u16(d20[
2 ], d20[
3 ],
7 ));
vst1q_u16(dst +
28 * stride +
24 , vextq_u16(d20[
3 ], d20[
4 ],
7 ));
vst1q_u16(dst +
29 * stride +
0 , vextq_u16(d20[
0 ], d20[
1 ],
5 ));
vst1q_u16(dst +
29 * stride +
8 , vextq_u16(d20[
1 ], d20[
2 ],
5 ));
vst1q_u16(dst +
29 * stride +
16 , vextq_u16(d20[
2 ], d20[
3 ],
5 ));
vst1q_u16(dst +
29 * stride +
24 , vextq_u16(d20[
3 ], d20[
4 ],
5 ));
vst1q_u16(dst +
30 * stride +
0 , vextq_u16(d20[
0 ], d20[
1 ],
3 ));
vst1q_u16(dst +
30 * stride +
8 , vextq_u16(d20[
1 ], d20[
2 ],
3 ));
vst1q_u16(dst +
30 * stride +
16 , vextq_u16(d20[
2 ], d20[
3 ],
3 ));
vst1q_u16(dst +
30 * stride +
24 , vextq_u16(d20[
3 ], d20[
4 ],
3 ));
vst1q_u16(dst +
31 * stride +
0 , vextq_u16(d20[
0 ], d20[
1 ],
1 ));
vst1q_u16(dst +
31 * stride +
8 , vextq_u16(d20[
1 ], d20[
2 ],
1 ));
vst1q_u16(dst +
31 * stride +
16 , vextq_u16(d20[
2 ], d20[
3 ],
1 ));
vst1q_u16(dst +
31 * stride +
24 , vextq_u16(d20[
3 ], d20[
4 ],
1 ));
}
// -----------------------------------------------------------------------------
void vpx_highbd_d135_predictor_4x4_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t XA0123___ = vld1q_u16(above -
1 );
const uint16x4_t L0123 = vld1_u16(left);
const uint16x4_t L3210 = vrev64_u16(L0123);
const uint16x8_t L____3210 = vcombine_u16(L0123, L3210);
const uint16x8_t L3210XA012 = vcombine_u16(L3210, vget_low_u16(XA0123___));
const uint16x8_t L210XA0123 = vextq_u16(L____3210, XA0123___,
5 );
const uint16x8_t L10XA0123_ = vextq_u16(L____3210, XA0123___,
6 );
const uint16x8_t avg1 = vhaddq_u16(L3210XA012, L10XA0123_);
const uint16x8_t avg2 = vrhaddq_u16(avg1, L210XA0123);
const uint16x4_t row_0 = vget_low_u16(avg2);
const uint16x4_t row_1 = vget_high_u16(avg2);
const uint16x4_t r0 = vext_u16(row_0, row_1,
3 );
const uint16x4_t r1 = vext_u16(row_0, row_1,
2 );
const uint16x4_t r2 = vext_u16(row_0, row_1,
1 );
(
void )bd;
vst1_u16(dst, r0);
dst += stride;
vst1_u16(dst, r1);
dst += stride;
vst1_u16(dst, r2);
dst += stride;
vst1_u16(dst, row_0);
}
void vpx_highbd_d135_predictor_8x8_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t XA0123456 = vld1q_u16(above -
1 );
const uint16x8_t A01234567 = vld1q_u16(above);
const uint16x8_t A1234567_ = vld1q_u16(above +
1 );
const uint16x8_t L01234567 = vld1q_u16(left);
const uint16x4_t L3210 = vrev64_u16(vget_low_u16(L01234567));
const uint16x4_t L7654 = vrev64_u16(vget_high_u16(L01234567));
const uint16x8_t L76543210 = vcombine_u16(L7654, L3210);
const uint16x8_t L6543210X = vextq_u16(L76543210, XA0123456,
1 );
const uint16x8_t L543210XA0 = vextq_u16(L76543210, XA0123456,
2 );
const uint16x8_t avg_0 = vhaddq_u16(L76543210, L543210XA0);
const uint16x8_t avg_1 = vhaddq_u16(XA0123456, A1234567_);
const uint16x8_t row_0 = vrhaddq_u16(avg_0, L6543210X);
const uint16x8_t row_1 = vrhaddq_u16(avg_1, A01234567);
const uint16x8_t r0 = vextq_u16(row_0, row_1,
7 );
const uint16x8_t r1 = vextq_u16(row_0, row_1,
6 );
const uint16x8_t r2 = vextq_u16(row_0, row_1,
5 );
const uint16x8_t r3 = vextq_u16(row_0, row_1,
4 );
const uint16x8_t r4 = vextq_u16(row_0, row_1,
3 );
const uint16x8_t r5 = vextq_u16(row_0, row_1,
2 );
const uint16x8_t r6 = vextq_u16(row_0, row_1,
1 );
(
void )bd;
vst1q_u16(dst, r0);
dst += stride;
vst1q_u16(dst, r1);
dst += stride;
vst1q_u16(dst, r2);
dst += stride;
vst1q_u16(dst, r3);
dst += stride;
vst1q_u16(dst, r4);
dst += stride;
vst1q_u16(dst, r5);
dst += stride;
vst1q_u16(dst, r6);
dst += stride;
vst1q_u16(dst, row_0);
}
static INLINE void d135_store_16(uint16_t **dst,
const ptrdiff_t stride,
const uint16x8_t row_0,
const uint16x8_t row_1) {
vst1q_u16(*dst, row_0);
*dst +=
8 ;
vst1q_u16(*dst, row_1);
*dst += stride -
8 ;
}
void vpx_highbd_d135_predictor_16x16_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t L01234567 = vld1q_u16(left);
const uint16x8_t L89abcdef = vld1q_u16(left +
8 );
const uint16x4_t L3210 = vrev64_u16(vget_low_u16(L01234567));
const uint16x4_t L7654 = vrev64_u16(vget_high_u16(L01234567));
const uint16x4_t Lba98 = vrev64_u16(vget_low_u16(L89abcdef));
const uint16x4_t Lfedc = vrev64_u16(vget_high_u16(L89abcdef));
const uint16x8_t L76543210 = vcombine_u16(L7654, L3210);
const uint16x8_t Lfedcba98 = vcombine_u16(Lfedc, Lba98);
const uint16x8_t Ledcba987 = vextq_u16(Lfedcba98, L76543210,
1 );
const uint16x8_t Ldcba9876 = vextq_u16(Lfedcba98, L76543210,
2 );
const uint16x8_t avg_0 = vhaddq_u16(Lfedcba98, Ldcba9876);
const uint16x8_t row_0 = vrhaddq_u16(avg_0, Ledcba987);
const uint16x8_t XA0123456 = vld1q_u16(above -
1 );
const uint16x8_t L6543210X = vextq_u16(L76543210, XA0123456,
1 );
const uint16x8_t L543210XA0 = vextq_u16(L76543210, XA0123456,
2 );
const uint16x8_t avg_1 = vhaddq_u16(L76543210, L543210XA0);
const uint16x8_t row_1 = vrhaddq_u16(avg_1, L6543210X);
const uint16x8_t A01234567 = vld1q_u16(above);
const uint16x8_t A12345678 = vld1q_u16(above +
1 );
const uint16x8_t avg_2 = vhaddq_u16(XA0123456, A12345678);
const uint16x8_t row_2 = vrhaddq_u16(avg_2, A01234567);
const uint16x8_t A789abcde = vld1q_u16(above +
7 );
const uint16x8_t A89abcdef = vld1q_u16(above +
8 );
const uint16x8_t A9abcdef_ = vld1q_u16(above +
9 );
const uint16x8_t avg_3 = vhaddq_u16(A789abcde, A9abcdef_);
const uint16x8_t row_3 = vrhaddq_u16(avg_3, A89abcdef);
const uint16x8_t r0_0 = vextq_u16(row_1, row_2,
7 );
const uint16x8_t r0_1 = vextq_u16(row_2, row_3,
7 );
const uint16x8_t r1_0 = vextq_u16(row_1, row_2,
6 );
const uint16x8_t r1_1 = vextq_u16(row_2, row_3,
6 );
const uint16x8_t r2_0 = vextq_u16(row_1, row_2,
5 );
const uint16x8_t r2_1 = vextq_u16(row_2, row_3,
5 );
const uint16x8_t r3_0 = vextq_u16(row_1, row_2,
4 );
const uint16x8_t r3_1 = vextq_u16(row_2, row_3,
4 );
const uint16x8_t r4_0 = vextq_u16(row_1, row_2,
3 );
const uint16x8_t r4_1 = vextq_u16(row_2, row_3,
3 );
const uint16x8_t r5_0 = vextq_u16(row_1, row_2,
2 );
const uint16x8_t r5_1 = vextq_u16(row_2, row_3,
2 );
const uint16x8_t r6_0 = vextq_u16(row_1, row_2,
1 );
const uint16x8_t r6_1 = vextq_u16(row_2, row_3,
1 );
const uint16x8_t r8_0 = vextq_u16(row_0, row_1,
7 );
const uint16x8_t r9_0 = vextq_u16(row_0, row_1,
6 );
const uint16x8_t ra_0 = vextq_u16(row_0, row_1,
5 );
const uint16x8_t rb_0 = vextq_u16(row_0, row_1,
4 );
const uint16x8_t rc_0 = vextq_u16(row_0, row_1,
3 );
const uint16x8_t rd_0 = vextq_u16(row_0, row_1,
2 );
const uint16x8_t re_0 = vextq_u16(row_0, row_1,
1 );
(
void )bd;
d135_store_16(&dst, stride, r0_0, r0_1);
d135_store_16(&dst, stride, r1_0, r1_1);
d135_store_16(&dst, stride, r2_0, r2_1);
d135_store_16(&dst, stride, r3_0, r3_1);
d135_store_16(&dst, stride, r4_0, r4_1);
d135_store_16(&dst, stride, r5_0, r5_1);
d135_store_16(&dst, stride, r6_0, r6_1);
d135_store_16(&dst, stride, row_1, row_2);
d135_store_16(&dst, stride, r8_0, r0_0);
d135_store_16(&dst, stride, r9_0, r1_0);
d135_store_16(&dst, stride, ra_0, r2_0);
d135_store_16(&dst, stride, rb_0, r3_0);
d135_store_16(&dst, stride, rc_0, r4_0);
d135_store_16(&dst, stride, rd_0, r5_0);
d135_store_16(&dst, stride, re_0, r6_0);
vst1q_u16(dst, row_0);
dst +=
8 ;
vst1q_u16(dst, row_1);
}
void vpx_highbd_d135_predictor_32x32_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t LL01234567 = vld1q_u16(left +
16 );
const uint16x8_t LL89abcdef = vld1q_u16(left +
24 );
const uint16x4_t LL3210 = vrev64_u16(vget_low_u16(LL01234567));
const uint16x4_t LL7654 = vrev64_u16(vget_high_u16(LL01234567));
const uint16x4_t LLba98 = vrev64_u16(vget_low_u16(LL89abcdef));
const uint16x4_t LLfedc = vrev64_u16(vget_high_u16(LL89abcdef));
const uint16x8_t LL76543210 = vcombine_u16(LL7654, LL3210);
const uint16x8_t LLfedcba98 = vcombine_u16(LLfedc, LLba98);
const uint16x8_t LLedcba987 = vextq_u16(LLfedcba98, LL76543210,
1 );
const uint16x8_t LLdcba9876 = vextq_u16(LLfedcba98, LL76543210,
2 );
const uint16x8_t avg_0 = vhaddq_u16(LLfedcba98, LLdcba9876);
uint16x8_t row_0 = vrhaddq_u16(avg_0, LLedcba987);
const uint16x8_t LU01234567 = vld1q_u16(left);
const uint16x8_t LU89abcdef = vld1q_u16(left +
8 );
const uint16x4_t LU3210 = vrev64_u16(vget_low_u16(LU01234567));
const uint16x4_t LU7654 = vrev64_u16(vget_high_u16(LU01234567));
const uint16x4_t LUba98 = vrev64_u16(vget_low_u16(LU89abcdef));
const uint16x4_t LUfedc = vrev64_u16(vget_high_u16(LU89abcdef));
const uint16x8_t LU76543210 = vcombine_u16(LU7654, LU3210);
const uint16x8_t LUfedcba98 = vcombine_u16(LUfedc, LUba98);
const uint16x8_t LL6543210Uf = vextq_u16(LL76543210, LUfedcba98,
1 );
const uint16x8_t LL543210Ufe = vextq_u16(LL76543210, LUfedcba98,
2 );
const uint16x8_t avg_1 = vhaddq_u16(LL76543210, LL543210Ufe);
uint16x8_t row_1 = vrhaddq_u16(avg_1, LL6543210Uf);
const uint16x8_t LUedcba987 = vextq_u16(LUfedcba98, LU76543210,
1 );
const uint16x8_t LUdcba9876 = vextq_u16(LUfedcba98, LU76543210,
2 );
const uint16x8_t avg_2 = vhaddq_u16(LUfedcba98, LUdcba9876);
uint16x8_t row_2 = vrhaddq_u16(avg_2, LUedcba987);
const uint16x8_t XAL0123456 = vld1q_u16(above -
1 );
const uint16x8_t LU6543210X = vextq_u16(LU76543210, XAL0123456,
1 );
const uint16x8_t LU543210XA0 = vextq_u16(LU76543210, XAL0123456,
2 );
const uint16x8_t avg_3 = vhaddq_u16(LU76543210, LU543210XA0);
uint16x8_t row_3 = vrhaddq_u16(avg_3, LU6543210X);
const uint16x8_t AL01234567 = vld1q_u16(above);
const uint16x8_t AL12345678 = vld1q_u16(above +
1 );
const uint16x8_t avg_4 = vhaddq_u16(XAL0123456, AL12345678);
uint16x8_t row_4 = vrhaddq_u16(avg_4, AL01234567);
const uint16x8_t AL789abcde = vld1q_u16(above +
7 );
const uint16x8_t AL89abcdef = vld1q_u16(above +
8 );
const uint16x8_t AL9abcdefg = vld1q_u16(above +
9 );
const uint16x8_t avg_5 = vhaddq_u16(AL789abcde, AL9abcdefg);
uint16x8_t row_5 = vrhaddq_u16(avg_5, AL89abcdef);
const uint16x8_t ALfR0123456 = vld1q_u16(above +
15 );
const uint16x8_t AR01234567 = vld1q_u16(above +
16 );
const uint16x8_t AR12345678 = vld1q_u16(above +
17 );
const uint16x8_t avg_6 = vhaddq_u16(ALfR0123456, AR12345678);
uint16x8_t row_6 = vrhaddq_u16(avg_6, AR01234567);
const uint16x8_t AR789abcde = vld1q_u16(above +
23 );
const uint16x8_t AR89abcdef = vld1q_u16(above +
24 );
const uint16x8_t AR9abcdef_ = vld1q_u16(above +
25 );
const uint16x8_t avg_7 = vhaddq_u16(AR789abcde, AR9abcdef_);
uint16x8_t row_7 = vrhaddq_u16(avg_7, AR89abcdef);
int i, j;
(
void )bd;
dst +=
31 * stride;
for (i =
0 ; i <
4 ; ++i) {
for (j =
0 ; j <
8 ; ++j) {
vst1q_u16(dst, row_0);
dst +=
8 ;
vst1q_u16(dst, row_1);
dst +=
8 ;
vst1q_u16(dst, row_2);
dst +=
8 ;
vst1q_u16(dst, row_3);
dst -= stride +
24 ;
row_0 = vextq_u16(row_0, row_1,
1 );
row_1 = vextq_u16(row_1, row_2,
1 );
row_2 = vextq_u16(row_2, row_3,
1 );
row_3 = vextq_u16(row_3, row_4,
1 );
row_4 = vextq_u16(row_4, row_4,
1 );
}
row_4 = row_5;
row_5 = row_6;
row_6 = row_7;
}
}
//------------------------------------------------------------------------------
void vpx_highbd_d207_predictor_4x4_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x4_t l0, l1, l2, l3, c0, c1, c01_lo, c01_hi;
(
void )above;
(
void )bd;
l0 = vld1_u16(left +
0 );
l3 = vld1_dup_u16(left +
3 );
// [ left[1], left[2], left[3], left[3] ]
l1 = vext_u16(l0, l3,
1 );
// [ left[2], left[3], left[3], left[3] ]
l2 = vext_u16(l0, l3,
2 );
c0 = vrhadd_u16(l0, l1);
c1 = vrhadd_u16(vhadd_u16(l0, l2), l1);
c01_lo = vzip_u16(c0, c1).val[
0 ];
c01_hi = vzip_u16(c0, c1).val[
1 ];
// stride=0 [ c0[0], c1[0], c0[1], c1[1] ]
// stride=1 [ c0[1], c1[1], c0[2], c1[2] ]
// stride=2 [ c0[2], c1[2], c0[3], c1[3] ]
// stride=3 [ c0[3], c1[3], left[3], left[3] ]
vst1_u16(dst +
0 * stride, c01_lo);
vst1_u16(dst +
1 * stride, vext_u16(c01_lo, c01_hi,
2 ));
vst1_u16(dst +
2 * stride, c01_hi);
vst1_u16(dst +
3 * stride, vext_u16(c01_hi, l3,
2 ));
}
void vpx_highbd_d207_predictor_8x8_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x8_t l0, l1, l2, l7, c0, c1, c01_lo, c01_hi;
(
void )above;
(
void )bd;
l0 = vld1q_u16(left +
0 );
l7 = vld1q_dup_u16(left +
7 );
// [ left[1], left[2], left[3], left[4], left[5], left[6], left[7], left[7] ]
l1 = vextq_u16(l0, l7,
1 );
// [ left[2], left[3], left[4], left[5], left[6], left[7], left[7], left[7] ]
l2 = vextq_u16(l0, l7,
2 );
c0 = vrhaddq_u16(l0, l1);
c1 = vrhaddq_u16(vhaddq_u16(l0, l2), l1);
c01_lo = vzipq_u16(c0, c1).val[
0 ];
c01_hi = vzipq_u16(c0, c1).val[
1 ];
vst1q_u16(dst +
0 * stride, c01_lo);
vst1q_u16(dst +
1 * stride, vextq_u16(c01_lo, c01_hi,
2 ));
vst1q_u16(dst +
2 * stride, vextq_u16(c01_lo, c01_hi,
4 ));
vst1q_u16(dst +
3 * stride, vextq_u16(c01_lo, c01_hi,
6 ));
vst1q_u16(dst +
4 * stride, c01_hi);
vst1q_u16(dst +
5 * stride, vextq_u16(c01_hi, l7,
2 ));
vst1q_u16(dst +
6 * stride, vextq_u16(c01_hi, l7,
4 ));
vst1q_u16(dst +
7 * stride, vextq_u16(c01_hi, l7,
6 ));
}
void vpx_highbd_d207_predictor_16x16_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x8_t l0, l1, l2, l8, l9, l10, l15, c0[
2 ], c1[
2 ], c01[
4 ];
(
void )above;
(
void )bd;
l0 = vld1q_u16(left +
0 );
l1 = vld1q_u16(left +
1 );
l2 = vld1q_u16(left +
2 );
l8 = vld1q_u16(left +
8 );
l15 = vld1q_dup_u16(left +
15 );
l9 = vextq_u16(l8, l15,
1 );
l10 = vextq_u16(l8, l15,
2 );
c0[
0 ] = vrhaddq_u16(l0, l1);
c0[
1 ] = vrhaddq_u16(l8, l9);
c1[
0 ] = vrhaddq_u16(vhaddq_u16(l0, l2), l1);
c1[
1 ] = vrhaddq_u16(vhaddq_u16(l8, l10), l9);
c01[
0 ] = vzipq_u16(c0[
0 ], c1[
0 ]).val[
0 ];
c01[
1 ] = vzipq_u16(c0[
0 ], c1[
0 ]).val[
1 ];
c01[
2 ] = vzipq_u16(c0[
1 ], c1[
1 ]).val[
0 ];
c01[
3 ] = vzipq_u16(c0[
1 ], c1[
1 ]).val[
1 ];
vst1q_u16(dst +
0 * stride +
0 , c01[
0 ]);
vst1q_u16(dst +
0 * stride +
8 , c01[
1 ]);
vst1q_u16(dst +
1 * stride +
0 , vextq_u16(c01[
0 ], c01[
1 ],
2 ));
vst1q_u16(dst +
1 * stride +
8 , vextq_u16(c01[
1 ], c01[
2 ],
2 ));
vst1q_u16(dst +
2 * stride +
0 , vextq_u16(c01[
0 ], c01[
1 ],
4 ));
vst1q_u16(dst +
2 * stride +
8 , vextq_u16(c01[
1 ], c01[
2 ],
4 ));
vst1q_u16(dst +
3 * stride +
0 , vextq_u16(c01[
0 ], c01[
1 ],
6 ));
vst1q_u16(dst +
3 * stride +
8 , vextq_u16(c01[
1 ], c01[
2 ],
6 ));
vst1q_u16(dst +
4 * stride +
0 , c01[
1 ]);
vst1q_u16(dst +
4 * stride +
8 , c01[
2 ]);
vst1q_u16(dst +
5 * stride +
0 , vextq_u16(c01[
1 ], c01[
2 ],
2 ));
vst1q_u16(dst +
5 * stride +
8 , vextq_u16(c01[
2 ], c01[
3 ],
2 ));
vst1q_u16(dst +
6 * stride +
0 , vextq_u16(c01[
1 ], c01[
2 ],
4 ));
vst1q_u16(dst +
6 * stride +
8 , vextq_u16(c01[
2 ], c01[
3 ],
4 ));
vst1q_u16(dst +
7 * stride +
0 , vextq_u16(c01[
1 ], c01[
2 ],
6 ));
vst1q_u16(dst +
7 * stride +
8 , vextq_u16(c01[
2 ], c01[
3 ],
6 ));
vst1q_u16(dst +
8 * stride +
0 , c01[
2 ]);
vst1q_u16(dst +
8 * stride +
8 , c01[
3 ]);
vst1q_u16(dst +
9 * stride +
0 , vextq_u16(c01[
2 ], c01[
3 ],
2 ));
vst1q_u16(dst +
9 * stride +
8 , vextq_u16(c01[
3 ], l15,
2 ));
vst1q_u16(dst +
10 * stride +
0 , vextq_u16(c01[
2 ], c01[
3 ],
4 ));
vst1q_u16(dst +
10 * stride +
8 , vextq_u16(c01[
3 ], l15,
4 ));
vst1q_u16(dst +
11 * stride +
0 , vextq_u16(c01[
2 ], c01[
3 ],
6 ));
vst1q_u16(dst +
11 * stride +
8 , vextq_u16(c01[
3 ], l15,
6 ));
vst1q_u16(dst +
12 * stride +
0 , c01[
3 ]);
vst1q_u16(dst +
12 * stride +
8 , l15);
vst1q_u16(dst +
13 * stride +
0 , vextq_u16(c01[
3 ], l15,
2 ));
vst1q_u16(dst +
13 * stride +
8 , l15);
vst1q_u16(dst +
14 * stride +
0 , vextq_u16(c01[
3 ], l15,
4 ));
vst1q_u16(dst +
14 * stride +
8 , l15);
vst1q_u16(dst +
15 * stride +
0 , vextq_u16(c01[
3 ], l15,
6 ));
vst1q_u16(dst +
15 * stride +
8 , l15);
}
void vpx_highbd_d207_predictor_32x32_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
uint16x8_t l0, l1, l2, l8, l9, l10, l16, l17, l18, l24, l25, l26, l31, c0[
4 ],
c1[
4 ], c01[
8 ];
(
void )above;
(
void )bd;
l0 = vld1q_u16(left +
0 );
l1 = vld1q_u16(left +
1 );
l2 = vld1q_u16(left +
2 );
l8 = vld1q_u16(left +
8 );
l9 = vld1q_u16(left +
9 );
l10 = vld1q_u16(left +
10 );
l16 = vld1q_u16(left +
16 );
l17 = vld1q_u16(left +
17 );
l18 = vld1q_u16(left +
18 );
l24 = vld1q_u16(left +
24 );
l31 = vld1q_dup_u16(left +
31 );
l25 = vextq_u16(l24, l31,
1 );
l26 = vextq_u16(l24, l31,
2 );
c0[
0 ] = vrhaddq_u16(l0, l1);
c0[
1 ] = vrhaddq_u16(l8, l9);
c0[
2 ] = vrhaddq_u16(l16, l17);
c0[
3 ] = vrhaddq_u16(l24, l25);
c1[
0 ] = vrhaddq_u16(vhaddq_u16(l0, l2), l1);
c1[
1 ] = vrhaddq_u16(vhaddq_u16(l8, l10), l9);
c1[
2 ] = vrhaddq_u16(vhaddq_u16(l16, l18), l17);
c1[
3 ] = vrhaddq_u16(vhaddq_u16(l24, l26), l25);
c01[
0 ] = vzipq_u16(c0[
0 ], c1[
0 ]).val[
0 ];
c01[
1 ] = vzipq_u16(c0[
0 ], c1[
0 ]).val[
1 ];
c01[
2 ] = vzipq_u16(c0[
1 ], c1[
1 ]).val[
0 ];
c01[
3 ] = vzipq_u16(c0[
1 ], c1[
1 ]).val[
1 ];
c01[
4 ] = vzipq_u16(c0[
2 ], c1[
2 ]).val[
0 ];
c01[
5 ] = vzipq_u16(c0[
2 ], c1[
2 ]).val[
1 ];
c01[
6 ] = vzipq_u16(c0[
3 ], c1[
3 ]).val[
0 ];
c01[
7 ] = vzipq_u16(c0[
3 ], c1[
3 ]).val[
1 ];
vst1q_u16(dst +
0 * stride +
0 , c01[
0 ]);
vst1q_u16(dst +
0 * stride +
8 , c01[
1 ]);
vst1q_u16(dst +
0 * stride +
16 , c01[
2 ]);
vst1q_u16(dst +
0 * stride +
24 , c01[
3 ]);
vst1q_u16(dst +
1 * stride +
0 , vextq_u16(c01[
0 ], c01[
1 ],
2 ));
vst1q_u16(dst +
1 * stride +
8 , vextq_u16(c01[
1 ], c01[
2 ],
2 ));
vst1q_u16(dst +
1 * stride +
16 , vextq_u16(c01[
2 ], c01[
3 ],
2 ));
vst1q_u16(dst +
1 * stride +
24 , vextq_u16(c01[
3 ], c01[
4 ],
2 ));
vst1q_u16(dst +
2 * stride +
0 , vextq_u16(c01[
0 ], c01[
1 ],
4 ));
vst1q_u16(dst +
2 * stride +
8 , vextq_u16(c01[
1 ], c01[
2 ],
4 ));
vst1q_u16(dst +
2 * stride +
16 , vextq_u16(c01[
2 ], c01[
3 ],
4 ));
vst1q_u16(dst +
2 * stride +
24 , vextq_u16(c01[
3 ], c01[
4 ],
4 ));
vst1q_u16(dst +
3 * stride +
0 , vextq_u16(c01[
0 ], c01[
1 ],
6 ));
vst1q_u16(dst +
3 * stride +
8 , vextq_u16(c01[
1 ], c01[
2 ],
6 ));
vst1q_u16(dst +
3 * stride +
16 , vextq_u16(c01[
2 ], c01[
3 ],
6 ));
vst1q_u16(dst +
3 * stride +
24 , vextq_u16(c01[
3 ], c01[
4 ],
6 ));
vst1q_u16(dst +
4 * stride +
0 , c01[
1 ]);
vst1q_u16(dst +
4 * stride +
8 , c01[
2 ]);
vst1q_u16(dst +
4 * stride +
16 , c01[
3 ]);
vst1q_u16(dst +
4 * stride +
24 , c01[
4 ]);
vst1q_u16(dst +
5 * stride +
0 , vextq_u16(c01[
1 ], c01[
2 ],
2 ));
vst1q_u16(dst +
5 * stride +
8 , vextq_u16(c01[
2 ], c01[
3 ],
2 ));
vst1q_u16(dst +
5 * stride +
16 , vextq_u16(c01[
3 ], c01[
4 ],
2 ));
vst1q_u16(dst +
5 * stride +
24 , vextq_u16(c01[
4 ], c01[
5 ],
2 ));
vst1q_u16(dst +
6 * stride +
0 , vextq_u16(c01[
1 ], c01[
2 ],
4 ));
vst1q_u16(dst +
6 * stride +
8 , vextq_u16(c01[
2 ], c01[
3 ],
4 ));
vst1q_u16(dst +
6 * stride +
16 , vextq_u16(c01[
3 ], c01[
4 ],
4 ));
vst1q_u16(dst +
6 * stride +
24 , vextq_u16(c01[
4 ], c01[
5 ],
4 ));
vst1q_u16(dst +
7 * stride +
0 , vextq_u16(c01[
1 ], c01[
2 ],
6 ));
vst1q_u16(dst +
7 * stride +
8 , vextq_u16(c01[
2 ], c01[
3 ],
6 ));
vst1q_u16(dst +
7 * stride +
16 , vextq_u16(c01[
3 ], c01[
4 ],
6 ));
vst1q_u16(dst +
7 * stride +
24 , vextq_u16(c01[
4 ], c01[
5 ],
6 ));
vst1q_u16(dst +
8 * stride +
0 , c01[
2 ]);
vst1q_u16(dst +
8 * stride +
8 , c01[
3 ]);
vst1q_u16(dst +
8 * stride +
16 , c01[
4 ]);
vst1q_u16(dst +
8 * stride +
24 , c01[
5 ]);
vst1q_u16(dst +
9 * stride +
0 , vextq_u16(c01[
2 ], c01[
3 ],
2 ));
vst1q_u16(dst +
9 * stride +
8 , vextq_u16(c01[
3 ], c01[
4 ],
2 ));
vst1q_u16(dst +
9 * stride +
16 , vextq_u16(c01[
4 ], c01[
5 ],
2 ));
vst1q_u16(dst +
9 * stride +
24 , vextq_u16(c01[
5 ], c01[
6 ],
2 ));
vst1q_u16(dst +
10 * stride +
0 , vextq_u16(c01[
2 ], c01[
3 ],
4 ));
vst1q_u16(dst +
10 * stride +
8 , vextq_u16(c01[
3 ], c01[
4 ],
4 ));
vst1q_u16(dst +
10 * stride +
16 , vextq_u16(c01[
4 ], c01[
5 ],
4 ));
vst1q_u16(dst +
10 * stride +
24 , vextq_u16(c01[
5 ], c01[
6 ],
4 ));
vst1q_u16(dst +
11 * stride +
0 , vextq_u16(c01[
2 ], c01[
3 ],
6 ));
vst1q_u16(dst +
11 * stride +
8 , vextq_u16(c01[
3 ], c01[
4 ],
6 ));
vst1q_u16(dst +
11 * stride +
16 , vextq_u16(c01[
4 ], c01[
5 ],
6 ));
vst1q_u16(dst +
11 * stride +
24 , vextq_u16(c01[
5 ], c01[
6 ],
6 ));
vst1q_u16(dst +
12 * stride +
0 , c01[
3 ]);
vst1q_u16(dst +
12 * stride +
8 , c01[
4 ]);
vst1q_u16(dst +
12 * stride +
16 , c01[
5 ]);
vst1q_u16(dst +
12 * stride +
24 , c01[
6 ]);
vst1q_u16(dst +
13 * stride +
0 , vextq_u16(c01[
3 ], c01[
4 ],
2 ));
vst1q_u16(dst +
13 * stride +
8 , vextq_u16(c01[
4 ], c01[
5 ],
2 ));
vst1q_u16(dst +
13 * stride +
16 , vextq_u16(c01[
5 ], c01[
6 ],
2 ));
vst1q_u16(dst +
13 * stride +
24 , vextq_u16(c01[
6 ], c01[
7 ],
2 ));
vst1q_u16(dst +
14 * stride +
0 , vextq_u16(c01[
3 ], c01[
4 ],
4 ));
vst1q_u16(dst +
14 * stride +
8 , vextq_u16(c01[
4 ], c01[
5 ],
4 ));
vst1q_u16(dst +
14 * stride +
16 , vextq_u16(c01[
5 ], c01[
6 ],
4 ));
vst1q_u16(dst +
14 * stride +
24 , vextq_u16(c01[
6 ], c01[
7 ],
4 ));
vst1q_u16(dst +
15 * stride +
0 , vextq_u16(c01[
3 ], c01[
4 ],
6 ));
vst1q_u16(dst +
15 * stride +
8 , vextq_u16(c01[
4 ], c01[
5 ],
6 ));
vst1q_u16(dst +
15 * stride +
16 , vextq_u16(c01[
5 ], c01[
6 ],
6 ));
vst1q_u16(dst +
15 * stride +
24 , vextq_u16(c01[
6 ], c01[
7 ],
6 ));
vst1q_u16(dst +
16 * stride +
0 , c01[
4 ]);
vst1q_u16(dst +
16 * stride +
8 , c01[
5 ]);
vst1q_u16(dst +
16 * stride +
16 , c01[
6 ]);
vst1q_u16(dst +
16 * stride +
24 , c01[
7 ]);
vst1q_u16(dst +
17 * stride +
0 , vextq_u16(c01[
4 ], c01[
5 ],
2 ));
vst1q_u16(dst +
17 * stride +
8 , vextq_u16(c01[
5 ], c01[
6 ],
2 ));
vst1q_u16(dst +
17 * stride +
16 , vextq_u16(c01[
6 ], c01[
7 ],
2 ));
vst1q_u16(dst +
17 * stride +
24 , vextq_u16(c01[
7 ], l31,
2 ));
vst1q_u16(dst +
18 * stride +
0 , vextq_u16(c01[
4 ], c01[
5 ],
4 ));
vst1q_u16(dst +
18 * stride +
8 , vextq_u16(c01[
5 ], c01[
6 ],
4 ));
vst1q_u16(dst +
18 * stride +
16 , vextq_u16(c01[
6 ], c01[
7 ],
4 ));
vst1q_u16(dst +
18 * stride +
24 , vextq_u16(c01[
7 ], l31,
4 ));
vst1q_u16(dst +
19 * stride +
0 , vextq_u16(c01[
4 ], c01[
5 ],
6 ));
vst1q_u16(dst +
19 * stride +
8 , vextq_u16(c01[
5 ], c01[
6 ],
6 ));
vst1q_u16(dst +
19 * stride +
16 , vextq_u16(c01[
6 ], c01[
7 ],
6 ));
vst1q_u16(dst +
19 * stride +
24 , vextq_u16(c01[
7 ], l31,
6 ));
vst1q_u16(dst +
20 * stride +
0 , c01[
5 ]);
vst1q_u16(dst +
20 * stride +
8 , c01[
6 ]);
vst1q_u16(dst +
20 * stride +
16 , c01[
7 ]);
vst1q_u16(dst +
20 * stride +
24 , l31);
vst1q_u16(dst +
21 * stride +
0 , vextq_u16(c01[
5 ], c01[
6 ],
2 ));
vst1q_u16(dst +
21 * stride +
8 , vextq_u16(c01[
6 ], c01[
7 ],
2 ));
vst1q_u16(dst +
21 * stride +
16 , vextq_u16(c01[
7 ], l31,
2 ));
vst1q_u16(dst +
21 * stride +
24 , vextq_u16(l31, l31,
2 ));
vst1q_u16(dst +
22 * stride +
0 , vextq_u16(c01[
5 ], c01[
6 ],
4 ));
vst1q_u16(dst +
22 * stride +
8 , vextq_u16(c01[
6 ], c01[
7 ],
4 ));
vst1q_u16(dst +
22 * stride +
16 , vextq_u16(c01[
7 ], l31,
4 ));
vst1q_u16(dst +
22 * stride +
24 , vextq_u16(l31, l31,
4 ));
vst1q_u16(dst +
23 * stride +
0 , vextq_u16(c01[
5 ], c01[
6 ],
6 ));
vst1q_u16(dst +
23 * stride +
8 , vextq_u16(c01[
6 ], c01[
7 ],
6 ));
vst1q_u16(dst +
23 * stride +
16 , vextq_u16(c01[
7 ], l31,
6 ));
vst1q_u16(dst +
23 * stride +
24 , vextq_u16(l31, l31,
6 ));
vst1q_u16(dst +
24 * stride +
0 , c01[
6 ]);
vst1q_u16(dst +
24 * stride +
8 , c01[
7 ]);
vst1q_u16(dst +
24 * stride +
16 , l31);
vst1q_u16(dst +
24 * stride +
24 , l31);
vst1q_u16(dst +
25 * stride +
0 , vextq_u16(c01[
6 ], c01[
7 ],
2 ));
vst1q_u16(dst +
25 * stride +
8 , vextq_u16(c01[
7 ], l31,
2 ));
vst1q_u16(dst +
25 * stride +
16 , vextq_u16(l31, l31,
2 ));
vst1q_u16(dst +
25 * stride +
24 , vextq_u16(l31, l31,
2 ));
vst1q_u16(dst +
26 * stride +
0 , vextq_u16(c01[
6 ], c01[
7 ],
4 ));
vst1q_u16(dst +
26 * stride +
8 , vextq_u16(c01[
7 ], l31,
4 ));
vst1q_u16(dst +
26 * stride +
16 , vextq_u16(l31, l31,
4 ));
vst1q_u16(dst +
26 * stride +
24 , vextq_u16(l31, l31,
4 ));
vst1q_u16(dst +
27 * stride +
0 , vextq_u16(c01[
6 ], c01[
7 ],
6 ));
vst1q_u16(dst +
27 * stride +
8 , vextq_u16(c01[
7 ], l31,
6 ));
vst1q_u16(dst +
27 * stride +
16 , vextq_u16(l31, l31,
6 ));
vst1q_u16(dst +
27 * stride +
24 , vextq_u16(l31, l31,
6 ));
vst1q_u16(dst +
28 * stride +
0 , c01[
7 ]);
vst1q_u16(dst +
28 * stride +
8 , l31);
vst1q_u16(dst +
28 * stride +
16 , l31);
vst1q_u16(dst +
28 * stride +
24 , l31);
vst1q_u16(dst +
29 * stride +
0 , vextq_u16(c01[
7 ], l31,
2 ));
vst1q_u16(dst +
29 * stride +
8 , vextq_u16(l31, l31,
2 ));
vst1q_u16(dst +
29 * stride +
16 , vextq_u16(l31, l31,
2 ));
vst1q_u16(dst +
29 * stride +
24 , vextq_u16(l31, l31,
2 ));
vst1q_u16(dst +
30 * stride +
0 , vextq_u16(c01[
7 ], l31,
4 ));
vst1q_u16(dst +
30 * stride +
8 , vextq_u16(l31, l31,
4 ));
vst1q_u16(dst +
30 * stride +
16 , vextq_u16(l31, l31,
4 ));
vst1q_u16(dst +
30 * stride +
24 , vextq_u16(l31, l31,
4 ));
vst1q_u16(dst +
31 * stride +
0 , vextq_u16(c01[
7 ], l31,
6 ));
vst1q_u16(dst +
31 * stride +
8 , vextq_u16(l31, l31,
6 ));
vst1q_u16(dst +
31 * stride +
16 , vextq_u16(l31, l31,
6 ));
vst1q_u16(dst +
31 * stride +
24 , vextq_u16(l31, l31,
6 ));
}
//------------------------------------------------------------------------------
void vpx_highbd_v_predictor_4x4_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x4_t row = vld1_u16(above);
int i;
(
void )left;
(
void )bd;
for (i =
0 ; i <
4 ; i++, dst += stride) {
vst1_u16(dst, row);
}
}
void vpx_highbd_v_predictor_8x8_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t row = vld1q_u16(above);
int i;
(
void )left;
(
void )bd;
for (i =
0 ; i <
8 ; i++, dst += stride) {
vst1q_u16(dst, row);
}
}
void vpx_highbd_v_predictor_16x16_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t row0 = vld1q_u16(above +
0 );
const uint16x8_t row1 = vld1q_u16(above +
8 );
int i;
(
void )left;
(
void )bd;
for (i =
0 ; i <
16 ; i++) {
vst1q_u16(dst +
0 , row0);
vst1q_u16(dst +
8 , row1);
dst += stride;
}
}
void vpx_highbd_v_predictor_32x32_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t row0 = vld1q_u16(above +
0 );
const uint16x8_t row1 = vld1q_u16(above +
8 );
const uint16x8_t row2 = vld1q_u16(above +
16 );
const uint16x8_t row3 = vld1q_u16(above +
24 );
int i;
(
void )left;
(
void )bd;
for (i =
0 ; i <
32 ; i++) {
vst1q_u16(dst +
0 , row0);
vst1q_u16(dst +
8 , row1);
vst1q_u16(dst +
16 , row2);
vst1q_u16(dst +
24 , row3);
dst += stride;
}
}
// -----------------------------------------------------------------------------
void vpx_highbd_h_predictor_4x4_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x4_t left_u16 = vld1_u16(left);
uint16x4_t row;
(
void )above;
(
void )bd;
row = vdup_lane_u16(left_u16,
0 );
vst1_u16(dst, row);
dst += stride;
row = vdup_lane_u16(left_u16,
1 );
vst1_u16(dst, row);
dst += stride;
row = vdup_lane_u16(left_u16,
2 );
vst1_u16(dst, row);
dst += stride;
row = vdup_lane_u16(left_u16,
3 );
vst1_u16(dst, row);
}
void vpx_highbd_h_predictor_8x8_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const uint16x8_t left_u16 = vld1q_u16(left);
const uint16x4_t left_low = vget_low_u16(left_u16);
const uint16x4_t left_high = vget_high_u16(left_u16);
uint16x8_t row;
(
void )above;
(
void )bd;
row = vdupq_lane_u16(left_low,
0 );
vst1q_u16(dst, row);
dst += stride;
row = vdupq_lane_u16(left_low,
1 );
vst1q_u16(dst, row);
dst += stride;
row = vdupq_lane_u16(left_low,
2 );
vst1q_u16(dst, row);
dst += stride;
row = vdupq_lane_u16(left_low,
3 );
vst1q_u16(dst, row);
dst += stride;
row = vdupq_lane_u16(left_high,
0 );
vst1q_u16(dst, row);
dst += stride;
row = vdupq_lane_u16(left_high,
1 );
vst1q_u16(dst, row);
dst += stride;
row = vdupq_lane_u16(left_high,
2 );
vst1q_u16(dst, row);
dst += stride;
row = vdupq_lane_u16(left_high,
3 );
vst1q_u16(dst, row);
}
static INLINE void h_store_16(uint16_t **dst,
const ptrdiff_t stride,
const uint16x8_t row) {
// Note: vst1q is faster than vst2q
vst1q_u16(*dst, row);
*dst +=
8 ;
vst1q_u16(*dst, row);
*dst += stride -
8 ;
}
void vpx_highbd_h_predictor_16x16_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
int i;
(
void )above;
(
void )bd;
for (i =
0 ; i <
2 ; i++, left +=
8 ) {
const uint16x8_t left_u16q = vld1q_u16(left);
const uint16x4_t left_low = vget_low_u16(left_u16q);
const uint16x4_t left_high = vget_high_u16(left_u16q);
uint16x8_t row;
row = vdupq_lane_u16(left_low,
0 );
h_store_16(&dst, stride, row);
row = vdupq_lane_u16(left_low,
1 );
h_store_16(&dst, stride, row);
row = vdupq_lane_u16(left_low,
2 );
h_store_16(&dst, stride, row);
row = vdupq_lane_u16(left_low,
3 );
h_store_16(&dst, stride, row);
row = vdupq_lane_u16(left_high,
0 );
h_store_16(&dst, stride, row);
row = vdupq_lane_u16(left_high,
1 );
h_store_16(&dst, stride, row);
row = vdupq_lane_u16(left_high,
2 );
h_store_16(&dst, stride, row);
row = vdupq_lane_u16(left_high,
3 );
h_store_16(&dst, stride, row);
}
}
static INLINE void h_store_32(uint16_t **dst,
const ptrdiff_t stride,
const uint16x8_t row) {
// Note: vst1q is faster than vst2q
vst1q_u16(*dst, row);
*dst +=
8 ;
vst1q_u16(*dst, row);
*dst +=
8 ;
vst1q_u16(*dst, row);
*dst +=
8 ;
vst1q_u16(*dst, row);
*dst += stride -
24 ;
}
void vpx_highbd_h_predictor_32x32_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
int i;
(
void )above;
(
void )bd;
for (i =
0 ; i <
4 ; i++, left +=
8 ) {
const uint16x8_t left_u16q = vld1q_u16(left);
const uint16x4_t left_low = vget_low_u16(left_u16q);
const uint16x4_t left_high = vget_high_u16(left_u16q);
uint16x8_t row;
row = vdupq_lane_u16(left_low,
0 );
h_store_32(&dst, stride, row);
row = vdupq_lane_u16(left_low,
1 );
h_store_32(&dst, stride, row);
row = vdupq_lane_u16(left_low,
2 );
h_store_32(&dst, stride, row);
row = vdupq_lane_u16(left_low,
3 );
h_store_32(&dst, stride, row);
row = vdupq_lane_u16(left_high,
0 );
h_store_32(&dst, stride, row);
row = vdupq_lane_u16(left_high,
1 );
h_store_32(&dst, stride, row);
row = vdupq_lane_u16(left_high,
2 );
h_store_32(&dst, stride, row);
row = vdupq_lane_u16(left_high,
3 );
h_store_32(&dst, stride, row);
}
}
// -----------------------------------------------------------------------------
void vpx_highbd_tm_predictor_4x4_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const int16x8_t max = vmovq_n_s16((
1 << bd) -
1 );
const int16x8_t top_left = vld1q_dup_s16((
const int16_t *)(above -
1 ));
const int16x4_t above_s16d = vld1_s16((
const int16_t *)above);
const int16x8_t above_s16 = vcombine_s16(above_s16d, above_s16d);
const int16x4_t left_s16 = vld1_s16((
const int16_t *)left);
const int16x8_t sub = vsubq_s16(above_s16, top_left);
int16x8_t sum;
uint16x8_t row;
sum = vcombine_s16(vdup_lane_s16(left_s16,
0 ), vdup_lane_s16(left_s16,
1 ));
sum = vaddq_s16(sum, sub);
sum = vminq_s16(sum, max);
row = vqshluq_n_s16(sum,
0 );
vst1_u16(dst, vget_low_u16(row));
dst += stride;
vst1_u16(dst, vget_high_u16(row));
dst += stride;
sum = vcombine_s16(vdup_lane_s16(left_s16,
2 ), vdup_lane_s16(left_s16,
3 ));
sum = vaddq_s16(sum, sub);
sum = vminq_s16(sum, max);
row = vqshluq_n_s16(sum,
0 );
vst1_u16(dst, vget_low_u16(row));
dst += stride;
vst1_u16(dst, vget_high_u16(row));
}
static INLINE void tm_8_kernel(uint16_t **dst,
const ptrdiff_t stride,
const int16x8_t left_dup,
const int16x8_t sub,
const int16x8_t max) {
uint16x8_t row;
int16x8_t sum = vaddq_s16(left_dup, sub);
sum = vminq_s16(sum, max);
row = vqshluq_n_s16(sum,
0 );
vst1q_u16(*dst, row);
*dst += stride;
}
void vpx_highbd_tm_predictor_8x8_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const int16x8_t max = vmovq_n_s16((
1 << bd) -
1 );
const int16x8_t top_left = vld1q_dup_s16((
const int16_t *)(above -
1 ));
const int16x8_t above_s16 = vld1q_s16((
const int16_t *)above);
const int16x8_t left_s16 = vld1q_s16((
const int16_t *)left);
const int16x8_t sub = vsubq_s16(above_s16, top_left);
int16x4_t left_s16d;
int16x8_t left_dup;
int i;
left_s16d = vget_low_s16(left_s16);
for (i =
0 ; i <
2 ; i++, left_s16d = vget_high_s16(left_s16)) {
left_dup = vdupq_lane_s16(left_s16d,
0 );
tm_8_kernel(&dst, stride, left_dup, sub, max);
left_dup = vdupq_lane_s16(left_s16d,
1 );
tm_8_kernel(&dst, stride, left_dup, sub, max);
left_dup = vdupq_lane_s16(left_s16d,
2 );
tm_8_kernel(&dst, stride, left_dup, sub, max);
left_dup = vdupq_lane_s16(left_s16d,
3 );
tm_8_kernel(&dst, stride, left_dup, sub, max);
}
}
static INLINE void tm_16_kernel(uint16_t **dst,
const ptrdiff_t stride,
const int16x8_t left_dup,
const int16x8_t sub0,
const int16x8_t sub1,
const int16x8_t max) {
uint16x8_t row0, row1;
int16x8_t sum0 = vaddq_s16(left_dup, sub0);
int16x8_t sum1 = vaddq_s16(left_dup, sub1);
sum0 = vminq_s16(sum0, max);
sum1 = vminq_s16(sum1, max);
row0 = vqshluq_n_s16(sum0,
0 );
row1 = vqshluq_n_s16(sum1,
0 );
vst1q_u16(*dst, row0);
*dst +=
8 ;
vst1q_u16(*dst, row1);
*dst += stride -
8 ;
}
void vpx_highbd_tm_predictor_16x16_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const int16x8_t max = vmovq_n_s16((
1 << bd) -
1 );
const int16x8_t top_left = vld1q_dup_s16((
const int16_t *)(above -
1 ));
const int16x8_t above0 = vld1q_s16((
const int16_t *)above);
const int16x8_t above1 = vld1q_s16((
const int16_t *)(above +
8 ));
const int16x8_t sub0 = vsubq_s16(above0, top_left);
const int16x8_t sub1 = vsubq_s16(above1, top_left);
int16x8_t left_dup;
int i, j;
for (j =
0 ; j <
2 ; j++, left +=
8 ) {
const int16x8_t left_s16q = vld1q_s16((
const int16_t *)left);
int16x4_t left_s16d = vget_low_s16(left_s16q);
for (i =
0 ; i <
2 ; i++, left_s16d = vget_high_s16(left_s16q)) {
left_dup = vdupq_lane_s16(left_s16d,
0 );
tm_16_kernel(&dst, stride, left_dup, sub0, sub1, max);
left_dup = vdupq_lane_s16(left_s16d,
1 );
tm_16_kernel(&dst, stride, left_dup, sub0, sub1, max);
left_dup = vdupq_lane_s16(left_s16d,
2 );
tm_16_kernel(&dst, stride, left_dup, sub0, sub1, max);
left_dup = vdupq_lane_s16(left_s16d,
3 );
tm_16_kernel(&dst, stride, left_dup, sub0, sub1, max);
}
}
}
static INLINE void tm_32_kernel(uint16_t **dst,
const ptrdiff_t stride,
const int16x8_t left_dup,
const int16x8_t sub0,
const int16x8_t sub1,
const int16x8_t sub2,
const int16x8_t sub3,
const int16x8_t max) {
uint16x8_t row0, row1, row2, row3;
int16x8_t sum0 = vaddq_s16(left_dup, sub0);
int16x8_t sum1 = vaddq_s16(left_dup, sub1);
int16x8_t sum2 = vaddq_s16(left_dup, sub2);
int16x8_t sum3 = vaddq_s16(left_dup, sub3);
sum0 = vminq_s16(sum0, max);
sum1 = vminq_s16(sum1, max);
sum2 = vminq_s16(sum2, max);
sum3 = vminq_s16(sum3, max);
row0 = vqshluq_n_s16(sum0,
0 );
row1 = vqshluq_n_s16(sum1,
0 );
row2 = vqshluq_n_s16(sum2,
0 );
row3 = vqshluq_n_s16(sum3,
0 );
vst1q_u16(*dst, row0);
*dst +=
8 ;
vst1q_u16(*dst, row1);
*dst +=
8 ;
vst1q_u16(*dst, row2);
*dst +=
8 ;
vst1q_u16(*dst, row3);
*dst += stride -
24 ;
}
void vpx_highbd_tm_predictor_32x32_neon(uint16_t *dst, ptrdiff_t stride,
const uint16_t *above,
const uint16_t *left,
int bd) {
const int16x8_t max = vmovq_n_s16((
1 << bd) -
1 );
const int16x8_t top_left = vld1q_dup_s16((
const int16_t *)(above -
1 ));
const int16x8_t above0 = vld1q_s16((
const int16_t *)above);
const int16x8_t above1 = vld1q_s16((
const int16_t *)(above +
8 ));
const int16x8_t above2 = vld1q_s16((
const int16_t *)(above +
16 ));
const int16x8_t above3 = vld1q_s16((
const int16_t *)(above +
24 ));
const int16x8_t sub0 = vsubq_s16(above0, top_left);
const int16x8_t sub1 = vsubq_s16(above1, top_left);
const int16x8_t sub2 = vsubq_s16(above2, top_left);
const int16x8_t sub3 = vsubq_s16(above3, top_left);
int16x8_t left_dup;
int i, j;
for (i =
0 ; i <
4 ; i++, left +=
8 ) {
const int16x8_t left_s16q = vld1q_s16((
const int16_t *)left);
int16x4_t left_s16d = vget_low_s16(left_s16q);
for (j =
0 ; j <
2 ; j++, left_s16d = vget_high_s16(left_s16q)) {
left_dup = vdupq_lane_s16(left_s16d,
0 );
tm_32_kernel(&dst, stride, left_dup, sub0, sub1, sub2, sub3, max);
left_dup = vdupq_lane_s16(left_s16d,
1 );
tm_32_kernel(&dst, stride, left_dup, sub0, sub1, sub2, sub3, max);
left_dup = vdupq_lane_s16(left_s16d,
2 );
tm_32_kernel(&dst, stride, left_dup, sub0, sub1, sub2, sub3, max);
left_dup = vdupq_lane_s16(left_s16d,
3 );
tm_32_kernel(&dst, stride, left_dup, sub0, sub1, sub2, sub3, max);
}
}
}
Messung V0.5 in Prozent C=93 H=95 G=93
¤ Dauer der Verarbeitung: 0.39 Sekunden
(vorverarbeitet am 2026-06-06)
¤ *© Formatika GbR, Deutschland
