CoCalc -- enc

GitHub Repository: Tetragramm/opencv
Path: blob/master/3rdparty/libwebp/src/dsp/enc_msa.c
¹⁶³⁴⁸ views
1
// Copyright 2016 Google Inc. All Rights Reserved.
2
//
3
// Use of this source code is governed by a BSD-style license
4
// that can be found in the COPYING file in the root of the source
5
// tree. An additional intellectual property rights grant can be found
6
// in the file PATENTS. All contributing project authors may
7
// be found in the AUTHORS file in the root of the source tree.
8
// -----------------------------------------------------------------------------
9
//
10
// MSA version of encoder dsp functions.
11
//
12
// Author:  Prashant Patil   ([email protected])
13

14
#include "src/dsp/dsp.h"
15

16
#if defined(WEBP_USE_MSA)
17

18
#include <stdlib.h>
19
#include "src/dsp/msa_macro.h"
20
#include "src/enc/vp8i_enc.h"
21

22
//------------------------------------------------------------------------------
23
// Transforms
24

25
#define IDCT_1D_W(in0, in1, in2, in3, out0, out1, out2, out3) do {  \
26
  v4i32 a1_m, b1_m, c1_m, d1_m;                                     \
27
  const v4i32 cospi8sqrt2minus1 = __msa_fill_w(20091);              \
28
  const v4i32 sinpi8sqrt2 = __msa_fill_w(35468);                    \
29
  v4i32 c_tmp1_m = in1 * sinpi8sqrt2;                               \
30
  v4i32 c_tmp2_m = in3 * cospi8sqrt2minus1;                         \
31
  v4i32 d_tmp1_m = in1 * cospi8sqrt2minus1;                         \
32
  v4i32 d_tmp2_m = in3 * sinpi8sqrt2;                               \
33
                                                                    \
34
  ADDSUB2(in0, in2, a1_m, b1_m);                                    \
35
  SRAI_W2_SW(c_tmp1_m, c_tmp2_m, 16);                               \
36
  c_tmp2_m = c_tmp2_m + in3;                                        \
37
  c1_m = c_tmp1_m - c_tmp2_m;                                       \
38
  SRAI_W2_SW(d_tmp1_m, d_tmp2_m, 16);                               \
39
  d_tmp1_m = d_tmp1_m + in1;                                        \
40
  d1_m = d_tmp1_m + d_tmp2_m;                                       \
41
  BUTTERFLY_4(a1_m, b1_m, c1_m, d1_m, out0, out1, out2, out3);      \
42
} while (0)
43

44
static WEBP_INLINE void ITransformOne(const uint8_t* ref, const int16_t* in,
45
                                      uint8_t* dst) {
46
  v8i16 input0, input1;
47
  v4i32 in0, in1, in2, in3, hz0, hz1, hz2, hz3, vt0, vt1, vt2, vt3;
48
  v4i32 res0, res1, res2, res3;
49
  v16i8 dest0, dest1, dest2, dest3;
50
  const v16i8 zero = { 0 };
51

52
  LD_SH2(in, 8, input0, input1);
53
  UNPCK_SH_SW(input0, in0, in1);
54
  UNPCK_SH_SW(input1, in2, in3);
55
  IDCT_1D_W(in0, in1, in2, in3, hz0, hz1, hz2, hz3);
56
  TRANSPOSE4x4_SW_SW(hz0, hz1, hz2, hz3, hz0, hz1, hz2, hz3);
57
  IDCT_1D_W(hz0, hz1, hz2, hz3, vt0, vt1, vt2, vt3);
58
  SRARI_W4_SW(vt0, vt1, vt2, vt3, 3);
59
  TRANSPOSE4x4_SW_SW(vt0, vt1, vt2, vt3, vt0, vt1, vt2, vt3);
60
  LD_SB4(ref, BPS, dest0, dest1, dest2, dest3);
61
  ILVR_B4_SW(zero, dest0, zero, dest1, zero, dest2, zero, dest3,
62
             res0, res1, res2, res3);
63
  ILVR_H4_SW(zero, res0, zero, res1, zero, res2, zero, res3,
64
             res0, res1, res2, res3);
65
  ADD4(res0, vt0, res1, vt1, res2, vt2, res3, vt3, res0, res1, res2, res3);
66
  CLIP_SW4_0_255(res0, res1, res2, res3);
67
  PCKEV_B2_SW(res0, res1, res2, res3, vt0, vt1);
68
  res0 = (v4i32)__msa_pckev_b((v16i8)vt0, (v16i8)vt1);
69
  ST4x4_UB(res0, res0, 3, 2, 1, 0, dst, BPS);
70
}
71

72
static void ITransform_MSA(const uint8_t* ref, const int16_t* in, uint8_t* dst,
73
                           int do_two) {
74
  ITransformOne(ref, in, dst);
75
  if (do_two) {
76
    ITransformOne(ref + 4, in + 16, dst + 4);
77
  }
78
}
79

