| OLD | NEW |
|---|
| (Empty) |
| 1 ; | |
| 2 ; Copyright (c) 2013 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 EXPORT |vp9_lpf_horizontal_4_neon| | |
| 12 EXPORT |vp9_lpf_vertical_4_neon| | |
| 13 EXPORT |vp9_lpf_horizontal_8_neon| | |
| 14 EXPORT |vp9_lpf_vertical_8_neon| | |
| 15 ARM | |
| 16 | |
| 17 AREA ||.text||, CODE, READONLY, ALIGN=2 | |
| 18 | |
| 19 ; Currently vp9 only works on iterations 8 at a time. The vp8 loop filter | |
| 20 ; works on 16 iterations at a time. | |
| 21 ; TODO(fgalligan): See about removing the count code as this function is only | |
| 22 ; called with a count of 1. | |
| 23 ; | |
| 24 ; void vp9_lpf_horizontal_4_neon(uint8_t *s, | |
| 25 ; int p /* pitch */, | |
| 26 ; const uint8_t *blimit, | |
| 27 ; const uint8_t *limit, | |
| 28 ; const uint8_t *thresh, | |
| 29 ; int count) | |
| 30 ; | |
| 31 ; r0 uint8_t *s, | |
| 32 ; r1 int p, /* pitch */ | |
| 33 ; r2 const uint8_t *blimit, | |
| 34 ; r3 const uint8_t *limit, | |
| 35 ; sp const uint8_t *thresh, | |
| 36 ; sp+4 int count | |
| 37 |vp9_lpf_horizontal_4_neon| PROC | |
| 38 push {lr} | |
| 39 | |
| 40 vld1.8 {d0[]}, [r2] ; duplicate *blimit | |
| 41 ldr r12, [sp, #8] ; load count | |
| 42 ldr r2, [sp, #4] ; load thresh | |
| 43 add r1, r1, r1 ; double pitch | |
| 44 | |
| 45 cmp r12, #0 | |
| 46 beq end_vp9_lf_h_edge | |
| 47 | |
| 48 vld1.8 {d1[]}, [r3] ; duplicate *limit | |
| 49 vld1.8 {d2[]}, [r2] ; duplicate *thresh | |
| 50 | |
| 51 count_lf_h_loop | |
| 52 sub r2, r0, r1, lsl #1 ; move src pointer down by 4 lines | |
| 53 add r3, r2, r1, lsr #1 ; set to 3 lines down | |
| 54 | |
| 55 vld1.u8 {d3}, [r2@64], r1 ; p3 | |
| 56 vld1.u8 {d4}, [r3@64], r1 ; p2 | |
| 57 vld1.u8 {d5}, [r2@64], r1 ; p1 | |
| 58 vld1.u8 {d6}, [r3@64], r1 ; p0 | |
| 59 vld1.u8 {d7}, [r2@64], r1 ; q0 | |
| 60 vld1.u8 {d16}, [r3@64], r1 ; q1 | |
| 61 vld1.u8 {d17}, [r2@64] ; q2 | |
| 62 vld1.u8 {d18}, [r3@64] ; q3 | |
| 63 | |
| 64 sub r2, r2, r1, lsl #1 | |
| 65 sub r3, r3, r1, lsl #1 | |
| 66 | |
| 67 bl vp9_loop_filter_neon | |
| 68 | |
| 69 vst1.u8 {d4}, [r2@64], r1 ; store op1 | |
| 70 vst1.u8 {d5}, [r3@64], r1 ; store op0 | |
| 71 vst1.u8 {d6}, [r2@64], r1 ; store oq0 | |
| 72 vst1.u8 {d7}, [r3@64], r1 ; store oq1 | |
| 73 | |
| 74 add r0, r0, #8 | |
| 75 subs r12, r12, #1 | |
| 76 bne count_lf_h_loop | |
| 77 | |
| 78 end_vp9_lf_h_edge | |
| 79 pop {pc} | |
| 80 ENDP ; |vp9_lpf_horizontal_4_neon| | |
| 81 | |
| 82 ; Currently vp9 only works on iterations 8 at a time. The vp8 loop filter | |
| 83 ; works on 16 iterations at a time. | |
| 84 ; TODO(fgalligan): See about removing the count code as this function is only | |
| 85 ; called with a count of 1. | |
| 86 ; | |
| 87 ; void vp9_lpf_vertical_4_neon(uint8_t *s, | |
| 88 ; int p /* pitch */, | |
| 89 ; const uint8_t *blimit, | |
| 90 ; const uint8_t *limit, | |
| 91 ; const uint8_t *thresh, | |
| 92 ; int count) | |
| 93 ; | |
| 94 ; r0 uint8_t *s, | |
| 95 ; r1 int p, /* pitch */ | |
| 96 ; r2 const uint8_t *blimit, | |
| 97 ; r3 const uint8_t *limit, | |
| 98 ; sp const uint8_t *thresh, | |
| 99 ; sp+4 int count | |
| 100 |vp9_lpf_vertical_4_neon| PROC | |
| 101 push {lr} | |
| 102 | |
| 103 vld1.8 {d0[]}, [r2] ; duplicate *blimit | |
| 104 ldr r12, [sp, #8] ; load count | |
| 105 vld1.8 {d1[]}, [r3] ; duplicate *limit | |
| 106 | |
| 107 ldr r3, [sp, #4] ; load thresh | |
| 108 sub r2, r0, #4 ; move s pointer down by 4 columns | |
| 109 cmp r12, #0 | |
| 110 beq end_vp9_lf_v_edge | |
| 111 | |
| 112 vld1.8 {d2[]}, [r3] ; duplicate *thresh | |
| 113 | |
| 114 count_lf_v_loop | |
| 115 vld1.u8 {d3}, [r2], r1 ; load s data | |
| 116 vld1.u8 {d4}, [r2], r1 | |
| 117 vld1.u8 {d5}, [r2], r1 | |
| 118 vld1.u8 {d6}, [r2], r1 | |
| 119 vld1.u8 {d7}, [r2], r1 | |
| 120 vld1.u8 {d16}, [r2], r1 | |
| 121 vld1.u8 {d17}, [r2], r1 | |
| 122 vld1.u8 {d18}, [r2] | |
| 123 | |
| 124 ;transpose to 8x16 matrix | |
| 125 vtrn.32 d3, d7 | |
| 126 vtrn.32 d4, d16 | |
| 127 vtrn.32 d5, d17 | |
| 128 vtrn.32 d6, d18 | |
| 129 | |
| 130 vtrn.16 d3, d5 | |
| 131 vtrn.16 d4, d6 | |
| 132 vtrn.16 d7, d17 | |
| 133 vtrn.16 d16, d18 | |
| 134 | |
| 135 vtrn.8 d3, d4 | |
| 136 vtrn.8 d5, d6 | |
| 137 vtrn.8 d7, d16 | |
| 138 vtrn.8 d17, d18 | |
| 139 | |
| 140 bl vp9_loop_filter_neon | |
| 141 | |
| 142 sub r0, r0, #2 | |
| 143 | |
| 144 ;store op1, op0, oq0, oq1 | |
| 145 vst4.8 {d4[0], d5[0], d6[0], d7[0]}, [r0], r1 | |
| 146 vst4.8 {d4[1], d5[1], d6[1], d7[1]}, [r0], r1 | |
| 147 vst4.8 {d4[2], d5[2], d6[2], d7[2]}, [r0], r1 | |
| 148 vst4.8 {d4[3], d5[3], d6[3], d7[3]}, [r0], r1 | |
| 149 vst4.8 {d4[4], d5[4], d6[4], d7[4]}, [r0], r1 | |
| 150 vst4.8 {d4[5], d5[5], d6[5], d7[5]}, [r0], r1 | |
| 151 vst4.8 {d4[6], d5[6], d6[6], d7[6]}, [r0], r1 | |
| 152 vst4.8 {d4[7], d5[7], d6[7], d7[7]}, [r0] | |
| 153 | |
| 154 add r0, r0, r1, lsl #3 ; s += pitch * 8 | |
| 155 subs r12, r12, #1 | |
| 156 subne r2, r0, #4 ; move s pointer down by 4 columns | |
| 157 bne count_lf_v_loop | |
| 158 | |
| 159 end_vp9_lf_v_edge | |
| 160 pop {pc} | |
| 161 ENDP ; |vp9_lpf_vertical_4_neon| | |
| 162 | |
| 163 ; void vp9_loop_filter_neon(); | |
| 164 ; This is a helper function for the loopfilters. The invidual functions do the | |
| 165 ; necessary load, transpose (if necessary) and store. The function does not use | |
| 166 ; registers d8-d15. | |
| 167 ; | |
| 168 ; Inputs: | |
| 169 ; r0-r3, r12 PRESERVE | |
| 170 ; d0 blimit | |
| 171 ; d1 limit | |
| 172 ; d2 thresh | |
| 173 ; d3 p3 | |
| 174 ; d4 p2 | |
| 175 ; d5 p1 | |
| 176 ; d6 p0 | |
| 177 ; d7 q0 | |
| 178 ; d16 q1 | |
| 179 ; d17 q2 | |
| 180 ; d18 q3 | |
| 181 ; | |
| 182 ; Outputs: | |
| 183 ; d4 op1 | |
| 184 ; d5 op0 | |
| 185 ; d6 oq0 | |
| 186 ; d7 oq1 | |
| 187 |vp9_loop_filter_neon| PROC | |
| 188 ; filter_mask | |
| 189 vabd.u8 d19, d3, d4 ; m1 = abs(p3 - p2) | |
| 190 vabd.u8 d20, d4, d5 ; m2 = abs(p2 - p1) | |
| 191 vabd.u8 d21, d5, d6 ; m3 = abs(p1 - p0) | |
| 192 vabd.u8 d22, d16, d7 ; m4 = abs(q1 - q0) | |
| 193 vabd.u8 d3, d17, d16 ; m5 = abs(q2 - q1) | |
| 194 vabd.u8 d4, d18, d17 ; m6 = abs(q3 - q2) | |
| 195 | |
| 196 ; only compare the largest value to limit | |
| 197 vmax.u8 d19, d19, d20 ; m1 = max(m1, m2) | |
| 198 vmax.u8 d20, d21, d22 ; m2 = max(m3, m4) | |
| 199 | |
| 200 vabd.u8 d17, d6, d7 ; abs(p0 - q0) | |
| 201 | |
| 202 vmax.u8 d3, d3, d4 ; m3 = max(m5, m6) | |
| 203 | |
| 204 vmov.u8 d18, #0x80 | |
| 205 | |
| 206 vmax.u8 d23, d19, d20 ; m1 = max(m1, m2) | |
| 207 | |
| 208 ; hevmask | |
| 209 vcgt.u8 d21, d21, d2 ; (abs(p1 - p0) > thresh)*-1 | |
| 210 vcgt.u8 d22, d22, d2 ; (abs(q1 - q0) > thresh)*-1 | |
| 211 vmax.u8 d23, d23, d3 ; m1 = max(m1, m3) | |
| 212 | |
| 213 vabd.u8 d28, d5, d16 ; a = abs(p1 - q1) | |
| 214 vqadd.u8 d17, d17, d17 ; b = abs(p0 - q0) * 2 | |
| 215 | |
| 216 veor d7, d7, d18 ; qs0 | |
| 217 | |
| 218 vcge.u8 d23, d1, d23 ; abs(m1) > limit | |
| 219 | |
| 220 ; filter() function | |
| 221 ; convert to signed | |
| 222 | |
| 223 vshr.u8 d28, d28, #1 ; a = a / 2 | |
| 224 veor d6, d6, d18 ; ps0 | |
| 225 | |
| 226 veor d5, d5, d18 ; ps1 | |
| 227 vqadd.u8 d17, d17, d28 ; a = b + a | |
| 228 | |
| 229 veor d16, d16, d18 ; qs1 | |
| 230 | |
| 231 vmov.u8 d19, #3 | |
| 232 | |
| 233 vsub.s8 d28, d7, d6 ; ( qs0 - ps0) | |
| 234 | |
| 235 vcge.u8 d17, d0, d17 ; a > blimit | |
| 236 | |
| 237 vqsub.s8 d27, d5, d16 ; filter = clamp(ps1-qs1) | |
| 238 vorr d22, d21, d22 ; hevmask | |
| 239 | |
| 240 vmull.s8 q12, d28, d19 ; 3 * ( qs0 - ps0) | |
| 241 | |
| 242 vand d27, d27, d22 ; filter &= hev | |
| 243 vand d23, d23, d17 ; filter_mask | |
| 244 | |
| 245 vaddw.s8 q12, q12, d27 ; filter + 3 * (qs0 - ps0) | |
| 246 | |
| 247 vmov.u8 d17, #4 | |
| 248 | |
| 249 ; filter = clamp(filter + 3 * ( qs0 - ps0)) | |
| 250 vqmovn.s16 d27, q12 | |
| 251 | |
| 252 vand d27, d27, d23 ; filter &= mask | |
| 253 | |
| 254 vqadd.s8 d28, d27, d19 ; filter2 = clamp(filter+3) | |
| 255 vqadd.s8 d27, d27, d17 ; filter1 = clamp(filter+4) | |
| 256 vshr.s8 d28, d28, #3 ; filter2 >>= 3 | |
| 257 vshr.s8 d27, d27, #3 ; filter1 >>= 3 | |
| 258 | |
| 259 vqadd.s8 d19, d6, d28 ; u = clamp(ps0 + filter2) | |
| 260 vqsub.s8 d26, d7, d27 ; u = clamp(qs0 - filter1) | |
| 261 | |
| 262 ; outer tap adjustments | |
| 263 vrshr.s8 d27, d27, #1 ; filter = ++filter1 >> 1 | |
| 264 | |
| 265 veor d6, d26, d18 ; *oq0 = u^0x80 | |
| 266 | |
| 267 vbic d27, d27, d22 ; filter &= ~hev | |
| 268 | |
| 269 vqadd.s8 d21, d5, d27 ; u = clamp(ps1 + filter) | |
| 270 vqsub.s8 d20, d16, d27 ; u = clamp(qs1 - filter) | |
| 271 | |
| 272 veor d5, d19, d18 ; *op0 = u^0x80 | |
| 273 veor d4, d21, d18 ; *op1 = u^0x80 | |
| 274 veor d7, d20, d18 ; *oq1 = u^0x80 | |
| 275 | |
| 276 bx lr | |
| 277 ENDP ; |vp9_loop_filter_neon| | |
| 278 | |
| 279 ; void vp9_lpf_horizontal_8_neon(uint8_t *s, int p, | |
| 280 ; const uint8_t *blimit, | |
| 281 ; const uint8_t *limit, | |
| 282 ; const uint8_t *thresh, | |
| 283 ; int count) | |
| 284 ; r0 uint8_t *s, | |
| 285 ; r1 int p, /* pitch */ | |
| 286 ; r2 const uint8_t *blimit, | |
| 287 ; r3 const uint8_t *limit, | |
| 288 ; sp const uint8_t *thresh, | |
| 289 ; sp+4 int count | |
| 290 |vp9_lpf_horizontal_8_neon| PROC | |
| 291 push {r4-r5, lr} | |
| 292 | |
| 293 vld1.8 {d0[]}, [r2] ; duplicate *blimit | |
| 294 ldr r12, [sp, #16] ; load count | |
| 295 ldr r2, [sp, #12] ; load thresh | |
| 296 add r1, r1, r1 ; double pitch | |
| 297 | |
| 298 cmp r12, #0 | |
| 299 beq end_vp9_mblf_h_edge | |
| 300 | |
| 301 vld1.8 {d1[]}, [r3] ; duplicate *limit | |
| 302 vld1.8 {d2[]}, [r2] ; duplicate *thresh | |
| 303 | |
| 304 count_mblf_h_loop | |
| 305 sub r3, r0, r1, lsl #1 ; move src pointer down by 4 lines | |
| 306 add r2, r3, r1, lsr #1 ; set to 3 lines down | |
| 307 | |
| 308 vld1.u8 {d3}, [r3@64], r1 ; p3 | |
| 309 vld1.u8 {d4}, [r2@64], r1 ; p2 | |
| 310 vld1.u8 {d5}, [r3@64], r1 ; p1 | |
| 311 vld1.u8 {d6}, [r2@64], r1 ; p0 | |
| 312 vld1.u8 {d7}, [r3@64], r1 ; q0 | |
| 313 vld1.u8 {d16}, [r2@64], r1 ; q1 | |
| 314 vld1.u8 {d17}, [r3@64] ; q2 | |
| 315 vld1.u8 {d18}, [r2@64], r1 ; q3 | |
| 316 | |
| 317 sub r3, r3, r1, lsl #1 | |
| 318 sub r2, r2, r1, lsl #2 | |
| 319 | |
| 320 bl vp9_mbloop_filter_neon | |
| 321 | |
| 322 vst1.u8 {d0}, [r2@64], r1 ; store op2 | |
| 323 vst1.u8 {d1}, [r3@64], r1 ; store op1 | |
| 324 vst1.u8 {d2}, [r2@64], r1 ; store op0 | |
| 325 vst1.u8 {d3}, [r3@64], r1 ; store oq0 | |
| 326 vst1.u8 {d4}, [r2@64], r1 ; store oq1 | |
| 327 vst1.u8 {d5}, [r3@64], r1 ; store oq2 | |
| 328 | |
| 329 add r0, r0, #8 | |
| 330 subs r12, r12, #1 | |
| 331 bne count_mblf_h_loop | |
| 332 | |
| 333 end_vp9_mblf_h_edge | |
| 334 pop {r4-r5, pc} | |
| 335 | |
| 336 ENDP ; |vp9_lpf_horizontal_8_neon| | |
| 337 | |
| 338 ; void vp9_lpf_vertical_8_neon(uint8_t *s, | |
| 339 ; int pitch, | |
| 340 ; const uint8_t *blimit, | |
| 341 ; const uint8_t *limit, | |
| 342 ; const uint8_t *thresh, | |
| 343 ; int count) | |
| 344 ; | |
| 345 ; r0 uint8_t *s, | |
| 346 ; r1 int pitch, | |
| 347 ; r2 const uint8_t *blimit, | |
| 348 ; r3 const uint8_t *limit, | |
| 349 ; sp const uint8_t *thresh, | |
| 350 ; sp+4 int count | |
| 351 |vp9_lpf_vertical_8_neon| PROC | |
| 352 push {r4-r5, lr} | |
| 353 | |
| 354 vld1.8 {d0[]}, [r2] ; duplicate *blimit | |
| 355 ldr r12, [sp, #16] ; load count | |
| 356 vld1.8 {d1[]}, [r3] ; duplicate *limit | |
| 357 | |
| 358 ldr r3, [sp, #12] ; load thresh | |
| 359 sub r2, r0, #4 ; move s pointer down by 4 columns | |
| 360 cmp r12, #0 | |
| 361 beq end_vp9_mblf_v_edge | |
| 362 | |
| 363 vld1.8 {d2[]}, [r3] ; duplicate *thresh | |
| 364 | |
| 365 count_mblf_v_loop | |
| 366 vld1.u8 {d3}, [r2], r1 ; load s data | |
| 367 vld1.u8 {d4}, [r2], r1 | |
| 368 vld1.u8 {d5}, [r2], r1 | |
| 369 vld1.u8 {d6}, [r2], r1 | |
| 370 vld1.u8 {d7}, [r2], r1 | |
| 371 vld1.u8 {d16}, [r2], r1 | |
| 372 vld1.u8 {d17}, [r2], r1 | |
| 373 vld1.u8 {d18}, [r2] | |
| 374 | |
| 375 ;transpose to 8x16 matrix | |
| 376 vtrn.32 d3, d7 | |
| 377 vtrn.32 d4, d16 | |
| 378 vtrn.32 d5, d17 | |
| 379 vtrn.32 d6, d18 | |
| 380 | |
| 381 vtrn.16 d3, d5 | |
| 382 vtrn.16 d4, d6 | |
| 383 vtrn.16 d7, d17 | |
| 384 vtrn.16 d16, d18 | |
| 385 | |
| 386 vtrn.8 d3, d4 | |
| 387 vtrn.8 d5, d6 | |
| 388 vtrn.8 d7, d16 | |
| 389 vtrn.8 d17, d18 | |
| 390 | |
| 391 sub r2, r0, #3 | |
| 392 add r3, r0, #1 | |
| 393 | |
| 394 bl vp9_mbloop_filter_neon | |
| 395 | |
| 396 ;store op2, op1, op0, oq0 | |
| 397 vst4.8 {d0[0], d1[0], d2[0], d3[0]}, [r2], r1 | |
| 398 vst4.8 {d0[1], d1[1], d2[1], d3[1]}, [r2], r1 | |
| 399 vst4.8 {d0[2], d1[2], d2[2], d3[2]}, [r2], r1 | |
| 400 vst4.8 {d0[3], d1[3], d2[3], d3[3]}, [r2], r1 | |
| 401 vst4.8 {d0[4], d1[4], d2[4], d3[4]}, [r2], r1 | |
| 402 vst4.8 {d0[5], d1[5], d2[5], d3[5]}, [r2], r1 | |
| 403 vst4.8 {d0[6], d1[6], d2[6], d3[6]}, [r2], r1 | |
| 404 vst4.8 {d0[7], d1[7], d2[7], d3[7]}, [r2] | |
| 405 | |
| 406 ;store oq1, oq2 | |
| 407 vst2.8 {d4[0], d5[0]}, [r3], r1 | |
| 408 vst2.8 {d4[1], d5[1]}, [r3], r1 | |
| 409 vst2.8 {d4[2], d5[2]}, [r3], r1 | |
| 410 vst2.8 {d4[3], d5[3]}, [r3], r1 | |
| 411 vst2.8 {d4[4], d5[4]}, [r3], r1 | |
| 412 vst2.8 {d4[5], d5[5]}, [r3], r1 | |
| 413 vst2.8 {d4[6], d5[6]}, [r3], r1 | |
| 414 vst2.8 {d4[7], d5[7]}, [r3] | |
| 415 | |
| 416 add r0, r0, r1, lsl #3 ; s += pitch * 8 | |
| 417 subs r12, r12, #1 | |
| 418 subne r2, r0, #4 ; move s pointer down by 4 columns | |
| 419 bne count_mblf_v_loop | |
| 420 | |
| 421 end_vp9_mblf_v_edge | |
| 422 pop {r4-r5, pc} | |
| 423 ENDP ; |vp9_lpf_vertical_8_neon| | |
| 424 | |
| 425 ; void vp9_mbloop_filter_neon(); | |
| 426 ; This is a helper function for the loopfilters. The invidual functions do the | |
| 427 ; necessary load, transpose (if necessary) and store. The function does not use | |
| 428 ; registers d8-d15. | |
| 429 ; | |
| 430 ; Inputs: | |
| 431 ; r0-r3, r12 PRESERVE | |
| 432 ; d0 blimit | |
| 433 ; d1 limit | |
| 434 ; d2 thresh | |
| 435 ; d3 p3 | |
| 436 ; d4 p2 | |
| 437 ; d5 p1 | |
| 438 ; d6 p0 | |
| 439 ; d7 q0 | |
| 440 ; d16 q1 | |
| 441 ; d17 q2 | |
| 442 ; d18 q3 | |
| 443 ; | |
| 444 ; Outputs: | |
| 445 ; d0 op2 | |
| 446 ; d1 op1 | |
| 447 ; d2 op0 | |
| 448 ; d3 oq0 | |
| 449 ; d4 oq1 | |
| 450 ; d5 oq2 | |
| 451 |vp9_mbloop_filter_neon| PROC | |
| 452 ; filter_mask | |
| 453 vabd.u8 d19, d3, d4 ; m1 = abs(p3 - p2) | |
| 454 vabd.u8 d20, d4, d5 ; m2 = abs(p2 - p1) | |
| 455 vabd.u8 d21, d5, d6 ; m3 = abs(p1 - p0) | |
| 456 vabd.u8 d22, d16, d7 ; m4 = abs(q1 - q0) | |
| 457 vabd.u8 d23, d17, d16 ; m5 = abs(q2 - q1) | |
| 458 vabd.u8 d24, d18, d17 ; m6 = abs(q3 - q2) | |
| 459 | |
| 460 ; only compare the largest value to limit | |
| 461 vmax.u8 d19, d19, d20 ; m1 = max(m1, m2) | |
| 462 vmax.u8 d20, d21, d22 ; m2 = max(m3, m4) | |
| 463 | |
| 464 vabd.u8 d25, d6, d4 ; m7 = abs(p0 - p2) | |
| 465 | |
| 466 vmax.u8 d23, d23, d24 ; m3 = max(m5, m6) | |
| 467 | |
| 468 vabd.u8 d26, d7, d17 ; m8 = abs(q0 - q2) | |
| 469 | |
| 470 vmax.u8 d19, d19, d20 | |
| 471 | |
| 472 vabd.u8 d24, d6, d7 ; m9 = abs(p0 - q0) | |
| 473 vabd.u8 d27, d3, d6 ; m10 = abs(p3 - p0) | |
| 474 vabd.u8 d28, d18, d7 ; m11 = abs(q3 - q0) | |
| 475 | |
| 476 vmax.u8 d19, d19, d23 | |
| 477 | |
| 478 vabd.u8 d23, d5, d16 ; a = abs(p1 - q1) | |
| 479 vqadd.u8 d24, d24, d24 ; b = abs(p0 - q0) * 2 | |
| 480 | |
| 481 ; abs () > limit | |
| 482 vcge.u8 d19, d1, d19 | |
| 483 | |
| 484 ; only compare the largest value to thresh | |
| 485 vmax.u8 d25, d25, d26 ; m4 = max(m7, m8) | |
| 486 vmax.u8 d26, d27, d28 ; m5 = max(m10, m11) | |
| 487 | |
| 488 vshr.u8 d23, d23, #1 ; a = a / 2 | |
| 489 | |
| 490 vmax.u8 d25, d25, d26 ; m4 = max(m4, m5) | |
| 491 | |
| 492 vqadd.u8 d24, d24, d23 ; a = b + a | |
| 493 | |
| 494 vmax.u8 d20, d20, d25 ; m2 = max(m2, m4) | |
| 495 | |
| 496 vmov.u8 d23, #1 | |
| 497 vcge.u8 d24, d0, d24 ; a > blimit | |
| 498 | |
| 499 vcgt.u8 d21, d21, d2 ; (abs(p1 - p0) > thresh)*-1 | |
| 500 | |
| 501 vcge.u8 d20, d23, d20 ; flat | |
| 502 | |
| 503 vand d19, d19, d24 ; mask | |
| 504 | |
| 505 vcgt.u8 d23, d22, d2 ; (abs(q1 - q0) > thresh)*-1 | |
| 506 | |
| 507 vand d20, d20, d19 ; flat & mask | |
| 508 | |
| 509 vmov.u8 d22, #0x80 | |
| 510 | |
| 511 vorr d23, d21, d23 ; hev | |
| 512 | |
| 513 ; This instruction will truncate the "flat & mask" masks down to 4 bits | |
| 514 ; each to fit into one 32 bit arm register. The values are stored in | |
| 515 ; q10.64[0]. | |
| 516 vshrn.u16 d30, q10, #4 | |
| 517 vmov.u32 r4, d30[0] ; flat & mask 4bits | |
| 518 | |
| 519 adds r5, r4, #1 ; Check for all 1's | |
| 520 | |
| 521 ; If mask and flat are 1's for all vectors, then we only need to execute | |
| 522 ; the power branch for all vectors. | |
| 523 beq power_branch_only | |
| 524 | |
| 525 cmp r4, #0 ; Check for 0, set flag for later | |
| 526 | |
| 527 ; mbfilter() function | |
| 528 ; filter() function | |
| 529 ; convert to signed | |
| 530 veor d21, d7, d22 ; qs0 | |
| 531 veor d24, d6, d22 ; ps0 | |
| 532 veor d25, d5, d22 ; ps1 | |
| 533 veor d26, d16, d22 ; qs1 | |
| 534 | |
| 535 vmov.u8 d27, #3 | |
| 536 | |
| 537 vsub.s8 d28, d21, d24 ; ( qs0 - ps0) | |
| 538 | |
| 539 vqsub.s8 d29, d25, d26 ; filter = clamp(ps1-qs1) | |
| 540 | |
| 541 vmull.s8 q15, d28, d27 ; 3 * ( qs0 - ps0) | |
| 542 | |
| 543 vand d29, d29, d23 ; filter &= hev | |
| 544 | |
| 545 vaddw.s8 q15, q15, d29 ; filter + 3 * (qs0 - ps0) | |
| 546 | |
| 547 vmov.u8 d29, #4 | |
| 548 | |
| 549 ; filter = clamp(filter + 3 * ( qs0 - ps0)) | |
| 550 vqmovn.s16 d28, q15 | |
| 551 | |
| 552 vand d28, d28, d19 ; filter &= mask | |
| 553 | |
| 554 vqadd.s8 d30, d28, d27 ; filter2 = clamp(filter+3) | |
| 555 vqadd.s8 d29, d28, d29 ; filter1 = clamp(filter+4) | |
| 556 vshr.s8 d30, d30, #3 ; filter2 >>= 3 | |
| 557 vshr.s8 d29, d29, #3 ; filter1 >>= 3 | |
| 558 | |
| 559 vqadd.s8 d24, d24, d30 ; op0 = clamp(ps0 + filter2) | |
| 560 vqsub.s8 d21, d21, d29 ; oq0 = clamp(qs0 - filter1) | |
| 561 | |
| 562 ; outer tap adjustments: ++filter1 >> 1 | |
| 563 vrshr.s8 d29, d29, #1 | |
| 564 vbic d29, d29, d23 ; filter &= ~hev | |
| 565 | |
| 566 vqadd.s8 d25, d25, d29 ; op1 = clamp(ps1 + filter) | |
| 567 vqsub.s8 d26, d26, d29 ; oq1 = clamp(qs1 - filter) | |
| 568 | |
| 569 ; If mask and flat are 0's for all vectors, then we only need to execute | |
| 570 ; the filter branch for all vectors. | |
| 571 beq filter_branch_only | |
| 572 | |
| 573 ; If mask and flat are mixed then we must perform both branches and | |
| 574 ; combine the data. | |
| 575 veor d24, d24, d22 ; *f_op0 = u^0x80 | |
| 576 veor d21, d21, d22 ; *f_oq0 = u^0x80 | |
| 577 veor d25, d25, d22 ; *f_op1 = u^0x80 | |
| 578 veor d26, d26, d22 ; *f_oq1 = u^0x80 | |
| 579 | |
| 580 ; At this point we have already executed the filter branch. The filter | |
| 581 ; branch does not set op2 or oq2, so use p2 and q2. Execute the power | |
| 582 ; branch and combine the data. | |
| 583 vmov.u8 d23, #2 | |
| 584 vaddl.u8 q14, d6, d7 ; r_op2 = p0 + q0 | |
| 585 vmlal.u8 q14, d3, d27 ; r_op2 += p3 * 3 | |
| 586 vmlal.u8 q14, d4, d23 ; r_op2 += p2 * 2 | |
| 587 | |
| 588 vbif d0, d4, d20 ; op2 |= p2 & ~(flat & mask) | |
| 589 | |
| 590 vaddw.u8 q14, d5 ; r_op2 += p1 | |
| 591 | |
| 592 vbif d1, d25, d20 ; op1 |= f_op1 & ~(flat & mask) | |
| 593 | |
| 594 vqrshrn.u16 d30, q14, #3 ; r_op2 | |
| 595 | |
| 596 vsubw.u8 q14, d3 ; r_op1 = r_op2 - p3 | |
| 597 vsubw.u8 q14, d4 ; r_op1 -= p2 | |
| 598 vaddw.u8 q14, d5 ; r_op1 += p1 | |
| 599 vaddw.u8 q14, d16 ; r_op1 += q1 | |
| 600 | |
| 601 vbif d2, d24, d20 ; op0 |= f_op0 & ~(flat & mask) | |
| 602 | |
| 603 vqrshrn.u16 d31, q14, #3 ; r_op1 | |
| 604 | |
| 605 vsubw.u8 q14, d3 ; r_op0 = r_op1 - p3 | |
| 606 vsubw.u8 q14, d5 ; r_op0 -= p1 | |
| 607 vaddw.u8 q14, d6 ; r_op0 += p0 | |
| 608 vaddw.u8 q14, d17 ; r_op0 += q2 | |
| 609 | |
| 610 vbit d0, d30, d20 ; op2 |= r_op2 & (flat & mask) | |
| 611 | |
| 612 vqrshrn.u16 d23, q14, #3 ; r_op0 | |
| 613 | |
| 614 vsubw.u8 q14, d3 ; r_oq0 = r_op0 - p3 | |
| 615 vsubw.u8 q14, d6 ; r_oq0 -= p0 | |
| 616 vaddw.u8 q14, d7 ; r_oq0 += q0 | |
| 617 | |
| 618 vbit d1, d31, d20 ; op1 |= r_op1 & (flat & mask) | |
| 619 | |
| 620 vaddw.u8 q14, d18 ; oq0 += q3 | |
| 621 | |
| 622 vbit d2, d23, d20 ; op0 |= r_op0 & (flat & mask) | |
| 623 | |
| 624 vqrshrn.u16 d22, q14, #3 ; r_oq0 | |
| 625 | |
| 626 vsubw.u8 q14, d4 ; r_oq1 = r_oq0 - p2 | |
| 627 vsubw.u8 q14, d7 ; r_oq1 -= q0 | |
| 628 vaddw.u8 q14, d16 ; r_oq1 += q1 | |
| 629 | |
| 630 vbif d3, d21, d20 ; oq0 |= f_oq0 & ~(flat & mask) | |
| 631 | |
| 632 vaddw.u8 q14, d18 ; r_oq1 += q3 | |
| 633 | |
| 634 vbif d4, d26, d20 ; oq1 |= f_oq1 & ~(flat & mask) | |
| 635 | |
| 636 vqrshrn.u16 d6, q14, #3 ; r_oq1 | |
| 637 | |
| 638 vsubw.u8 q14, d5 ; r_oq2 = r_oq1 - p1 | |
| 639 vsubw.u8 q14, d16 ; r_oq2 -= q1 | |
| 640 vaddw.u8 q14, d17 ; r_oq2 += q2 | |
| 641 vaddw.u8 q14, d18 ; r_oq2 += q3 | |
| 642 | |
| 643 vbif d5, d17, d20 ; oq2 |= q2 & ~(flat & mask) | |
| 644 | |
| 645 vqrshrn.u16 d7, q14, #3 ; r_oq2 | |
| 646 | |
| 647 vbit d3, d22, d20 ; oq0 |= r_oq0 & (flat & mask) | |
| 648 vbit d4, d6, d20 ; oq1 |= r_oq1 & (flat & mask) | |
| 649 vbit d5, d7, d20 ; oq2 |= r_oq2 & (flat & mask) | |
| 650 | |
| 651 bx lr | |
| 652 | |
| 653 power_branch_only | |
| 654 vmov.u8 d27, #3 | |
| 655 vmov.u8 d21, #2 | |
| 656 vaddl.u8 q14, d6, d7 ; op2 = p0 + q0 | |
| 657 vmlal.u8 q14, d3, d27 ; op2 += p3 * 3 | |
| 658 vmlal.u8 q14, d4, d21 ; op2 += p2 * 2 | |
| 659 vaddw.u8 q14, d5 ; op2 += p1 | |
| 660 vqrshrn.u16 d0, q14, #3 ; op2 | |
| 661 | |
| 662 vsubw.u8 q14, d3 ; op1 = op2 - p3 | |
| 663 vsubw.u8 q14, d4 ; op1 -= p2 | |
| 664 vaddw.u8 q14, d5 ; op1 += p1 | |
| 665 vaddw.u8 q14, d16 ; op1 += q1 | |
| 666 vqrshrn.u16 d1, q14, #3 ; op1 | |
| 667 | |
| 668 vsubw.u8 q14, d3 ; op0 = op1 - p3 | |
| 669 vsubw.u8 q14, d5 ; op0 -= p1 | |
| 670 vaddw.u8 q14, d6 ; op0 += p0 | |
| 671 vaddw.u8 q14, d17 ; op0 += q2 | |
| 672 vqrshrn.u16 d2, q14, #3 ; op0 | |
| 673 | |
| 674 vsubw.u8 q14, d3 ; oq0 = op0 - p3 | |
| 675 vsubw.u8 q14, d6 ; oq0 -= p0 | |
| 676 vaddw.u8 q14, d7 ; oq0 += q0 | |
| 677 vaddw.u8 q14, d18 ; oq0 += q3 | |
| 678 vqrshrn.u16 d3, q14, #3 ; oq0 | |
| 679 | |
| 680 vsubw.u8 q14, d4 ; oq1 = oq0 - p2 | |
| 681 vsubw.u8 q14, d7 ; oq1 -= q0 | |
| 682 vaddw.u8 q14, d16 ; oq1 += q1 | |
| 683 vaddw.u8 q14, d18 ; oq1 += q3 | |
| 684 vqrshrn.u16 d4, q14, #3 ; oq1 | |
| 685 | |
| 686 vsubw.u8 q14, d5 ; oq2 = oq1 - p1 | |
| 687 vsubw.u8 q14, d16 ; oq2 -= q1 | |
| 688 vaddw.u8 q14, d17 ; oq2 += q2 | |
| 689 vaddw.u8 q14, d18 ; oq2 += q3 | |
| 690 vqrshrn.u16 d5, q14, #3 ; oq2 | |
| 691 | |
| 692 bx lr | |
| 693 | |
| 694 filter_branch_only | |
| 695 ; TODO(fgalligan): See if we can rearange registers so we do not need to | |
| 696 ; do the 2 vswp. | |
| 697 vswp d0, d4 ; op2 | |
| 698 vswp d5, d17 ; oq2 | |
| 699 veor d2, d24, d22 ; *op0 = u^0x80 | |
| 700 veor d3, d21, d22 ; *oq0 = u^0x80 | |
| 701 veor d1, d25, d22 ; *op1 = u^0x80 | |
| 702 veor d4, d26, d22 ; *oq1 = u^0x80 | |
| 703 | |
| 704 bx lr | |
| 705 | |
| 706 ENDP ; |vp9_mbloop_filter_neon| | |
| 707 | |
| 708 END | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 812033011:
libvpx: Pull from upstream (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/deps/third_party/libvpx/