git.sesse.net Git - ffmpeg/blob - libavcodec/mips/hevcpred_msa.c

   1 /*
   2  * Copyright (c) 2015 Shivraj Patil (Shivraj.Patil@imgtec.com)
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include "libavcodec/hevcdec.h"
  22 #include "libavutil/mips/generic_macros_msa.h"
  23 #include "hevcpred_mips.h"
  24
  25 static const int8_t intra_pred_angle_up[17] = {
  26     -32, -26, -21, -17, -13, -9, -5, -2, 0, 2, 5, 9, 13, 17, 21, 26, 32
  27 };
  28
  29 static const int8_t intra_pred_angle_low[16] = {
  30     32, 26, 21, 17, 13, 9, 5, 2, 0, -2, -5, -9, -13, -17, -21, -26
  31 };
  32
  33 #define HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,          \
  34                               mul_val_h0, mul_val_h1, mul_val_h2, mul_val_h3,  \
  35                               res0, res1, mul_val_b0, mul_val_b1, round)       \
  36 {                                                                              \
  37     v8i16 res0_m, res1_m, res2_m, res3_m;                                      \
  38                                                                                \
  39     MUL4(mul_val_h0, vec0, mul_val_h2, vec0, mul_val_h0, vec1,                 \
  40          mul_val_h2, vec1, res0_m, res1_m, res2_m, res3_m);                    \
  41                                                                                \
  42     res0_m += mul_val_h1 * tmp0;                                               \
  43     res1_m += mul_val_h3 * tmp0;                                               \
  44     res2_m += mul_val_h1 * tmp0;                                               \
  45     res3_m += mul_val_h3 * tmp0;                                               \
  46                                                                                \
  47     res0_m += mul_val_b0 * src0_r;                                             \
  48     res1_m += mul_val_b0 * src0_l;                                             \
  49     res2_m += (mul_val_b0 - 1) * src0_r;                                       \
  50     res3_m += (mul_val_b0 - 1) * src0_l;                                       \
  51                                                                                \
  52     res0_m += mul_val_b1 * tmp1;                                               \
  53     res1_m += mul_val_b1 * tmp1;                                               \
  54     res2_m += (mul_val_b1 + 1) * tmp1;                                         \
  55     res3_m += (mul_val_b1 + 1) * tmp1;                                         \
  56                                                                                \
  57     SRARI_H4_SH(res0_m, res1_m, res2_m, res3_m, round);                        \
  58     PCKEV_B2_SH(res1_m, res0_m, res3_m, res2_m, res0, res1);                   \
  59 }
  60
  61 static void hevc_intra_pred_vert_4x4_msa(const uint8_t *src_top,
  62                                          const uint8_t *src_left,
  63                                          uint8_t *dst, int32_t stride,
  64                                          int32_t flag)
  65 {
  66     uint32_t col;
  67     uint32_t src_data;
  68     v8i16 vec0, vec1, vec2;
  69     v16i8 zero = { 0 };
  70
  71     src_data = LW(src_top);
  72     SW4(src_data, src_data, src_data, src_data, dst, stride);
  73
  74     if (0 == flag) {
  75         src_data = LW(src_left);
  76
  77         vec2 = (v8i16) __msa_insert_w((v4i32) vec2, 0, src_data);
  78
  79         vec0 = __msa_fill_h(src_left[-1]);
  80         vec1 = __msa_fill_h(src_top[0]);
  81
  82         vec2 = (v8i16) __msa_ilvr_b(zero, (v16i8) vec2);
  83         vec2 -= vec0;
  84         vec2 >>= 1;
  85         vec2 += vec1;
  86         vec2 = CLIP_SH_0_255(vec2);
  87
  88         for (col = 0; col < 4; col++) {
  89             dst[stride * col] = (uint8_t) vec2[col];
  90         }
  91     }
  92 }
  93
  94 static void hevc_intra_pred_vert_8x8_msa(const uint8_t *src_top,
  95                                          const uint8_t *src_left,
  96                                          uint8_t *dst, int32_t stride,
  97                                          int32_t flag)
  98 {
  99     uint8_t *tmp_dst = dst;
 100     uint32_t row;
 101     uint16_t val0, val1, val2, val3;
 102     uint64_t src_data1;
 103     v8i16 vec0, vec1, vec2;
 104     v16i8 zero = { 0 };
 105
 106     src_data1 = LD(src_top);
 107
 108     for (row = 8; row--;) {
 109         SD(src_data1, tmp_dst);
 110         tmp_dst += stride;
 111     }
 112
 113     if (0 == flag) {
 114         src_data1 = LD(src_left);
 115
 116         vec2 = (v8i16) __msa_insert_d((v2i64) zero, 0, src_data1);
 117
 118         vec0 = __msa_fill_h(src_left[-1]);
 119         vec1 = __msa_fill_h(src_top[0]);
 120
 121         vec2 = (v8i16) __msa_ilvr_b(zero, (v16i8) vec2);
 122         vec2 -= vec0;
 123         vec2 >>= 1;
 124         vec2 += vec1;
 125         vec2 = CLIP_SH_0_255(vec2);
 126
 127         val0 = vec2[0];
 128         val1 = vec2[1];
 129         val2 = vec2[2];
 130         val3 = vec2[3];
 131
 132         dst[0] = val0;
 133         dst[stride] = val1;
 134         dst[2 * stride] = val2;
 135         dst[3 * stride] = val3;
 136
 137         val0 = vec2[4];
 138         val1 = vec2[5];
 139         val2 = vec2[6];
 140         val3 = vec2[7];
 141
 142         dst[4 * stride] = val0;
 143         dst[5 * stride] = val1;
 144         dst[6 * stride] = val2;
 145         dst[7 * stride] = val3;
 146     }
 147 }
 148
 149 static void hevc_intra_pred_vert_16x16_msa(const uint8_t *src_top,
 150                                            const uint8_t *src_left,
 151                                            uint8_t *dst, int32_t stride,
 152                                            int32_t flag)
 153 {
 154     int32_t col;
 155     uint8_t *tmp_dst = dst;
 156     uint32_t row;
 157     v16u8 src;
 158     v8i16 vec0, vec1, vec2, vec3;
 159
 160     src = LD_UB(src_top);
 161
 162     for (row = 16; row--;) {
 163         ST_UB(src, tmp_dst);
 164         tmp_dst += stride;
 165     }
 166
 167     if (0 == flag) {
 168         src = LD_UB(src_left);
 169
 170         vec0 = __msa_fill_h(src_left[-1]);
 171         vec1 = __msa_fill_h(src_top[0]);
 172
 173         UNPCK_UB_SH(src, vec2, vec3);
 174         SUB2(vec2, vec0, vec3, vec0, vec2, vec3);
 175
 176         vec2 >>= 1;
 177         vec3 >>= 1;
 178
 179         ADD2(vec2, vec1, vec3, vec1, vec2, vec3);
 180         CLIP_SH2_0_255(vec2, vec3);
 181
 182         src = (v16u8) __msa_pckev_b((v16i8) vec3, (v16i8) vec2);
 183
 184         for (col = 0; col < 16; col++) {
 185             dst[stride * col] = src[col];
 186         }
 187     }
 188 }
 189
 190 static void hevc_intra_pred_horiz_4x4_msa(const uint8_t *src_top,
 191                                           const uint8_t *src_left,
 192                                           uint8_t *dst, int32_t stride,
 193                                           int32_t flag)
 194 {
 195     uint32_t val0, val1, val2, val3;
 196     v16i8 src0;
 197     v8i16 src0_r, src_top_val, src_left_val;
 198     v16i8 zero = { 0 };
 199
 200     val0 = src_left[0] * 0x01010101;
 201     val1 = src_left[1] * 0x01010101;
 202     val2 = src_left[2] * 0x01010101;
 203     val3 = src_left[3] * 0x01010101;
 204     SW4(val0, val1, val2, val3, dst, stride);
 205
 206     if (0 == flag) {
 207         val0 = LW(src_top);
 208         src0 = (v16i8) __msa_insert_w((v4i32) src0, 0, val0);
 209         src_top_val = __msa_fill_h(src_top[-1]);
 210         src_left_val = __msa_fill_h(src_left[0]);
 211
 212         src0_r = (v8i16) __msa_ilvr_b(zero, src0);
 213
 214         src0_r -= src_top_val;
 215         src0_r >>= 1;
 216         src0_r += src_left_val;
 217         src0_r = CLIP_SH_0_255(src0_r);
 218         src0 = __msa_pckev_b((v16i8) src0_r, (v16i8) src0_r);
 219         val0 = __msa_copy_s_w((v4i32) src0, 0);
 220         SW(val0, dst);
 221     }
 222 }
 223
 224 static void hevc_intra_pred_horiz_8x8_msa(const uint8_t *src_top,
 225                                           const uint8_t *src_left,
 226                                           uint8_t *dst, int32_t stride,
 227                                           int32_t flag)
 228 {
 229     uint64_t val0, val1, val2, val3;
 230     v16i8 src0;
 231     v8i16 src0_r, src_top_val, src_left_val;
 232     v16i8 zero = { 0 };
 233
 234     val0 = src_left[0] * 0x0101010101010101;
 235     val1 = src_left[1] * 0x0101010101010101;
 236     val2 = src_left[2] * 0x0101010101010101;
 237     val3 = src_left[3] * 0x0101010101010101;
 238     SD4(val0, val1, val2, val3, dst, stride);
 239
 240     val0 = src_left[4] * 0x0101010101010101;
 241     val1 = src_left[5] * 0x0101010101010101;
 242     val2 = src_left[6] * 0x0101010101010101;
 243     val3 = src_left[7] * 0x0101010101010101;
 244     SD4(val0, val1, val2, val3, dst + 4 * stride, stride);
 245
 246     if (0 == flag) {
 247         val0 = LD(src_top);
 248         src0 = (v16i8) __msa_insert_d((v2i64) src0, 0, val0);
 249         src_top_val = __msa_fill_h(src_top[-1]);
 250         src_left_val = __msa_fill_h(src_left[0]);
 251
 252         src0_r = (v8i16) __msa_ilvr_b(zero, src0);
 253
 254         src0_r -= src_top_val;
 255         src0_r >>= 1;
 256         src0_r += src_left_val;
 257         src0_r = CLIP_SH_0_255(src0_r);
 258         src0 = __msa_pckev_b((v16i8) src0_r, (v16i8) src0_r);
 259         val0 = __msa_copy_s_d((v2i64) src0, 0);
 260         SD(val0, dst);
 261     }
 262 }
 263
 264 static void hevc_intra_pred_horiz_16x16_msa(const uint8_t *src_top,
 265                                             const uint8_t *src_left,
 266                                             uint8_t *dst, int32_t stride,
 267                                             int32_t flag)
 268 {
 269     uint8_t *tmp_dst = dst;
 270     uint32_t row;
 271     uint8_t inp0, inp1, inp2, inp3;
 272     v16i8 src0, src1, src2, src3;
 273     v8i16 src0_r, src0_l, src_left_val, src_top_val;
 274
 275     src_left_val = __msa_fill_h(src_left[0]);
 276
 277     for (row = 4; row--;) {
 278         inp0 = src_left[0];
 279         inp1 = src_left[1];
 280         inp2 = src_left[2];
 281         inp3 = src_left[3];
 282         src_left += 4;
 283
 284         src0 = __msa_fill_b(inp0);
 285         src1 = __msa_fill_b(inp1);
 286         src2 = __msa_fill_b(inp2);
 287         src3 = __msa_fill_b(inp3);
 288
 289         ST_SB4(src0, src1, src2, src3, tmp_dst, stride);
 290         tmp_dst += (4 * stride);
 291     }
 292
 293     if (0 == flag) {
 294         src0 = LD_SB(src_top);
 295         src_top_val = __msa_fill_h(src_top[-1]);
 296
 297         UNPCK_UB_SH(src0, src0_r, src0_l);
 298         SUB2(src0_r, src_top_val, src0_l, src_top_val, src0_r, src0_l);
 299
 300         src0_r >>= 1;
 301         src0_l >>= 1;
 302
 303         ADD2(src0_r, src_left_val, src0_l, src_left_val, src0_r, src0_l);
 304         CLIP_SH2_0_255(src0_r, src0_l);
 305         src0 = __msa_pckev_b((v16i8) src0_l, (v16i8) src0_r);
 306         ST_SB(src0, dst);
 307     }
 308 }
 309
 310 static void hevc_intra_pred_horiz_32x32_msa(const uint8_t *src_top,
 311                                             const uint8_t *src_left,
 312                                             uint8_t *dst, int32_t stride)
 313 {
 314     uint32_t row;
 315     uint8_t inp0, inp1, inp2, inp3;
 316     v16i8 src0, src1, src2, src3;
 317
 318     for (row = 0; row < 8; row++) {
 319         inp0 = src_left[row * 4];
 320         inp1 = src_left[row * 4 + 1];
 321         inp2 = src_left[row * 4 + 2];
 322         inp3 = src_left[row * 4 + 3];
 323
 324         src0 = __msa_fill_b(inp0);
 325         src1 = __msa_fill_b(inp1);
 326         src2 = __msa_fill_b(inp2);
 327         src3 = __msa_fill_b(inp3);
 328
 329         ST_SB2(src0, src0, dst, 16);
 330         dst += stride;
 331         ST_SB2(src1, src1, dst, 16);
 332         dst += stride;
 333         ST_SB2(src2, src2, dst, 16);
 334         dst += stride;
 335         ST_SB2(src3, src3, dst, 16);
 336         dst += stride;
 337     }
 338 }
 339
 340 static void hevc_intra_pred_dc_4x4_msa(const uint8_t *src_top,
 341                                        const uint8_t *src_left,
 342                                        uint8_t *dst, int32_t stride,
 343                                        int32_t flag)
 344 {
 345     uint8_t *tmp_dst = dst;
 346     uint32_t addition = 0;
 347     uint32_t val0, val1, val2;
 348     v16i8 src = { 0 };
 349     v16u8 store;
 350     v16i8 zero = { 0 };
 351     v8u16 sum, vec0, vec1;
 352
 353     val0 = LW(src_top);
 354     val1 = LW(src_left);
 355     INSERT_W2_SB(val0, val1, src);
 356     sum = __msa_hadd_u_h((v16u8) src, (v16u8) src);
 357     sum = (v8u16) __msa_hadd_u_w(sum, sum);
 358     sum = (v8u16) __msa_hadd_u_d((v4u32) sum, (v4u32) sum);
 359     sum = (v8u16) __msa_srari_w((v4i32) sum, 3);
 360     addition = __msa_copy_u_w((v4i32) sum, 0);
 361     store = (v16u8) __msa_fill_b(addition);
 362     val0 = __msa_copy_u_w((v4i32) store, 0);
 363     SW4(val0, val0, val0, val0, dst, stride)
 364
 365         if (0 == flag) {
 366         ILVR_B2_UH(zero, store, zero, src, vec0, vec1);
 367
 368         vec1 += vec0;
 369         vec0 += vec0;
 370         vec1 += vec0;
 371
 372         vec1 = (v8u16) __msa_srari_h((v8i16) vec1, 2);
 373         store = (v16u8) __msa_pckev_b((v16i8) vec1, (v16i8) vec1);
 374         val1 = (src_left[0] + 2 * addition + src_top[0] + 2) >> 2;
 375         store = (v16u8) __msa_insert_b((v16i8) store, 0, val1);
 376         val0 = __msa_copy_u_w((v4i32) store, 0);
 377         SW(val0, tmp_dst);
 378
 379         val0 = src_left[1];
 380         val1 = src_left[2];
 381         val2 = src_left[3];
 382
 383         addition *= 3;
 384
 385         ADD2(val0, addition, val1, addition, val0, val1);
 386         val2 += addition;
 387
 388         val0 += 2;
 389         val1 += 2;
 390         val2 += 2;
 391         val0 >>= 2;
 392         val1 >>= 2;
 393         val2 >>= 2;
 394
 395         tmp_dst[stride * 1] = val0;
 396         tmp_dst[stride * 2] = val1;
 397         tmp_dst[stride * 3] = val2;
 398     }
 399 }
 400
 401 static void hevc_intra_pred_dc_8x8_msa(const uint8_t *src_top,
 402                                        const uint8_t *src_left,
 403                                        uint8_t *dst, int32_t stride,
 404                                        int32_t flag)
 405 {
 406     uint8_t *tmp_dst = dst;
 407     uint32_t row, col, val;
 408     uint32_t addition = 0;
 409     uint64_t val0, val1;
 410     v16u8 src = { 0 };
 411     v16u8 store;
 412     v8u16 sum, vec0, vec1;
 413     v16i8 zero = { 0 };
 414
 415     val0 = LD(src_top);
 416     val1 = LD(src_left);
 417     INSERT_D2_UB(val0, val1, src);
 418     sum = __msa_hadd_u_h((v16u8) src, (v16u8) src);
 419     sum = (v8u16) __msa_hadd_u_w(sum, sum);
 420     sum = (v8u16) __msa_hadd_u_d((v4u32) sum, (v4u32) sum);
 421     sum = (v8u16) __msa_pckev_w((v4i32) sum, (v4i32) sum);
 422     sum = (v8u16) __msa_hadd_u_d((v4u32) sum, (v4u32) sum);
 423     sum = (v8u16) __msa_srari_w((v4i32) sum, 4);
 424     addition = __msa_copy_u_w((v4i32) sum, 0);
 425     store = (v16u8) __msa_fill_b(addition);
 426     val0 = __msa_copy_u_d((v2i64) store, 0);
 427
 428     for (row = 8; row--;) {
 429         SD(val0, dst);
 430         dst += stride;
 431     }
 432
 433     if (0 == flag) {
 434         ILVR_B2_UH(zero, store, zero, src, vec0, vec1);
 435
 436         vec1 += vec0;
 437         vec0 += vec0;
 438         vec1 += vec0;
 439         vec1 = (v8u16) __msa_srari_h((v8i16) vec1, 2);
 440         store = (v16u8) __msa_pckev_b((v16i8) vec1, (v16i8) vec1);
 441         val = (src_left[0] + 2 * addition + src_top[0] + 2) >> 2;
 442         store = (v16u8) __msa_insert_b((v16i8) store, 0, val);
 443         val0 = __msa_copy_u_d((v2i64) store, 0);
 444         SD(val0, tmp_dst);
 445
 446         val0 = LD(src_left);
 447         src = (v16u8) __msa_insert_d((v2i64) src, 0, val0);
 448         vec1 = (v8u16) __msa_ilvr_b(zero, (v16i8) src);
 449         vec0 = (v8u16) __msa_fill_h(addition);
 450         vec0 *= 3;
 451         vec1 += vec0;
 452         vec1 = (v8u16) __msa_srari_h((v8i16) vec1, 2);
 453
 454         for (col = 1; col < 8; col++) {
 455             tmp_dst[stride * col] = vec1[col];
 456         }
 457     }
 458 }
 459
 460 static void hevc_intra_pred_dc_16x16_msa(const uint8_t *src_top,
 461                                          const uint8_t *src_left,
 462                                          uint8_t *dst, int32_t stride,
 463                                          int32_t flag)
 464 {
 465     uint8_t *tmp_dst = dst;
 466     uint32_t row, col, val;
 467     uint32_t addition = 0;
 468     v16u8 src_above1, store, src_left1;
 469     v8u16 sum, sum_above, sum_left;
 470     v8u16 vec0, vec1, vec2;
 471     v16i8 zero = { 0 };
 472
 473     src_above1 = LD_UB(src_top);
 474     src_left1 = LD_UB(src_left);
 475
 476     HADD_UB2_UH(src_above1, src_left1, sum_above, sum_left);
 477     sum = sum_above + sum_left;
 478     sum = (v8u16) __msa_hadd_u_w(sum, sum);
 479     sum = (v8u16) __msa_hadd_u_d((v4u32) sum, (v4u32) sum);
 480     sum = (v8u16) __msa_pckev_w((v4i32) sum, (v4i32) sum);
 481     sum = (v8u16) __msa_hadd_u_d((v4u32) sum, (v4u32) sum);
 482     sum = (v8u16) __msa_srari_w((v4i32) sum, 5);
 483     addition = __msa_copy_u_w((v4i32) sum, 0);
 484     store = (v16u8) __msa_fill_b(addition);
 485
 486     for (row = 16; row--;) {
 487         ST_UB(store, dst);
 488         dst += stride;
 489     }
 490
 491     if (0 == flag) {
 492         vec0 = (v8u16) __msa_ilvr_b(zero, (v16i8) store);
 493         ILVRL_B2_UH(zero, src_above1, vec1, vec2);
 494         ADD2(vec1, vec0, vec2, vec0, vec1, vec2);
 495         vec0 += vec0;
 496         ADD2(vec1, vec0, vec2, vec0, vec1, vec2);
 497         SRARI_H2_UH(vec1, vec2, 2);
 498         store = (v16u8) __msa_pckev_b((v16i8) vec2, (v16i8) vec1);
 499         val = (src_left[0] + 2 * addition + src_top[0] + 2) >> 2;
 500         store = (v16u8) __msa_insert_b((v16i8) store, 0, val);
 501         ST_UB(store, tmp_dst);
 502
 503         ILVRL_B2_UH(zero, src_left1, vec1, vec2);
 504         vec0 = (v8u16) __msa_fill_h(addition);
 505         vec0 *= 3;
 506         ADD2(vec1, vec0, vec2, vec0, vec1, vec2);
 507         SRARI_H2_UH(vec1, vec2, 2);
 508         store = (v16u8) __msa_pckev_b((v16i8) vec2, (v16i8) vec1);
 509
 510         for (col = 1; col < 16; col++) {
 511             tmp_dst[stride * col] = store[col];
 512         }
 513     }
 514 }
 515
 516 static void hevc_intra_pred_dc_32x32_msa(const uint8_t *src_top,
 517                                          const uint8_t *src_left,
 518                                          uint8_t *dst, int32_t stride)
 519 {
 520     uint32_t row;
 521     v16u8 src_above1, src_above2, store, src_left1, src_left2;
 522     v8u16 sum_above1, sum_above2;
 523     v8u16 sum_left1, sum_left2;
 524     v8u16 sum, sum_above, sum_left;
 525
 526     LD_UB2(src_top, 16, src_above1, src_above2);
 527     LD_UB2(src_left, 16, src_left1, src_left2);
 528     HADD_UB2_UH(src_above1, src_above2, sum_above1, sum_above2);
 529     HADD_UB2_UH(src_left1, src_left2, sum_left1, sum_left2);
 530     sum_above = sum_above1 + sum_above2;
 531     sum_left = sum_left1 + sum_left2;
 532     sum = sum_above + sum_left;
 533     sum = (v8u16) __msa_hadd_u_w(sum, sum);
 534     sum = (v8u16) __msa_hadd_u_d((v4u32) sum, (v4u32) sum);
 535     sum = (v8u16) __msa_pckev_w((v4i32) sum, (v4i32) sum);
 536     sum = (v8u16) __msa_hadd_u_d((v4u32) sum, (v4u32) sum);
 537     sum = (v8u16) __msa_srari_w((v4i32) sum, 6);
 538     store = (v16u8) __msa_splati_b((v16i8) sum, 0);
 539
 540     for (row = 16; row--;) {
 541         ST_UB2(store, store, dst, 16);
 542         dst += stride;
 543         ST_UB2(store, store, dst, 16);
 544         dst += stride;
 545     }
 546 }
 547
 548 static void hevc_intra_pred_plane_4x4_msa(const uint8_t *src_top,
 549                                           const uint8_t *src_left,
 550                                           uint8_t *dst, int32_t stride)
 551 {
 552     uint32_t src0, src1;
 553     v16i8 src_vec0, src_vec1;
 554     v8i16 src_vec0_r, src1_r, tmp0, tmp1, mul_val1;
 555     v8i16 vec0, vec1, vec2, vec3, res0, res1, res2, res3;
 556     v8i16 mul_val0 = { 3, 2, 1, 0, 1, 2, 3, 4 };
 557     v16i8 zero = { 0 };
 558
 559     src0 = LW(src_top);
 560     src1 = LW(src_left);
 561
 562     mul_val1 = (v8i16) __msa_pckod_d((v2i64) mul_val0, (v2i64) mul_val0);
 563
 564     src_vec0 = (v16i8) __msa_insert_w((v4i32) zero, 0, src0);
 565     src_vec1 = (v16i8) __msa_insert_w((v4i32) zero, 0, src1);
 566
 567     ILVR_B2_SH(zero, src_vec0, zero, src_vec1, src_vec0_r, src1_r);
 568     SPLATI_H4_SH(src1_r, 0, 1, 2, 3, vec0, vec1, vec2, vec3);
 569
 570     tmp0 = __msa_fill_h(src_top[4]);
 571     tmp1 = __msa_fill_h(src_left[4]);
 572
 573     MUL4(mul_val0, vec0, mul_val0, vec1, mul_val0, vec2, mul_val0, vec3,
 574          res0, res1, res2, res3);
 575
 576     res0 += mul_val1 * tmp0;
 577     res1 += mul_val1 * tmp0;
 578     res2 += mul_val1 * tmp0;
 579     res3 += mul_val1 * tmp0;
 580
 581     res0 += 3 * src_vec0_r;
 582     res1 += 2 * src_vec0_r;
 583     res2 += src_vec0_r;
 584     res0 += tmp1;
 585     res1 += 2 * tmp1;
 586     res2 += 3 * tmp1;
 587     res3 += 4 * tmp1;
 588
 589     PCKEV_D2_SH(res1, res0, res3, res2, res0, res1);
 590     SRARI_H2_SH(res0, res1, 3);
 591     src_vec0 = __msa_pckev_b((v16i8) res1, (v16i8) res0);
 592     ST4x4_UB(src_vec0, src_vec0, 0, 1, 2, 3, dst, stride);
 593 }
 594
 595 static void hevc_intra_pred_plane_8x8_msa(const uint8_t *src_top,
 596                                           const uint8_t *src_left,
 597                                           uint8_t *dst, int32_t stride)
 598 {
 599     uint64_t src0, src1;
 600     v16i8 src_vec0, src_vec1, src_vec2, src_vec3;
 601     v8i16 src_vec0_r, src_vec1_r;
 602     v8i16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
 603     v8i16 res0, res1, res2, res3, res4, res5, res6, res7;
 604     v8i16 tmp0, tmp1, tmp2;
 605     v8i16 mul_val1 = { 1, 2, 3, 4, 5, 6, 7, 8 };
 606     v8i16 mul_val0 = { 7, 6, 5, 4, 3, 2, 1, 0 };
 607     v16i8 zero = { 0 };
 608
 609     src0 = LD(src_top);
 610     src1 = LD(src_left);
 611
 612     src_vec0 = (v16i8) __msa_insert_d((v2i64) zero, 0, src0);
 613     src_vec1 = (v16i8) __msa_insert_d((v2i64) zero, 0, src1);
 614
 615     ILVR_B2_SH(zero, src_vec0, zero, src_vec1, src_vec0_r, src_vec1_r);
 616     SPLATI_H4_SH(src_vec1_r, 0, 1, 2, 3, vec0, vec1, vec2, vec3);
 617     SPLATI_H4_SH(src_vec1_r, 4, 5, 6, 7, vec4, vec5, vec6, vec7);
 618
 619     tmp0 = __msa_fill_h(src_top[8]);
 620     tmp1 = __msa_fill_h(src_left[8]);
 621
 622     MUL4(mul_val0, vec0, mul_val0, vec1, mul_val0, vec2, mul_val0, vec3,
 623          res0, res1, res2, res3);
 624     MUL4(mul_val0, vec4, mul_val0, vec5, mul_val0, vec6, mul_val0, vec7,
 625          res4, res5, res6, res7);
 626
 627     tmp2 = mul_val1 * tmp0;
 628     res0 += tmp2;
 629     res1 += tmp2;
 630     res2 += tmp2;
 631     res3 += tmp2;
 632     res4 += tmp2;
 633     res5 += tmp2;
 634     res6 += tmp2;
 635     res7 += tmp2;
 636
 637     res0 += 7 * src_vec0_r;
 638     res1 += 6 * src_vec0_r;
 639     res2 += 5 * src_vec0_r;
 640     res3 += 4 * src_vec0_r;
 641     res4 += 3 * src_vec0_r;
 642     res5 += 2 * src_vec0_r;
 643     res6 += src_vec0_r;
 644
 645     res0 += tmp1;
 646     res1 += 2 * tmp1;
 647     res2 += 3 * tmp1;
 648     res3 += 4 * tmp1;
 649     res4 += 5 * tmp1;
 650     res5 += 6 * tmp1;
 651     res6 += 7 * tmp1;
 652     res7 += 8 * tmp1;
 653
 654     SRARI_H4_SH(res0, res1, res2, res3, 4);
 655     SRARI_H4_SH(res4, res5, res6, res7, 4);
 656     PCKEV_B4_SB(res1, res0, res3, res2, res5, res4, res7, res6,
 657                 src_vec0, src_vec1, src_vec2, src_vec3);
 658
 659     ST8x8_UB(src_vec0, src_vec1, src_vec2, src_vec3, dst, stride);
 660 }
 661
 662 static void hevc_intra_pred_plane_16x16_msa(const uint8_t *src_top,
 663                                             const uint8_t *src_left,
 664                                             uint8_t *dst, int32_t stride)
 665 {
 666     v16u8 src0, src1;
 667     v8i16 src0_r, src1_r, src0_l, src1_l;
 668     v8i16 vec0, vec1;
 669     v8i16 res0, res1, tmp0, tmp1;
 670     v8i16 mul_val2, mul_val3;
 671     v8i16 mul_val1 = { 1, 2, 3, 4, 5, 6, 7, 8 };
 672     v8i16 mul_val0 = { 15, 14, 13, 12, 11, 10, 9, 8 };
 673
 674     src0 = LD_UB(src_top);
 675     src1 = LD_UB(src_left);
 676
 677     UNPCK_UB_SH(src0, src0_r, src0_l);
 678     UNPCK_UB_SH(src1, src1_r, src1_l);
 679
 680     mul_val2 = mul_val0 - 8;
 681     mul_val3 = mul_val1 + 8;
 682
 683     tmp0 = __msa_fill_h(src_top[16]);
 684     tmp1 = __msa_fill_h(src_left[16]);
 685
 686     SPLATI_H2_SH(src1_r, 0, 1, vec0, vec1);
 687     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 688                           mul_val0, mul_val1, mul_val2, mul_val3,
 689                           res0, res1, 15, 1, 5);
 690     ST_SH2(res0, res1, dst, stride);
 691     dst += (2 * stride);
 692
 693     SPLATI_H2_SH(src1_r, 2, 3, vec0, vec1);
 694     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 695                           mul_val0, mul_val1, mul_val2, mul_val3,
 696                           res0, res1, 13, 3, 5);
 697     ST_SH2(res0, res1, dst, stride);
 698     dst += (2 * stride);
 699
 700     SPLATI_H2_SH(src1_r, 4, 5, vec0, vec1);
 701     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 702                           mul_val0, mul_val1, mul_val2, mul_val3,
 703                           res0, res1, 11, 5, 5);
 704     ST_SH2(res0, res1, dst, stride);
 705     dst += (2 * stride);
 706
 707     SPLATI_H2_SH(src1_r, 6, 7, vec0, vec1);
 708     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 709                           mul_val0, mul_val1, mul_val2, mul_val3,
 710                           res0, res1, 9, 7, 5);
 711     ST_SH2(res0, res1, dst, stride);
 712     dst += (2 * stride);
 713
 714     SPLATI_H2_SH(src1_l, 0, 1, vec0, vec1);
 715     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 716                           mul_val0, mul_val1, mul_val2, mul_val3,
 717                           res0, res1, 7, 9, 5);
 718     ST_SH2(res0, res1, dst, stride);
 719     dst += (2 * stride);
 720
 721     SPLATI_H2_SH(src1_l, 2, 3, vec0, vec1);
 722     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 723                           mul_val0, mul_val1, mul_val2, mul_val3,
 724                           res0, res1, 5, 11, 5);
 725     ST_SH2(res0, res1, dst, stride);
 726     dst += (2 * stride);
 727
 728     SPLATI_H2_SH(src1_l, 4, 5, vec0, vec1);
 729     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 730                           mul_val0, mul_val1, mul_val2, mul_val3,
 731                           res0, res1, 3, 13, 5);
 732     ST_SH2(res0, res1, dst, stride);
 733     dst += (2 * stride);
 734
 735     SPLATI_H2_SH(src1_l, 6, 7, vec0, vec1);
 736     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 737                           mul_val0, mul_val1, mul_val2, mul_val3,
 738                           res0, res1, 1, 15, 5);
 739     ST_SH2(res0, res1, dst, stride);
 740 }
 741
 742 static void process_intra_upper_16x16_msa(const uint8_t *src_top,
 743                                           const uint8_t *src_left,
 744                                           uint8_t *dst, int32_t stride,
 745                                           uint8_t offset)
 746 {
 747     v16i8 src0, src1;
 748     v8i16 src0_r, src1_r, src0_l, src1_l;
 749     v8i16 vec0, vec1, res0, res1;
 750     v8i16 tmp0, tmp1;
 751     v8i16 mul_val2, mul_val3;
 752     v8i16 mul_val1 = { 1, 2, 3, 4, 5, 6, 7, 8 };
 753     v8i16 mul_val0 = { 31, 30, 29, 28, 27, 26, 25, 24 };
 754
 755     tmp0 = __msa_fill_h(src_top[32 - offset]);
 756     tmp1 = __msa_fill_h(src_left[32]);
 757
 758     src0 = LD_SB(src_top);
 759     src1 = LD_SB(src_left);
 760
 761     UNPCK_UB_SH(src0, src0_r, src0_l);
 762     UNPCK_UB_SH(src1, src1_r, src1_l);
 763
 764     mul_val1 += offset;
 765     mul_val0 -= offset;
 766     mul_val2 = mul_val0 - 8;
 767     mul_val3 = mul_val1 + 8;
 768
 769     SPLATI_H2_SH(src1_r, 0, 1, vec0, vec1);
 770     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 771                           mul_val0, mul_val1, mul_val2, mul_val3,
 772                           res0, res1, 31, 1, 6);
 773     ST_SH2(res0, res1, dst, stride);
 774     dst += (2 * stride);
 775
 776     SPLATI_H2_SH(src1_r, 2, 3, vec0, vec1);
 777     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 778                           mul_val0, mul_val1, mul_val2, mul_val3,
 779                           res0, res1, 29, 3, 6);
 780     ST_SH2(res0, res1, dst, stride);
 781     dst += (2 * stride);
 782
 783     SPLATI_H2_SH(src1_r, 4, 5, vec0, vec1);
 784     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 785                           mul_val0, mul_val1, mul_val2, mul_val3,
 786                           res0, res1, 27, 5, 6);
 787     ST_SH2(res0, res1, dst, stride);
 788     dst += (2 * stride);
 789
 790     SPLATI_H2_SH(src1_r, 6, 7, vec0, vec1);
 791     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 792                           mul_val0, mul_val1, mul_val2, mul_val3,
 793                           res0, res1, 25, 7, 6);
 794     ST_SH2(res0, res1, dst, stride);
 795     dst += (2 * stride);
 796
 797     SPLATI_H2_SH(src1_l, 0, 1, vec0, vec1);
 798     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 799                           mul_val0, mul_val1, mul_val2, mul_val3,
 800                           res0, res1, 23, 9, 6);
 801     ST_SH2(res0, res1, dst, stride);
 802     dst += (2 * stride);
 803
 804     SPLATI_H2_SH(src1_l, 2, 3, vec0, vec1);
 805     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 806                           mul_val0, mul_val1, mul_val2, mul_val3,
 807                           res0, res1, 21, 11, 6);
 808     ST_SH2(res0, res1, dst, stride);
 809     dst += (2 * stride);
 810
 811     SPLATI_H2_SH(src1_l, 4, 5, vec0, vec1);
 812     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 813                           mul_val0, mul_val1, mul_val2, mul_val3,
 814                           res0, res1, 19, 13, 6);
 815     ST_SH2(res0, res1, dst, stride);
 816     dst += (2 * stride);
 817
 818     SPLATI_H2_SH(src1_l, 6, 7, vec0, vec1);
 819     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 820                           mul_val0, mul_val1, mul_val2, mul_val3,
 821                           res0, res1, 17, 15, 6);
 822     ST_SH2(res0, res1, dst, stride);
 823 }
 824
 825 static void process_intra_lower_16x16_msa(const uint8_t *src_top,
 826                                           const uint8_t *src_left,
 827                                           uint8_t *dst, int32_t stride,
 828                                           uint8_t offset)
 829 {
 830     v16i8 src0, src1;
 831     v8i16 src0_r, src1_r, src0_l, src1_l;
 832     v8i16 vec0, vec1, res0, res1, tmp0, tmp1;
 833     v8i16 mul_val2, mul_val3;
 834     v8i16 mul_val1 = { 1, 2, 3, 4, 5, 6, 7, 8 };
 835     v8i16 mul_val0 = { 31, 30, 29, 28, 27, 26, 25, 24 };
 836
 837     tmp0 = __msa_fill_h(src_top[32 - offset]);
 838     tmp1 = __msa_fill_h(src_left[16]);
 839
 840     src0 = LD_SB(src_top);
 841     src1 = LD_SB(src_left);
 842
 843     UNPCK_UB_SH(src0, src0_r, src0_l);
 844     UNPCK_UB_SH(src1, src1_r, src1_l);
 845
 846     mul_val1 += offset;
 847     mul_val0 -= offset;
 848     mul_val2 = mul_val0 - 8;
 849     mul_val3 = mul_val1 + 8;
 850
 851     SPLATI_H2_SH(src1_r, 0, 1, vec0, vec1);
 852     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 853                           mul_val0, mul_val1, mul_val2, mul_val3,
 854                           res0, res1, 15, 17, 6);
 855     ST_SH2(res0, res1, dst, stride);
 856     dst += (2 * stride);
 857
 858     SPLATI_H2_SH(src1_r, 2, 3, vec0, vec1);
 859     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 860                           mul_val0, mul_val1, mul_val2, mul_val3,
 861                           res0, res1, 13, 19, 6);
 862     ST_SH2(res0, res1, dst, stride);
 863     dst += (2 * stride);
 864
 865     SPLATI_H2_SH(src1_r, 4, 5, vec0, vec1);
 866     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 867                           mul_val0, mul_val1, mul_val2, mul_val3,
 868                           res0, res1, 11, 21, 6);
 869     ST_SH2(res0, res1, dst, stride);
 870     dst += (2 * stride);
 871
 872     SPLATI_H2_SH(src1_r, 6, 7, vec0, vec1);
 873     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 874                           mul_val0, mul_val1, mul_val2, mul_val3,
 875                           res0, res1, 9, 23, 6);
 876     ST_SH2(res0, res1, dst, stride);
 877     dst += (2 * stride);
 878
 879     SPLATI_H2_SH(src1_l, 0, 1, vec0, vec1);
 880     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 881                           mul_val0, mul_val1, mul_val2, mul_val3,
 882                           res0, res1, 7, 25, 6);
 883     ST_SH2(res0, res1, dst, stride);
 884     dst += (2 * stride);
 885
 886     SPLATI_H2_SH(src1_l, 2, 3, vec0, vec1);
 887     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 888                           mul_val0, mul_val1, mul_val2, mul_val3,
 889                           res0, res1, 5, 27, 6);
 890     ST_SH2(res0, res1, dst, stride);
 891     dst += (2 * stride);
 892
 893     SPLATI_H2_SH(src1_l, 4, 5, vec0, vec1);
 894     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 895                           mul_val0, mul_val1, mul_val2, mul_val3,
 896                           res0, res1, 3, 29, 6);
 897     ST_SH2(res0, res1, dst, stride);
 898     dst += (2 * stride);
 899
 900     SPLATI_H2_SH(src1_l, 6, 7, vec0, vec1);
 901     HEVC_PRED_PLANAR_16x2(src0_r, src0_l, tmp0, tmp1, vec0, vec1,
 902                           mul_val0, mul_val1, mul_val2, mul_val3,
 903                           res0, res1, 1, 31, 6);
 904     ST_SH2(res0, res1, dst, stride);
 905 }
 906
 907 static void hevc_intra_pred_plane_32x32_msa(const uint8_t *src_top,
 908                                             const uint8_t *src_left,
 909                                             uint8_t *dst, int32_t stride)
 910 {
 911     process_intra_upper_16x16_msa(src_top, src_left, dst, stride, 0);
 912     process_intra_upper_16x16_msa((src_top + 16), src_left,
 913                                   (dst + 16), stride, 16);
 914     dst += (16 * stride);
 915     src_left += 16;
 916
 917     process_intra_lower_16x16_msa(src_top, src_left, dst, stride, 0);
 918     process_intra_lower_16x16_msa((src_top + 16), src_left,
 919                                   (dst + 16), stride, 16);
 920 }
 921
 922 static void hevc_intra_pred_angular_upper_4width_msa(const uint8_t *src_top,
 923                                                      const uint8_t *src_left,
 924                                                      uint8_t *dst,
 925                                                      int32_t stride,
 926                                                      int32_t mode)
 927 {
 928     int16_t inv_angle[] = { -256, -315, -390, -482, -630, -910, -1638, -4096 };
 929     uint8_t ref_array[3 * 32 + 4];
 930     uint8_t *ref_tmp = ref_array + 4;
 931     const uint8_t *ref;
 932     int32_t last;
 933     int32_t h_cnt, idx0, fact_val0, idx1, fact_val1;
 934     int32_t idx2, fact_val2, idx3, fact_val3;
 935     int32_t angle, angle_loop;
 936     int32_t inv_angle_val, offset;
 937     uint64_t tmp0;
 938     v16i8 top0, top1, top2, top3;
 939     v16i8 dst_val0;
 940     v16i8 zero = { 0 };
 941     v8i16 diff0, diff1, diff2, diff3, diff4, diff5, diff6, diff7;
 942     v8i16 fact0, fact1, fact2, fact3, fact4, fact5, fact6, fact7;
 943
 944     angle = intra_pred_angle_up[mode - 18];
 945     inv_angle_val = inv_angle[mode - 18];
 946     last = (angle) >> 3;
 947     angle_loop = angle;
 948
 949     ref = src_top - 1;
 950     if (angle < 0 && last < -1) {
 951         inv_angle_val = inv_angle[mode - 18];
 952
 953         tmp0 = LD(ref);
 954         SD(tmp0, ref_tmp);
 955
 956         for (h_cnt = last; h_cnt <= -1; h_cnt++) {
 957             offset = -1 + ((h_cnt * inv_angle_val + 128) >> 8);
 958             ref_tmp[h_cnt] = src_left[offset];
 959         }
 960
 961         ref = ref_tmp;
 962     }
 963
 964     idx0 = angle_loop >> 5;
 965     fact_val0 = angle_loop & 31;
 966     angle_loop += angle;
 967
 968     idx1 = angle_loop >> 5;
 969     fact_val1 = angle_loop & 31;
 970     angle_loop += angle;
 971
 972     idx2 = angle_loop >> 5;
 973     fact_val2 = angle_loop & 31;
 974     angle_loop += angle;
 975
 976     idx3 = angle_loop >> 5;
 977     fact_val3 = angle_loop & 31;
 978
 979     top0 = LD_SB(ref + idx0 + 1);
 980     top1 = LD_SB(ref + idx1 + 1);
 981     top2 = LD_SB(ref + idx2 + 1);
 982     top3 = LD_SB(ref + idx3 + 1);
 983
 984     fact0 = __msa_fill_h(fact_val0);
 985     fact1 = __msa_fill_h(32 - fact_val0);
 986
 987     fact2 = __msa_fill_h(fact_val1);
 988     fact3 = __msa_fill_h(32 - fact_val1);
 989
 990     fact4 = __msa_fill_h(fact_val2);
 991     fact5 = __msa_fill_h(32 - fact_val2);
 992
 993     fact6 = __msa_fill_h(fact_val3);
 994     fact7 = __msa_fill_h(32 - fact_val3);
 995
 996     ILVR_D2_SH(fact2, fact0, fact6, fact4, fact0, fact2);
 997     ILVR_D2_SH(fact3, fact1, fact7, fact5, fact1, fact3);
 998     ILVR_B4_SH(zero, top0, zero, top1, zero, top2, zero, top3,
 999                diff0, diff2, diff4, diff6);
1000     SLDI_B4_0_SH(diff0, diff2, diff4, diff6, diff1, diff3, diff5, diff7, 2);
1001     ILVR_D2_SH(diff2, diff0, diff6, diff4, diff0, diff2);
1002     ILVR_D2_SH(diff3, diff1, diff7, diff5, diff1, diff3);
1003     MUL2(diff1, fact0, diff3, fact2, diff1, diff3);
1004
1005     diff1 += diff0 * fact1;
1006     diff3 += diff2 * fact3;
1007
1008     SRARI_H2_SH(diff1, diff3, 5);
1009     dst_val0 = __msa_pckev_b((v16i8) diff3, (v16i8) diff1);
1010     ST4x4_UB(dst_val0, dst_val0, 0, 1, 2, 3, dst, stride);
1011 }
1012
1013 static void hevc_intra_pred_angular_upper_8width_msa(const uint8_t *src_top,
1014                                                      const uint8_t *src_left,
1015                                                      uint8_t *dst,
1016                                                      int32_t stride,
1017                                                      int32_t mode)
1018 {
1019     int16_t inv_angle[] = { -256, -315, -390, -482, -630, -910, -1638, -4096 };
1020     uint8_t ref_array[3 * 32 + 4];
1021     uint8_t *ref_tmp = ref_array + 8;
1022     const uint8_t *ref;
1023     const uint8_t *src_left_tmp = src_left - 1;
1024     int32_t last, offset;
1025     int32_t h_cnt, v_cnt, idx0, fact_val0, idx1, fact_val1;
1026     int32_t idx2, fact_val2, idx3, fact_val3;
1027     int32_t angle, angle_loop;
1028     int32_t inv_angle_val, inv_angle_val_loop;
1029     int32_t tmp0, tmp1, tmp2;
1030     v16i8 top0, top1, top2, top3;
1031     v16u8 dst_val0, dst_val1;
1032     v8i16 fact0, fact1, fact2, fact3, fact4, fact5, fact6, fact7;
1033     v8i16 diff0, diff1, diff2, diff3, diff4, diff5, diff6, diff7;
1034
1035     angle = intra_pred_angle_up[mode - 18];
1036     inv_angle_val = inv_angle[mode - 18];
1037     last = (angle) >> 2;
1038     angle_loop = angle;
1039
1040     ref = src_top - 1;
1041     if (last < -1) {
1042         inv_angle_val_loop = inv_angle_val * last;
1043
1044         tmp0 = LW(ref);
1045         tmp1 = LW(ref + 4);
1046         tmp2 = LW(ref + 8);
1047         SW(tmp0, ref_tmp);
1048         SW(tmp1, ref_tmp + 4);
1049         SW(tmp2, ref_tmp + 8);
1050
1051         for (h_cnt = last; h_cnt <= -1; h_cnt++) {
1052             offset = (inv_angle_val_loop + 128) >> 8;
1053             ref_tmp[h_cnt] = src_left_tmp[offset];
1054             inv_angle_val_loop += inv_angle_val;
1055         }
1056         ref = ref_tmp;
1057     }
1058
1059     for (v_cnt = 0; v_cnt < 2; v_cnt++) {
1060         idx0 = (angle_loop) >> 5;
1061         fact_val0 = (angle_loop) & 31;
1062         angle_loop += angle;
1063
1064         idx1 = (angle_loop) >> 5;
1065         fact_val1 = (angle_loop) & 31;
1066         angle_loop += angle;
1067
1068         idx2 = (angle_loop) >> 5;
1069         fact_val2 = (angle_loop) & 31;
1070         angle_loop += angle;
1071
1072         idx3 = (angle_loop) >> 5;
1073         fact_val3 = (angle_loop) & 31;
1074         angle_loop += angle;
1075
1076         top0 = LD_SB(ref + idx0 + 1);
1077         top1 = LD_SB(ref + idx1 + 1);
1078         top2 = LD_SB(ref + idx2 + 1);
1079         top3 = LD_SB(ref + idx3 + 1);
1080
1081         fact0 = __msa_fill_h(fact_val0);
1082         fact1 = __msa_fill_h(32 - fact_val0);
1083         fact2 = __msa_fill_h(fact_val1);
1084         fact3 = __msa_fill_h(32 - fact_val1);
1085         fact4 = __msa_fill_h(fact_val2);
1086         fact5 = __msa_fill_h(32 - fact_val2);
1087         fact6 = __msa_fill_h(fact_val3);
1088         fact7 = __msa_fill_h(32 - fact_val3);
1089
1090         UNPCK_UB_SH(top0, diff0, diff1);
1091         UNPCK_UB_SH(top1, diff2, diff3);
1092         UNPCK_UB_SH(top2, diff4, diff5);
1093         UNPCK_UB_SH(top3, diff6, diff7);
1094
1095         SLDI_B2_SH(diff1, diff3, diff0, diff2, diff1, diff3, 2);
1096         SLDI_B2_SH(diff5, diff7, diff4, diff6, diff5, diff7, 2);
1097         MUL4(diff1, fact0, diff3, fact2, diff5, fact4, diff7, fact6,
1098              diff1, diff3, diff5, diff7);
1099
1100         diff1 += diff0 * fact1;
1101         diff3 += diff2 * fact3;
1102         diff5 += diff4 * fact5;
1103         diff7 += diff6 * fact7;
1104
1105         SRARI_H4_SH(diff1, diff3, diff5, diff7, 5);
1106         PCKEV_B2_UB(diff3, diff1, diff7, diff5, dst_val0, dst_val1);
1107         ST8x4_UB(dst_val0, dst_val1, dst, stride);
1108         dst += (4 * stride);
1109     }
1110 }
1111
1112 static void hevc_intra_pred_angular_upper_16width_msa(const uint8_t *src_top,
1113                                                       const uint8_t *src_left,
1114                                                       uint8_t *dst,
1115                                                       int32_t stride,
1116                                                       int32_t mode)
1117 {
1118     int16_t inv_angle[] = { -256, -315, -390, -482, -630, -910, -1638, -4096 };
1119     int32_t h_cnt, v_cnt, idx0, fact_val0, idx1, fact_val1;
1120     int32_t idx2, fact_val2, idx3, fact_val3;
1121     int32_t tmp0;
1122     int32_t angle, angle_loop, offset;
1123     int32_t inv_angle_val, inv_angle_val_loop;
1124     uint8_t ref_array[3 * 32 + 4];
1125     uint8_t *ref_tmp = ref_array + 16;
1126     const uint8_t *ref;
1127     const uint8_t *src_left_tmp = src_left - 1;
1128     int32_t last;
1129     v16u8 top0, top1, top2, top3, top4, top5, top6, top7;
1130     v16i8 dst0, dst1, dst2, dst3;
1131     v8i16 fact0, fact1, fact2, fact3, fact4, fact5, fact6, fact7;
1132     v8i16 diff0, diff1, diff2, diff3, diff4, diff5, diff6, diff7;
1133     v8i16 diff8, diff9, diff10, diff11, diff12, diff13, diff14, diff15;
1134
1135     angle = intra_pred_angle_up[mode - 18];
1136     inv_angle_val = inv_angle[mode - 18];
1137     last = angle >> 1;
1138     angle_loop = angle;
1139
1140     ref = src_top - 1;
1141     if (last < -1) {
1142         inv_angle_val_loop = inv_angle_val * last;
1143
1144         top0 = LD_UB(ref);
1145         tmp0 = LW(ref + 16);
1146         ST_UB(top0, ref_tmp);
1147         SW(tmp0, ref_tmp + 16);
1148
1149         for (h_cnt = last; h_cnt <= -1; h_cnt++) {
1150             offset = (inv_angle_val_loop + 128) >> 8;
1151             ref_tmp[h_cnt] = src_left_tmp[offset];
1152             inv_angle_val_loop += inv_angle_val;
1153         }
1154         ref = ref_tmp;
1155     }
1156
1157     for (v_cnt = 4; v_cnt--;) {
1158         idx0 = (angle_loop) >> 5;
1159         fact_val0 = (angle_loop) & 31;
1160         angle_loop += angle;
1161
1162         idx1 = (angle_loop) >> 5;
1163         fact_val1 = (angle_loop) & 31;
1164         angle_loop += angle;
1165
1166         idx2 = (angle_loop) >> 5;
1167         fact_val2 = (angle_loop) & 31;
1168         angle_loop += angle;
1169
1170         idx3 = (angle_loop) >> 5;
1171         fact_val3 = (angle_loop) & 31;
1172         angle_loop += angle;
1173
1174         LD_UB2(ref + idx0 + 1, 16, top0, top1);
1175         LD_UB2(ref + idx1 + 1, 16, top2, top3);
1176         LD_UB2(ref + idx2 + 1, 16, top4, top5);
1177         LD_UB2(ref + idx3 + 1, 16, top6, top7);
1178
1179         fact0 = __msa_fill_h(fact_val0);
1180         fact1 = __msa_fill_h(32 - fact_val0);
1181         fact2 = __msa_fill_h(fact_val1);
1182         fact3 = __msa_fill_h(32 - fact_val1);
1183         fact4 = __msa_fill_h(fact_val2);
1184         fact5 = __msa_fill_h(32 - fact_val2);
1185         fact6 = __msa_fill_h(fact_val3);
1186         fact7 = __msa_fill_h(32 - fact_val3);
1187
1188         SLDI_B2_UB(top1, top3, top0, top2, top1, top3, 1);
1189         SLDI_B2_UB(top5, top7, top4, top6, top5, top7, 1);
1190         UNPCK_UB_SH(top0, diff0, diff1);
1191         UNPCK_UB_SH(top1, diff2, diff3);
1192         UNPCK_UB_SH(top2, diff4, diff5);
1193         UNPCK_UB_SH(top3, diff6, diff7);
1194         UNPCK_UB_SH(top4, diff8, diff9);
1195         UNPCK_UB_SH(top5, diff10, diff11);
1196         UNPCK_UB_SH(top6, diff12, diff13);
1197         UNPCK_UB_SH(top7, diff14, diff15);
1198
1199         MUL4(diff2, fact0, diff3, fact0, diff6, fact2, diff7, fact2,
1200              diff2, diff3, diff6, diff7);
1201         MUL4(diff10, fact4, diff11, fact4, diff14, fact6, diff15, fact6,
1202              diff10, diff11, diff14, diff15);
1203
1204         diff2 += diff0 * fact1;
1205         diff3 += diff1 * fact1;
1206         diff6 += diff4 * fact3;
1207         diff7 += diff5 * fact3;
1208         diff10 += diff8 * fact5;
1209         diff11 += diff9 * fact5;
1210         diff14 += diff12 * fact7;
1211         diff15 += diff13 * fact7;
1212
1213         SRARI_H4_SH(diff2, diff3, diff6, diff7, 5);
1214         SRARI_H4_SH(diff10, diff11, diff14, diff15, 5);
1215         PCKEV_B4_SB(diff3, diff2, diff7, diff6, diff11, diff10, diff15, diff14,
1216                     dst0, dst1, dst2, dst3);
1217         ST_SB4(dst0, dst1, dst2, dst3, dst, stride);
1218         dst += (4 * stride);
1219     }
1220 }
1221
1222 static void hevc_intra_pred_angular_upper_32width_msa(const uint8_t *src_top,
1223                                                       const uint8_t *src_left,
1224                                                       uint8_t *dst,
1225                                                       int32_t stride,
1226                                                       int32_t mode)
1227 {
1228     int16_t inv_angle[] = { -256, -315, -390, -482, -630, -910, -1638, -4096 };
1229     uint8_t ref_array[3 * 32 + 4];
1230     uint8_t *ref_tmp;
1231     const uint8_t *ref;
1232     const uint8_t *src_left_tmp = src_left - 1;
1233     int32_t h_cnt, v_cnt, idx0, fact_val0, idx1, fact_val1;
1234     int32_t tmp0, tmp1, tmp2, tmp3;
1235     int32_t angle, angle_loop;
1236     int32_t inv_angle_val, inv_angle_val_loop;
1237     int32_t last, offset;
1238     v16u8 top0, top1, top2, top3, top4, top5, top6, top7;
1239     v16i8 dst0, dst1, dst2, dst3;
1240     v8i16 fact0, fact1, fact2, fact3;
1241     v8i16 diff0, diff1, diff2, diff3, diff4, diff5, diff6, diff7;
1242     v8i16 diff8, diff9, diff10, diff11, diff12, diff13, diff14, diff15;
1243
1244     ref_tmp = ref_array + 32;
1245
1246     angle = intra_pred_angle_up[mode - 18];
1247     inv_angle_val = inv_angle[mode - 18];
1248     last = angle;
1249     angle_loop = angle;
1250
1251     ref = src_top - 1;
1252     if (last < -1) {
1253         inv_angle_val_loop = inv_angle_val * last;
1254         LD_UB2(ref, 16, top0, top1);
1255         tmp0 = ref[32];
1256         tmp1 = ref[33];
1257         tmp2 = ref[34];
1258         tmp3 = ref[35];
1259
1260         ST_UB2(top0, top1, ref_tmp, 16);
1261         ref_tmp[32] = tmp0;
1262         ref_tmp[33] = tmp1;
1263         ref_tmp[34] = tmp2;
1264         ref_tmp[35] = tmp3;
1265
1266         for (h_cnt = last; h_cnt <= -1; h_cnt++) {
1267             offset = (inv_angle_val_loop + 128) >> 8;
1268             ref_tmp[h_cnt] = src_left_tmp[offset];
1269             inv_angle_val_loop += inv_angle_val;
1270         }
1271
1272         ref = ref_tmp;
1273     }
1274
1275     for (v_cnt = 16; v_cnt--;) {
1276         idx0 = (angle_loop) >> 5;
1277         fact_val0 = (angle_loop) & 31;
1278         angle_loop += angle;
1279
1280         idx1 = (angle_loop) >> 5;
1281         fact_val1 = (angle_loop) & 31;
1282         angle_loop += angle;
1283
1284         top0 = LD_UB(ref + idx0 + 1);
1285         top4 = LD_UB(ref + idx1 + 1);
1286         top1 = LD_UB(ref + idx0 + 17);
1287         top5 = LD_UB(ref + idx1 + 17);
1288         top3 = LD_UB(ref + idx0 + 33);
1289         top7 = LD_UB(ref + idx1 + 33);
1290
1291         fact0 = __msa_fill_h(fact_val0);
1292         fact1 = __msa_fill_h(32 - fact_val0);
1293         fact2 = __msa_fill_h(fact_val1);
1294         fact3 = __msa_fill_h(32 - fact_val1);
1295
1296         top2 = top1;
1297         top6 = top5;
1298
1299         SLDI_B2_UB(top1, top3, top0, top2, top1, top3, 1);
1300         SLDI_B2_UB(top5, top7, top4, top6, top5, top7, 1);
1301         UNPCK_UB_SH(top0, diff0, diff1);
1302         UNPCK_UB_SH(top1, diff2, diff3);
1303         UNPCK_UB_SH(top2, diff4, diff5);
1304         UNPCK_UB_SH(top3, diff6, diff7);
1305         UNPCK_UB_SH(top4, diff8, diff9);
1306         UNPCK_UB_SH(top5, diff10, diff11);
1307         UNPCK_UB_SH(top6, diff12, diff13);
1308         UNPCK_UB_SH(top7, diff14, diff15);
1309
1310         MUL4(diff2, fact0, diff3, fact0, diff6, fact0, diff7, fact0,
1311              diff2, diff3, diff6, diff7);
1312         MUL4(diff10, fact2, diff11, fact2, diff14, fact2, diff15, fact2,
1313              diff10, diff11, diff14, diff15);
1314
1315         diff2 += diff0 * fact1;
1316         diff3 += diff1 * fact1;
1317         diff6 += diff4 * fact1;
1318         diff7 += diff5 * fact1;
1319         diff10 += diff8 * fact3;
1320         diff11 += diff9 * fact3;
1321         diff14 += diff12 * fact3;
1322         diff15 += diff13 * fact3;
1323
1324         SRARI_H4_SH(diff2, diff3, diff6, diff7, 5);
1325         SRARI_H4_SH(diff10, diff11, diff14, diff15, 5);
1326         PCKEV_B4_SB(diff3, diff2, diff7, diff6, diff11, diff10, diff15, diff14,
1327                     dst0, dst1, dst2, dst3);
1328
1329         ST_SB2(dst0, dst1, dst, 16);
1330         dst += stride;
1331         ST_SB2(dst2, dst3, dst, 16);
1332         dst += stride;
1333     }
1334 }
1335
1336 static void hevc_intra_pred_angular_lower_4width_msa(const uint8_t *src_top,
1337                                                      const uint8_t *src_left,
1338                                                      uint8_t *dst,
1339                                                      int32_t stride,
1340                                                      int32_t mode)
1341 {
1342     int16_t inv_angle[] = { -4096, -1638, -910, -630, -482, -390, -315 };
1343     uint8_t ref_array[3 * 32 + 4];
1344     uint8_t *ref_tmp = ref_array + 4;
1345     const uint8_t *ref;
1346     int32_t last, offset;
1347     int32_t h_cnt, idx0, fact_val0, idx1, fact_val1;
1348     int32_t idx2, fact_val2, idx3, fact_val3;
1349     int32_t angle, angle_loop, inv_angle_val;
1350     uint64_t tmp0;
1351     v16i8 dst_val0, dst_val1;
1352     v16u8 top0, top1, top2, top3;
1353     v16u8 zero = { 0 };
1354     v8i16 diff0, diff1, diff2, diff3, diff4, diff5, diff6, diff7;
1355     v8i16 fact0, fact1, fact2, fact3, fact4, fact5, fact6, fact7;
1356
1357     angle = intra_pred_angle_low[mode - 2];
1358     last = angle >> 3;
1359     angle_loop = angle;
1360
1361     ref = src_left - 1;
1362     if (last < -1) {
1363         inv_angle_val = inv_angle[mode - 11];
1364
1365         tmp0 = LD(ref);
1366         SD(tmp0, ref_tmp);
1367
1368         for (h_cnt = last; h_cnt <= -1; h_cnt++) {
1369             offset = -1 + ((h_cnt * inv_angle_val + 128) >> 8);
1370             ref_tmp[h_cnt] = src_top[offset];
1371         }
1372
1373         ref = ref_tmp;
1374     }
1375
1376     idx0 = angle_loop >> 5;
1377     fact_val0 = angle_loop & 31;
1378     angle_loop += angle;
1379
1380     idx1 = angle_loop >> 5;
1381     fact_val1 = angle_loop & 31;
1382     angle_loop += angle;
1383
1384     idx2 = angle_loop >> 5;
1385     fact_val2 = angle_loop & 31;
1386     angle_loop += angle;
1387
1388     idx3 = angle_loop >> 5;
1389     fact_val3 = angle_loop & 31;
1390
1391     top0 = LD_UB(ref + idx0 + 1);
1392     top1 = LD_UB(ref + idx1 + 1);
1393     top2 = LD_UB(ref + idx2 + 1);
1394     top3 = LD_UB(ref + idx3 + 1);
1395
1396     fact0 = __msa_fill_h(fact_val0);
1397     fact1 = __msa_fill_h(32 - fact_val0);
1398     fact2 = __msa_fill_h(fact_val1);
1399     fact3 = __msa_fill_h(32 - fact_val1);
1400     fact4 = __msa_fill_h(fact_val2);
1401     fact5 = __msa_fill_h(32 - fact_val2);
1402     fact6 = __msa_fill_h(fact_val3);
1403     fact7 = __msa_fill_h(32 - fact_val3);
1404
1405     ILVR_D2_SH(fact2, fact0, fact6, fact4, fact0, fact2);
1406     ILVR_D2_SH(fact3, fact1, fact7, fact5, fact1, fact3);
1407     ILVR_B4_SH(zero, top0, zero, top1, zero, top2, zero, top3,
1408                diff0, diff2, diff4, diff6);
1409     SLDI_B4_0_SH(diff0, diff2, diff4, diff6, diff1, diff3, diff5, diff7, 2);
1410     ILVR_D2_SH(diff2, diff0, diff6, diff4, diff0, diff2);
1411     ILVR_D2_SH(diff3, diff1, diff7, diff5, diff1, diff3);
1412     MUL2(diff1, fact0, diff3, fact2, diff1, diff3);
1413
1414     diff1 += diff0 * fact1;
1415     diff3 += diff2 * fact3;
1416
1417     SRARI_H2_SH(diff1, diff3, 5);
1418     PCKEV_B2_SB(diff1, diff1, diff3, diff3, dst_val0, dst_val1);
1419
1420     diff0 = (v8i16) __msa_pckev_b(dst_val1, dst_val0);
1421     diff1 = (v8i16) __msa_pckod_b(dst_val1, dst_val0);
1422
1423     diff2 = (v8i16) __msa_pckev_w((v4i32) diff1, (v4i32) diff0);
1424
1425     dst_val0 = __msa_pckev_b((v16i8) diff2, (v16i8) diff2);
1426     dst_val1 = __msa_pckod_b((v16i8) diff2, (v16i8) diff2);
1427
1428     ST4x2_UB(dst_val0, dst, stride);
1429     dst += (2 * stride);
1430     ST4x2_UB(dst_val1, dst, stride);
1431 }
1432
1433 static void hevc_intra_pred_angular_lower_8width_msa(const uint8_t *src_top,
1434                                                      const uint8_t *src_left,
1435                                                      uint8_t *dst,
1436                                                      int32_t stride,
1437                                                      int32_t mode)
1438 {
1439     int16_t inv_angle[] = { -4096, -1638, -910, -630, -482, -390, -315 };
1440     uint8_t ref_array[3 * 32 + 4];
1441     uint8_t *ref_tmp = ref_array + 8;
1442     const uint8_t *ref;
1443     const uint8_t *src_top_tmp = src_top - 1;
1444     uint8_t *dst_org;
1445     int32_t last, offset, tmp0, tmp1, tmp2;
1446     int32_t h_cnt, v_cnt, idx0, fact_val0, idx1, fact_val1;
1447     int32_t idx2, fact_val2, idx3, fact_val3;
1448     int32_t angle, angle_loop, inv_angle_val;
1449     v16i8 top0, top1, top2, top3;
1450     v16i8 dst_val0, dst_val1, dst_val2, dst_val3;
1451     v8i16 diff0, diff1, diff2, diff3, diff4, diff5, diff6, diff7;
1452     v8i16 fact0, fact1, fact2, fact3, fact4, fact5, fact6, fact7;
1453
1454     angle = intra_pred_angle_low[mode - 2];
1455     last = (angle) >> 2;
1456     angle_loop = angle;
1457
1458     ref = src_left - 1;
1459     if (last < -1) {
1460         inv_angle_val = inv_angle[mode - 11];
1461
1462         tmp0 = LW(ref);
1463         tmp1 = LW(ref + 4);
1464         tmp2 = LW(ref + 8);
1465         SW(tmp0, ref_tmp);
1466         SW(tmp1, ref_tmp + 4);
1467         SW(tmp2, ref_tmp + 8);
1468
1469         for (h_cnt = last; h_cnt <= -1; h_cnt++) {
1470             offset = (h_cnt * inv_angle_val + 128) >> 8;
1471             ref_tmp[h_cnt] = src_top_tmp[offset];
1472         }
1473
1474         ref = ref_tmp;
1475     }
1476
1477     for (v_cnt = 0; v_cnt < 2; v_cnt++) {
1478         dst_org = dst;
1479
1480         idx0 = angle_loop >> 5;
1481         fact_val0 = angle_loop & 31;
1482         angle_loop += angle;
1483
1484         idx1 = angle_loop >> 5;
1485         fact_val1 = angle_loop & 31;
1486         angle_loop += angle;
1487
1488         idx2 = angle_loop >> 5;
1489         fact_val2 = angle_loop & 31;
1490         angle_loop += angle;
1491
1492         idx3 = angle_loop >> 5;
1493         fact_val3 = angle_loop & 31;
1494         angle_loop += angle;
1495
1496         top0 = LD_SB(ref + idx0 + 1);
1497         top1 = LD_SB(ref + idx1 + 1);
1498         top2 = LD_SB(ref + idx2 + 1);
1499         top3 = LD_SB(ref + idx3 + 1);
1500
1501         fact0 = __msa_fill_h(fact_val0);
1502         fact1 = __msa_fill_h(32 - fact_val0);
1503         fact2 = __msa_fill_h(fact_val1);
1504         fact3 = __msa_fill_h(32 - fact_val1);
1505         fact4 = __msa_fill_h(fact_val2);
1506         fact5 = __msa_fill_h(32 - fact_val2);
1507         fact6 = __msa_fill_h(fact_val3);
1508         fact7 = __msa_fill_h(32 - fact_val3);
1509
1510         UNPCK_UB_SH(top0, diff0, diff1);
1511         UNPCK_UB_SH(top1, diff2, diff3);
1512         UNPCK_UB_SH(top2, diff4, diff5);
1513         UNPCK_UB_SH(top3, diff6, diff7);
1514         SLDI_B2_SH(diff1, diff3, diff0, diff2, diff1, diff3, 2);
1515         SLDI_B2_SH(diff5, diff7, diff4, diff6, diff5, diff7, 2);
1516         MUL4(diff1, fact0, diff3, fact2, diff5, fact4, diff7, fact6,
1517              diff1, diff3, diff5, diff7);
1518
1519         diff1 += diff0 * fact1;
1520         diff3 += diff2 * fact3;
1521         diff5 += diff4 * fact5;
1522         diff7 += diff6 * fact7;
1523
1524         SRARI_H4_SH(diff1, diff3, diff5, diff7, 5);
1525         PCKEV_B4_SB(diff1, diff1, diff3, diff3, diff5, diff5, diff7, diff7,
1526                     dst_val0, dst_val1, dst_val2, dst_val3);
1527         ILVR_B2_SH(dst_val1, dst_val0, dst_val3, dst_val2, diff0, diff1);
1528         ILVRL_H2_SH(diff1, diff0, diff3, diff4);
1529         ST4x8_UB(diff3, diff4, dst_org, stride);
1530         dst += 4;
1531     }
1532 }
1533
1534 static void hevc_intra_pred_angular_lower_16width_msa(const uint8_t *src_top,
1535                                                       const uint8_t *src_left,
1536                                                       uint8_t *dst,
1537                                                       int32_t stride,
1538                                                       int32_t mode)
1539 {
1540     int16_t inv_angle[] = { -4096, -1638, -910, -630, -482, -390, -315 };
1541     int32_t h_cnt, v_cnt, idx0, fact_val0, idx1, fact_val1;
1542     int32_t idx2, fact_val2, idx3, fact_val3, tmp0;
1543     v16i8 top0, top1, dst_val0, top2, top3, dst_val1;
1544     v16i8 top4, top5, dst_val2, top6, top7, dst_val3;
1545     v8i16 fact0, fact1, fact2, fact3, fact4, fact5, fact6, fact7;
1546     v8i16 diff0, diff1, diff2, diff3, diff4, diff5, diff6, diff7;
1547     v8i16 diff8, diff9, diff10, diff11, diff12, diff13, diff14, diff15;
1548     int32_t angle, angle_loop, inv_angle_val, offset;
1549     uint8_t ref_array[3 * 32 + 4];
1550     uint8_t *ref_tmp = ref_array + 16;
1551     const uint8_t *ref, *src_top_tmp = src_top - 1;
1552     uint8_t *dst_org;
1553     int32_t last;
1554
1555     angle = intra_pred_angle_low[mode - 2];
1556     last = (angle) >> 1;
1557     angle_loop = angle;
1558
1559     ref = src_left - 1;
1560     if (last < -1) {
1561         inv_angle_val = inv_angle[mode - 11];
1562
1563         top0 = LD_SB(ref);
1564         tmp0 = LW(ref + 16);
1565         ST_SB(top0, ref_tmp);
1566         SW(tmp0, ref_tmp + 16);
1567
1568         for (h_cnt = last; h_cnt <= -1; h_cnt++) {
1569             offset = (h_cnt * inv_angle_val + 128) >> 8;
1570             ref_tmp[h_cnt] = src_top_tmp[offset];
1571         }
1572
1573         ref = ref_tmp;
1574     }
1575
1576     for (v_cnt = 0; v_cnt < 4; v_cnt++) {
1577         dst_org = dst;
1578
1579         idx0 = angle_loop >> 5;
1580         fact_val0 = angle_loop & 31;
1581         angle_loop += angle;
1582
1583         idx1 = angle_loop >> 5;
1584         fact_val1 = angle_loop & 31;
1585         angle_loop += angle;
1586
1587         idx2 = angle_loop >> 5;
1588         fact_val2 = angle_loop & 31;
1589         angle_loop += angle;
1590
1591         idx3 = angle_loop >> 5;
1592         fact_val3 = angle_loop & 31;
1593         angle_loop += angle;
1594
1595         LD_SB2(ref + idx0 + 1, 16, top0, top1);
1596         LD_SB2(ref + idx1 + 1, 16, top2, top3);
1597         LD_SB2(ref + idx2 + 1, 16, top4, top5);
1598         LD_SB2(ref + idx3 + 1, 16, top6, top7);
1599
1600         fact0 = __msa_fill_h(fact_val0);
1601         fact1 = __msa_fill_h(32 - fact_val0);
1602         fact2 = __msa_fill_h(fact_val1);
1603         fact3 = __msa_fill_h(32 - fact_val1);
1604         fact4 = __msa_fill_h(fact_val2);
1605         fact5 = __msa_fill_h(32 - fact_val2);
1606         fact6 = __msa_fill_h(fact_val3);
1607         fact7 = __msa_fill_h(32 - fact_val3);
1608
1609         SLDI_B2_SB(top1, top3, top0, top2, top1, top3, 1);
1610         SLDI_B2_SB(top5, top7, top4, top6, top5, top7, 1);
1611
1612         UNPCK_UB_SH(top0, diff0, diff1);
1613         UNPCK_UB_SH(top1, diff2, diff3);
1614         UNPCK_UB_SH(top2, diff4, diff5);
1615         UNPCK_UB_SH(top3, diff6, diff7);
1616         UNPCK_UB_SH(top4, diff8, diff9);
1617         UNPCK_UB_SH(top5, diff10, diff11);
1618         UNPCK_UB_SH(top6, diff12, diff13);
1619         UNPCK_UB_SH(top7, diff14, diff15);
1620
1621         MUL4(diff2, fact0, diff3, fact0, diff6, fact2, diff7, fact2,
1622              diff2, diff3, diff6, diff7);
1623         MUL4(diff10, fact4, diff11, fact4, diff14, fact6, diff15, fact6,
1624              diff10, diff11, diff14, diff15);
1625
1626         diff2 += diff0 * fact1;
1627         diff3 += diff1 * fact1;
1628         diff6 += diff4 * fact3;
1629         diff7 += diff5 * fact3;
1630         diff10 += diff8 * fact5;
1631         diff11 += diff9 * fact5;
1632         diff14 += diff12 * fact7;
1633         diff15 += diff13 * fact7;
1634
1635         SRARI_H4_SH(diff2, diff3, diff6, diff7, 5);
1636         SRARI_H4_SH(diff10, diff11, diff14, diff15, 5);
1637         PCKEV_B4_SB(diff3, diff2, diff7, diff6, diff11, diff10, diff15, diff14,
1638                     dst_val0, dst_val1, dst_val2, dst_val3);
1639         ILVR_B2_SH(dst_val1, dst_val0, dst_val3, dst_val2, diff0, diff1);
1640         ILVL_B2_SH(dst_val1, dst_val0, dst_val3, dst_val2, diff2, diff3);
1641         ILVRL_H2_SH(diff1, diff0, diff4, diff5);
1642         ILVRL_H2_SH(diff3, diff2, diff6, diff7);
1643         ST4x8_UB(diff4, diff5, dst_org, stride);
1644         dst_org += (8 * stride);
1645         ST4x8_UB(diff6, diff7, dst_org, stride);
1646         dst += 4;
1647     }
1648 }
1649
1650 static void hevc_intra_pred_angular_lower_32width_msa(const uint8_t *src_top,
1651                                                       const uint8_t *src_left,
1652                                                       uint8_t *dst,
1653                                                       int32_t stride,
1654                                                       int32_t mode)
1655 {
1656     int16_t inv_angle[] = { -4096, -1638, -910, -630, -482, -390, -315 };
1657     int32_t h_cnt, v_cnt, idx0, fact_val0, idx1, fact_val1, tmp0;
1658     v16i8 top0, top1, dst_val0, top2, top3, dst_val1;
1659     v16i8 top4, top5, dst_val2, top6, top7, dst_val3;
1660     v8i16 fact0, fact1, fact2, fact3;
1661     v8i16 diff0, diff1, diff2, diff3, diff4, diff5, diff6, diff7;
1662     v8i16 diff8, diff9, diff10, diff11, diff12, diff13, diff14, diff15;
1663     int32_t angle, angle_loop, inv_angle_val, offset;
1664     uint8_t ref_array[3 * 32 + 4];
1665     uint8_t *ref_tmp = ref_array + 32;
1666     const uint8_t *ref, *src_top_tmp = src_top - 1;
1667     uint8_t *dst_org;
1668     int32_t last;
1669
1670     angle = intra_pred_angle_low[mode - 2];
1671     last = angle;
1672     angle_loop = angle;
1673
1674     ref = src_left - 1;
1675     if (last < -1) {
1676         inv_angle_val = inv_angle[mode - 11];
1677
1678         LD_SB2(ref, 16, top0, top1);
1679         tmp0 = LW(ref + 32);
1680         ST_SB2(top0, top1, ref_tmp, 16);
1681         SW(tmp0, ref_tmp + 32);
1682
1683         for (h_cnt = last; h_cnt <= -1; h_cnt++) {
1684             offset = (h_cnt * inv_angle_val + 128) >> 8;
1685             ref_tmp[h_cnt] = src_top_tmp[offset];
1686         }
1687
1688         ref = ref_tmp;
1689     }
1690
1691     for (v_cnt = 0; v_cnt < 16; v_cnt++) {
1692         dst_org = dst;
1693         idx0 = angle_loop >> 5;
1694         fact_val0 = angle_loop & 31;
1695         angle_loop += angle;
1696
1697         idx1 = angle_loop >> 5;
1698         fact_val1 = angle_loop & 31;
1699         angle_loop += angle;
1700
1701         top0 = LD_SB(ref + idx0 + 1);
1702         top4 = LD_SB(ref + idx1 + 1);
1703         top1 = LD_SB(ref + idx0 + 17);
1704         top5 = LD_SB(ref + idx1 + 17);
1705         top3 = LD_SB(ref + idx0 + 33);
1706         top7 = LD_SB(ref + idx1 + 33);
1707
1708         fact0 = __msa_fill_h(fact_val0);
1709         fact1 = __msa_fill_h(32 - fact_val0);
1710         fact2 = __msa_fill_h(fact_val1);
1711         fact3 = __msa_fill_h(32 - fact_val1);
1712
1713         top2 = top1;
1714         top6 = top5;
1715
1716         SLDI_B2_SB(top1, top3, top0, top2, top1, top3, 1);
1717         SLDI_B2_SB(top5, top7, top4, top6, top5, top7, 1);
1718
1719         UNPCK_UB_SH(top0, diff0, diff1);
1720         UNPCK_UB_SH(top1, diff2, diff3);
1721         UNPCK_UB_SH(top2, diff4, diff5);
1722         UNPCK_UB_SH(top3, diff6, diff7);
1723         UNPCK_UB_SH(top4, diff8, diff9);
1724         UNPCK_UB_SH(top5, diff10, diff11);
1725         UNPCK_UB_SH(top6, diff12, diff13);
1726         UNPCK_UB_SH(top7, diff14, diff15);
1727
1728         MUL4(diff2, fact0, diff3, fact0, diff6, fact0, diff7, fact0,
1729              diff2, diff3, diff6, diff7);
1730         MUL4(diff10, fact2, diff11, fact2, diff14, fact2, diff15, fact2,
1731              diff10, diff11, diff14, diff15);
1732
1733         diff2 += diff0 * fact1;
1734         diff3 += diff1 * fact1;
1735         diff6 += diff4 * fact1;
1736         diff7 += diff5 * fact1;
1737         diff10 += diff8 * fact3;
1738         diff11 += diff9 * fact3;
1739         diff14 += diff12 * fact3;
1740         diff15 += diff13 * fact3;
1741
1742         SRARI_H4_SH(diff2, diff3, diff6, diff7, 5);
1743         SRARI_H4_SH(diff10, diff11, diff14, diff15, 5);
1744         PCKEV_B4_SB(diff3, diff2, diff7, diff6, diff11, diff10, diff15, diff14,
1745                     dst_val0, dst_val1, dst_val2, dst_val3);
1746         ILVRL_B2_SH(dst_val2, dst_val0, diff0, diff1);
1747         ILVRL_B2_SH(dst_val3, dst_val1, diff2, diff3);
1748
1749         ST2x4_UB(diff0, 0, dst_org, stride);
1750         dst_org += (4 * stride);
1751         ST2x4_UB(diff0, 4, dst_org, stride);
1752         dst_org += (4 * stride);
1753         ST2x4_UB(diff1, 0, dst_org, stride);
1754         dst_org += (4 * stride);
1755         ST2x4_UB(diff1, 4, dst_org, stride);
1756         dst_org += (4 * stride);
1757
1758         ST2x4_UB(diff2, 0, dst_org, stride);
1759         dst_org += (4 * stride);
1760         ST2x4_UB(diff2, 4, dst_org, stride);
1761         dst_org += (4 * stride);
1762         ST2x4_UB(diff3, 0, dst_org, stride);
1763         dst_org += (4 * stride);
1764         ST2x4_UB(diff3, 4, dst_org, stride);
1765         dst_org += (4 * stride);
1766
1767         dst += 2;
1768     }
1769 }
1770
1771 static void intra_predict_vert_32x32_msa(const uint8_t *src, uint8_t *dst,
1772                                          int32_t dst_stride)
1773 {
1774     uint32_t row;
1775     v16u8 src1, src2;
1776
1777     src1 = LD_UB(src);
1778     src2 = LD_UB(src + 16);
1779
1780     for (row = 32; row--;) {
1781         ST_UB2(src1, src2, dst, 16);
1782         dst += dst_stride;
1783     }
1784 }
1785
1786 void ff_hevc_intra_pred_planar_0_msa(uint8_t *dst,
1787                                      const uint8_t *src_top,
1788                                      const uint8_t *src_left,
1789                                      ptrdiff_t stride)
1790 {
1791     hevc_intra_pred_plane_4x4_msa(src_top, src_left, dst, stride);
1792 }
1793
1794 void ff_hevc_intra_pred_planar_1_msa(uint8_t *dst,
1795                                      const uint8_t *src_top,
1796                                      const uint8_t *src_left,
1797                                      ptrdiff_t stride)
1798 {
1799     hevc_intra_pred_plane_8x8_msa(src_top, src_left, dst, stride);
1800 }
1801
1802 void ff_hevc_intra_pred_planar_2_msa(uint8_t *dst,
1803                                      const uint8_t *src_top,
1804                                      const uint8_t *src_left,
1805                                      ptrdiff_t stride)
1806 {
1807     hevc_intra_pred_plane_16x16_msa(src_top, src_left, dst, stride);
1808 }
1809
1810 void ff_hevc_intra_pred_planar_3_msa(uint8_t *dst,
1811                                      const uint8_t *src_top,
1812                                      const uint8_t *src_left,
1813                                      ptrdiff_t stride)
1814 {
1815     hevc_intra_pred_plane_32x32_msa(src_top, src_left, dst, stride);
1816 }
1817
1818 void ff_hevc_intra_pred_dc_msa(uint8_t *dst, const uint8_t *src_top,
1819                                const uint8_t *src_left,
1820                                ptrdiff_t stride, int log2, int c_idx)
1821 {
1822     switch (log2) {
1823     case 2:
1824         hevc_intra_pred_dc_4x4_msa(src_top, src_left, dst, stride, c_idx);
1825         break;
1826
1827     case 3:
1828         hevc_intra_pred_dc_8x8_msa(src_top, src_left, dst, stride, c_idx);
1829         break;
1830
1831     case 4:
1832         hevc_intra_pred_dc_16x16_msa(src_top, src_left, dst, stride, c_idx);
1833         break;
1834
1835     case 5:
1836         hevc_intra_pred_dc_32x32_msa(src_top, src_left, dst, stride);
1837         break;
1838     }
1839 }
1840
1841 void ff_pred_intra_pred_angular_0_msa(uint8_t *dst,
1842                                       const uint8_t *src_top,
1843                                       const uint8_t *src_left,
1844                                       ptrdiff_t stride, int c_idx, int mode)
1845 {
1846     if (mode == 10) {
1847         hevc_intra_pred_horiz_4x4_msa(src_top, src_left, dst, stride, c_idx);
1848     } else if (mode == 26) {
1849         hevc_intra_pred_vert_4x4_msa(src_top, src_left, dst, stride, c_idx);
1850     } else if (mode >= 18) {
1851         hevc_intra_pred_angular_upper_4width_msa(src_top, src_left,
1852                                                  dst, stride, mode);
1853     } else {
1854         hevc_intra_pred_angular_lower_4width_msa(src_top, src_left,
1855                                                  dst, stride, mode);
1856     }
1857 }
1858
1859 void ff_pred_intra_pred_angular_1_msa(uint8_t *dst,
1860                                       const uint8_t *src_top,
1861                                       const uint8_t *src_left,
1862                                       ptrdiff_t stride, int c_idx, int mode)
1863 {
1864     if (mode == 10) {
1865         hevc_intra_pred_horiz_8x8_msa(src_top, src_left, dst, stride, c_idx);
1866     } else if (mode == 26) {
1867         hevc_intra_pred_vert_8x8_msa(src_top, src_left, dst, stride, c_idx);
1868     } else if (mode >= 18) {
1869         hevc_intra_pred_angular_upper_8width_msa(src_top, src_left,
1870                                                  dst, stride, mode);
1871     } else {
1872         hevc_intra_pred_angular_lower_8width_msa(src_top, src_left,
1873                                                  dst, stride, mode);
1874     }
1875 }
1876
1877 void ff_pred_intra_pred_angular_2_msa(uint8_t *dst,
1878                                       const uint8_t *src_top,
1879                                       const uint8_t *src_left,
1880                                       ptrdiff_t stride, int c_idx, int mode)
1881 {
1882     if (mode == 10) {
1883         hevc_intra_pred_horiz_16x16_msa(src_top, src_left, dst, stride, c_idx);
1884     } else if (mode == 26) {
1885         hevc_intra_pred_vert_16x16_msa(src_top, src_left, dst, stride, c_idx);
1886     } else if (mode >= 18) {
1887         hevc_intra_pred_angular_upper_16width_msa(src_top, src_left,
1888                                                   dst, stride, mode);
1889     } else {
1890         hevc_intra_pred_angular_lower_16width_msa(src_top, src_left,
1891                                                   dst, stride, mode);
1892     }
1893 }
1894
1895 void ff_pred_intra_pred_angular_3_msa(uint8_t *dst,
1896                                       const uint8_t *src_top,
1897                                       const uint8_t *src_left,
1898                                       ptrdiff_t stride, int c_idx, int mode)
1899 {
1900     if (mode == 10) {
1901         hevc_intra_pred_horiz_32x32_msa(src_top, src_left, dst, stride);
1902     } else if (mode == 26) {
1903         intra_predict_vert_32x32_msa(src_top, dst, stride);
1904     } else if (mode >= 18) {
1905         hevc_intra_pred_angular_upper_32width_msa(src_top, src_left,
1906                                                   dst, stride, mode);
1907     } else {
1908         hevc_intra_pred_angular_lower_32width_msa(src_top, src_left,
1909                                                   dst, stride, mode);
1910     }
1911 }
1912
1913 void ff_intra_pred_8_16x16_msa(HEVCContext *s, int x0, int y0, int c_idx)
1914 {
1915     v16u8 vec0;
1916     HEVCLocalContext *lc = s->HEVClc;
1917     int i;
1918     int hshift = s->ps.sps->hshift[c_idx];
1919     int vshift = s->ps.sps->vshift[c_idx];
1920     int size_in_luma_h = 16 << hshift;
1921     int size_in_tbs_h = size_in_luma_h >> s->ps.sps->log2_min_tb_size;
1922     int size_in_luma_v = 16 << vshift;
1923     int size_in_tbs_v = size_in_luma_v >> s->ps.sps->log2_min_tb_size;
1924     int x = x0 >> hshift;
1925     int y = y0 >> vshift;
1926     int x_tb = (x0 >> s->ps.sps->log2_min_tb_size) & s->ps.sps->tb_mask;
1927     int y_tb = (y0 >> s->ps.sps->log2_min_tb_size) & s->ps.sps->tb_mask;
1928
1929     int cur_tb_addr =
1930         s->ps.pps->min_tb_addr_zs[(y_tb) * (s->ps.sps->tb_mask + 2) + (x_tb)];
1931
1932     ptrdiff_t stride = s->frame->linesize[c_idx] / sizeof(uint8_t);
1933     uint8_t *src = (uint8_t *) s->frame->data[c_idx] + x + y * stride;
1934
1935     int min_pu_width = s->ps.sps->min_pu_width;
1936
1937     enum IntraPredMode mode = c_idx ? lc->tu.intra_pred_mode_c :
1938         lc->tu.intra_pred_mode;
1939     uint32_t a;
1940     uint8_t left_array[2 * 32 + 1];
1941     uint8_t filtered_left_array[2 * 32 + 1];
1942     uint8_t top_array[2 * 32 + 1];
1943     uint8_t filtered_top_array[2 * 32 + 1];
1944
1945     uint8_t *left = left_array + 1;
1946     uint8_t *top = top_array + 1;
1947     uint8_t *filtered_left = filtered_left_array + 1;
1948     uint8_t *filtered_top = filtered_top_array + 1;
1949     int cand_bottom_left = lc->na.cand_bottom_left
1950         && cur_tb_addr >
1951         s->ps.pps->min_tb_addr_zs[((y_tb + size_in_tbs_v) & s->ps.sps->tb_mask) *
1952                                (s->ps.sps->tb_mask + 2) + (x_tb - 1)];
1953     int cand_left = lc->na.cand_left;
1954     int cand_up_left = lc->na.cand_up_left;
1955     int cand_up = lc->na.cand_up;
1956     int cand_up_right = lc->na.cand_up_right
1957         && cur_tb_addr >
1958         s->ps.pps->min_tb_addr_zs[(y_tb - 1) * (s->ps.sps->tb_mask + 2) +
1959                                ((x_tb + size_in_tbs_h) & s->ps.sps->tb_mask)];
1960
1961     int bottom_left_size =
1962         (((y0 + 2 * size_in_luma_v) >
1963           (s->ps.sps->height) ? (s->ps.sps->height) : (y0 +
1964                                                  2 * size_in_luma_v)) -
1965          (y0 + size_in_luma_v)) >> vshift;
1966     int top_right_size =
1967         (((x0 + 2 * size_in_luma_h) >
1968           (s->ps.sps->width) ? (s->ps.sps->width) : (x0 + 2 * size_in_luma_h)) -
1969          (x0 + size_in_luma_h)) >> hshift;
1970
1971     if (s->ps.pps->constrained_intra_pred_flag == 1) {
1972         int size_in_luma_pu_v = ((size_in_luma_v) >> s->ps.sps->log2_min_pu_size);
1973         int size_in_luma_pu_h = ((size_in_luma_h) >> s->ps.sps->log2_min_pu_size);
1974         int on_pu_edge_x = !(x0 & ((1 << s->ps.sps->log2_min_pu_size) - 1));
1975         int on_pu_edge_y = !(y0 & ((1 << s->ps.sps->log2_min_pu_size) - 1));
1976         if (!size_in_luma_pu_h)
1977             size_in_luma_pu_h++;
1978         if (cand_bottom_left == 1 && on_pu_edge_x) {
1979             int x_left_pu = ((x0 - 1) >> s->ps.sps->log2_min_pu_size);
1980             int y_bottom_pu =
1981                 ((y0 + size_in_luma_v) >> s->ps.sps->log2_min_pu_size);
1982             int max =
1983                 ((size_in_luma_pu_v) >
1984                  (s->ps.sps->min_pu_height -
1985                   y_bottom_pu) ? (s->ps.sps->min_pu_height -
1986                                   y_bottom_pu) : (size_in_luma_pu_v));
1987             cand_bottom_left = 0;
1988             for (i = 0; i < max; i += 2)
1989                 cand_bottom_left |=
1990                     ((s->ref->tab_mvf[(x_left_pu) +
1991                                       (y_bottom_pu +
1992                                        i) * min_pu_width]).pred_flag ==
1993                      PF_INTRA);
1994         }
1995         if (cand_left == 1 && on_pu_edge_x) {
1996             int x_left_pu = ((x0 - 1) >> s->ps.sps->log2_min_pu_size);
1997             int y_left_pu = ((y0) >> s->ps.sps->log2_min_pu_size);
1998             int max =
1999                 ((size_in_luma_pu_v) >
2000                  (s->ps.sps->min_pu_height -
2001                   y_left_pu) ? (s->ps.sps->min_pu_height -
2002                                 y_left_pu) : (size_in_luma_pu_v));
2003             cand_left = 0;
2004             for (i = 0; i < max; i += 2)
2005                 cand_left |=
2006                     ((s->ref->tab_mvf[(x_left_pu) +
2007                                       (y_left_pu +
2008                                        i) * min_pu_width]).pred_flag ==
2009                      PF_INTRA);
2010         }
2011         if (cand_up_left == 1) {
2012             int x_left_pu = ((x0 - 1) >> s->ps.sps->log2_min_pu_size);
2013             int y_top_pu = ((y0 - 1) >> s->ps.sps->log2_min_pu_size);
2014             cand_up_left =
2015                 (s->ref->tab_mvf[(x_left_pu) +
2016                                  (y_top_pu) * min_pu_width]).pred_flag ==
2017                 PF_INTRA;
2018         }
2019         if (cand_up == 1 && on_pu_edge_y) {
2020             int x_top_pu = ((x0) >> s->ps.sps->log2_min_pu_size);
2021             int y_top_pu = ((y0 - 1) >> s->ps.sps->log2_min_pu_size);
2022             int max =
2023                 ((size_in_luma_pu_h) >
2024                  (s->ps.sps->min_pu_width -
2025                   x_top_pu) ? (s->ps.sps->min_pu_width -
2026                                x_top_pu) : (size_in_luma_pu_h));
2027             cand_up = 0;
2028             for (i = 0; i < max; i += 2)
2029                 cand_up |=
2030                     ((s->ref->tab_mvf[(x_top_pu + i) +
2031                                       (y_top_pu) *
2032                                       min_pu_width]).pred_flag == PF_INTRA);
2033         }
2034         if (cand_up_right == 1 && on_pu_edge_y) {
2035             int y_top_pu = ((y0 - 1) >> s->ps.sps->log2_min_pu_size);
2036             int x_right_pu =
2037                 ((x0 + size_in_luma_h) >> s->ps.sps->log2_min_pu_size);
2038             int max =
2039                 ((size_in_luma_pu_h) >
2040                  (s->ps.sps->min_pu_width -
2041                   x_right_pu) ? (s->ps.sps->min_pu_width -
2042                                  x_right_pu) : (size_in_luma_pu_h));
2043             cand_up_right = 0;
2044             for (i = 0; i < max; i += 2)
2045                 cand_up_right |=
2046                     ((s->ref->tab_mvf[(x_right_pu + i) +
2047                                       (y_top_pu) *
2048                                       min_pu_width]).pred_flag == PF_INTRA);
2049         }
2050
2051         vec0 = (v16u8) __msa_ldi_b(128);
2052
2053         ST_UB4(vec0, vec0, vec0, vec0, left, 16);
2054
2055         ST_UB4(vec0, vec0, vec0, vec0, top, 16);
2056
2057         top[-1] = 128;
2058     }
2059     if (cand_up_left) {
2060         left[-1] = src[(-1) + stride * (-1)];
2061         top[-1] = left[-1];
2062     }
2063     if (cand_up) {
2064         vec0 = LD_UB(src - stride);
2065         ST_UB(vec0, top);
2066     }
2067     if (cand_up_right) {
2068         vec0 = LD_UB(src - stride + 16);
2069         ST_UB(vec0, (top + 16));
2070
2071         do {
2072             uint32_t pix =
2073                 ((src[(16 + top_right_size - 1) + stride * (-1)]) *
2074                  0x01010101U);
2075             for (i = 0; i < (16 - top_right_size); i += 4)
2076                 ((((union unaligned_32 *) (top + 16 + top_right_size +
2077                                            i))->l) = (pix));
2078         } while (0);
2079     }
2080     if (cand_left)
2081         for (i = 0; i < 16; i++)
2082             left[i] = src[(-1) + stride * (i)];
2083     if (cand_bottom_left) {
2084         for (i = 16; i < 16 + bottom_left_size; i++)
2085             left[i] = src[(-1) + stride * (i)];
2086         do {
2087             uint32_t pix =
2088                 ((src[(-1) + stride * (16 + bottom_left_size - 1)]) *
2089                  0x01010101U);
2090             for (i = 0; i < (16 - bottom_left_size); i += 4)
2091                 ((((union unaligned_32 *) (left + 16 + bottom_left_size +
2092                                            i))->l) = (pix));
2093         } while (0);
2094     }
2095
2096     if (s->ps.pps->constrained_intra_pred_flag == 1) {
2097         if (cand_bottom_left || cand_left || cand_up_left || cand_up
2098             || cand_up_right) {
2099             int size_max_x =
2100                 x0 + ((2 * 16) << hshift) <
2101                 s->ps.sps->width ? 2 * 16 : (s->ps.sps->width - x0) >> hshift;
2102             int size_max_y =
2103                 y0 + ((2 * 16) << vshift) <
2104                 s->ps.sps->height ? 2 * 16 : (s->ps.sps->height - y0) >> vshift;
2105             int j = 16 + (cand_bottom_left ? bottom_left_size : 0) - 1;
2106             if (!cand_up_right) {
2107                 size_max_x = x0 + ((16) << hshift) < s->ps.sps->width ?
2108                     16 : (s->ps.sps->width - x0) >> hshift;
2109             }
2110             if (!cand_bottom_left) {
2111                 size_max_y = y0 + ((16) << vshift) < s->ps.sps->height ?
2112                     16 : (s->ps.sps->height - y0) >> vshift;
2113             }
2114             if (cand_bottom_left || cand_left || cand_up_left) {
2115                 while (j > -1
2116                        &&
2117                        !((s->ref->tab_mvf[(((x0 +
2118                                              ((-1) << hshift)) >> s->ps.sps->
2119                                             log2_min_pu_size)) + (((y0 +
2120                                                                     ((j) <<
2121                                                                      vshift))
2122                                                                    >> s->ps.sps->
2123                                                                    log2_min_pu_size))
2124                                           * min_pu_width]).pred_flag ==
2125                          PF_INTRA))
2126                     j--;
2127                 if (!
2128                     ((s->ref->tab_mvf[(((x0 +
2129                                          ((-1) << hshift)) >> s->ps.sps->
2130                                         log2_min_pu_size)) + (((y0 + ((j)
2131                                                                       <<
2132                                                                       vshift))
2133                                                                >> s->ps.sps->
2134                                                                log2_min_pu_size))
2135                                       * min_pu_width]).pred_flag == PF_INTRA)) {
2136                     j = 0;
2137                     while (j < size_max_x
2138                            &&
2139                            !((s->ref->tab_mvf[(((x0 +
2140                                                  ((j) << hshift)) >> s->ps.sps->
2141                                                 log2_min_pu_size)) + (((y0 +
2142                                                                         ((-1) <<
2143                                                                          vshift))
2144                                                                        >> s->
2145                                                                        ps.sps->
2146                                                                        log2_min_pu_size))
2147                                               * min_pu_width]).pred_flag ==
2148                              PF_INTRA))
2149                         j++;
2150                     for (i = j; i > (j) - (j + 1); i--)
2151                         if (!
2152                             ((s->ref->tab_mvf[(((x0 +
2153                                                  ((i -
2154                                                    1) << hshift)) >> s->ps.sps->
2155                                                 log2_min_pu_size)) + (((y0 +
2156                                                                         ((-1) <<
2157                                                                          vshift))
2158                                                                        >> s->
2159                                                                        ps.sps->
2160                                                                        log2_min_pu_size))
2161                                               * min_pu_width]).pred_flag ==
2162                              PF_INTRA))
2163                             top[i - 1] = top[i];
2164                     left[-1] = top[-1];
2165                 }
2166             } else {
2167                 j = 0;
2168                 while (j < size_max_x
2169                        &&
2170                        !((s->ref->tab_mvf[(((x0 +
2171                                              ((j) << hshift)) >> s->ps.sps->
2172                                             log2_min_pu_size)) + (((y0 + ((-1)
2173                                                                           <<
2174                                                                           vshift))
2175                                                                    >> s->ps.sps->
2176                                                                    log2_min_pu_size))
2177                                           * min_pu_width]).pred_flag ==
2178                          PF_INTRA))
2179                     j++;
2180                 if (j > 0)
2181                     if (x0 > 0) {
2182                         for (i = j; i > (j) - (j + 1); i--)
2183                             if (!
2184                                 ((s->ref->tab_mvf[(((x0 +
2185                                                      ((i -
2186                                                        1) << hshift)) >>
2187                                                     s->ps.sps->log2_min_pu_size))
2188                                                   + (((y0 + ((-1)
2189                                                              << vshift))
2190                                                       >>
2191                                                       s->ps.sps->log2_min_pu_size))
2192                                                   *
2193                                                   min_pu_width]).pred_flag ==
2194                                  PF_INTRA))
2195                                 top[i - 1] = top[i];
2196                     } else {
2197                         for (i = j; i > (j) - (j); i--)
2198                             if (!
2199                                 ((s->ref->tab_mvf[(((x0 +
2200                                                      ((i -
2201                                                        1) << hshift)) >>
2202                                                     s->ps.sps->log2_min_pu_size))
2203                                                   + (((y0 + ((-1)
2204                                                              << vshift))
2205                                                       >>
2206                                                       s->ps.sps->log2_min_pu_size))
2207                                                   *
2208                                                   min_pu_width]).pred_flag ==
2209                                  PF_INTRA))
2210                                 top[i - 1] = top[i];
2211                         top[-1] = top[0];
2212                     }
2213                 left[-1] = top[-1];
2214             }
2215             left[-1] = top[-1];
2216             if (cand_bottom_left || cand_left) {
2217                 a = ((left[-1]) * 0x01010101U);
2218                 for (i = 0; i < (0) + (size_max_y); i += 4)
2219                     if (!
2220                         ((s->ref->tab_mvf[(((x0 +
2221                                              ((-1) << hshift)) >> s->ps.sps->
2222                                             log2_min_pu_size)) + (((y0 +
2223                                                                     ((i) <<
2224                                                                      vshift))
2225                                                                    >> s->ps.sps->
2226                                                                    log2_min_pu_size))
2227                                           * min_pu_width]).pred_flag ==
2228                          PF_INTRA))
2229                         ((((union unaligned_32 *) (&left[i]))->l) = (a));
2230                     else
2231                         a = ((left[i + 3]) * 0x01010101U);
2232             }
2233             if (!cand_left) {
2234                 vec0 = (v16u8) __msa_fill_b(left[-1]);
2235
2236                 ST_UB(vec0, left);
2237             }
2238             if (!cand_bottom_left) {
2239
2240                 vec0 = (v16u8) __msa_fill_b(left[15]);
2241
2242                 ST_UB(vec0, (left + 16));
2243             }
2244             if (x0 != 0 && y0 != 0) {
2245                 a = ((left[size_max_y - 1]) * 0x01010101U);
2246                 for (i = (size_max_y - 1);
2247                      i > (size_max_y - 1) - (size_max_y); i -= 4)
2248                     if (!
2249                         ((s->ref->tab_mvf[(((x0 +
2250                                              ((-1) << hshift)) >> s->ps.sps->
2251                                             log2_min_pu_size)) + (((y0 +
2252                                                                     ((i -
2253                                                                       3) <<
2254                                                                      vshift))
2255                                                                    >> s->ps.sps->
2256                                                                    log2_min_pu_size))
2257                                           * min_pu_width]).pred_flag ==
2258                          PF_INTRA))
2259                         ((((union unaligned_32 *) (&left[i - 3]))->l) = (a));
2260                     else
2261                         a = ((left[i - 3]) * 0x01010101U);
2262                 if (!
2263                     ((s->ref->tab_mvf[(((x0 +
2264                                          ((-1) << hshift)) >> s->ps.sps->
2265                                         log2_min_pu_size)) + (((y0 + ((-1)
2266                                                                       <<
2267                                                                       vshift))
2268                                                                >> s->ps.sps->
2269                                                                log2_min_pu_size))
2270                                       * min_pu_width]).pred_flag == PF_INTRA))
2271                     left[-1] = left[0];
2272             } else if (x0 == 0) {
2273                 do {
2274                     uint32_t pix = ((0) * 0x01010101U);
2275                     for (i = 0; i < (size_max_y); i += 4)
2276                         ((((union unaligned_32 *) (left + i))->l) = (pix));
2277                 } while (0);
2278             } else {
2279                 a = ((left[size_max_y - 1]) * 0x01010101U);
2280                 for (i = (size_max_y - 1);
2281                      i > (size_max_y - 1) - (size_max_y); i -= 4)
2282                     if (!
2283                         ((s->ref->tab_mvf[(((x0 +
2284                                              ((-1) << hshift)) >> s->ps.sps->
2285                                             log2_min_pu_size)) + (((y0 +
2286                                                                     ((i -
2287                                                                       3) <<
2288                                                                      vshift))
2289                                                                    >> s->ps.sps->
2290                                                                    log2_min_pu_size))
2291                                           * min_pu_width]).pred_flag ==
2292                          PF_INTRA))
2293                         ((((union unaligned_32 *) (&left[i - 3]))->l) = (a));
2294                     else
2295                         a = ((left[i - 3]) * 0x01010101U);
2296             }
2297             top[-1] = left[-1];
2298             if (y0 != 0) {
2299                 a = ((left[-1]) * 0x01010101U);
2300                 for (i = 0; i < (0) + (size_max_x); i += 4)
2301                     if (!
2302                         ((s->ref->tab_mvf[(((x0 +
2303                                              ((i) << hshift)) >> s->ps.sps->
2304                                             log2_min_pu_size)) + (((y0 + ((-1)
2305                                                                           <<
2306                                                                           vshift))
2307                                                                    >> s->ps.sps->
2308                                                                    log2_min_pu_size))
2309                                           * min_pu_width]).pred_flag ==
2310                          PF_INTRA))
2311                         ((((union unaligned_32 *) (&top[i]))->l) = (a));
2312                     else
2313                         a = ((top[i + 3]) * 0x01010101U);
2314             }
2315         }
2316     }
2317
2318     if (!cand_bottom_left) {
2319         if (cand_left) {
2320             vec0 = (v16u8) __msa_fill_b(left[15]);
2321
2322             ST_UB(vec0, (left + 16));
2323
2324         } else if (cand_up_left) {
2325             vec0 = (v16u8) __msa_fill_b(left[-1]);
2326
2327             ST_UB2(vec0, vec0, left, 16);
2328
2329             cand_left = 1;
2330         } else if (cand_up) {
2331             left[-1] = top[0];
2332
2333             vec0 = (v16u8) __msa_fill_b(left[-1]);
2334
2335             ST_UB2(vec0, vec0, left, 16);
2336
2337             cand_up_left = 1;
2338             cand_left = 1;
2339         } else if (cand_up_right) {
2340             vec0 = (v16u8) __msa_fill_b(top[16]);
2341
2342             ST_UB(vec0, top);
2343
2344             left[-1] = top[16];
2345
2346             ST_UB2(vec0, vec0, left, 16);
2347
2348             cand_up = 1;
2349             cand_up_left = 1;
2350             cand_left = 1;
2351         } else {
2352             left[-1] = 128;
2353             vec0 = (v16u8) __msa_ldi_b(128);
2354
2355             ST_UB2(vec0, vec0, top, 16);
2356             ST_UB2(vec0, vec0, left, 16);
2357         }
2358     }
2359
2360     if (!cand_left) {
2361         vec0 = (v16u8) __msa_fill_b(left[16]);
2362         ST_UB(vec0, left);
2363     }
2364     if (!cand_up_left) {
2365         left[-1] = left[0];
2366     }
2367     if (!cand_up) {
2368         vec0 = (v16u8) __msa_fill_b(left[-1]);
2369         ST_UB(vec0, top);
2370     }
2371     if (!cand_up_right) {
2372         vec0 = (v16u8) __msa_fill_b(top[15]);
2373         ST_UB(vec0, (top + 16));
2374     }
2375
2376     top[-1] = left[-1];
2377
2378
2379     if (!s->ps.sps->intra_smoothing_disabled_flag
2380         && (c_idx == 0 || s->ps.sps->chroma_format_idc == 3)) {
2381         if (mode != INTRA_DC && 16 != 4) {
2382             int intra_hor_ver_dist_thresh[] = { 7, 1, 0 };
2383             int min_dist_vert_hor =
2384                 (((((int) (mode - 26U)) >=
2385                    0 ? ((int) (mode - 26U)) : (-((int) (mode - 26U))))) >
2386                  ((((int) (mode - 10U)) >=
2387                    0 ? ((int) (mode - 10U)) : (-((int) (mode - 10U)))))
2388                  ? ((((int) (mode - 10U)) >=
2389                      0 ? ((int) (mode - 10U)) : (-((int) (mode - 10U)))))
2390                  : ((((int) (mode - 26U)) >=
2391                      0 ? ((int) (mode - 26U)) : (-((int) (mode - 26U))))));
2392             if (min_dist_vert_hor > intra_hor_ver_dist_thresh[4 - 3]) {
2393                 filtered_left[2 * 16 - 1] = left[2 * 16 - 1];
2394                 filtered_top[2 * 16 - 1] = top[2 * 16 - 1];
2395                 for (i = 2 * 16 - 2; i >= 0; i--)
2396                     filtered_left[i] = (left[i + 1] + 2 * left[i] +
2397                                         left[i - 1] + 2) >> 2;
2398                 filtered_top[-1] =
2399                     filtered_left[-1] =
2400                     (left[0] + 2 * left[-1] + top[0] + 2) >> 2;
2401                 for (i = 2 * 16 - 2; i >= 0; i--)
2402                     filtered_top[i] = (top[i + 1] + 2 * top[i] +
2403                                        top[i - 1] + 2) >> 2;
2404                 left = filtered_left;
2405                 top = filtered_top;
2406             }
2407         }
2408     }
2409
2410     switch (mode) {
2411     case INTRA_PLANAR:
2412         s->hpc.pred_planar[4 - 2] ((uint8_t *) src, (uint8_t *) top,
2413                                    (uint8_t *) left, stride);
2414         break;
2415     case INTRA_DC:
2416         s->hpc.pred_dc((uint8_t *) src, (uint8_t *) top,
2417                        (uint8_t *) left, stride, 4, c_idx);
2418         break;
2419     default:
2420         s->hpc.pred_angular[4 - 2] ((uint8_t *) src, (uint8_t *) top,
2421                                     (uint8_t *) left, stride, c_idx, mode);
2422         break;
2423     }
2424 }
2425
2426 void ff_intra_pred_8_32x32_msa(HEVCContext *s, int x0, int y0, int c_idx)
2427 {
2428     v16u8 vec0, vec1;
2429     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
2430     v8i16 res0, res1, res2, res3;
2431     v8i16 mul_val0 = { 63, 62, 61, 60, 59, 58, 57, 56 };
2432     v8i16 mul_val1 = { 1, 2, 3, 4, 5, 6, 7, 8 };
2433     HEVCLocalContext *lc = s->HEVClc;
2434     int i;
2435     int hshift = s->ps.sps->hshift[c_idx];
2436     int vshift = s->ps.sps->vshift[c_idx];
2437     int size_in_luma_h = 32 << hshift;
2438     int size_in_tbs_h = size_in_luma_h >> s->ps.sps->log2_min_tb_size;
2439     int size_in_luma_v = 32 << vshift;
2440     int size_in_tbs_v = size_in_luma_v >> s->ps.sps->log2_min_tb_size;
2441     int x = x0 >> hshift;
2442     int y = y0 >> vshift;
2443     int x_tb = (x0 >> s->ps.sps->log2_min_tb_size) & s->ps.sps->tb_mask;
2444     int y_tb = (y0 >> s->ps.sps->log2_min_tb_size) & s->ps.sps->tb_mask;
2445
2446     int cur_tb_addr =
2447         s->ps.pps->min_tb_addr_zs[(y_tb) * (s->ps.sps->tb_mask + 2) + (x_tb)];
2448
2449     ptrdiff_t stride = s->frame->linesize[c_idx] / sizeof(uint8_t);
2450     uint8_t *src = (uint8_t *) s->frame->data[c_idx] + x + y * stride;
2451
2452     int min_pu_width = s->ps.sps->min_pu_width;
2453
2454     enum IntraPredMode mode = c_idx ? lc->tu.intra_pred_mode_c :
2455         lc->tu.intra_pred_mode;
2456     uint32_t a;
2457     uint8_t left_array[2 * 32 + 1];
2458     uint8_t filtered_left_array[2 * 32 + 1];
2459     uint8_t top_array[2 * 32 + 1];
2460     uint8_t filtered_top_array[2 * 32 + 1];
2461
2462     uint8_t *left = left_array + 1;
2463     uint8_t *top = top_array + 1;
2464     uint8_t *filtered_left = filtered_left_array + 1;
2465     uint8_t *filtered_top = filtered_top_array + 1;
2466     int cand_bottom_left = lc->na.cand_bottom_left
2467         && cur_tb_addr >
2468         s->ps.pps->min_tb_addr_zs[((y_tb + size_in_tbs_v) & s->ps.sps->tb_mask) *
2469                                (s->ps.sps->tb_mask + 2) + (x_tb - 1)];
2470     int cand_left = lc->na.cand_left;
2471     int cand_up_left = lc->na.cand_up_left;
2472     int cand_up = lc->na.cand_up;
2473     int cand_up_right = lc->na.cand_up_right
2474         && cur_tb_addr >
2475         s->ps.pps->min_tb_addr_zs[(y_tb - 1) * (s->ps.sps->tb_mask + 2) +
2476                                ((x_tb + size_in_tbs_h) & s->ps.sps->tb_mask)];
2477
2478     int bottom_left_size =
2479         (((y0 + 2 * size_in_luma_v) >
2480           (s->ps.sps->height) ? (s->ps.sps->height) : (y0 +
2481                                                  2 * size_in_luma_v)) -
2482          (y0 + size_in_luma_v)) >> vshift;
2483     int top_right_size =
2484         (((x0 + 2 * size_in_luma_h) >
2485           (s->ps.sps->width) ? (s->ps.sps->width) : (x0 + 2 * size_in_luma_h)) -
2486          (x0 + size_in_luma_h)) >> hshift;
2487
2488     if (s->ps.pps->constrained_intra_pred_flag == 1) {
2489         int size_in_luma_pu_v = ((size_in_luma_v) >> s->ps.sps->log2_min_pu_size);
2490         int size_in_luma_pu_h = ((size_in_luma_h) >> s->ps.sps->log2_min_pu_size);
2491         int on_pu_edge_x = !(x0 & ((1 << s->ps.sps->log2_min_pu_size) - 1));
2492         int on_pu_edge_y = !(y0 & ((1 << s->ps.sps->log2_min_pu_size) - 1));
2493         if (!size_in_luma_pu_h)
2494             size_in_luma_pu_h++;
2495         if (cand_bottom_left == 1 && on_pu_edge_x) {
2496             int x_left_pu = ((x0 - 1) >> s->ps.sps->log2_min_pu_size);
2497             int y_bottom_pu =
2498                 ((y0 + size_in_luma_v) >> s->ps.sps->log2_min_pu_size);
2499             int max =
2500                 ((size_in_luma_pu_v) >
2501                  (s->ps.sps->min_pu_height -
2502                   y_bottom_pu) ? (s->ps.sps->min_pu_height -
2503                                   y_bottom_pu) : (size_in_luma_pu_v));
2504             cand_bottom_left = 0;
2505             for (i = 0; i < max; i += 2)
2506                 cand_bottom_left |=
2507                     ((s->ref->tab_mvf[(x_left_pu) +
2508                                       (y_bottom_pu +
2509                                        i) * min_pu_width]).pred_flag ==
2510                      PF_INTRA);
2511         }
2512         if (cand_left == 1 && on_pu_edge_x) {
2513             int x_left_pu = ((x0 - 1) >> s->ps.sps->log2_min_pu_size);
2514             int y_left_pu = ((y0) >> s->ps.sps->log2_min_pu_size);
2515             int max =
2516                 ((size_in_luma_pu_v) >
2517                  (s->ps.sps->min_pu_height -
2518                   y_left_pu) ? (s->ps.sps->min_pu_height -
2519                                 y_left_pu) : (size_in_luma_pu_v));
2520             cand_left = 0;
2521             for (i = 0; i < max; i += 2)
2522                 cand_left |=
2523                     ((s->ref->tab_mvf[(x_left_pu) +
2524                                       (y_left_pu +
2525                                        i) * min_pu_width]).pred_flag ==
2526                      PF_INTRA);
2527         }
2528         if (cand_up_left == 1) {
2529             int x_left_pu = ((x0 - 1) >> s->ps.sps->log2_min_pu_size);
2530             int y_top_pu = ((y0 - 1) >> s->ps.sps->log2_min_pu_size);
2531             cand_up_left =
2532                 (s->ref->tab_mvf[(x_left_pu) +
2533                                  (y_top_pu) * min_pu_width]).pred_flag ==
2534                 PF_INTRA;
2535         }
2536         if (cand_up == 1 && on_pu_edge_y) {
2537             int x_top_pu = ((x0) >> s->ps.sps->log2_min_pu_size);
2538             int y_top_pu = ((y0 - 1) >> s->ps.sps->log2_min_pu_size);
2539             int max =
2540                 ((size_in_luma_pu_h) >
2541                  (s->ps.sps->min_pu_width -
2542                   x_top_pu) ? (s->ps.sps->min_pu_width -
2543                                x_top_pu) : (size_in_luma_pu_h));
2544             cand_up = 0;
2545             for (i = 0; i < max; i += 2)
2546                 cand_up |=
2547                     ((s->ref->tab_mvf[(x_top_pu + i) +
2548                                       (y_top_pu) *
2549                                       min_pu_width]).pred_flag == PF_INTRA);
2550         }
2551         if (cand_up_right == 1 && on_pu_edge_y) {
2552             int y_top_pu = ((y0 - 1) >> s->ps.sps->log2_min_pu_size);
2553             int x_right_pu =
2554                 ((x0 + size_in_luma_h) >> s->ps.sps->log2_min_pu_size);
2555             int max =
2556                 ((size_in_luma_pu_h) >
2557                  (s->ps.sps->min_pu_width -
2558                   x_right_pu) ? (s->ps.sps->min_pu_width -
2559                                  x_right_pu) : (size_in_luma_pu_h));
2560             cand_up_right = 0;
2561             for (i = 0; i < max; i += 2)
2562                 cand_up_right |=
2563                     ((s->ref->tab_mvf[(x_right_pu + i) +
2564                                       (y_top_pu) *
2565                                       min_pu_width]).pred_flag == PF_INTRA);
2566         }
2567         vec0 = (v16u8) __msa_ldi_b(128);
2568
2569         ST_UB4(vec0, vec0, vec0, vec0, left, 16);
2570         ST_UB4(vec0, vec0, vec0, vec0, top, 16);
2571
2572         top[-1] = 128;
2573     }
2574     if (cand_up_left) {
2575         left[-1] = src[(-1) + stride * (-1)];
2576         top[-1] = left[-1];
2577     }
2578     if (cand_up) {
2579         LD_UB2(src - stride, 16, vec0, vec1);
2580         ST_UB2(vec0, vec1, top, 16);
2581     }
2582
2583     if (cand_up_right) {
2584         LD_UB2(src - stride + 32, 16, vec0, vec1);
2585         ST_UB2(vec0, vec1, (top + 32), 16);
2586         do {
2587             uint32_t pix =
2588                 ((src[(32 + top_right_size - 1) + stride * (-1)]) *
2589                  0x01010101U);
2590             for (i = 0; i < (32 - top_right_size); i += 4)
2591                 ((((union unaligned_32 *) (top + 32 + top_right_size +
2592                                            i))->l) = (pix));
2593         } while (0);
2594     }
2595     if (cand_left)
2596         for (i = 0; i < 32; i++)
2597             left[i] = src[(-1) + stride * (i)];
2598     if (cand_bottom_left) {
2599         for (i = 32; i < 32 + bottom_left_size; i++)
2600             left[i] = src[(-1) + stride * (i)];
2601         do {
2602             uint32_t pix =
2603                 ((src[(-1) + stride * (32 + bottom_left_size - 1)]) *
2604                  0x01010101U);
2605             for (i = 0; i < (32 - bottom_left_size); i += 4)
2606                 ((((union unaligned_32 *) (left + 32 + bottom_left_size +
2607                                            i))->l) = (pix));
2608         } while (0);
2609     }
2610
2611     if (s->ps.pps->constrained_intra_pred_flag == 1) {
2612         if (cand_bottom_left || cand_left || cand_up_left || cand_up
2613             || cand_up_right) {
2614             int size_max_x =
2615                 x0 + ((2 * 32) << hshift) <
2616                 s->ps.sps->width ? 2 * 32 : (s->ps.sps->width - x0) >> hshift;
2617             int size_max_y =
2618                 y0 + ((2 * 32) << vshift) <
2619                 s->ps.sps->height ? 2 * 32 : (s->ps.sps->height - y0) >> vshift;
2620             int j = 32 + (cand_bottom_left ? bottom_left_size : 0) - 1;
2621             if (!cand_up_right) {
2622                 size_max_x = x0 + ((32) << hshift) < s->ps.sps->width ?
2623                     32 : (s->ps.sps->width - x0) >> hshift;
2624             }
2625             if (!cand_bottom_left) {
2626                 size_max_y = y0 + ((32) << vshift) < s->ps.sps->height ?
2627                     32 : (s->ps.sps->height - y0) >> vshift;
2628             }
2629             if (cand_bottom_left || cand_left || cand_up_left) {
2630                 while (j > -1
2631                        &&
2632                        !((s->ref->tab_mvf[(((x0 +
2633                                              ((-1) << hshift)) >> s->ps.sps->
2634                                             log2_min_pu_size)) + (((y0 +
2635                                                                     ((j) <<
2636                                                                      vshift))
2637                                                                    >> s->ps.sps->
2638                                                                    log2_min_pu_size))
2639                                           * min_pu_width]).pred_flag ==
2640                          PF_INTRA))
2641                     j--;
2642                 if (!
2643                     ((s->ref->tab_mvf[(((x0 +
2644                                          ((-1) << hshift)) >> s->ps.sps->
2645                                         log2_min_pu_size)) + (((y0 + ((j)
2646                                                                       <<
2647                                                                       vshift))
2648                                                                >> s->ps.sps->
2649                                                                log2_min_pu_size))
2650                                       * min_pu_width]).pred_flag == PF_INTRA)) {
2651                     j = 0;
2652                     while (j < size_max_x
2653                            &&
2654                            !((s->ref->tab_mvf[(((x0 +
2655                                                  ((j) << hshift)) >> s->ps.sps->
2656                                                 log2_min_pu_size)) + (((y0 +
2657                                                                         ((-1) <<
2658                                                                          vshift))
2659                                                                        >> s->
2660                                                                        ps.sps->
2661                                                                        log2_min_pu_size))
2662                                               * min_pu_width]).pred_flag ==
2663                              PF_INTRA))
2664                         j++;
2665                     for (i = j; i > (j) - (j + 1); i--)
2666                         if (!
2667                             ((s->ref->tab_mvf[(((x0 +
2668                                                  ((i -
2669                                                    1) << hshift)) >> s->ps.sps->
2670                                                 log2_min_pu_size)) + (((y0 +
2671                                                                         ((-1) <<
2672                                                                          vshift))
2673                                                                        >> s->
2674                                                                        ps.sps->
2675                                                                        log2_min_pu_size))
2676                                               * min_pu_width]).pred_flag ==
2677                              PF_INTRA))
2678                             top[i - 1] = top[i];
2679                     left[-1] = top[-1];
2680                 }
2681             } else {
2682                 j = 0;
2683                 while (j < size_max_x
2684                        &&
2685                        !((s->ref->tab_mvf[(((x0 +
2686                                              ((j) << hshift)) >> s->ps.sps->
2687                                             log2_min_pu_size)) + (((y0 + ((-1)
2688                                                                           <<
2689                                                                           vshift))
2690                                                                    >> s->ps.sps->
2691                                                                    log2_min_pu_size))
2692                                           * min_pu_width]).pred_flag ==
2693                          PF_INTRA))
2694                     j++;
2695                 if (j > 0)
2696                     if (x0 > 0) {
2697                         for (i = j; i > (j) - (j + 1); i--)
2698                             if (!
2699                                 ((s->ref->tab_mvf[(((x0 +
2700                                                      ((i -
2701                                                        1) << hshift)) >>
2702                                                     s->ps.sps->log2_min_pu_size))
2703                                                   + (((y0 + ((-1)
2704                                                              << vshift))
2705                                                       >>
2706                                                       s->ps.sps->log2_min_pu_size))
2707                                                   *
2708                                                   min_pu_width]).pred_flag ==
2709                                  PF_INTRA))
2710                                 top[i - 1] = top[i];
2711                     } else {
2712                         for (i = j; i > (j) - (j); i--)
2713                             if (!
2714                                 ((s->ref->tab_mvf[(((x0 +
2715                                                      ((i -
2716                                                        1) << hshift)) >>
2717                                                     s->ps.sps->log2_min_pu_size))
2718                                                   + (((y0 + ((-1)
2719                                                              << vshift))
2720                                                       >>
2721                                                       s->ps.sps->log2_min_pu_size))
2722                                                   *
2723                                                   min_pu_width]).pred_flag ==
2724                                  PF_INTRA))
2725                                 top[i - 1] = top[i];
2726                         top[-1] = top[0];
2727                     }
2728                 left[-1] = top[-1];
2729             }
2730             left[-1] = top[-1];
2731             if (cand_bottom_left || cand_left) {
2732                 a = ((left[-1]) * 0x01010101U);
2733                 for (i = 0; i < (0) + (size_max_y); i += 4)
2734                     if (!
2735                         ((s->ref->tab_mvf[(((x0 +
2736                                              ((-1) << hshift)) >> s->ps.sps->
2737                                             log2_min_pu_size)) + (((y0 +
2738                                                                     ((i) <<
2739                                                                      vshift))
2740                                                                    >> s->ps.sps->
2741                                                                    log2_min_pu_size))
2742                                           * min_pu_width]).pred_flag ==
2743                          PF_INTRA))
2744                         ((((union unaligned_32 *) (&left[i]))->l) = (a));
2745                     else
2746                         a = ((left[i + 3]) * 0x01010101U);
2747             }
2748             if (!cand_left) {
2749                 vec0 = (v16u8) __msa_fill_b(left[-1]);
2750
2751                 ST_UB2(vec0, vec0, left, 16);
2752             }
2753             if (!cand_bottom_left) {
2754                 vec0 = (v16u8) __msa_fill_b(left[31]);
2755
2756                 ST_UB2(vec0, vec0, (left + 32), 16);
2757             }
2758             if (x0 != 0 && y0 != 0) {
2759                 a = ((left[size_max_y - 1]) * 0x01010101U);
2760                 for (i = (size_max_y - 1);
2761                      i > (size_max_y - 1) - (size_max_y); i -= 4)
2762                     if (!
2763                         ((s->ref->tab_mvf[(((x0 +
2764                                              ((-1) << hshift)) >> s->ps.sps->
2765                                             log2_min_pu_size)) + (((y0 +
2766                                                                     ((i -
2767                                                                       3) <<
2768                                                                      vshift))
2769                                                                    >> s->ps.sps->
2770                                                                    log2_min_pu_size))
2771                                           * min_pu_width]).pred_flag ==
2772                          PF_INTRA))
2773                         ((((union unaligned_32 *) (&left[i - 3]))->l) = (a));
2774                     else
2775                         a = ((left[i - 3]) * 0x01010101U);
2776                 if (!
2777                     ((s->ref->tab_mvf[(((x0 +
2778                                          ((-1) << hshift)) >> s->ps.sps->
2779                                         log2_min_pu_size)) + (((y0 + ((-1)
2780                                                                       <<
2781                                                                       vshift))
2782                                                                >> s->ps.sps->
2783                                                                log2_min_pu_size))
2784                                       * min_pu_width]).pred_flag == PF_INTRA))
2785                     left[-1] = left[0];
2786             } else if (x0 == 0) {
2787                 do {
2788                     uint32_t pix = ((0) * 0x01010101U);
2789                     for (i = 0; i < (size_max_y); i += 4)
2790                         ((((union unaligned_32 *) (left + i))->l) = (pix));
2791                 } while (0);
2792             } else {
2793                 a = ((left[size_max_y - 1]) * 0x01010101U);
2794                 for (i = (size_max_y - 1);
2795                      i > (size_max_y - 1) - (size_max_y); i -= 4)
2796                     if (!
2797                         ((s->ref->tab_mvf[(((x0 +
2798                                              ((-1) << hshift)) >> s->ps.sps->
2799                                             log2_min_pu_size)) + (((y0 +
2800                                                                     ((i -
2801                                                                       3) <<
2802                                                                      vshift))
2803                                                                    >> s->ps.sps->
2804                                                                    log2_min_pu_size))
2805                                           * min_pu_width]).pred_flag ==
2806                          PF_INTRA))
2807                         ((((union unaligned_32 *) (&left[i - 3]))->l) = (a));
2808                     else
2809                         a = ((left[i - 3]) * 0x01010101U);
2810             }
2811             top[-1] = left[-1];
2812             if (y0 != 0) {
2813                 a = ((left[-1]) * 0x01010101U);
2814                 for (i = 0; i < (0) + (size_max_x); i += 4)
2815                     if (!
2816                         ((s->ref->tab_mvf[(((x0 +
2817                                              ((i) << hshift)) >> s->ps.sps->
2818                                             log2_min_pu_size)) + (((y0 + ((-1)
2819                                                                           <<
2820                                                                           vshift))
2821                                                                    >> s->ps.sps->
2822                                                                    log2_min_pu_size))
2823                                           * min_pu_width]).pred_flag ==
2824                          PF_INTRA))
2825                         ((((union unaligned_32 *) (&top[i]))->l) = (a));
2826                     else
2827                         a = ((top[i + 3]) * 0x01010101U);
2828             }
2829         }
2830     }
2831
2832     if (!cand_bottom_left) {
2833         if (cand_left) {
2834             vec0 = (v16u8) __msa_fill_b(left[31]);
2835
2836             ST_UB2(vec0, vec0, (left + 32), 16);
2837         } else if (cand_up_left) {
2838             vec0 = (v16u8) __msa_fill_b(left[-1]);
2839
2840             ST_UB4(vec0, vec0, vec0, vec0, left, 16);
2841
2842             cand_left = 1;
2843         } else if (cand_up) {
2844             left[-1] = top[0];
2845
2846             vec0 = (v16u8) __msa_fill_b(left[-1]);
2847
2848             ST_UB4(vec0, vec0, vec0, vec0, left, 16);
2849
2850             cand_up_left = 1;
2851             cand_left = 1;
2852         } else if (cand_up_right) {
2853             vec0 = (v16u8) __msa_fill_b(top[32]);
2854
2855             ST_UB2(vec0, vec0, top, 16);
2856
2857             left[-1] = top[32];
2858
2859             ST_UB4(vec0, vec0, vec0, vec0, left, 16);
2860
2861             cand_up = 1;
2862             cand_up_left = 1;
2863             cand_left = 1;
2864         } else {
2865             left[-1] = 128;
2866
2867             vec0 = (v16u8) __msa_ldi_b(128);
2868
2869             ST_UB4(vec0, vec0, vec0, vec0, top, 16);
2870             ST_UB4(vec0, vec0, vec0, vec0, left, 16);
2871         }
2872     }
2873
2874     if (!cand_left) {
2875         vec0 = (v16u8) __msa_fill_b(left[32]);
2876
2877         ST_UB2(vec0, vec0, left, 16);
2878     }
2879     if (!cand_up_left) {
2880         left[-1] = left[0];
2881     }
2882     if (!cand_up) {
2883         vec0 = (v16u8) __msa_fill_b(left[-1]);
2884
2885         ST_UB2(vec0, vec0, top, 16);
2886     }
2887     if (!cand_up_right) {
2888         vec0 = (v16u8) __msa_fill_b(top[31]);
2889
2890         ST_UB2(vec0, vec0, (top + 32), 16);
2891     }
2892
2893     top[-1] = left[-1];
2894
2895
2896     if (!s->ps.sps->intra_smoothing_disabled_flag
2897         && (c_idx == 0 || s->ps.sps->chroma_format_idc == 3)) {
2898         if (mode != INTRA_DC && 32 != 4) {
2899             int intra_hor_ver_dist_thresh[] = { 7, 1, 0 };
2900             int min_dist_vert_hor =
2901                 (((((int) (mode - 26U)) >=
2902                    0 ? ((int) (mode - 26U)) : (-((int) (mode - 26U))))) >
2903                  ((((int) (mode - 10U)) >=
2904                    0 ? ((int) (mode - 10U)) : (-((int) (mode - 10U)))))
2905                  ? ((((int) (mode - 10U)) >=
2906                      0 ? ((int) (mode - 10U)) : (-((int) (mode - 10U)))))
2907                  : ((((int) (mode - 26U)) >=
2908                      0 ? ((int) (mode - 26U)) : (-((int) (mode - 26U))))));
2909             if (min_dist_vert_hor > intra_hor_ver_dist_thresh[5 - 3]) {
2910                 int threshold = 1 << (8 - 5);
2911                 if (s->ps.sps->sps_strong_intra_smoothing_enable_flag
2912                     && c_idx == 0
2913                     && ((top[-1] + top[63] - 2 * top[31]) >=
2914                         0 ? (top[-1] + top[63] -
2915                              2 * top[31]) : (-(top[-1] + top[63] -
2916                                                2 * top[31]))) < threshold
2917                     && ((left[-1] + left[63] - 2 * left[31]) >=
2918                         0 ? (left[-1] + left[63] -
2919                              2 * left[31]) : (-(left[-1] + left[63] -
2920                                                 2 * left[31]))) < threshold) {
2921
2922
2923                     filtered_top[-1] = top[-1];
2924                     filtered_top[63] = top[63];
2925
2926
2927                     for (i = 0; i < 63; i++) {
2928                         filtered_top[i] =
2929                             ((63 - i) * top[-1] + (i + 1) * top[63] + 32) >> 6;
2930                     }
2931
2932                     tmp0 = __msa_fill_h(top[-1]);
2933                     tmp1 = __msa_fill_h(top[63]);
2934
2935                     tmp2 = mul_val0 - 8;
2936                     tmp3 = mul_val0 - 16;
2937                     tmp4 = mul_val0 - 24;
2938                     tmp5 = mul_val1 + 8;
2939                     tmp6 = mul_val1 + 16;
2940                     tmp7 = mul_val1 + 24;
2941
2942                     res0 = mul_val0 * tmp0;
2943                     res1 = tmp2 * tmp0;
2944                     res2 = tmp3 * tmp0;
2945                     res3 = tmp4 * tmp0;
2946                     res0 += mul_val1 * tmp1;
2947                     res1 += tmp5 * tmp1;
2948                     res2 += tmp6 * tmp1;
2949                     res3 += tmp7 * tmp1;
2950
2951                     res0 = __msa_srari_h(res0, 6);
2952                     res1 = __msa_srari_h(res1, 6);
2953                     res2 = __msa_srari_h(res2, 6);
2954                     res3 = __msa_srari_h(res3, 6);
2955
2956                     vec0 = (v16u8) __msa_pckev_b((v16i8) res1, (v16i8) res0);
2957                     vec1 = (v16u8) __msa_pckev_b((v16i8) res3, (v16i8) res2);
2958
2959                     ST_UB2(vec0, vec1, filtered_top, 16);
2960
2961                     res0 = mul_val0 - 32;
2962                     tmp2 = mul_val0 - 40;
2963                     tmp3 = mul_val0 - 48;
2964                     tmp4 = mul_val0 - 56;
2965                     res3 = mul_val1 + 32;
2966                     tmp5 = mul_val1 + 40;
2967                     tmp6 = mul_val1 + 48;
2968                     tmp7 = mul_val1 + 56;
2969
2970                     res0 = res0 * tmp0;
2971                     res1 = tmp2 * tmp0;
2972                     res2 = tmp3 * tmp0;
2973                     res0 += res3 * tmp1;
2974                     res3 = tmp4 * tmp0;
2975                     res1 += tmp5 * tmp1;
2976                     res2 += tmp6 * tmp1;
2977                     res3 += tmp7 * tmp1;
2978
2979                     res0 = __msa_srari_h(res0, 6);
2980                     res1 = __msa_srari_h(res1, 6);
2981                     res2 = __msa_srari_h(res2, 6);
2982                     res3 = __msa_srari_h(res3, 6);
2983
2984                     vec0 = (v16u8) __msa_pckev_b((v16i8) res1, (v16i8) res0);
2985                     vec1 = (v16u8) __msa_pckev_b((v16i8) res3, (v16i8) res2);
2986
2987                     ST_UB2(vec0, vec1, (filtered_top + 32), 16);
2988
2989                     filtered_top[63] = top[63];
2990
2991                     tmp0 = __msa_fill_h(left[-1]);
2992                     tmp1 = __msa_fill_h(left[63]);
2993
2994                     tmp2 = mul_val0 - 8;
2995                     tmp3 = mul_val0 - 16;
2996                     tmp4 = mul_val0 - 24;
2997                     tmp5 = mul_val1 + 8;
2998                     tmp6 = mul_val1 + 16;
2999                     tmp7 = mul_val1 + 24;
3000
3001                     res0 = mul_val0 * tmp0;
3002                     res1 = tmp2 * tmp0;
3003                     res2 = tmp3 * tmp0;
3004                     res3 = tmp4 * tmp0;
3005                     res0 += mul_val1 * tmp1;
3006                     res1 += tmp5 * tmp1;
3007                     res2 += tmp6 * tmp1;
3008                     res3 += tmp7 * tmp1;
3009
3010                     res0 = __msa_srari_h(res0, 6);
3011                     res1 = __msa_srari_h(res1, 6);
3012                     res2 = __msa_srari_h(res2, 6);
3013                     res3 = __msa_srari_h(res3, 6);
3014
3015                     vec0 = (v16u8) __msa_pckev_b((v16i8) res1, (v16i8) res0);
3016                     vec1 = (v16u8) __msa_pckev_b((v16i8) res3, (v16i8) res2);
3017
3018                     ST_UB2(vec0, vec1, left, 16);
3019
3020                     res0 = mul_val0 - 32;
3021                     tmp2 = mul_val0 - 40;
3022                     tmp3 = mul_val0 - 48;
3023                     tmp4 = mul_val0 - 56;
3024                     res3 = mul_val1 + 32;
3025                     tmp5 = mul_val1 + 40;
3026                     tmp6 = mul_val1 + 48;
3027                     tmp7 = mul_val1 + 56;
3028
3029                     res0 = res0 * tmp0;
3030                     res1 = tmp2 * tmp0;
3031                     res2 = tmp3 * tmp0;
3032                     res0 += res3 * tmp1;
3033                     res3 = tmp4 * tmp0;
3034                     res1 += tmp5 * tmp1;
3035                     res2 += tmp6 * tmp1;
3036                     res3 += tmp7 * tmp1;
3037
3038                     res0 = __msa_srari_h(res0, 6);
3039                     res1 = __msa_srari_h(res1, 6);
3040                     res2 = __msa_srari_h(res2, 6);
3041                     res3 = __msa_srari_h(res3, 6);
3042
3043                     vec0 = (v16u8) __msa_pckev_b((v16i8) res1, (v16i8) res0);
3044                     vec1 = (v16u8) __msa_pckev_b((v16i8) res3, (v16i8) res2);
3045
3046                     ST_UB2(vec0, vec1, (left + 32), 16);
3047
3048                     left[63] = tmp1[0];
3049
3050                     top = filtered_top;
3051                 } else {
3052                     filtered_left[2 * 32 - 1] = left[2 * 32 - 1];
3053                     filtered_top[2 * 32 - 1] = top[2 * 32 - 1];
3054                     for (i = 2 * 32 - 2; i >= 0; i--)
3055                         filtered_left[i] = (left[i + 1] + 2 * left[i] +
3056                                             left[i - 1] + 2) >> 2;
3057                     filtered_top[-1] =
3058                         filtered_left[-1] =
3059                         (left[0] + 2 * left[-1] + top[0] + 2) >> 2;
3060                     for (i = 2 * 32 - 2; i >= 0; i--)
3061                         filtered_top[i] = (top[i + 1] + 2 * top[i] +
3062                                            top[i - 1] + 2) >> 2;
3063                     left = filtered_left;
3064                     top = filtered_top;
3065                 }
3066             }
3067         }
3068     }
3069
3070     switch (mode) {
3071     case INTRA_PLANAR:
3072         s->hpc.pred_planar[3] ((uint8_t *) src, (uint8_t *) top,
3073                                (uint8_t *) left, stride);
3074         break;
3075     case INTRA_DC:
3076         s->hpc.pred_dc((uint8_t *) src, (uint8_t *) top,
3077                        (uint8_t *) left, stride, 5, c_idx);
3078         break;
3079     default:
3080         s->hpc.pred_angular[3] ((uint8_t *) src, (uint8_t *) top,
3081                                 (uint8_t *) left, stride, c_idx, mode);
3082         break;
3083     }
3084 }