80
static void FTransform_MSA(const uint8_t* src, const uint8_t* ref,
81
                           int16_t* out) {
82
  uint64_t out0, out1, out2, out3;
83
  uint32_t in0, in1, in2, in3;
84
  v4i32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
85
  v8i16 t0, t1, t2, t3;
86
  v16u8 srcl0, srcl1, src0 = { 0 }, src1 = { 0 };
87
  const v8i16 mask0 = { 0, 4, 8, 12, 1, 5, 9, 13 };
88
  const v8i16 mask1 = { 3, 7, 11, 15, 2, 6, 10, 14 };
89
  const v8i16 mask2 = { 4, 0, 5, 1, 6, 2, 7, 3 };
90
  const v8i16 mask3 = { 0, 4, 1, 5, 2, 6, 3, 7 };
91
  const v8i16 cnst0 = { 2217, -5352, 2217, -5352, 2217, -5352, 2217, -5352 };
92
  const v8i16 cnst1 = { 5352, 2217, 5352, 2217, 5352, 2217, 5352, 2217 };
93

94
  LW4(src, BPS, in0, in1, in2, in3);
95
  INSERT_W4_UB(in0, in1, in2, in3, src0);
96
  LW4(ref, BPS, in0, in1, in2, in3);
97
  INSERT_W4_UB(in0, in1, in2, in3, src1);
98
  ILVRL_B2_UB(src0, src1, srcl0, srcl1);
99
  HSUB_UB2_SH(srcl0, srcl1, t0, t1);
100
  VSHF_H2_SH(t0, t1, t0, t1, mask0, mask1, t2, t3);
101
  ADDSUB2(t2, t3, t0, t1);
102
  t0 = SRLI_H(t0, 3);
103
  VSHF_H2_SH(t0, t0, t1, t1, mask2, mask3, t3, t2);
104
  tmp0 = __msa_hadd_s_w(t3, t3);
105
  tmp2 = __msa_hsub_s_w(t3, t3);
106
  FILL_W2_SW(1812, 937, tmp1, tmp3);
107
  DPADD_SH2_SW(t2, t2, cnst0, cnst1, tmp3, tmp1);
108
  SRAI_W2_SW(tmp1, tmp3, 9);
109
  PCKEV_H2_SH(tmp1, tmp0, tmp3, tmp2, t0, t1);
110
  VSHF_H2_SH(t0, t1, t0, t1, mask0, mask1, t2, t3);
111
  ADDSUB2(t2, t3, t0, t1);
112
  VSHF_H2_SH(t0, t0, t1, t1, mask2, mask3, t3, t2);
113
  tmp0 = __msa_hadd_s_w(t3, t3);
114
  tmp2 = __msa_hsub_s_w(t3, t3);
115
  ADDVI_W2_SW(tmp0, 7, tmp2, 7, tmp0, tmp2);
116
  SRAI_W2_SW(tmp0, tmp2, 4);
117
  FILL_W2_SW(12000, 51000, tmp1, tmp3);
118
  DPADD_SH2_SW(t2, t2, cnst0, cnst1, tmp3, tmp1);
119
  SRAI_W2_SW(tmp1, tmp3, 16);
120
  UNPCK_R_SH_SW(t1, tmp4);
121
  tmp5 = __msa_ceqi_w(tmp4, 0);
122
  tmp4 = (v4i32)__msa_nor_v((v16u8)tmp5, (v16u8)tmp5);
123
  tmp5 = __msa_fill_w(1);
124
  tmp5 = (v4i32)__msa_and_v((v16u8)tmp5, (v16u8)tmp4);
125
  tmp1 += tmp5;
126
  PCKEV_H2_SH(tmp1, tmp0, tmp3, tmp2, t0, t1);
127
  out0 = __msa_copy_s_d((v2i64)t0, 0);
128
  out1 = __msa_copy_s_d((v2i64)t0, 1);
129
  out2 = __msa_copy_s_d((v2i64)t1, 0);
130
  out3 = __msa_copy_s_d((v2i64)t1, 1);
131
  SD4(out0, out1, out2, out3, out, 8);
132
}
133

134
static void FTransformWHT_MSA(const int16_t* in, int16_t* out) {
135
  v8i16 in0 = { 0 };
136
  v8i16 in1 = { 0 };
137
  v8i16 tmp0, tmp1, tmp2, tmp3;
138
  v8i16 out0, out1;
139
  const v8i16 mask0 = { 0, 1, 2, 3, 8, 9, 10, 11 };
140
  const v8i16 mask1 = { 4, 5, 6, 7, 12, 13, 14, 15 };
141
  const v8i16 mask2 = { 0, 4, 8, 12, 1, 5, 9, 13 };
142
  const v8i16 mask3 = { 3, 7, 11, 15, 2, 6, 10, 14 };
143

144
  in0 = __msa_insert_h(in0, 0, in[  0]);
145
  in0 = __msa_insert_h(in0, 1, in[ 64]);
146
  in0 = __msa_insert_h(in0, 2, in[128]);
147
  in0 = __msa_insert_h(in0, 3, in[192]);
148
  in0 = __msa_insert_h(in0, 4, in[ 16]);
149
  in0 = __msa_insert_h(in0, 5, in[ 80]);
150
  in0 = __msa_insert_h(in0, 6, in[144]);
151
  in0 = __msa_insert_h(in0, 7, in[208]);
152
  in1 = __msa_insert_h(in1, 0, in[ 48]);
153
  in1 = __msa_insert_h(in1, 1, in[112]);
154
  in1 = __msa_insert_h(in1, 2, in[176]);
155
  in1 = __msa_insert_h(in1, 3, in[240]);
156
  in1 = __msa_insert_h(in1, 4, in[ 32]);
157
  in1 = __msa_insert_h(in1, 5, in[ 96]);
158
  in1 = __msa_insert_h(in1, 6, in[160]);
159
  in1 = __msa_insert_h(in1, 7, in[224]);
160
  ADDSUB2(in0, in1, tmp0, tmp1);
161
  VSHF_H2_SH(tmp0, tmp1, tmp0, tmp1, mask0, mask1, tmp2, tmp3);
162
  ADDSUB2(tmp2, tmp3, tmp0, tmp1);
163
  VSHF_H2_SH(tmp0, tmp1, tmp0, tmp1, mask2, mask3, in0, in1);
164
  ADDSUB2(in0, in1, tmp0, tmp1);
165
  VSHF_H2_SH(tmp0, tmp1, tmp0, tmp1, mask0, mask1, tmp2, tmp3);
166
  ADDSUB2(tmp2, tmp3, out0, out1);
167
  SRAI_H2_SH(out0, out1, 1);
168
  ST_SH2(out0, out1, out, 8);
169
}
170

171
static int TTransform_MSA(const uint8_t* in, const uint16_t* w) {
172
  int sum;
173
  uint32_t in0_m, in1_m, in2_m, in3_m;
174
  v16i8 src0 = { 0 };
175
  v8i16 in0, in1, tmp0, tmp1, tmp2, tmp3;
176
  v4i32 dst0, dst1;
177
  const v16i8 zero = { 0 };
178
  const v8i16 mask0 = { 0, 1, 2, 3, 8, 9, 10, 11 };
179
  const v8i16 mask1 = { 4, 5, 6, 7, 12, 13, 14, 15 };
180
  const v8i16 mask2 = { 0, 4, 8, 12, 1, 5, 9, 13 };
181
  const v8i16 mask3 = { 3, 7, 11, 15, 2, 6, 10, 14 };
182

183
  LW4(in, BPS, in0_m, in1_m, in2_m, in3_m);
184
  INSERT_W4_SB(in0_m, in1_m, in2_m, in3_m, src0);
185
  ILVRL_B2_SH(zero, src0, tmp0, tmp1);
186
  VSHF_H2_SH(tmp0, tmp1, tmp0, tmp1, mask2, mask3, in0, in1);
187
  ADDSUB2(in0, in1, tmp0, tmp1);
188
  VSHF_H2_SH(tmp0, tmp1, tmp0, tmp1, mask0, mask1, tmp2, tmp3);
189
  ADDSUB2(tmp2, tmp3, tmp0, tmp1);
190
  VSHF_H2_SH(tmp0, tmp1, tmp0, tmp1, mask2, mask3, in0, in1);
191
  ADDSUB2(in0, in1, tmp0, tmp1);
192
  VSHF_H2_SH(tmp0, tmp1, tmp0, tmp1, mask0, mask1, tmp2, tmp3);
193
  ADDSUB2(tmp2, tmp3, tmp0, tmp1);
194
  tmp0 = __msa_add_a_h(tmp0, (v8i16)zero);
195
  tmp1 = __msa_add_a_h(tmp1, (v8i16)zero);
196
  LD_SH2(w, 8, tmp2, tmp3);
197
  DOTP_SH2_SW(tmp0, tmp1, tmp2, tmp3, dst0, dst1);
198
  dst0 = dst0 + dst1;
199
  sum = HADD_SW_S32(dst0);
200
  return sum;
201
}
202

