| OLD | NEW |
|---|
| (Empty) | |
| 1 /* |
| 2 * Copyright (c) 2015 The WebM project authors. All Rights Reserved. |
| 3 * |
| 4 * Use of this source code is governed by a BSD-style license |
| 5 * that can be found in the LICENSE file in the root of the source |
| 6 * tree. An additional intellectual property rights grant can be found |
| 7 * in the file PATENTS. All contributing project authors may |
| 8 * be found in the AUTHORS file in the root of the source tree. |
| 9 */ |
| 10 |
| 11 #include "vp9/common/mips/msa/vp9_macros_msa.h" |
| 12 |
| 13 static void avg_width4_msa(const uint8_t *src, int32_t src_stride, |
| 14 uint8_t *dst, int32_t dst_stride, int32_t height) { |
| 15 int32_t cnt; |
| 16 uint32_t out0, out1, out2, out3; |
| 17 v16u8 src0, src1, src2, src3; |
| 18 v16u8 dst0, dst1, dst2, dst3; |
| 19 |
| 20 if (0 == (height % 4)) { |
| 21 for (cnt = (height / 4); cnt--;) { |
| 22 LOAD_4VECS_UB(src, src_stride, src0, src1, src2, src3); |
| 23 src += (4 * src_stride); |
| 24 |
| 25 LOAD_4VECS_UB(dst, dst_stride, dst0, dst1, dst2, dst3); |
| 26 |
| 27 dst0 = __msa_aver_u_b(src0, dst0); |
| 28 dst1 = __msa_aver_u_b(src1, dst1); |
| 29 dst2 = __msa_aver_u_b(src2, dst2); |
| 30 dst3 = __msa_aver_u_b(src3, dst3); |
| 31 |
| 32 out0 = __msa_copy_u_w((v4i32)dst0, 0); |
| 33 out1 = __msa_copy_u_w((v4i32)dst1, 0); |
| 34 out2 = __msa_copy_u_w((v4i32)dst2, 0); |
| 35 out3 = __msa_copy_u_w((v4i32)dst3, 0); |
| 36 |
| 37 STORE_WORD(dst, out0); |
| 38 dst += dst_stride; |
| 39 STORE_WORD(dst, out1); |
| 40 dst += dst_stride; |
| 41 STORE_WORD(dst, out2); |
| 42 dst += dst_stride; |
| 43 STORE_WORD(dst, out3); |
| 44 dst += dst_stride; |
| 45 } |
| 46 } else if (0 == (height % 2)) { |
| 47 for (cnt = (height / 2); cnt--;) { |
| 48 LOAD_2VECS_UB(src, src_stride, src0, src1); |
| 49 src += (2 * src_stride); |
| 50 |
| 51 LOAD_2VECS_UB(dst, dst_stride, dst0, dst1); |
| 52 |
| 53 dst0 = __msa_aver_u_b(src0, dst0); |
| 54 dst1 = __msa_aver_u_b(src1, dst1); |
| 55 |
| 56 out0 = __msa_copy_u_w((v4i32)dst0, 0); |
| 57 out1 = __msa_copy_u_w((v4i32)dst1, 0); |
| 58 |
| 59 STORE_WORD(dst, out0); |
| 60 dst += dst_stride; |
| 61 STORE_WORD(dst, out1); |
| 62 dst += dst_stride; |
| 63 } |
| 64 } |
| 65 } |
| 66 |
| 67 static void avg_width8_msa(const uint8_t *src, int32_t src_stride, |
| 68 uint8_t *dst, int32_t dst_stride, int32_t height) { |
| 69 int32_t cnt; |
| 70 uint64_t out0, out1, out2, out3; |
| 71 v16u8 src0, src1, src2, src3; |
| 72 v16u8 dst0, dst1, dst2, dst3; |
| 73 |
| 74 for (cnt = (height / 4); cnt--;) { |
| 75 LOAD_4VECS_UB(src, src_stride, src0, src1, src2, src3); |
| 76 src += (4 * src_stride); |
| 77 |
| 78 LOAD_4VECS_UB(dst, dst_stride, dst0, dst1, dst2, dst3); |
| 79 |
| 80 dst0 = __msa_aver_u_b(src0, dst0); |
| 81 dst1 = __msa_aver_u_b(src1, dst1); |
| 82 dst2 = __msa_aver_u_b(src2, dst2); |
| 83 dst3 = __msa_aver_u_b(src3, dst3); |
| 84 |
| 85 out0 = __msa_copy_u_d((v2i64)dst0, 0); |
| 86 out1 = __msa_copy_u_d((v2i64)dst1, 0); |
| 87 out2 = __msa_copy_u_d((v2i64)dst2, 0); |
| 88 out3 = __msa_copy_u_d((v2i64)dst3, 0); |
| 89 |
| 90 STORE_DWORD(dst, out0); |
| 91 dst += dst_stride; |
| 92 STORE_DWORD(dst, out1); |
| 93 dst += dst_stride; |
| 94 STORE_DWORD(dst, out2); |
| 95 dst += dst_stride; |
| 96 STORE_DWORD(dst, out3); |
| 97 dst += dst_stride; |
| 98 } |
| 99 } |
| 100 |
| 101 static void avg_width16_msa(const uint8_t *src, int32_t src_stride, |
| 102 uint8_t *dst, int32_t dst_stride, int32_t height) { |
| 103 int32_t cnt; |
| 104 v16u8 src0, src1, src2, src3, src4, src5, src6, src7; |
| 105 v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7; |
| 106 |
| 107 for (cnt = (height / 8); cnt--;) { |
| 108 LOAD_8VECS_UB(src, src_stride, |
| 109 src0, src1, src2, src3, src4, src5, src6, src7); |
| 110 src += (8 * src_stride); |
| 111 |
| 112 LOAD_8VECS_UB(dst, dst_stride, |
| 113 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7); |
| 114 |
| 115 dst0 = __msa_aver_u_b(src0, dst0); |
| 116 dst1 = __msa_aver_u_b(src1, dst1); |
| 117 dst2 = __msa_aver_u_b(src2, dst2); |
| 118 dst3 = __msa_aver_u_b(src3, dst3); |
| 119 dst4 = __msa_aver_u_b(src4, dst4); |
| 120 dst5 = __msa_aver_u_b(src5, dst5); |
| 121 dst6 = __msa_aver_u_b(src6, dst6); |
| 122 dst7 = __msa_aver_u_b(src7, dst7); |
| 123 |
| 124 STORE_8VECS_UB(dst, dst_stride, |
| 125 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7); |
| 126 dst += (8 * dst_stride); |
| 127 } |
| 128 } |
| 129 |
| 130 static void avg_width32_msa(const uint8_t *src, int32_t src_stride, |
| 131 uint8_t *dst, int32_t dst_stride, int32_t height) { |
| 132 int32_t cnt; |
| 133 uint8_t *dst_dup = dst; |
| 134 v16u8 src0, src1, src2, src3, src4, src5, src6, src7; |
| 135 v16u8 src8, src9, src10, src11, src12, src13, src14, src15; |
| 136 v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7; |
| 137 v16u8 dst8, dst9, dst10, dst11, dst12, dst13, dst14, dst15; |
| 138 |
| 139 for (cnt = (height / 8); cnt--;) { |
| 140 src0 = LOAD_UB(src); |
| 141 src1 = LOAD_UB(src + 16); |
| 142 src += src_stride; |
| 143 src2 = LOAD_UB(src); |
| 144 src3 = LOAD_UB(src + 16); |
| 145 src += src_stride; |
| 146 src4 = LOAD_UB(src); |
| 147 src5 = LOAD_UB(src + 16); |
| 148 src += src_stride; |
| 149 src6 = LOAD_UB(src); |
| 150 src7 = LOAD_UB(src + 16); |
| 151 src += src_stride; |
| 152 |
| 153 dst0 = LOAD_UB(dst_dup); |
| 154 dst1 = LOAD_UB(dst_dup + 16); |
| 155 dst_dup += dst_stride; |
| 156 dst2 = LOAD_UB(dst_dup); |
| 157 dst3 = LOAD_UB(dst_dup + 16); |
| 158 dst_dup += dst_stride; |
| 159 dst4 = LOAD_UB(dst_dup); |
| 160 dst5 = LOAD_UB(dst_dup + 16); |
| 161 dst_dup += dst_stride; |
| 162 dst6 = LOAD_UB(dst_dup); |
| 163 dst7 = LOAD_UB(dst_dup + 16); |
| 164 dst_dup += dst_stride; |
| 165 |
| 166 src8 = LOAD_UB(src); |
| 167 src9 = LOAD_UB(src + 16); |
| 168 src += src_stride; |
| 169 src10 = LOAD_UB(src); |
| 170 src11 = LOAD_UB(src + 16); |
| 171 src += src_stride; |
| 172 src12 = LOAD_UB(src); |
| 173 src13 = LOAD_UB(src + 16); |
| 174 src += src_stride; |
| 175 src14 = LOAD_UB(src); |
| 176 src15 = LOAD_UB(src + 16); |
| 177 src += src_stride; |
| 178 |
| 179 dst8 = LOAD_UB(dst_dup); |
| 180 dst9 = LOAD_UB(dst_dup + 16); |
| 181 dst_dup += dst_stride; |
| 182 dst10 = LOAD_UB(dst_dup); |
| 183 dst11 = LOAD_UB(dst_dup + 16); |
| 184 dst_dup += dst_stride; |
| 185 dst12 = LOAD_UB(dst_dup); |
| 186 dst13 = LOAD_UB(dst_dup + 16); |
| 187 dst_dup += dst_stride; |
| 188 dst14 = LOAD_UB(dst_dup); |
| 189 dst15 = LOAD_UB(dst_dup + 16); |
| 190 dst_dup += dst_stride; |
| 191 |
| 192 dst0 = __msa_aver_u_b(src0, dst0); |
| 193 dst1 = __msa_aver_u_b(src1, dst1); |
| 194 dst2 = __msa_aver_u_b(src2, dst2); |
| 195 dst3 = __msa_aver_u_b(src3, dst3); |
| 196 dst4 = __msa_aver_u_b(src4, dst4); |
| 197 dst5 = __msa_aver_u_b(src5, dst5); |
| 198 dst6 = __msa_aver_u_b(src6, dst6); |
| 199 dst7 = __msa_aver_u_b(src7, dst7); |
| 200 dst8 = __msa_aver_u_b(src8, dst8); |
| 201 dst9 = __msa_aver_u_b(src9, dst9); |
| 202 dst10 = __msa_aver_u_b(src10, dst10); |
| 203 dst11 = __msa_aver_u_b(src11, dst11); |
| 204 dst12 = __msa_aver_u_b(src12, dst12); |
| 205 dst13 = __msa_aver_u_b(src13, dst13); |
| 206 dst14 = __msa_aver_u_b(src14, dst14); |
| 207 dst15 = __msa_aver_u_b(src15, dst15); |
| 208 |
| 209 STORE_UB(dst0, dst); |
| 210 STORE_UB(dst1, dst + 16); |
| 211 dst += dst_stride; |
| 212 STORE_UB(dst2, dst); |
| 213 STORE_UB(dst3, dst + 16); |
| 214 dst += dst_stride; |
| 215 STORE_UB(dst4, dst); |
| 216 STORE_UB(dst5, dst + 16); |
| 217 dst += dst_stride; |
| 218 STORE_UB(dst6, dst); |
| 219 STORE_UB(dst7, dst + 16); |
| 220 dst += dst_stride; |
| 221 STORE_UB(dst8, dst); |
| 222 STORE_UB(dst9, dst + 16); |
| 223 dst += dst_stride; |
| 224 STORE_UB(dst10, dst); |
| 225 STORE_UB(dst11, dst + 16); |
| 226 dst += dst_stride; |
| 227 STORE_UB(dst12, dst); |
| 228 STORE_UB(dst13, dst + 16); |
| 229 dst += dst_stride; |
| 230 STORE_UB(dst14, dst); |
| 231 STORE_UB(dst15, dst + 16); |
| 232 dst += dst_stride; |
| 233 } |
| 234 } |
| 235 |
| 236 static void avg_width64_msa(const uint8_t *src, int32_t src_stride, |
| 237 uint8_t *dst, int32_t dst_stride, int32_t height) { |
| 238 int32_t cnt; |
| 239 uint8_t *dst_dup = dst; |
| 240 v16u8 src0, src1, src2, src3, src4, src5, src6, src7; |
| 241 v16u8 src8, src9, src10, src11, src12, src13, src14, src15; |
| 242 v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7; |
| 243 v16u8 dst8, dst9, dst10, dst11, dst12, dst13, dst14, dst15; |
| 244 |
| 245 for (cnt = (height / 4); cnt--;) { |
| 246 LOAD_4VECS_UB(src, 16, src0, src1, src2, src3); |
| 247 src += src_stride; |
| 248 LOAD_4VECS_UB(src, 16, src4, src5, src6, src7); |
| 249 src += src_stride; |
| 250 LOAD_4VECS_UB(src, 16, src8, src9, src10, src11); |
| 251 src += src_stride; |
| 252 LOAD_4VECS_UB(src, 16, src12, src13, src14, src15); |
| 253 src += src_stride; |
| 254 |
| 255 LOAD_4VECS_UB(dst_dup, 16, dst0, dst1, dst2, dst3); |
| 256 dst_dup += dst_stride; |
| 257 LOAD_4VECS_UB(dst_dup, 16, dst4, dst5, dst6, dst7); |
| 258 dst_dup += dst_stride; |
| 259 LOAD_4VECS_UB(dst_dup, 16, dst8, dst9, dst10, dst11); |
| 260 dst_dup += dst_stride; |
| 261 LOAD_4VECS_UB(dst_dup, 16, dst12, dst13, dst14, dst15); |
| 262 dst_dup += dst_stride; |
| 263 |
| 264 dst0 = __msa_aver_u_b(src0, dst0); |
| 265 dst1 = __msa_aver_u_b(src1, dst1); |
| 266 dst2 = __msa_aver_u_b(src2, dst2); |
| 267 dst3 = __msa_aver_u_b(src3, dst3); |
| 268 dst4 = __msa_aver_u_b(src4, dst4); |
| 269 dst5 = __msa_aver_u_b(src5, dst5); |
| 270 dst6 = __msa_aver_u_b(src6, dst6); |
| 271 dst7 = __msa_aver_u_b(src7, dst7); |
| 272 dst8 = __msa_aver_u_b(src8, dst8); |
| 273 dst9 = __msa_aver_u_b(src9, dst9); |
| 274 dst10 = __msa_aver_u_b(src10, dst10); |
| 275 dst11 = __msa_aver_u_b(src11, dst11); |
| 276 dst12 = __msa_aver_u_b(src12, dst12); |
| 277 dst13 = __msa_aver_u_b(src13, dst13); |
| 278 dst14 = __msa_aver_u_b(src14, dst14); |
| 279 dst15 = __msa_aver_u_b(src15, dst15); |
| 280 |
| 281 STORE_4VECS_UB(dst, 16, dst0, dst1, dst2, dst3); |
| 282 dst += dst_stride; |
| 283 STORE_4VECS_UB(dst, 16, dst4, dst5, dst6, dst7); |
| 284 dst += dst_stride; |
| 285 STORE_4VECS_UB(dst, 16, dst8, dst9, dst10, dst11); |
| 286 dst += dst_stride; |
| 287 STORE_4VECS_UB(dst, 16, dst12, dst13, dst14, dst15); |
| 288 dst += dst_stride; |
| 289 } |
| 290 } |
| 291 |
| 292 void vp9_convolve_avg_msa(const uint8_t *src, ptrdiff_t src_stride, |
| 293 uint8_t *dst, ptrdiff_t dst_stride, |
| 294 const int16_t *filter_x, int32_t filter_x_stride, |
| 295 const int16_t *filter_y, int32_t filter_y_stride, |
| 296 int32_t w, int32_t h) { |
| 297 (void)filter_x; |
| 298 (void)filter_y; |
| 299 (void)filter_x_stride; |
| 300 (void)filter_y_stride; |
| 301 |
| 302 switch (w) { |
| 303 case 4: { |
| 304 avg_width4_msa(src, src_stride, dst, dst_stride, h); |
| 305 break; |
| 306 } |
| 307 case 8: { |
| 308 avg_width8_msa(src, src_stride, dst, dst_stride, h); |
| 309 break; |
| 310 } |
| 311 case 16: { |
| 312 avg_width16_msa(src, src_stride, dst, dst_stride, h); |
| 313 break; |
| 314 } |
| 315 case 32: { |
| 316 avg_width32_msa(src, src_stride, dst, dst_stride, h); |
| 317 break; |
| 318 } |
| 319 case 64: { |
| 320 avg_width64_msa(src, src_stride, dst, dst_stride, h); |
| 321 break; |
| 322 } |
| 323 default: { |
| 324 int32_t lp, cnt; |
| 325 for (cnt = h; cnt--;) { |
| 326 for (lp = 0; lp < w; ++lp) { |
| 327 dst[lp] = (((dst[lp] + src[lp]) + 1) >> 1); |
| 328 } |
| 329 src += src_stride; |
| 330 dst += dst_stride; |
| 331 } |
| 332 break; |
| 333 } |
| 334 } |
| 335 } |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1124333011:
libvpx: Pull from upstream (Closed)
Base URL: https://chromium.googlesource.com/chromium/deps/libvpx.git@master