203
static int Disto4x4_MSA(const uint8_t* const a, const uint8_t* const b,
204
                        const uint16_t* const w) {
205
  const int sum1 = TTransform_MSA(a, w);
206
  const int sum2 = TTransform_MSA(b, w);
207
  return abs(sum2 - sum1) >> 5;
208
}
209

210
static int Disto16x16_MSA(const uint8_t* const a, const uint8_t* const b,
211
                          const uint16_t* const w) {
212
  int D = 0;
213
  int x, y;
214
  for (y = 0; y < 16 * BPS; y += 4 * BPS) {
215
    for (x = 0; x < 16; x += 4) {
216
      D += Disto4x4_MSA(a + x + y, b + x + y, w);
217
    }
218
  }
219
  return D;
220
}
221

222
//------------------------------------------------------------------------------
223
// Histogram
224

225
static void CollectHistogram_MSA(const uint8_t* ref, const uint8_t* pred,
226
                                 int start_block, int end_block,
227
                                 VP8Histogram* const histo) {
228
  int j;
229
  int distribution[MAX_COEFF_THRESH + 1] = { 0 };
230
  for (j = start_block; j < end_block; ++j) {
231
    int16_t out[16];
232
    VP8FTransform(ref + VP8DspScan[j], pred + VP8DspScan[j], out);
233
    {
234
      int k;
235
      v8i16 coeff0, coeff1;
236
      const v8i16 zero = { 0 };
237
      const v8i16 max_coeff_thr = __msa_ldi_h(MAX_COEFF_THRESH);
238
      LD_SH2(&out[0], 8, coeff0, coeff1);
239
      coeff0 = __msa_add_a_h(coeff0, zero);
240
      coeff1 = __msa_add_a_h(coeff1, zero);
241
      SRAI_H2_SH(coeff0, coeff1, 3);
242
      coeff0 = __msa_min_s_h(coeff0, max_coeff_thr);
243
      coeff1 = __msa_min_s_h(coeff1, max_coeff_thr);
244
      ST_SH2(coeff0, coeff1, &out[0], 8);
245
      for (k = 0; k < 16; ++k) {
246
        ++distribution[out[k]];
247
      }
248
    }
249
  }
250
  VP8SetHistogramData(distribution, histo);
251
}
252

253
//------------------------------------------------------------------------------
254
// Intra predictions
255

256
// luma 4x4 prediction
257

258
#define DST(x, y) dst[(x) + (y) * BPS]
259
#define AVG3(a, b, c) (((a) + 2 * (b) + (c) + 2) >> 2)
260
#define AVG2(a, b) (((a) + (b) + 1) >> 1)
261

262
static WEBP_INLINE void VE4(uint8_t* dst, const uint8_t* top) {    // vertical
263
  const v16u8 A1 = { 0 };
264
  const uint64_t val_m = LD(top - 1);
265
  const v16u8 A = (v16u8)__msa_insert_d((v2i64)A1, 0, val_m);
266
  const v16u8 B = SLDI_UB(A, A, 1);
267
  const v16u8 C = SLDI_UB(A, A, 2);
268
  const v16u8 AC = __msa_ave_u_b(A, C);
269
  const v16u8 B2 = __msa_ave_u_b(B, B);
270
  const v16u8 R = __msa_aver_u_b(AC, B2);
271
  const uint32_t out = __msa_copy_s_w((v4i32)R, 0);
272
  SW4(out, out, out, out, dst, BPS);
273
}
274

275
static WEBP_INLINE void HE4(uint8_t* dst, const uint8_t* top) {    // horizontal
276
  const int X = top[-1];
277
  const int I = top[-2];
278
  const int J = top[-3];
279
  const int K = top[-4];
280
  const int L = top[-5];
281
  WebPUint32ToMem(dst + 0 * BPS, 0x01010101U * AVG3(X, I, J));
282
  WebPUint32ToMem(dst + 1 * BPS, 0x01010101U * AVG3(I, J, K));
283
  WebPUint32ToMem(dst + 2 * BPS, 0x01010101U * AVG3(J, K, L));
284
  WebPUint32ToMem(dst + 3 * BPS, 0x01010101U * AVG3(K, L, L));
285
}
286

287
static WEBP_INLINE void DC4(uint8_t* dst, const uint8_t* top) {
288
  uint32_t dc = 4;
289
  int i;
290
  for (i = 0; i < 4; ++i) dc += top[i] + top[-5 + i];
291
  dc >>= 3;
292
  dc = dc | (dc << 8) | (dc << 16) | (dc << 24);
293
  SW4(dc, dc, dc, dc, dst, BPS);
294
}
295

296
static WEBP_INLINE void RD4(uint8_t* dst, const uint8_t* top) {
297
  const v16u8 A2 = { 0 };
298
  const uint64_t val_m = LD(top - 5);
299
  const v16u8 A1 = (v16u8)__msa_insert_d((v2i64)A2, 0, val_m);
300
  const v16u8 A = (v16u8)__msa_insert_b((v16i8)A1, 8, top[3]);
301
  const v16u8 B = SLDI_UB(A, A, 1);
302
  const v16u8 C = SLDI_UB(A, A, 2);
303
  const v16u8 AC = __msa_ave_u_b(A, C);
304
  const v16u8 B2 = __msa_ave_u_b(B, B);
305
  const v16u8 R0 = __msa_aver_u_b(AC, B2);
306
  const v16u8 R1 = SLDI_UB(R0, R0, 1);
307
  const v16u8 R2 = SLDI_UB(R1, R1, 1);
308
  const v16u8 R3 = SLDI_UB(R2, R2, 1);
309
  const uint32_t val0 = __msa_copy_s_w((v4i32)R0, 0);
310
  const uint32_t val1 = __msa_copy_s_w((v4i32)R1, 0);
311
  const uint32_t val2 = __msa_copy_s_w((v4i32)R2, 0);
312
  const uint32_t val3 = __msa_copy_s_w((v4i32)R3, 0);
313
  SW4(val3, val2, val1, val0, dst, BPS);
314
}
315

316
static WEBP_INLINE void LD4(uint8_t* dst, const uint8_t* top) {
317
  const v16u8 A1 = { 0 };
318
  const uint64_t val_m = LD(top);
319
  const v16u8 A = (v16u8)__msa_insert_d((v2i64)A1, 0, val_m);
320
  const v16u8 B = SLDI_UB(A, A, 1);
321
  const v16u8 C1 = SLDI_UB(A, A, 2);
322
  const v16u8 C = (v16u8)__msa_insert_b((v16i8)C1, 6, top[7]);
323
  const v16u8 AC = __msa_ave_u_b(A, C);
324
  const v16u8 B2 = __msa_ave_u_b(B, B);
325
  const v16u8 R0 = __msa_aver_u_b(AC, B2);
326
  const v16u8 R1 = SLDI_UB(R0, R0, 1);
327
  const v16u8 R2 = SLDI_UB(R1, R1, 1);
328
  const v16u8 R3 = SLDI_UB(R2, R2, 1);
329
  const uint32_t val0 = __msa_copy_s_w((v4i32)R0, 0);
330
  const uint32_t val1 = __msa_copy_s_w((v4i32)R1, 0);
331
  const uint32_t val2 = __msa_copy_s_w((v4i32)R2, 0);
332
  const uint32_t val3 = __msa_copy_s_w((v4i32)R3, 0);
333
  SW4(val0, val1, val2, val3, dst, BPS);
334
}
335

336
static WEBP_INLINE void VR4(uint8_t* dst, const uint8_t* top) {
337
  const int X = top[-1];
338
  const int I = top[-2];
339
  const int J = top[-3];
340
  const int K = top[-4];
341
  const int A = top[0];
342
  const int B = top[1];
343
  const int C = top[2];
344
  const int D = top[3];
345
  DST(0, 0) = DST(1, 2) = AVG2(X, A);
346
  DST(1, 0) = DST(2, 2) = AVG2(A, B);
347
  DST(2, 0) = DST(3, 2) = AVG2(B, C);
348
  DST(3, 0)             = AVG2(C, D);
349
  DST(0, 3) =             AVG3(K, J, I);
350
  DST(0, 2) =             AVG3(J, I, X);
351
  DST(0, 1) = DST(1, 3) = AVG3(I, X, A);
352
  DST(1, 1) = DST(2, 3) = AVG3(X, A, B);
353
  DST(2, 1) = DST(3, 3) = AVG3(A, B, C);
354
  DST(3, 1) =             AVG3(B, C, D);
355
}
356

357
static WEBP_INLINE void VL4(uint8_t* dst, const uint8_t* top) {
358
  const int A = top[0];
359
  const int B = top[1];
360
  const int C = top[2];
361
  const int D = top[3];
362
  const int E = top[4];
363
  const int F = top[5];
364
  const int G = top[6];
365
  const int H = top[7];
366
  DST(0, 0) =             AVG2(A, B);
367
  DST(1, 0) = DST(0, 2) = AVG2(B, C);
368
  DST(2, 0) = DST(1, 2) = AVG2(C, D);
369
  DST(3, 0) = DST(2, 2) = AVG2(D, E);
370
  DST(0, 1) =             AVG3(A, B, C);
371
  DST(1, 1) = DST(0, 3) = AVG3(B, C, D);
372
  DST(2, 1) = DST(1, 3) = AVG3(C, D, E);
373
  DST(3, 1) = DST(2, 3) = AVG3(D, E, F);
374
              DST(3, 2) = AVG3(E, F, G);
375
              DST(3, 3) = AVG3(F, G, H);
376
}
377

378
static WEBP_INLINE void HU4(uint8_t* dst, const uint8_t* top) {
379
  const int I = top[-2];
380
  const int J = top[-3];
381
  const int K = top[-4];
382
  const int L = top[-5];
383
  DST(0, 0) =             AVG2(I, J);
384
  DST(2, 0) = DST(0, 1) = AVG2(J, K);
385
  DST(2, 1) = DST(0, 2) = AVG2(K, L);
386
  DST(1, 0) =             AVG3(I, J, K);
387
  DST(3, 0) = DST(1, 1) = AVG3(J, K, L);
388
  DST(3, 1) = DST(1, 2) = AVG3(K, L, L);
389
  DST(3, 2) = DST(2, 2) =
390
  DST(0, 3) = DST(1, 3) = DST(2, 3) = DST(3, 3) = L;
391
}
392

393
static WEBP_INLINE void HD4(uint8_t* dst, const uint8_t* top) {
394
  const int X = top[-1];
395
  const int I = top[-2];
396
  const int J = top[-3];
397
  const int K = top[-4];
398
  const int L = top[-5];
399
  const int A = top[0];
400
  const int B = top[1];
401
  const int C = top[2];
402
  DST(0, 0) = DST(2, 1) = AVG2(I, X);
403
  DST(0, 1) = DST(2, 2) = AVG2(J, I);
404
  DST(0, 2) = DST(2, 3) = AVG2(K, J);
405
  DST(0, 3)             = AVG2(L, K);
406
  DST(3, 0)             = AVG3(A, B, C);
407
  DST(2, 0)             = AVG3(X, A, B);
408
  DST(1, 0) = DST(3, 1) = AVG3(I, X, A);
409
  DST(1, 1) = DST(3, 2) = AVG3(J, I, X);
410
  DST(1, 2) = DST(3, 3) = AVG3(K, J, I);
411
  DST(1, 3)             = AVG3(L, K, J);
412
}
413

414
static WEBP_INLINE void TM4(uint8_t* dst, const uint8_t* top) {
415
  const v16i8 zero = { 0 };
416
  const v8i16 TL = (v8i16)__msa_fill_h(top[-1]);
417
  const v8i16 L0 = (v8i16)__msa_fill_h(top[-2]);
418
  const v8i16 L1 = (v8i16)__msa_fill_h(top[-3]);
419
  const v8i16 L2 = (v8i16)__msa_fill_h(top[-4]);
420
  const v8i16 L3 = (v8i16)__msa_fill_h(top[-5]);
421
  const v16u8 T1 = LD_UB(top);
422
  const v8i16 T  = (v8i16)__msa_ilvr_b(zero, (v16i8)T1);
423
  const v8i16 d = T - TL;
424
  v8i16 r0, r1, r2, r3;
425
  ADD4(d, L0, d, L1, d, L2, d, L3, r0, r1, r2, r3);
426
  CLIP_SH4_0_255(r0, r1, r2, r3);
427
  PCKEV_ST4x4_UB(r0, r1, r2, r3, dst, BPS);
428
}
429

430
#undef DST
431
#undef AVG3
432
#undef AVG2
433

434
static void Intra4Preds_MSA(uint8_t* dst, const uint8_t* top) {
435
  DC4(I4DC4 + dst, top);
436
  TM4(I4TM4 + dst, top);
437
  VE4(I4VE4 + dst, top);
438
  HE4(I4HE4 + dst, top);
439
  RD4(I4RD4 + dst, top);
440
  VR4(I4VR4 + dst, top);
441
  LD4(I4LD4 + dst, top);
442
  VL4(I4VL4 + dst, top);
443
  HD4(I4HD4 + dst, top);
444
  HU4(I4HU4 + dst, top);
445
}
446

447
// luma 16x16 prediction
448

449
#define STORE16x16(out, dst) do {                                        \
450
    ST_UB8(out, out, out, out, out, out, out, out, dst + 0 * BPS, BPS);  \
451
    ST_UB8(out, out, out, out, out, out, out, out, dst + 8 * BPS, BPS);  \
452
} while (0)
453

454
static WEBP_INLINE void VerticalPred16x16(uint8_t* dst, const uint8_t* top) {
455
  if (top != NULL) {
456
    const v16u8 out = LD_UB(top);
457
    STORE16x16(out, dst);
458
  } else {
459
    const v16u8 out = (v16u8)__msa_fill_b(0x7f);
460
    STORE16x16(out, dst);
461
  }
462
}
463

464
static WEBP_INLINE void HorizontalPred16x16(uint8_t* dst,
465
                                            const uint8_t* left) {
466
  if (left != NULL) {
467
    int j;
468
    for (j = 0; j < 16; j += 4) {
469
      const v16u8 L0 = (v16u8)__msa_fill_b(left[0]);
470
      const v16u8 L1 = (v16u8)__msa_fill_b(left[1]);
471
      const v16u8 L2 = (v16u8)__msa_fill_b(left[2]);
472
      const v16u8 L3 = (v16u8)__msa_fill_b(left[3]);
473
      ST_UB4(L0, L1, L2, L3, dst, BPS);
474
      dst += 4 * BPS;
475
      left += 4;
476
    }
477
  } else {
478
    const v16u8 out = (v16u8)__msa_fill_b(0x81);
479
    STORE16x16(out, dst);
480
  }
481
}
482

483
static WEBP_INLINE void TrueMotion16x16(uint8_t* dst, const uint8_t* left,
484
                                        const uint8_t* top) {
485
  if (left != NULL) {
486
    if (top != NULL) {
487
      int j;
488
      v8i16 d1, d2;
489
      const v16i8 zero = { 0 };
490
      const v8i16 TL = (v8i16)__msa_fill_h(left[-1]);
491
      const v16u8 T = LD_UB(top);
492
      ILVRL_B2_SH(zero, T, d1, d2);
493
      SUB2(d1, TL, d2, TL, d1, d2);
494
      for (j = 0; j < 16; j += 4) {
495
        v16i8 t0, t1, t2, t3;
496
        v8i16 r0, r1, r2, r3, r4, r5, r6, r7;
497
        const v8i16 L0 = (v8i16)__msa_fill_h(left[j + 0]);
498
        const v8i16 L1 = (v8i16)__msa_fill_h(left[j + 1]);
499
        const v8i16 L2 = (v8i16)__msa_fill_h(left[j + 2]);
500
        const v8i16 L3 = (v8i16)__msa_fill_h(left[j + 3]);
501
        ADD4(d1, L0, d1, L1, d1, L2, d1, L3, r0, r1, r2, r3);
502
        ADD4(d2, L0, d2, L1, d2, L2, d2, L3, r4, r5, r6, r7);
503
        CLIP_SH4_0_255(r0, r1, r2, r3);
504
        CLIP_SH4_0_255(r4, r5, r6, r7);
505
        PCKEV_B4_SB(r4, r0, r5, r1, r6, r2, r7, r3, t0, t1, t2, t3);
506
        ST_SB4(t0, t1, t2, t3, dst, BPS);
507
        dst += 4 * BPS;
508
      }
509
    } else {
510
      HorizontalPred16x16(dst, left);
511
    }
512
  } else {
513
    if (top != NULL) {
514
      VerticalPred16x16(dst, top);
515
    } else {
516
      const v16u8 out = (v16u8)__msa_fill_b(0x81);
517
      STORE16x16(out, dst);
518
    }
519
  }
520
}
521

522
static WEBP_INLINE void DCMode16x16(uint8_t* dst, const uint8_t* left,
523
                                    const uint8_t* top) {
524
  int DC;
525
  v16u8 out;
526
  if (top != NULL && left != NULL) {
527
    const v16u8 rtop = LD_UB(top);
528
    const v8u16 dctop = __msa_hadd_u_h(rtop, rtop);
529
    const v16u8 rleft = LD_UB(left);
530
    const v8u16 dcleft = __msa_hadd_u_h(rleft, rleft);
531
    const v8u16 dctemp = dctop + dcleft;
532
    DC = HADD_UH_U32(dctemp);
533
    DC = (DC + 16) >> 5;
534
  } else if (left != NULL) {   // left but no top
535
    const v16u8 rleft = LD_UB(left);
536
    const v8u16 dcleft = __msa_hadd_u_h(rleft, rleft);
537
    DC = HADD_UH_U32(dcleft);
538
    DC = (DC + DC + 16) >> 5;
539
  } else if (top != NULL) {   // top but no left
540
    const v16u8 rtop = LD_UB(top);
541
    const v8u16 dctop = __msa_hadd_u_h(rtop, rtop);
542
    DC = HADD_UH_U32(dctop);
543
    DC = (DC + DC + 16) >> 5;
544
  } else {   // no top, no left, nothing.
545
    DC = 0x80;
546
  }
547
  out = (v16u8)__msa_fill_b(DC);
548
  STORE16x16(out, dst);
549
}
550

551
static void Intra16Preds_MSA(uint8_t* dst,
552
                             const uint8_t* left, const uint8_t* top) {
553
  DCMode16x16(I16DC16 + dst, left, top);
554
  VerticalPred16x16(I16VE16 + dst, top);
555
  HorizontalPred16x16(I16HE16 + dst, left);
556
  TrueMotion16x16(I16TM16 + dst, left, top);
557
}
558

559
// Chroma 8x8 prediction
560

561
#define CALC_DC8(in, out) do {                              \
562
  const v8u16 temp0 = __msa_hadd_u_h(in, in);               \
563
  const v4u32 temp1 = __msa_hadd_u_w(temp0, temp0);         \
564
  const v2i64 temp2 = (v2i64)__msa_hadd_u_d(temp1, temp1);  \
565
  const v2i64 temp3 = __msa_splati_d(temp2, 1);             \
566
  const v2i64 temp4 = temp3 + temp2;                        \
567
  const v16i8 temp5 = (v16i8)__msa_srari_d(temp4, 4);       \
568
  const v2i64 temp6 = (v2i64)__msa_splati_b(temp5, 0);      \
569
  out = __msa_copy_s_d(temp6, 0);                           \
570
} while (0)
571

572
#define STORE8x8(out, dst) do {                 \
573
  SD4(out, out, out, out, dst + 0 * BPS, BPS);  \
574
  SD4(out, out, out, out, dst + 4 * BPS, BPS);  \
575
} while (0)
576

577
static WEBP_INLINE void VerticalPred8x8(uint8_t* dst, const uint8_t* top) {
578
  if (top != NULL) {
579
    const uint64_t out = LD(top);
580
    STORE8x8(out, dst);
581
  } else {
582
    const uint64_t out = 0x7f7f7f7f7f7f7f7fULL;
583
    STORE8x8(out, dst);
584
  }
585
}
586

587
static WEBP_INLINE void HorizontalPred8x8(uint8_t* dst, const uint8_t* left) {
588
  if (left != NULL) {
589
    int j;
590
    for (j = 0; j < 8; j += 4) {
591
      const v16u8 L0 = (v16u8)__msa_fill_b(left[0]);
592
      const v16u8 L1 = (v16u8)__msa_fill_b(left[1]);
593
      const v16u8 L2 = (v16u8)__msa_fill_b(left[2]);
594
      const v16u8 L3 = (v16u8)__msa_fill_b(left[3]);
595
      const uint64_t out0 = __msa_copy_s_d((v2i64)L0, 0);
596
      const uint64_t out1 = __msa_copy_s_d((v2i64)L1, 0);
597
      const uint64_t out2 = __msa_copy_s_d((v2i64)L2, 0);
598
      const uint64_t out3 = __msa_copy_s_d((v2i64)L3, 0);
599
      SD4(out0, out1, out2, out3, dst, BPS);
600
      dst += 4 * BPS;
601
      left += 4;
602
    }
603
  } else {
604
    const uint64_t out = 0x8181818181818181ULL;
605
    STORE8x8(out, dst);
606
  }
607
}
608

609
static WEBP_INLINE void TrueMotion8x8(uint8_t* dst, const uint8_t* left,
610
                                      const uint8_t* top) {
611
  if (left != NULL) {
612
    if (top != NULL) {
613
      int j;
614
      const v8i16 TL = (v8i16)__msa_fill_h(left[-1]);
615
      const v16u8 T1 = LD_UB(top);
616
      const v16i8 zero = { 0 };
617
      const v8i16 T  = (v8i16)__msa_ilvr_b(zero, (v16i8)T1);
618
      const v8i16 d = T - TL;
619
      for (j = 0; j < 8; j += 4) {
620
        uint64_t out0, out1, out2, out3;
621
        v16i8 t0, t1;
622
        v8i16 r0 = (v8i16)__msa_fill_h(left[j + 0]);
623
        v8i16 r1 = (v8i16)__msa_fill_h(left[j + 1]);
624
        v8i16 r2 = (v8i16)__msa_fill_h(left[j + 2]);
625
        v8i16 r3 = (v8i16)__msa_fill_h(left[j + 3]);
626
        ADD4(d, r0, d, r1, d, r2, d, r3, r0, r1, r2, r3);
627
        CLIP_SH4_0_255(r0, r1, r2, r3);
628
        PCKEV_B2_SB(r1, r0, r3, r2, t0, t1);
629
        out0 = __msa_copy_s_d((v2i64)t0, 0);
630
        out1 = __msa_copy_s_d((v2i64)t0, 1);
631
        out2 = __msa_copy_s_d((v2i64)t1, 0);
632
        out3 = __msa_copy_s_d((v2i64)t1, 1);
633
        SD4(out0, out1, out2, out3, dst, BPS);
634
        dst += 4 * BPS;
635
      }
636
    } else {
637
      HorizontalPred8x8(dst, left);
638
    }
639
  } else {
640
    if (top != NULL) {
641
      VerticalPred8x8(dst, top);
642
    } else {
643
      const uint64_t out = 0x8181818181818181ULL;
644
      STORE8x8(out, dst);
645
    }
646
  }
647
}
648

649
static WEBP_INLINE void DCMode8x8(uint8_t* dst, const uint8_t* left,
650
                                  const uint8_t* top) {
651
  uint64_t out;
652
  v16u8 src = { 0 };
653
  if (top != NULL && left != NULL) {
654
    const uint64_t left_m = LD(left);
655
    const uint64_t top_m = LD(top);
656
    INSERT_D2_UB(left_m, top_m, src);
657
    CALC_DC8(src, out);
658
  } else if (left != NULL) {   // left but no top
659
    const uint64_t left_m = LD(left);
660
    INSERT_D2_UB(left_m, left_m, src);
661
    CALC_DC8(src, out);
662
  } else if (top != NULL) {   // top but no left
663
    const uint64_t top_m = LD(top);
664
    INSERT_D2_UB(top_m, top_m, src);
665
    CALC_DC8(src, out);
666
  } else {   // no top, no left, nothing.
667
    src = (v16u8)__msa_fill_b(0x80);
668
    out = __msa_copy_s_d((v2i64)src, 0);
669
  }
670
  STORE8x8(out, dst);
671
}
672

673
static void IntraChromaPreds_MSA(uint8_t* dst, const uint8_t* left,
674
                                 const uint8_t* top) {
675
  // U block
676
  DCMode8x8(C8DC8 + dst, left, top);
677
  VerticalPred8x8(C8VE8 + dst, top);
678
  HorizontalPred8x8(C8HE8 + dst, left);
679
  TrueMotion8x8(C8TM8 + dst, left, top);
680
  // V block
681
  dst += 8;
682
  if (top != NULL) top += 8;
683
  if (left != NULL) left += 16;
684
  DCMode8x8(C8DC8 + dst, left, top);
685
  VerticalPred8x8(C8VE8 + dst, top);
686
  HorizontalPred8x8(C8HE8 + dst, left);
687
  TrueMotion8x8(C8TM8 + dst, left, top);
688
}
689

690
//------------------------------------------------------------------------------
691
// Metric
692

693
#define PACK_DOTP_UB4_SW(in0, in1, in2, in3, out0, out1, out2, out3) do {  \
694
  v16u8 tmp0, tmp1;                                                        \
695
  v8i16 tmp2, tmp3;                                                        \
696
  ILVRL_B2_UB(in0, in1, tmp0, tmp1);                                       \
697
  HSUB_UB2_SH(tmp0, tmp1, tmp2, tmp3);                                     \
698
  DOTP_SH2_SW(tmp2, tmp3, tmp2, tmp3, out0, out1);                         \
699
  ILVRL_B2_UB(in2, in3, tmp0, tmp1);                                       \
700
  HSUB_UB2_SH(tmp0, tmp1, tmp2, tmp3);                                     \
701
  DOTP_SH2_SW(tmp2, tmp3, tmp2, tmp3, out2, out3);                         \
702
} while (0)
703

704
#define PACK_DPADD_UB4_SW(in0, in1, in2, in3, out0, out1, out2, out3) do {  \
705
  v16u8 tmp0, tmp1;                                                         \
706
  v8i16 tmp2, tmp3;                                                         \
707
  ILVRL_B2_UB(in0, in1, tmp0, tmp1);                                        \
708
  HSUB_UB2_SH(tmp0, tmp1, tmp2, tmp3);                                      \
709
  DPADD_SH2_SW(tmp2, tmp3, tmp2, tmp3, out0, out1);                         \
710
  ILVRL_B2_UB(in2, in3, tmp0, tmp1);                                        \
711
  HSUB_UB2_SH(tmp0, tmp1, tmp2, tmp3);                                      \
712
  DPADD_SH2_SW(tmp2, tmp3, tmp2, tmp3, out2, out3);                         \
713
} while (0)
714

715
static int SSE16x16_MSA(const uint8_t* a, const uint8_t* b) {
716
  uint32_t sum;
717
  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
718
  v16u8 ref0, ref1, ref2, ref3, ref4, ref5, ref6, ref7;
719
  v4i32 out0, out1, out2, out3;
720

721
  LD_UB8(a, BPS, src0, src1, src2, src3, src4, src5, src6, src7);
722
  LD_UB8(b, BPS, ref0, ref1, ref2, ref3, ref4, ref5, ref6, ref7);
723
  PACK_DOTP_UB4_SW(src0, ref0, src1, ref1, out0, out1, out2, out3);
724
  PACK_DPADD_UB4_SW(src2, ref2, src3, ref3, out0, out1, out2, out3);
725
  PACK_DPADD_UB4_SW(src4, ref4, src5, ref5, out0, out1, out2, out3);
726
  PACK_DPADD_UB4_SW(src6, ref6, src7, ref7, out0, out1, out2, out3);
727
  a += 8 * BPS;
728
  b += 8 * BPS;
729
  LD_UB8(a, BPS, src0, src1, src2, src3, src4, src5, src6, src7);
730
  LD_UB8(b, BPS, ref0, ref1, ref2, ref3, ref4, ref5, ref6, ref7);
731
  PACK_DPADD_UB4_SW(src0, ref0, src1, ref1, out0, out1, out2, out3);
732
  PACK_DPADD_UB4_SW(src2, ref2, src3, ref3, out0, out1, out2, out3);
733
  PACK_DPADD_UB4_SW(src4, ref4, src5, ref5, out0, out1, out2, out3);
734
  PACK_DPADD_UB4_SW(src6, ref6, src7, ref7, out0, out1, out2, out3);
735
  out0 += out1;
736
  out2 += out3;
737
  out0 += out2;
738
  sum = HADD_SW_S32(out0);
739
  return sum;
740
}
741

742
static int SSE16x8_MSA(const uint8_t* a, const uint8_t* b) {
743
  uint32_t sum;
744
  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
745
  v16u8 ref0, ref1, ref2, ref3, ref4, ref5, ref6, ref7;
746
  v4i32 out0, out1, out2, out3;
747

748
  LD_UB8(a, BPS, src0, src1, src2, src3, src4, src5, src6, src7);
749
  LD_UB8(b, BPS, ref0, ref1, ref2, ref3, ref4, ref5, ref6, ref7);
750
  PACK_DOTP_UB4_SW(src0, ref0, src1, ref1, out0, out1, out2, out3);
751
  PACK_DPADD_UB4_SW(src2, ref2, src3, ref3, out0, out1, out2, out3);
752
  PACK_DPADD_UB4_SW(src4, ref4, src5, ref5, out0, out1, out2, out3);
753
  PACK_DPADD_UB4_SW(src6, ref6, src7, ref7, out0, out1, out2, out3);
754
  out0 += out1;
755
  out2 += out3;
756
  out0 += out2;
757
  sum = HADD_SW_S32(out0);
758
  return sum;
759
}
760

761
static int SSE8x8_MSA(const uint8_t* a, const uint8_t* b) {
762
  uint32_t sum;
763
  v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
764
  v16u8 ref0, ref1, ref2, ref3, ref4, ref5, ref6, ref7;
765
  v16u8 t0, t1, t2, t3;
766
  v4i32 out0, out1, out2, out3;
767

768
  LD_UB8(a, BPS, src0, src1, src2, src3, src4, src5, src6, src7);
769
  LD_UB8(b, BPS, ref0, ref1, ref2, ref3, ref4, ref5, ref6, ref7);
770
  ILVR_B4_UB(src0, src1, src2, src3, ref0, ref1, ref2, ref3, t0, t1, t2, t3);
771
  PACK_DOTP_UB4_SW(t0, t2, t1, t3, out0, out1, out2, out3);
772
  ILVR_B4_UB(src4, src5, src6, src7, ref4, ref5, ref6, ref7, t0, t1, t2, t3);
773
  PACK_DPADD_UB4_SW(t0, t2, t1, t3, out0, out1, out2, out3);
774
  out0 += out1;
775
  out2 += out3;
776
  out0 += out2;
777
  sum = HADD_SW_S32(out0);
778
  return sum;
779
}
780

781
static int SSE4x4_MSA(const uint8_t* a, const uint8_t* b) {
782
  uint32_t sum = 0;
783
  uint32_t src0, src1, src2, src3, ref0, ref1, ref2, ref3;
784
  v16u8 src = { 0 }, ref = { 0 }, tmp0, tmp1;
785
  v8i16 diff0, diff1;
786
  v4i32 out0, out1;
787

788
  LW4(a, BPS, src0, src1, src2, src3);
789
  LW4(b, BPS, ref0, ref1, ref2, ref3);
790
  INSERT_W4_UB(src0, src1, src2, src3, src);
791
  INSERT_W4_UB(ref0, ref1, ref2, ref3, ref);
792
  ILVRL_B2_UB(src, ref, tmp0, tmp1);
793
  HSUB_UB2_SH(tmp0, tmp1, diff0, diff1);
794
  DOTP_SH2_SW(diff0, diff1, diff0, diff1, out0, out1);
795
  out0 += out1;
796
  sum = HADD_SW_S32(out0);
797
  return sum;
798
}
799

800
//------------------------------------------------------------------------------
801
// Quantization
802

803
static int QuantizeBlock_MSA(int16_t in[16], int16_t out[16],
804
                             const VP8Matrix* const mtx) {
805
  int sum;
806
  v8i16 in0, in1, sh0, sh1, out0, out1;
807
  v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, sign0, sign1;
808
  v4i32 s0, s1, s2, s3, b0, b1, b2, b3, t0, t1, t2, t3;
809
  const v8i16 zero = { 0 };
810
  const v8i16 zigzag0 = { 0, 1, 4, 8, 5, 2, 3, 6 };
811
  const v8i16 zigzag1 = { 9, 12, 13, 10, 7, 11, 14, 15 };
812
  const v8i16 maxlevel = __msa_fill_h(MAX_LEVEL);
813

814
  LD_SH2(&in[0], 8, in0, in1);
815
  LD_SH2(&mtx->sharpen_[0], 8, sh0, sh1);
816
  tmp4 = __msa_add_a_h(in0, zero);
817
  tmp5 = __msa_add_a_h(in1, zero);
818
  ILVRL_H2_SH(sh0, tmp4, tmp0, tmp1);
819
  ILVRL_H2_SH(sh1, tmp5, tmp2, tmp3);
820
  HADD_SH4_SW(tmp0, tmp1, tmp2, tmp3, s0, s1, s2, s3);
821
  sign0 = (in0 < zero);
822
  sign1 = (in1 < zero);                           // sign
823
  LD_SH2(&mtx->iq_[0], 8, tmp0, tmp1);            // iq
824
  ILVRL_H2_SW(zero, tmp0, t0, t1);
825
  ILVRL_H2_SW(zero, tmp1, t2, t3);
826
  LD_SW4(&mtx->bias_[0], 4, b0, b1, b2, b3);      // bias
827
  MUL4(t0, s0, t1, s1, t2, s2, t3, s3, t0, t1, t2, t3);
828
  ADD4(b0, t0, b1, t1, b2, t2, b3, t3, b0, b1, b2, b3);
829
  SRAI_W4_SW(b0, b1, b2, b3, 17);
830
  PCKEV_H2_SH(b1, b0, b3, b2, tmp2, tmp3);
831
  tmp0 = (tmp2 > maxlevel);
832
  tmp1 = (tmp3 > maxlevel);
833
  tmp2 = (v8i16)__msa_bmnz_v((v16u8)tmp2, (v16u8)maxlevel, (v16u8)tmp0);
834
  tmp3 = (v8i16)__msa_bmnz_v((v16u8)tmp3, (v16u8)maxlevel, (v16u8)tmp1);
835
  SUB2(zero, tmp2, zero, tmp3, tmp0, tmp1);
836
  tmp2 = (v8i16)__msa_bmnz_v((v16u8)tmp2, (v16u8)tmp0, (v16u8)sign0);
837
  tmp3 = (v8i16)__msa_bmnz_v((v16u8)tmp3, (v16u8)tmp1, (v16u8)sign1);
838
  LD_SW4(&mtx->zthresh_[0], 4, t0, t1, t2, t3);   // zthresh
839
  t0 = (s0 > t0);
840
  t1 = (s1 > t1);
841
  t2 = (s2 > t2);
842
  t3 = (s3 > t3);
843
  PCKEV_H2_SH(t1, t0, t3, t2, tmp0, tmp1);
844
  tmp4 = (v8i16)__msa_bmnz_v((v16u8)zero, (v16u8)tmp2, (v16u8)tmp0);
845
  tmp5 = (v8i16)__msa_bmnz_v((v16u8)zero, (v16u8)tmp3, (v16u8)tmp1);
846
  LD_SH2(&mtx->q_[0], 8, tmp0, tmp1);
847
  MUL2(tmp4, tmp0, tmp5, tmp1, in0, in1);
848
  VSHF_H2_SH(tmp4, tmp5, tmp4, tmp5, zigzag0, zigzag1, out0, out1);
849
  ST_SH2(in0, in1, &in[0], 8);
850
  ST_SH2(out0, out1, &out[0], 8);
851
  out0 = __msa_add_a_h(out0, out1);
852
  sum = HADD_SH_S32(out0);
853
  return (sum > 0);
854
}
855

856
static int Quantize2Blocks_MSA(int16_t in[32], int16_t out[32],
857
                               const VP8Matrix* const mtx) {
858
  int nz;
859
  nz  = VP8EncQuantizeBlock(in + 0 * 16, out + 0 * 16, mtx) << 0;
860
  nz |= VP8EncQuantizeBlock(in + 1 * 16, out + 1 * 16, mtx) << 1;
861
  return nz;
862
}
863

864
//------------------------------------------------------------------------------
865
// Entry point
866

867
extern void VP8EncDspInitMSA(void);
868

869
WEBP_TSAN_IGNORE_FUNCTION void VP8EncDspInitMSA(void) {
870
  VP8ITransform = ITransform_MSA;
871
  VP8FTransform = FTransform_MSA;
872
  VP8FTransformWHT = FTransformWHT_MSA;
873

874
  VP8TDisto4x4 = Disto4x4_MSA;
875
  VP8TDisto16x16 = Disto16x16_MSA;
876
  VP8CollectHistogram = CollectHistogram_MSA;
877

878
  VP8EncPredLuma4 = Intra4Preds_MSA;
879
  VP8EncPredLuma16 = Intra16Preds_MSA;
880
  VP8EncPredChroma8 = IntraChromaPreds_MSA;
881

882
  VP8SSE16x16 = SSE16x16_MSA;
883
  VP8SSE16x8 = SSE16x8_MSA;
884
  VP8SSE8x8 = SSE8x8_MSA;
885
  VP8SSE4x4 = SSE4x4_MSA;
886

887
  VP8EncQuantizeBlock = QuantizeBlock_MSA;
888
  VP8EncQuantize2Blocks = Quantize2Blocks_MSA;
889
  VP8EncQuantizeBlockWHT = QuantizeBlock_MSA;
890
}
891

892
#else  // !WEBP_USE_MSA
893

894
WEBP_DSP_INIT_STUB(VP8EncDspInitMSA)
895

896
#endif  // WEBP_USE_MSA
897

898
Product

Resources

Company
