git.sesse.net Git - ffmpeg/blob - libavcodec/arm/vc1dsp_neon.S

   1 /*
   2  * VC1 NEON optimisations
   3  *
   4  * Copyright (c) 2010 Rob Clark <rob@ti.com>
   5  * Copyright (c) 2011 Mans Rullgard <mans@mansr.com>
   6  *
   7  * This file is part of Libav.
   8  *
   9  * Libav is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * Libav is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with Libav; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 #include "libavutil/arm/asm.S"
  25 #include "neon.S"
  26
  27 #include "config.h"
  28
  29 @ Transpose rows into columns of a matrix of 16-bit elements. For 4x4, pass
  30 @ double-word registers, for 8x4, pass quad-word registers.
  31 .macro transpose16 r0, r1, r2, r3
  32         @ At this point:
  33         @   row[0]  r0
  34         @   row[1]  r1
  35         @   row[2]  r2
  36         @   row[3]  r3
  37
  38         vtrn.16         \r0,  \r1         @ first and second row
  39         vtrn.16         \r2,  \r3         @ third and fourth row
  40         vtrn.32         \r0,  \r2         @ first and third row
  41         vtrn.32         \r1,  \r3         @ second and fourth row
  42
  43         @ At this point, if registers are quad-word:
  44         @   column[0]   d0
  45         @   column[1]   d2
  46         @   column[2]   d4
  47         @   column[3]   d6
  48         @   column[4]   d1
  49         @   column[5]   d3
  50         @   column[6]   d5
  51         @   column[7]   d7
  52
  53         @ At this point, if registers are double-word:
  54         @   column[0]   d0
  55         @   column[1]   d1
  56         @   column[2]   d2
  57         @   column[3]   d3
  58 .endm
  59
  60 @ ff_vc1_inv_trans_{4,8}x{4,8}_neon and overflow: The input values in the file
  61 @ are supposed to be in a specific range as to allow for 16-bit math without
  62 @ causing overflows, but sometimes the input values are just big enough to
  63 @ barely cause overflow in vadd instructions like:
  64 @
  65 @   vadd.i16  q0, q8, q10
  66 @   vshr.s16  q0, q0, #\rshift
  67 @
  68 @ To prevent these borderline cases from overflowing, we just need one more
  69 @ bit of precision, which is accomplished by replacing the sequence above with:
  70 @
  71 @   vhadd.s16 q0, q8, q10
  72 @   vshr.s16  q0, q0, #(\rshift -1)
  73 @
  74 @ This works because vhadd is a single instruction that adds, then shifts to
  75 @ the right once, all before writing the result to the destination register.
  76 @
  77 @ Even with this workaround, there were still some files that caused overflows
  78 @ in ff_vc1_inv_trans_8x8_neon. See the comments in ff_vc1_inv_trans_8x8_neon
  79 @ for the additional workaround.
  80
  81 @ Takes 4 columns of 8 values each and operates on it. Modeled after the first
  82 @ for loop in vc1_inv_trans_4x8_c.
  83 @ Input columns: q0 q1 q2 q3
  84 @ Output columns: q0 q1 q2 q3
  85 @ Trashes: r12 q8 q9 q10 q11 q12 q13
  86 .macro vc1_inv_trans_4x8_helper add rshift
  87         @ Compute temp1, temp2 and setup scalar #17, #22, #10
  88         vadd.i16        q12,   q0,  q2              @ temp1 = src[0] + src[2]
  89         movw            r12,   #17
  90         vsub.i16        q13,   q0,  q2              @ temp2 = src[0] - src[2]
  91         movt            r12,   #22
  92         vmov.32         d0[0], r12
  93         movw            r12,   #10
  94         vmov.16         d1[0], r12
  95
  96         vmov.i16        q8,  #\add                  @ t1 will accumulate here
  97         vmov.i16        q9,  #\add                  @ t2 will accumulate here
  98
  99         vmul.i16        q10, q1,  d0[1]             @ t3 = 22 * (src[1])
 100         vmul.i16        q11, q3,  d0[1]             @ t4 = 22 * (src[3])
 101
 102         vmla.i16        q8,  q12, d0[0]             @ t1 = 17 * (temp1) + 4
 103         vmla.i16        q9,  q13, d0[0]             @ t2 = 17 * (temp2) + 4
 104
 105         vmla.i16        q10, q3,  d1[0]             @ t3 += 10 * src[3]
 106         vmls.i16        q11, q1,  d1[0]             @ t4 -= 10 * src[1]
 107
 108         vhadd.s16       q0,  q8,  q10               @ dst[0] = (t1 + t3) >> 1
 109         vhsub.s16       q3,  q8,  q10               @ dst[3] = (t1 - t3) >> 1
 110         vhsub.s16       q1,  q9,  q11               @ dst[1] = (t2 - t4) >> 1
 111         vhadd.s16       q2,  q9,  q11               @ dst[2] = (t2 + t4) >> 1
 112
 113         @ Halving add/sub above already did one shift
 114         vshr.s16        q0,  q0,  #(\rshift - 1)    @ dst[0] >>= (rshift - 1)
 115         vshr.s16        q3,  q3,  #(\rshift - 1)    @ dst[3] >>= (rshift - 1)
 116         vshr.s16        q1,  q1,  #(\rshift - 1)    @ dst[1] >>= (rshift - 1)
 117         vshr.s16        q2,  q2,  #(\rshift - 1)    @ dst[2] >>= (rshift - 1)
 118 .endm
 119
 120 @ Takes 8 columns of 4 values each and operates on it. Modeled after the second
 121 @ for loop in vc1_inv_trans_4x8_c.
 122 @ Input columns: d0 d2 d4 d6 d1 d3 d5 d7
 123 @ Output columns: d16 d17 d18 d19 d21 d20 d23 d22
 124 @ Trashes all NEON registers (and r12) except for: q4 q5 q6 q7
 125 .macro vc1_inv_trans_8x4_helper add add1beforeshift rshift
 126         @ At this point:
 127         @   src[0]      d0 overwritten later
 128         @   src[8]      d2
 129         @   src[16]     d4 overwritten later
 130         @   src[24]     d6
 131         @   src[32]     d1 overwritten later
 132         @   src[40]     d3
 133         @   src[48]     d5 overwritten later
 134         @   src[56]     d7
 135
 136         movw            r12,   #12
 137         vmov.i16        q14,   #\add            @ t1|t2 will accumulate here
 138         movt            r12,   #6
 139
 140         vadd.i16        d20,   d0,  d1          @ temp1 = src[0] + src[32]
 141         vsub.i16        d21,   d0,  d1          @ temp2 = src[0] - src[32]
 142         vmov.i32        d0[0], r12              @ 16-bit: d0[0] = #12, d0[1] = #6
 143
 144         vshl.i16        q15,   q2,  #4          @ t3|t4 = 16 * (src[16]|src[48])
 145         vswp            d4,    d5               @ q2 = src[48]|src[16]
 146         vmla.i16        q14,   q10, d0[0]       @ t1|t2 = 12 * (temp1|temp2) + 64
 147         movw            r12,   #15
 148         movt            r12,   #9
 149         vmov.i32        d0[1], r12              @ 16-bit: d0[2] = #15, d0[3] = #9
 150         vneg.s16        d31,   d31              @ t4 = -t4
 151         vmla.i16        q15,   q2,  d0[1]       @ t3|t4 += 6 * (src[48]|src[16])
 152
 153         @ At this point:
 154         @   d0[2]   #15
 155         @   d0[3]   #9
 156         @   q1      src[8]|src[40]
 157         @   q3      src[24]|src[56]
 158         @   q14     old t1|t2
 159         @   q15     old t3|t4
 160
 161         vshl.i16        q8,  q1,  #4            @ t1|t2 = 16 * (src[8]|src[40])
 162         vswp            d2,  d3                 @ q1 = src[40]|src[8]
 163         vshl.i16        q12, q3,  #4            @ temp3a|temp4a = 16 * src[24]|src[56]
 164         vswp            d6,  d7                 @ q3 = src[56]|src[24]
 165         vshl.i16        q13, q1,  #2            @ temp3b|temp4b = 4 * (src[40]|src[8])
 166         vshl.i16        q2,  q3,  #2            @ temp1|temp2 = 4 * (src[56]|src[24])
 167         vswp            d3,  d6                 @ q1 = src[40]|src[56], q3 = src[8]|src[24]
 168         vsub.i16        q9,  q13, q12           @ t3|t4 = - (temp3a|temp4a) + (temp3b|temp4b)
 169         vadd.i16        q8,  q8,  q2            @ t1|t2 += temp1|temp2
 170         vmul.i16        q12, q3,  d0[3]         @ temp3|temp4 = 9 * src[8]|src[24]
 171         vmla.i16        q8,  q1,  d0[3]         @ t1|t2 += 9 * (src[40]|src[56])
 172         vswp            d6,  d7                 @ q3 = src[24]|src[8]
 173         vswp            d2,  d3                 @ q1 = src[56]|src[40]
 174
 175         vsub.i16        q11, q14, q15           @ t8|t7 = old t1|t2 - old t3|t4
 176         vadd.i16        q10, q14, q15           @ t5|t6 = old t1|t2 + old t3|t4
 177   .if \add1beforeshift
 178         vmov.i16        q15, #1
 179   .endif
 180
 181         vadd.i16        d18, d18, d24           @ t3 += temp3
 182         vsub.i16        d19, d19, d25           @ t4 -= temp4
 183
 184         vswp            d22, d23                @ q11 = t7|t8
 185
 186         vneg.s16        d17, d17                @ t2 = -t2
 187         vmla.i16        q9,  q1,  d0[2]         @ t3|t4 += 15 * src[56]|src[40]
 188         vmla.i16        q8,  q3,  d0[2]         @ t1|t2 += 15 * src[24]|src[8]
 189
 190         @ At this point:
 191         @   t1  d16
 192         @   t2  d17
 193         @   t3  d18
 194         @   t4  d19
 195         @   t5  d20
 196         @   t6  d21
 197         @   t7  d22
 198         @   t8  d23
 199         @   #1  q15
 200
 201   .if \add1beforeshift
 202         vadd.i16        q3,  q15, q10           @ line[7,6] = t5|t6 + 1
 203         vadd.i16        q2,  q15, q11           @ line[5,4] = t7|t8 + 1
 204   .endif
 205
 206         @ Sometimes this overflows, so to get one additional bit of precision, use
 207         @ a single instruction that both adds and shifts right (halving).
 208         vhadd.s16       q1,  q9,  q11           @ line[2,3] = (t3|t4 + t7|t8) >> 1
 209         vhadd.s16       q0,  q8,  q10           @ line[0,1] = (t1|t2 + t5|t6) >> 1
 210   .if \add1beforeshift
 211         vhsub.s16       q2,  q2,  q9            @ line[5,4] = (t7|t8 - t3|t4 + 1) >> 1
 212         vhsub.s16       q3,  q3,  q8            @ line[7,6] = (t5|t6 - t1|t2 + 1) >> 1
 213   .else
 214         vhsub.s16       q2,  q11, q9            @ line[5,4] = (t7|t8 - t3|t4) >> 1
 215         vhsub.s16       q3,  q10, q8            @ line[7,6] = (t5|t6 - t1|t2) >> 1
 216   .endif
 217
 218         vshr.s16        q9,  q1,  #(\rshift - 1)    @ one shift is already done by vhadd/vhsub above
 219         vshr.s16        q8,  q0,  #(\rshift - 1)
 220         vshr.s16        q10, q2,  #(\rshift - 1)
 221         vshr.s16        q11, q3,  #(\rshift - 1)
 222
 223         @ At this point:
 224         @   dst[0]   d16
 225         @   dst[1]   d17
 226         @   dst[2]   d18
 227         @   dst[3]   d19
 228         @   dst[4]   d21
 229         @   dst[5]   d20
 230         @   dst[6]   d23
 231         @   dst[7]   d22
 232 .endm
 233
 234 @ This is modeled after the first and second for loop in vc1_inv_trans_8x8_c.
 235 @ Input columns:  q8, q9, q10, q11, q12, q13, q14, q15
 236 @ Output columns: q8, q9, q10, q11, q12, q13, q14, q15
 237 @ Trashes all NEON registers (and r12) except for: q4 q5 q6 q7
 238 .macro vc1_inv_trans_8x8_helper add add1beforeshift rshift
 239         @ This actually computes half of t1, t2, t3, t4, as explained below
 240         @ near `tNhalf`.
 241         vmov.i16        q0,    #(6 / 2)         @ q0 = #6/2
 242         vshl.i16        q1,    q10, #3          @ t3 = 16/2 * src[16]
 243         vshl.i16        q3,    q14, #3          @ temp4 = 16/2 * src[48]
 244         vmul.i16        q2,    q10, q0          @ t4 = 6/2 * src[16]
 245         vmla.i16        q1,    q14, q0          @ t3 += 6/2 * src[48]
 246         @ unused: q0, q10, q14
 247         vmov.i16        q0,    #(12 / 2)        @ q0 = #12/2
 248         vadd.i16        q10,   q8,  q12         @ temp1 = src[0] + src[32]
 249         vsub.i16        q14,   q8,  q12         @ temp2 = src[0] - src[32]
 250         @ unused: q8, q12
 251         vmov.i16        q8,    #(\add / 2)      @ t1 will accumulate here
 252         vmov.i16        q12,   #(\add / 2)      @ t2 will accumulate here
 253         movw            r12,   #15
 254         vsub.i16        q2,    q2,  q3          @ t4 = 6/2 * src[16] - 16/2 * src[48]
 255         movt            r12,   #9
 256         @ unused: q3
 257         vmla.i16        q8,    q10, q0          @ t1 = 12/2 * temp1 + add
 258         vmla.i16        q12,   q14, q0          @ t2 = 12/2 * temp2 + add
 259         vmov.i32        d0[0], r12
 260         @ unused: q3, q10, q14
 261
 262         @ At this point:
 263         @   q0          d0=#15|#9
 264         @   q1  old t3
 265         @   q2  old t4
 266         @   q3
 267         @   q8  old t1
 268         @   q9          src[8]
 269         @   q10
 270         @   q11         src[24]
 271         @   q12 old t2
 272         @   q13         src[40]
 273         @   q14
 274         @   q15         src[56]
 275
 276         @ unused: q3, q10, q14
 277         movw            r12,   #16
 278         vshl.i16        q3,    q9,  #4          @ t1 = 16 * src[8]
 279         movt            r12,   #4
 280         vshl.i16        q10,   q9,  #2          @ t4 = 4 * src[8]
 281         vmov.i32        d1[0], r12
 282         vmul.i16        q14,   q9,  d0[0]       @ t2 = 15 * src[8]
 283         vmul.i16        q9,    q9,  d0[1]       @ t3 = 9 * src[8]
 284         @ unused: none
 285         vmla.i16        q3,    q11, d0[0]       @ t1 += 15 * src[24]
 286         vmls.i16        q10,   q11, d0[1]       @ t4 -= 9 * src[24]
 287         vmls.i16        q14,   q11, d1[1]       @ t2 -= 4 * src[24]
 288         vmls.i16        q9,    q11, d1[0]       @ t3 -= 16 * src[24]
 289         @ unused: q11
 290         vmla.i16        q3,    q13, d0[1]       @ t1 += 9 * src[40]
 291         vmla.i16        q10,   q13, d0[0]       @ t4 += 15 * src[40]
 292         vmls.i16        q14,   q13, d1[0]       @ t2 -= 16 * src[40]
 293         vmla.i16        q9,    q13, d1[1]       @ t3 += 4 * src[40]
 294         @ unused: q11, q13
 295
 296         @ Compute t5, t6, t7, t8 from old t1, t2, t3, t4. Actually, it computes
 297         @ half of t5, t6, t7, t8 since t1, t2, t3, t4 are halved.
 298         vadd.i16        q11,   q8,  q1          @ t5 = t1 + t3
 299         vsub.i16        q1,    q8,  q1          @ t8 = t1 - t3
 300         vadd.i16        q13,   q12, q2          @ t6 = t2 + t4
 301         vsub.i16        q2,    q12, q2          @ t7 = t2 - t4
 302         @ unused: q8, q12
 303
 304   .if \add1beforeshift
 305         vmov.i16        q12,   #1
 306   .endif
 307
 308         @ unused: q8
 309         vmla.i16        q3,    q15, d1[1]       @ t1 += 4 * src[56]
 310         vmls.i16        q14,   q15, d0[1]       @ t2 -= 9 * src[56]
 311         vmla.i16        q9,    q15, d0[0]       @ t3 += 15 * src[56]
 312         vmls.i16        q10,   q15, d1[0]       @ t4 -= 16 * src[56]
 313         @ unused: q0, q8, q15
 314
 315         @ At this point:
 316         @   t1      q3
 317         @   t2      q14
 318         @   t3      q9
 319         @   t4      q10
 320         @   t5half  q11
 321         @   t6half  q13
 322         @   t7half  q2
 323         @   t8half  q1
 324         @   #1      q12
 325         @
 326         @ tNhalf is half of the value of tN (as described in vc1_inv_trans_8x8_c).
 327         @ This is done because sometimes files have input that causes tN + tM to
 328         @ overflow. To avoid this overflow, we compute tNhalf, then compute
 329         @ tNhalf + tM (which doesn't overflow), and then we use vhadd to compute
 330         @ (tNhalf + (tNhalf + tM)) >> 1 which does not overflow because it is
 331         @ one instruction.
 332
 333         @ For each pair of tN and tM, do:
 334         @   lineA = t5half + t1
 335         @   if add1beforeshift:  t1 -= 1
 336         @   lineA = (t5half + lineA) >> 1
 337         @   lineB = t5half - t1
 338         @   lineB = (t5half + lineB) >> 1
 339         @   lineA >>= rshift - 1
 340         @   lineB >>= rshift - 1
 341
 342         vadd.i16        q8,  q11, q3                @ q8 = t5half + t1
 343   .if \add1beforeshift
 344         vsub.i16        q3,  q3,  q12               @ q3 = t1 - 1
 345   .endif
 346
 347         vadd.i16        q0,  q13, q14               @ q0  = t6half + t2
 348   .if \add1beforeshift
 349         vsub.i16        q14, q14, q12               @ q14 = t2 - 1
 350   .endif
 351
 352         vadd.i16        q15, q2,  q9                @ q15 = t7half + t3
 353   .if \add1beforeshift
 354         vsub.i16        q9,  q9,  q12               @ q9  = t3 - 1
 355   .endif
 356         @ unused: none
 357
 358         vhadd.s16       q8,  q11, q8                @ q8  = (t5half + t5half + t1) >> 1
 359         vsub.i16        q3,  q11, q3                @ q3  = t5half - t1 + 1
 360
 361         vhadd.s16       q0,  q13, q0                @ q0  = (t6half + t6half + t2) >> 1
 362         vsub.i16        q14, q13, q14               @ q14 = t6half - t2 + 1
 363
 364         vhadd.s16       q15, q2,  q15               @ q15 = (t7half + t7half + t3) >> 1
 365         vsub.i16        q9,  q2,  q9                @ q9  = t7half - t3 + 1
 366
 367         vhadd.s16       q3,  q11, q3                @ q3  = (t5half + t5half - t1 + 1) >> 1
 368         @ unused: q11
 369
 370         vadd.i16        q11, q1,  q10               @ q11 = t8half + t4
 371   .if \add1beforeshift
 372         vsub.i16        q10, q10, q12               @ q10 = t4 - 1
 373   .endif
 374         @ unused: q12
 375
 376         vhadd.s16       q14, q13, q14               @ q14 = (t6half + t6half - t2 + 1) >> 1
 377         @ unused: q12, q13
 378         vhadd.s16       q13, q2,  q9                @ q9  = (t7half + t7half - t3 + 1) >> 1
 379         @ unused: q12, q2, q9
 380
 381         vsub.i16        q10, q1,  q10               @ q10 = t8half - t4 + 1
 382         vhadd.s16       q11, q1,  q11               @ q11 = (t8half + t8half + t4) >> 1
 383
 384         vshr.s16        q8,  q8,  #(\rshift - 1)    @ q8  = line[0]
 385         vhadd.s16       q12, q1,  q10               @ q12 = (t8half + t8half - t4 + 1) >> 1
 386         vshr.s16        q9,  q0,  #(\rshift - 1)    @ q9  = line[1]
 387         vshr.s16        q10, q15, #(\rshift - 1)    @ q10 = line[2]
 388         vshr.s16        q11, q11, #(\rshift - 1)    @ q11 = line[3]
 389         vshr.s16        q12, q12, #(\rshift - 1)    @ q12 = line[4]
 390         vshr.s16        q13, q13, #(\rshift - 1)    @ q13 = line[5]
 391         vshr.s16        q14, q14, #(\rshift - 1)    @ q14 = line[6]
 392         vshr.s16        q15, q3,  #(\rshift - 1)    @ q15 = line[7]
 393 .endm
 394
 395 @ (int16_t *block [r0])
 396 function ff_vc1_inv_trans_8x8_neon, export=1
 397         vld1.64         {q8-q9},   [r0,:128]!
 398         vld1.64         {q10-q11}, [r0,:128]!
 399         vld1.64         {q12-q13}, [r0,:128]!
 400         vld1.64         {q14-q15}, [r0,:128]
 401         sub             r0, r0, #(16 * 2 * 3)   @ restore r0
 402
 403         @ At this point:
 404         @   src[0]  q8
 405         @   src[8]  q9
 406         @   src[16] q10
 407         @   src[24] q11
 408         @   src[32] q12
 409         @   src[40] q13
 410         @   src[48] q14
 411         @   src[56] q15
 412
 413         vc1_inv_trans_8x8_helper add=4 add1beforeshift=0 rshift=3
 414
 415         @ Transpose result matrix of 8x8
 416         swap4           d17, d19, d21, d23, d24, d26, d28, d30
 417         transpose16_4x4 q8,  q9,  q10, q11, q12, q13, q14, q15
 418
 419         vc1_inv_trans_8x8_helper add=64 add1beforeshift=1 rshift=7
 420
 421         vst1.64         {q8-q9},   [r0,:128]!
 422         vst1.64         {q10-q11}, [r0,:128]!
 423         vst1.64         {q12-q13}, [r0,:128]!
 424         vst1.64         {q14-q15}, [r0,:128]
 425
 426         bx              lr
 427 endfunc
 428
 429 @ (uint8_t *dest [r0], int linesize [r1], int16_t *block [r2])
 430 function ff_vc1_inv_trans_8x4_neon, export=1
 431         vld1.64         {q0-q1}, [r2,:128]!     @ load 8 * 4 * 2 = 64 bytes / 16 bytes per quad = 4 quad registers
 432         vld1.64         {q2-q3}, [r2,:128]
 433
 434         transpose16     q0 q1 q2 q3             @ transpose rows to columns
 435
 436         @ At this point:
 437         @   src[0]   d0
 438         @   src[1]   d2
 439         @   src[2]   d4
 440         @   src[3]   d6
 441         @   src[4]   d1
 442         @   src[5]   d3
 443         @   src[6]   d5
 444         @   src[7]   d7
 445
 446         vc1_inv_trans_8x4_helper    add=4 add1beforeshift=0 rshift=3
 447
 448         @ Move output to more standardized registers
 449         vmov        d0, d16
 450         vmov        d2, d17
 451         vmov        d4, d18
 452         vmov        d6, d19
 453         vmov        d1, d21
 454         vmov        d3, d20
 455         vmov        d5, d23
 456         vmov        d7, d22
 457
 458         @ At this point:
 459         @   dst[0]   d0
 460         @   dst[1]   d2
 461         @   dst[2]   d4
 462         @   dst[3]   d6
 463         @   dst[4]   d1
 464         @   dst[5]   d3
 465         @   dst[6]   d5
 466         @   dst[7]   d7
 467
 468         transpose16     q0 q1 q2 q3   @ turn columns into rows
 469
 470         @ At this point:
 471         @   row[0] q0
 472         @   row[1] q1
 473         @   row[2] q2
 474         @   row[3] q3
 475
 476         vc1_inv_trans_4x8_helper    add=64 rshift=7
 477
 478         @ At this point:
 479         @   line[0].l   d0
 480         @   line[0].h   d1
 481         @   line[1].l   d2
 482         @   line[1].h   d3
 483         @   line[2].l   d4
 484         @   line[2].h   d5
 485         @   line[3].l   d6
 486         @   line[3].h   d7
 487
 488         @ unused registers: q12, q13, q14, q15
 489
 490         vld1.64         {d28}, [r0,:64], r1     @ read dest
 491         vld1.64         {d29}, [r0,:64], r1
 492         vld1.64         {d30}, [r0,:64], r1
 493         vld1.64         {d31}, [r0,:64], r1
 494         sub             r0,  r0,  r1, lsl #2    @ restore original r0 value
 495
 496         vaddw.u8        q0,  q0,  d28           @ line[0] += dest[0]
 497         vaddw.u8        q1,  q1,  d29           @ line[1] += dest[1]
 498         vaddw.u8        q2,  q2,  d30           @ line[2] += dest[2]
 499         vaddw.u8        q3,  q3,  d31           @ line[3] += dest[3]
 500
 501         vqmovun.s16     d0,  q0                 @ line[0]
 502         vqmovun.s16     d1,  q1                 @ line[1]
 503         vqmovun.s16     d2,  q2                 @ line[2]
 504         vqmovun.s16     d3,  q3                 @ line[3]
 505
 506         vst1.64         {d0},  [r0,:64], r1     @ write dest
 507         vst1.64         {d1},  [r0,:64], r1
 508         vst1.64         {d2},  [r0,:64], r1
 509         vst1.64         {d3},  [r0,:64]
 510
 511         bx              lr
 512 endfunc
 513
 514 @ (uint8_t *dest [r0], int linesize [r1], int16_t *block [r2])
 515 function ff_vc1_inv_trans_4x8_neon, export=1
 516         mov             r12, #(8 * 2)  @ 8 elements per line, each element 2 bytes
 517         vld4.16         {d0[],  d2[],  d4[],  d6[]},  [r2,:64], r12     @ read each column into a q register
 518         vld4.16         {d0[1], d2[1], d4[1], d6[1]}, [r2,:64], r12
 519         vld4.16         {d0[2], d2[2], d4[2], d6[2]}, [r2,:64], r12
 520         vld4.16         {d0[3], d2[3], d4[3], d6[3]}, [r2,:64], r12
 521         vld4.16         {d1[],  d3[],  d5[],  d7[]},  [r2,:64], r12
 522         vld4.16         {d1[1], d3[1], d5[1], d7[1]}, [r2,:64], r12
 523         vld4.16         {d1[2], d3[2], d5[2], d7[2]}, [r2,:64], r12
 524         vld4.16         {d1[3], d3[3], d5[3], d7[3]}, [r2,:64]
 525
 526         vc1_inv_trans_4x8_helper    add=4 rshift=3
 527
 528         @ At this point:
 529         @   dst[0] = q0
 530         @   dst[1] = q1
 531         @   dst[2] = q2
 532         @   dst[3] = q3
 533
 534         transpose16     q0 q1 q2 q3     @ Transpose rows (registers) into columns
 535
 536         vc1_inv_trans_8x4_helper    add=64 add1beforeshift=1 rshift=7
 537
 538         vld1.32         {d28[]},  [r0,:32], r1  @ read dest
 539         vld1.32         {d28[1]}, [r0,:32], r1
 540         vld1.32         {d29[]},  [r0,:32], r1
 541         vld1.32         {d29[1]}, [r0,:32], r1
 542
 543         vld1.32         {d30[]},  [r0,:32], r1
 544         vld1.32         {d30[0]}, [r0,:32], r1
 545         vld1.32         {d31[]},  [r0,:32], r1
 546         vld1.32         {d31[0]}, [r0,:32], r1
 547         sub             r0,  r0,  r1, lsl #3    @ restore original r0 value
 548
 549         vaddw.u8        q8,  q8,  d28           @ line[0,1] += dest[0,1]
 550         vaddw.u8        q9,  q9,  d29           @ line[2,3] += dest[2,3]
 551         vaddw.u8        q10, q10, d30           @ line[5,4] += dest[5,4]
 552         vaddw.u8        q11, q11, d31           @ line[7,6] += dest[7,6]
 553
 554         vqmovun.s16     d16, q8                 @ clip(line[0,1])
 555         vqmovun.s16     d18, q9                 @ clip(line[2,3])
 556         vqmovun.s16     d20, q10                @ clip(line[5,4])
 557         vqmovun.s16     d22, q11                @ clip(line[7,6])
 558
 559         vst1.32         {d16[0]}, [r0,:32], r1  @ write dest
 560         vst1.32         {d16[1]}, [r0,:32], r1
 561         vst1.32         {d18[0]}, [r0,:32], r1
 562         vst1.32         {d18[1]}, [r0,:32], r1
 563
 564         vst1.32         {d20[1]}, [r0,:32], r1
 565         vst1.32         {d20[0]}, [r0,:32], r1
 566         vst1.32         {d22[1]}, [r0,:32], r1
 567         vst1.32         {d22[0]}, [r0,:32]
 568
 569         bx              lr
 570 endfunc
 571
 572 @ Setup constants in registers which are used by vc1_inv_trans_4x4_helper
 573 .macro vc1_inv_trans_4x4_helper_setup
 574         vmov.i16        q13, #17
 575         vmov.i16        q14, #22
 576         vmov.i16        d30, #10                @ only need double-word, not quad-word
 577 .endm
 578
 579 @ This is modeled after the first for loop in vc1_inv_trans_4x4_c.
 580 .macro vc1_inv_trans_4x4_helper add rshift
 581         vmov.i16        q2,  #\add              @ t1|t2 will accumulate here
 582
 583         vadd.i16        d16, d0,  d1            @ temp1 = src[0] + src[2]
 584         vsub.i16        d17, d0,  d1            @ temp2 = src[0] - src[2]
 585         vmul.i16        q3,  q14, q1            @ t3|t4 = 22 * (src[1]|src[3])
 586         vmla.i16        q2,  q13, q8            @ t1|t2 = 17 * (temp1|temp2) + add
 587         vmla.i16        d6,  d30, d3            @ t3 += 10 * src[3]
 588         vmls.i16        d7,  d30, d2            @ t4 -= 10 * src[1]
 589
 590         vadd.i16        q0,  q2,  q3            @ dst[0,2] = (t1|t2 + t3|t4)
 591         vsub.i16        q1,  q2,  q3            @ dst[3,1] = (t1|t2 - t3|t4)
 592         vshr.s16        q0,  q0,  #\rshift      @ dst[0,2] >>= rshift
 593         vshr.s16        q1,  q1,  #\rshift      @ dst[3,1] >>= rshift
 594 .endm
 595
 596 @ (uint8_t *dest [r0], int linesize [r1], int16_t *block [r2])
 597 function ff_vc1_inv_trans_4x4_neon, export=1
 598         mov             r12, #(8 * 2)  @ 8 elements per line, each element 2 bytes
 599         vld4.16         {d0[],  d1[],  d2[],  d3[]},  [r2,:64], r12     @ read each column into a register
 600         vld4.16         {d0[1], d1[1], d2[1], d3[1]}, [r2,:64], r12
 601         vld4.16         {d0[2], d1[2], d2[2], d3[2]}, [r2,:64], r12
 602         vld4.16         {d0[3], d1[3], d2[3], d3[3]}, [r2,:64]
 603
 604         vswp            d1,  d2         @ so that we can later access column 1 and column 3 as a single q1 register
 605
 606         vc1_inv_trans_4x4_helper_setup
 607
 608         @ At this point:
 609         @   src[0] = d0
 610         @   src[1] = d2
 611         @   src[2] = d1
 612         @   src[3] = d3
 613
 614         vc1_inv_trans_4x4_helper add=4 rshift=3      @ compute t1, t2, t3, t4 and combine them into dst[0-3]
 615
 616         @ At this point:
 617         @   dst[0] = d0
 618         @   dst[1] = d3
 619         @   dst[2] = d1
 620         @   dst[3] = d2
 621
 622         transpose16     d0 d3 d1 d2     @ Transpose rows (registers) into columns
 623
 624         @ At this point:
 625         @   src[0]  = d0
 626         @   src[8]  = d3
 627         @   src[16] = d1
 628         @   src[24] = d2
 629
 630         vswp            d2,  d3         @ so that we can later access column 1 and column 3 in order as a single q1 register
 631
 632         @ At this point:
 633         @   src[0]  = d0
 634         @   src[8]  = d2
 635         @   src[16] = d1
 636         @   src[24] = d3
 637
 638         vc1_inv_trans_4x4_helper add=64 rshift=7              @ compute t1, t2, t3, t4 and combine them into dst[0-3]
 639
 640         @ At this point:
 641         @   line[0] = d0
 642         @   line[1] = d3
 643         @   line[2] = d1
 644         @   line[3] = d2
 645
 646         vld1.32         {d18[]},  [r0,:32], r1  @ read dest
 647         vld1.32         {d19[]},  [r0,:32], r1
 648         vld1.32         {d18[1]}, [r0,:32], r1
 649         vld1.32         {d19[0]}, [r0,:32], r1
 650         sub             r0,  r0,  r1, lsl #2    @ restore original r0 value
 651
 652         vaddw.u8        q0,  q0,  d18           @ line[0,2] += dest[0,2]
 653         vaddw.u8        q1,  q1,  d19           @ line[3,1] += dest[3,1]
 654
 655         vqmovun.s16     d0,  q0                 @ clip(line[0,2])
 656         vqmovun.s16     d1,  q1                 @ clip(line[3,1])
 657
 658         vst1.32         {d0[0]},  [r0,:32], r1  @ write dest
 659         vst1.32         {d1[1]},  [r0,:32], r1
 660         vst1.32         {d0[1]},  [r0,:32], r1
 661         vst1.32         {d1[0]},  [r0,:32]
 662
 663         bx              lr
 664 endfunc
 665
 666 #if HAVE_AS_DN_DIRECTIVE
 667 @ The absolute value of multiplication constants from vc1_mspel_filter and vc1_mspel_{ver,hor}_filter_16bits.
 668 @ The sign is embedded in the code below that carries out the multiplication (mspel_filter{,.16}).
 669 #define MSPEL_MODE_1_MUL_CONSTANTS  4 53 18 3
 670 #define MSPEL_MODE_2_MUL_CONSTANTS  1 9  9  1
 671 #define MSPEL_MODE_3_MUL_CONSTANTS  3 18 53 4
 672
 673 @ These constants are from reading the source code of vc1_mspel_mc and determining the value that
 674 @ is added to `rnd` to result in the variable `r`, and the value of the variable `shift`.
 675 #define MSPEL_MODES_11_ADDSHIFT_CONSTANTS   15 5
 676 #define MSPEL_MODES_12_ADDSHIFT_CONSTANTS   3  3
 677 #define MSPEL_MODES_13_ADDSHIFT_CONSTANTS   15 5
 678 #define MSPEL_MODES_21_ADDSHIFT_CONSTANTS   MSPEL_MODES_12_ADDSHIFT_CONSTANTS
 679 #define MSPEL_MODES_22_ADDSHIFT_CONSTANTS   0  1
 680 #define MSPEL_MODES_23_ADDSHIFT_CONSTANTS   3  3
 681 #define MSPEL_MODES_31_ADDSHIFT_CONSTANTS   MSPEL_MODES_13_ADDSHIFT_CONSTANTS
 682 #define MSPEL_MODES_32_ADDSHIFT_CONSTANTS   MSPEL_MODES_23_ADDSHIFT_CONSTANTS
 683 #define MSPEL_MODES_33_ADDSHIFT_CONSTANTS   15 5
 684
 685 @ The addition and shift constants from vc1_mspel_filter.
 686 #define MSPEL_MODE_1_ADDSHIFT_CONSTANTS     32 6
 687 #define MSPEL_MODE_2_ADDSHIFT_CONSTANTS     8  4
 688 #define MSPEL_MODE_3_ADDSHIFT_CONSTANTS     32 6
 689
 690 @ Setup constants in registers for a subsequent use of mspel_filter{,.16}.
 691 .macro mspel_constants typesize reg_a reg_b reg_c reg_d filter_a filter_b filter_c filter_d reg_add filter_add_register
 692   @ Define double-word register aliases. Typesize should be i8 or i16.
 693   ra .dn \reg_a\().\typesize
 694   rb .dn \reg_b\().\typesize
 695   rc .dn \reg_c\().\typesize
 696   rd .dn \reg_d\().\typesize
 697
 698   @ Only set the register if the value is not 1 and unique
 699   .if \filter_a != 1
 700         vmov            ra,  #\filter_a              @ ra = filter_a
 701   .endif
 702         vmov            rb,  #\filter_b              @ rb = filter_b
 703   .if \filter_b != \filter_c
 704         vmov            rc,  #\filter_c              @ rc = filter_c
 705   .endif
 706   .if \filter_d != 1
 707         vmov            rd,  #\filter_d              @ rd = filter_d
 708   .endif
 709   @ vdup to double the size of typesize
 710   .ifc \typesize,i8
 711         vdup.16         \reg_add,  \filter_add_register     @ reg_add = filter_add_register
 712   .else
 713         vdup.32         \reg_add,  \filter_add_register     @ reg_add = filter_add_register
 714   .endif
 715
 716   .unreq ra
 717   .unreq rb
 718   .unreq rc
 719   .unreq rd
 720 .endm
 721
 722 @ After mspel_constants has been used, do the filtering.
 723 .macro mspel_filter acc dest src0 src1 src2 src3 filter_a filter_b filter_c filter_d reg_a reg_b reg_c reg_d reg_add filter_shift narrow=1
 724   .if \filter_a != 1
 725         @ If filter_a != 1, then we need a move and subtract instruction
 726         vmov            \acc,  \reg_add                     @ acc = reg_add
 727         vmlsl.u8        \acc,  \reg_a,  \src0               @ acc -= filter_a * src[-stride]
 728   .else
 729         @ If filter_a is 1, then just subtract without an extra move
 730         vsubw.u8        \acc,  \reg_add,  \src0             @ acc = reg_add - src[-stride]      @ since filter_a == 1
 731   .endif
 732         vmlal.u8        \acc,  \reg_b,  \src1               @ acc += filter_b * src[0]
 733   .if \filter_b != \filter_c
 734         vmlal.u8        \acc,  \reg_c,  \src2               @ acc += filter_c * src[stride]
 735   .else
 736         @ If filter_b is the same as filter_c, use the same reg_b register
 737         vmlal.u8        \acc,  \reg_b,  \src2               @ acc += filter_c * src[stride]     @ where filter_c == filter_b
 738   .endif
 739   .if \filter_d != 1
 740         @ If filter_d != 1, then do a multiply accumulate
 741         vmlsl.u8        \acc,  \reg_d,  \src3               @ acc -= filter_d * src[stride * 2]
 742   .else
 743         @ If filter_d is 1, then just do a subtract
 744         vsubw.u8        \acc,  \acc,    \src3               @ acc -= src[stride * 2]            @ since filter_d == 1
 745   .endif
 746   .if \narrow
 747         vqshrun.s16     \dest, \acc,    #\filter_shift      @ dest = clip_uint8(acc >> filter_shift)
 748   .else
 749         vshr.s16        \dest, \acc,    #\filter_shift      @ dest = acc >> filter_shift
 750   .endif
 751 .endm
 752
 753 @ This is similar to mspel_filter, but the input is 16-bit instead of 8-bit and narrow=0 is not supported.
 754 .macro mspel_filter.16 acc0 acc1 acc0_0 acc0_1 dest src0 src1 src2 src3 src4 src5 src6 src7 filter_a filter_b filter_c filter_d reg_a reg_b reg_c reg_d reg_add filter_shift
 755   .if \filter_a != 1
 756         vmov            \acc0,  \reg_add
 757         vmov            \acc1,  \reg_add
 758         vmlsl.s16       \acc0,  \reg_a,  \src0
 759         vmlsl.s16       \acc1,  \reg_a,  \src1
 760   .else
 761         vsubw.s16       \acc0,  \reg_add,  \src0
 762         vsubw.s16       \acc1,  \reg_add,  \src1
 763   .endif
 764         vmlal.s16       \acc0,  \reg_b,  \src2
 765         vmlal.s16       \acc1,  \reg_b,  \src3
 766   .if \filter_b != \filter_c
 767         vmlal.s16       \acc0,  \reg_c,  \src4
 768         vmlal.s16       \acc1,  \reg_c,  \src5
 769   .else
 770         vmlal.s16       \acc0,  \reg_b,  \src4
 771         vmlal.s16       \acc1,  \reg_b,  \src5
 772   .endif
 773   .if \filter_d != 1
 774         vmlsl.s16       \acc0,  \reg_d,  \src6
 775         vmlsl.s16       \acc1,  \reg_d,  \src7
 776   .else
 777         vsubw.s16       \acc0,  \acc0,   \src6
 778         vsubw.s16       \acc1,  \acc1,   \src7
 779   .endif
 780         @ Use acc0_0 and acc0_1 as temp space
 781         vqshrun.s32     \acc0_0, \acc0,  #\filter_shift     @ Shift and narrow with saturation from s32 to u16
 782         vqshrun.s32     \acc0_1, \acc1,  #\filter_shift
 783         vqmovn.u16      \dest,  \acc0                       @ Narrow with saturation from u16 to u8
 784 .endm
 785
 786 @ Register usage for put_vc1_mspel_mc functions. Registers marked 'hv' are only used in put_vc1_mspel_mc_hv.
 787 @
 788 @   r0        adjusted dst
 789 @   r1        adjusted src
 790 @   r2        stride
 791 @   r3        adjusted rnd
 792 @   r4 [hv]   tmp
 793 @   r11 [hv]  sp saved
 794 @   r12       loop counter
 795 @   d0        src[-stride]
 796 @   d1        src[0]
 797 @   d2        src[stride]
 798 @   d3        src[stride * 2]
 799 @   q0 [hv]   src[-stride]
 800 @   q1 [hv]   src[0]
 801 @   q2 [hv]   src[stride]
 802 @   q3 [hv]   src[stride * 2]
 803 @   d21       often result from mspel_filter
 804 @   q11       accumulator 0
 805 @   q12 [hv]  accumulator 1
 806 @   q13       accumulator initial value
 807 @   d28       filter_a
 808 @   d29       filter_b
 809 @   d30       filter_c
 810 @   d31       filter_d
 811
 812 @ (uint8_t *dst [r0], const uint8_t *src [r1], ptrdiff_t stride [r2], int rnd [r3])
 813 .macro put_vc1_mspel_mc_hv hmode vmode filter_h_a filter_h_b filter_h_c filter_h_d filter_v_a filter_v_b filter_v_c filter_v_d filter_add filter_shift
 814 function ff_put_vc1_mspel_mc\hmode\()\vmode\()_neon, export=1
 815         push            {r4, r11, lr}
 816         mov             r11, sp                 @ r11 = stack pointer before realignmnet
 817 A       bic             sp,  sp,  #15           @ sp = round down to multiple of 16 bytes
 818 T       bic             r4,  r11, #15
 819 T       mov             sp,  r4
 820         sub             sp,  sp,  #(8*2*16)     @ make space for 8 rows * 2 byte per element * 16 elements per row (to fit 11 actual elements per row)
 821         mov             r4,  sp                 @ r4 = int16_t tmp[8 * 16]
 822
 823         sub             r1,  r1,  #1            @ src -= 1
 824   .if \filter_add != 0
 825         add             r3,  r3,  #\filter_add  @ r3 = filter_add + rnd
 826   .endif
 827         mov             r12, #8                 @ loop counter
 828         sub             r1,  r1,  r2            @ r1 = &src[-stride]      @ slide back
 829
 830         @ Do vertical filtering from src into tmp
 831         mspel_constants i8 d28 d29 d30 d31 \filter_v_a \filter_v_b \filter_v_c \filter_v_d q13 r3
 832
 833         vld1.64         {d0,d1}, [r1], r2
 834         vld1.64         {d2,d3}, [r1], r2
 835         vld1.64         {d4,d5}, [r1], r2
 836
 837 1:
 838         subs            r12,  r12,  #4
 839
 840         vld1.64         {d6,d7}, [r1], r2
 841         mspel_filter    q11 q11 d0 d2 d4 d6 \filter_v_a \filter_v_b \filter_v_c \filter_v_d d28 d29 d30 d31 q13 \filter_shift narrow=0
 842         mspel_filter    q12 q12 d1 d3 d5 d7 \filter_v_a \filter_v_b \filter_v_c \filter_v_d d28 d29 d30 d31 q13 \filter_shift narrow=0
 843         vst1.64         {q11,q12}, [r4,:128]!   @ store and increment
 844
 845         vld1.64         {d0,d1}, [r1], r2
 846         mspel_filter    q11 q11 d2 d4 d6 d0 \filter_v_a \filter_v_b \filter_v_c \filter_v_d d28 d29 d30 d31 q13 \filter_shift narrow=0
 847         mspel_filter    q12 q12 d3 d5 d7 d1 \filter_v_a \filter_v_b \filter_v_c \filter_v_d d28 d29 d30 d31 q13 \filter_shift narrow=0
 848         vst1.64         {q11,q12}, [r4,:128]!   @ store and increment
 849
 850         vld1.64         {d2,d3}, [r1], r2
 851         mspel_filter    q11 q11 d4 d6 d0 d2 \filter_v_a \filter_v_b \filter_v_c \filter_v_d d28 d29 d30 d31 q13 \filter_shift narrow=0
 852         mspel_filter    q12 q12 d5 d7 d1 d3 \filter_v_a \filter_v_b \filter_v_c \filter_v_d d28 d29 d30 d31 q13 \filter_shift narrow=0
 853         vst1.64         {q11,q12}, [r4,:128]!   @ store and increment
 854
 855         vld1.64         {d4,d5}, [r1], r2
 856         mspel_filter    q11 q11 d6 d0 d2 d4 \filter_v_a \filter_v_b \filter_v_c \filter_v_d d28 d29 d30 d31 q13 \filter_shift narrow=0
 857         mspel_filter    q12 q12 d7 d1 d3 d5 \filter_v_a \filter_v_b \filter_v_c \filter_v_d d28 d29 d30 d31 q13 \filter_shift narrow=0
 858         vst1.64         {q11,q12}, [r4,:128]!   @ store and increment
 859
 860         bne             1b
 861
 862         rsb             r3,   r3,  #(64 + \filter_add)      @ r3 = (64 + filter_add) - r3
 863         mov             r12,  #8                @ loop counter
 864         mov             r4,   sp                @ r4 = tmp
 865
 866         @ Do horizontal filtering from temp to dst
 867         mspel_constants i16 d28 d29 d30 d31 \filter_h_a \filter_h_b \filter_h_c \filter_h_d q13 r3
 868
 869 2:
 870         subs            r12,  r12,  #1
 871
 872         vld1.64         {q0,q1}, [r4,:128]!     @ read one line of tmp
 873         vext.16         q2,   q0,   q1,  #2
 874         vext.16         q3,   q0,   q1,  #3
 875         vext.16         q1,   q0,   q1,  #1     @ do last because it writes to q1 which is read by the other vext instructions
 876
 877         mspel_filter.16 q11 q12 d22 d23 d21 d0 d1 d2 d3 d4 d5 d6 d7 \filter_h_a \filter_h_b \filter_h_c \filter_h_d d28 d29 d30 d31 q13 7
 878
 879         vst1.64         {d21}, [r0,:64], r2     @ store and increment dst
 880
 881         bne             2b
 882
 883         mov             sp,  r11
 884         pop             {r4, r11, pc}
 885 endfunc
 886 .endm
 887
 888 @ Use C preprocessor and assembler macros to expand to functions for horizontal and vertical filtering.
 889 #define PUT_VC1_MSPEL_MC_HV(hmode, vmode)   \
 890     put_vc1_mspel_mc_hv hmode vmode \
 891         MSPEL_MODE_ ## hmode ## _MUL_CONSTANTS \
 892         MSPEL_MODE_ ## vmode ## _MUL_CONSTANTS \
 893         MSPEL_MODES_ ## hmode ## vmode ## _ADDSHIFT_CONSTANTS
 894
 895 PUT_VC1_MSPEL_MC_HV(1, 1)
 896 PUT_VC1_MSPEL_MC_HV(1, 2)
 897 PUT_VC1_MSPEL_MC_HV(1, 3)
 898 PUT_VC1_MSPEL_MC_HV(2, 1)
 899 PUT_VC1_MSPEL_MC_HV(2, 2)
 900 PUT_VC1_MSPEL_MC_HV(2, 3)
 901 PUT_VC1_MSPEL_MC_HV(3, 1)
 902 PUT_VC1_MSPEL_MC_HV(3, 2)
 903 PUT_VC1_MSPEL_MC_HV(3, 3)
 904
 905 #undef PUT_VC1_MSPEL_MC_HV
 906
 907 .macro  put_vc1_mspel_mc_h_only hmode filter_a filter_b filter_c filter_d filter_add filter_shift
 908 function ff_put_vc1_mspel_mc\hmode\()0_neon, export=1
 909         rsb             r3,   r3,   #\filter_add        @ r3 = filter_add - r = filter_add - rnd
 910         mov             r12,  #8                        @ loop counter
 911         sub             r1,   r1,   #1                  @ slide back, using immediate
 912
 913         mspel_constants i8 d28 d29 d30 d31 \filter_a \filter_b \filter_c \filter_d q13 r3
 914
 915 1:
 916         subs            r12,  r12,  #1
 917
 918         vld1.64         {d0,d1}, [r1], r2               @ read 16 bytes even though we only need 11, also src += stride
 919         vext.8          d2,   d0,   d1,  #2
 920         vext.8          d3,   d0,   d1,  #3
 921         vext.8          d1,   d0,   d1,  #1             @ do last because it writes to d1 which is read by the other vext instructions
 922
 923         mspel_filter    q11 d21 d0 d1 d2 d3 \filter_a \filter_b \filter_c \filter_d d28 d29 d30 d31 q13 \filter_shift
 924
 925         vst1.64         {d21}, [r0,:64], r2             @ store and increment dst
 926
 927         bne             1b
 928
 929         bx              lr
 930 endfunc
 931 .endm
 932
 933 @ Use C preprocessor and assembler macros to expand to functions for horizontal only filtering.
 934 #define PUT_VC1_MSPEL_MC_H_ONLY(hmode) \
 935         put_vc1_mspel_mc_h_only hmode MSPEL_MODE_ ## hmode ## _MUL_CONSTANTS MSPEL_MODE_ ## hmode ## _ADDSHIFT_CONSTANTS
 936
 937 PUT_VC1_MSPEL_MC_H_ONLY(1)
 938 PUT_VC1_MSPEL_MC_H_ONLY(2)
 939 PUT_VC1_MSPEL_MC_H_ONLY(3)
 940
 941 #undef PUT_VC1_MSPEL_MC_H_ONLY
 942
 943 @ (uint8_t *dst [r0], const uint8_t *src [r1], ptrdiff_t stride [r2], int rnd [r3])
 944 .macro put_vc1_mspel_mc_v_only vmode filter_a filter_b filter_c filter_d filter_add filter_shift
 945 function ff_put_vc1_mspel_mc0\vmode\()_neon, export=1
 946         add             r3,   r3,   #\filter_add - 1    @ r3 = filter_add - r = filter_add - (1 - rnd) = filter_add - 1 + rnd
 947         mov             r12,  #8                        @ loop counter
 948         sub             r1,   r1,   r2                  @ r1 = &src[-stride]      @ slide back
 949
 950         mspel_constants i8 d28 d29 d30 d31 \filter_a \filter_b \filter_c \filter_d q13 r3
 951
 952         vld1.64         {d0},  [r1], r2                 @ d0 = src[-stride]
 953         vld1.64         {d1},  [r1], r2                 @ d1 = src[0]
 954         vld1.64         {d2},  [r1], r2                 @ d2 = src[stride]
 955
 956 1:
 957         subs            r12,  r12,  #4
 958
 959         vld1.64         {d3},  [r1], r2                 @ d3 = src[stride * 2]
 960         mspel_filter    q11 d21 d0 d1 d2 d3 \filter_a \filter_b \filter_c \filter_d d28 d29 d30 d31 q13 \filter_shift
 961         vst1.64         {d21}, [r0,:64], r2             @ store and increment dst
 962
 963         vld1.64         {d0},  [r1], r2                 @ d0 = next line
 964         mspel_filter    q11 d21 d1 d2 d3 d0 \filter_a \filter_b \filter_c \filter_d d28 d29 d30 d31 q13 \filter_shift
 965         vst1.64         {d21}, [r0,:64], r2             @ store and increment dst
 966
 967         vld1.64         {d1},  [r1], r2                 @ d1 = next line
 968         mspel_filter    q11 d21 d2 d3 d0 d1 \filter_a \filter_b \filter_c \filter_d d28 d29 d30 d31 q13 \filter_shift
 969         vst1.64         {d21}, [r0,:64], r2             @ store and increment dst
 970
 971         vld1.64         {d2},  [r1], r2                 @ d2 = next line
 972         mspel_filter    q11 d21 d3 d0 d1 d2 \filter_a \filter_b \filter_c \filter_d d28 d29 d30 d31 q13 \filter_shift
 973         vst1.64         {d21}, [r0,:64], r2             @ store and increment dst
 974
 975         bne             1b
 976
 977         bx              lr
 978 endfunc
 979 .endm
 980
 981 @ Use C preprocessor and assembler macros to expand to functions for vertical only filtering.
 982 #define PUT_VC1_MSPEL_MC_V_ONLY(vmode) \
 983         put_vc1_mspel_mc_v_only vmode MSPEL_MODE_ ## vmode ## _MUL_CONSTANTS MSPEL_MODE_ ## vmode ## _ADDSHIFT_CONSTANTS
 984
 985 PUT_VC1_MSPEL_MC_V_ONLY(1)
 986 PUT_VC1_MSPEL_MC_V_ONLY(2)
 987 PUT_VC1_MSPEL_MC_V_ONLY(3)
 988
 989 #undef PUT_VC1_MSPEL_MC_V_ONLY
 990 #endif
 991
 992 function ff_put_pixels8x8_neon, export=1
 993         vld1.64         {d0}, [r1], r2
 994         vld1.64         {d1}, [r1], r2
 995         vld1.64         {d2}, [r1], r2
 996         vld1.64         {d3}, [r1], r2
 997         vld1.64         {d4}, [r1], r2
 998         vld1.64         {d5}, [r1], r2
 999         vld1.64         {d6}, [r1], r2
1000         vld1.64         {d7}, [r1]
1001         vst1.64         {d0}, [r0,:64], r2
1002         vst1.64         {d1}, [r0,:64], r2
1003         vst1.64         {d2}, [r0,:64], r2
1004         vst1.64         {d3}, [r0,:64], r2
1005         vst1.64         {d4}, [r0,:64], r2
1006         vst1.64         {d5}, [r0,:64], r2
1007         vst1.64         {d6}, [r0,:64], r2
1008         vst1.64         {d7}, [r0,:64]
1009         bx              lr
1010 endfunc
1011
1012 function ff_vc1_inv_trans_8x8_dc_neon, export=1
1013         ldrsh           r2, [r2]              @ int dc = block[0];
1014
1015         vld1.64         {d0},  [r0,:64], r1
1016         vld1.64         {d1},  [r0,:64], r1
1017         vld1.64         {d4},  [r0,:64], r1
1018         vld1.64         {d5},  [r0,:64], r1
1019
1020         add             r2, r2, r2, lsl #1    @ dc = (3 * dc +  1) >> 1;
1021         vld1.64         {d6},  [r0,:64], r1
1022         add             r2, r2, #1
1023         vld1.64         {d7},  [r0,:64], r1
1024         vld1.64         {d16}, [r0,:64], r1
1025         vld1.64         {d17}, [r0,:64], r1
1026         asr             r2, r2, #1
1027
1028         sub             r0,  r0,  r1, lsl #3  @ restore r0 to original value
1029
1030         add             r2, r2, r2, lsl #1    @ dc = (3 * dc + 16) >> 5;
1031         add             r2, r2, #16
1032         asr             r2, r2, #5
1033
1034         vdup.16         q1,  r2               @ dc
1035
1036         vaddw.u8        q9,   q1,  d0
1037         vaddw.u8        q10,  q1,  d1
1038         vaddw.u8        q11,  q1,  d4
1039         vaddw.u8        q12,  q1,  d5
1040         vqmovun.s16     d0,  q9
1041         vqmovun.s16     d1,  q10
1042         vqmovun.s16     d4,  q11
1043         vst1.64         {d0},  [r0,:64], r1
1044         vqmovun.s16     d5,  q12
1045         vst1.64         {d1},  [r0,:64], r1
1046         vaddw.u8        q13,  q1,  d6
1047         vst1.64         {d4},  [r0,:64], r1
1048         vaddw.u8        q14,  q1,  d7
1049         vst1.64         {d5},  [r0,:64], r1
1050         vaddw.u8        q15,  q1,  d16
1051         vaddw.u8        q1,   q1,  d17        @ this destroys q1
1052         vqmovun.s16     d6,  q13
1053         vqmovun.s16     d7,  q14
1054         vqmovun.s16     d16, q15
1055         vqmovun.s16     d17, q1
1056         vst1.64         {d6},  [r0,:64], r1
1057         vst1.64         {d7},  [r0,:64], r1
1058         vst1.64         {d16}, [r0,:64], r1
1059         vst1.64         {d17}, [r0,:64]
1060         bx              lr
1061 endfunc
1062
1063 function ff_vc1_inv_trans_8x4_dc_neon, export=1
1064         ldrsh           r2, [r2]              @ int dc = block[0];
1065
1066         vld1.64         {d0},  [r0,:64], r1
1067         vld1.64         {d1},  [r0,:64], r1
1068         vld1.64         {d4},  [r0,:64], r1
1069         vld1.64         {d5},  [r0,:64], r1
1070
1071         add             r2, r2, r2, lsl #1    @ dc = ( 3 * dc +  1) >> 1;
1072
1073         sub             r0,  r0,  r1, lsl #2  @ restore r0 to original value
1074
1075         add             r2, r2, #1
1076         asr             r2, r2, #1
1077
1078         add             r2, r2, r2, lsl #4    @ dc = (17 * dc + 64) >> 7;
1079         add             r2, r2, #64
1080         asr             r2, r2, #7
1081
1082         vdup.16         q1,  r2               @ dc
1083
1084         vaddw.u8        q3,  q1,  d0
1085         vaddw.u8        q8,  q1,  d1
1086         vaddw.u8        q9,  q1,  d4
1087         vaddw.u8        q10, q1,  d5
1088         vqmovun.s16     d0,  q3
1089         vqmovun.s16     d1,  q8
1090         vqmovun.s16     d4,  q9
1091         vst1.64         {d0},  [r0,:64], r1
1092         vqmovun.s16     d5,  q10
1093         vst1.64         {d1},  [r0,:64], r1
1094         vst1.64         {d4},  [r0,:64], r1
1095         vst1.64         {d5},  [r0,:64]
1096         bx              lr
1097 endfunc
1098
1099 function ff_vc1_inv_trans_4x8_dc_neon, export=1
1100         ldrsh           r2, [r2]              @ int dc = block[0];
1101
1102         vld1.32         {d0[]},   [r0,:32], r1
1103         vld1.32         {d1[]},   [r0,:32], r1
1104         vld1.32         {d0[1]},  [r0,:32], r1
1105         vld1.32         {d1[1]},  [r0,:32], r1
1106
1107         add             r2, r2, r2, lsl #4    @ dc = (17 * dc +  4) >> 3;
1108         vld1.32         {d4[]},   [r0,:32], r1
1109         add             r2, r2, #4
1110         vld1.32         {d5[]},   [r0,:32], r1
1111         vld1.32         {d4[1]},  [r0,:32], r1
1112         asr             r2, r2, #3
1113         vld1.32         {d5[1]},  [r0,:32], r1
1114
1115         add             r2, r2, r2, lsl #1    @ dc = (12 * dc + 64) >> 7;
1116
1117         sub             r0,  r0,  r1, lsl #3  @ restore r0 to original value
1118
1119         lsl             r2, r2, #2
1120         add             r2, r2, #64
1121         asr             r2, r2, #7
1122
1123         vdup.16         q1,  r2               @ dc
1124
1125         vaddw.u8        q3,  q1,  d0
1126         vaddw.u8        q8,  q1,  d1
1127         vaddw.u8        q9,  q1,  d4
1128         vaddw.u8        q10, q1,  d5
1129         vqmovun.s16     d0,  q3
1130         vst1.32         {d0[0]},  [r0,:32], r1
1131         vqmovun.s16     d1,  q8
1132         vst1.32         {d1[0]},  [r0,:32], r1
1133         vqmovun.s16     d4,  q9
1134         vst1.32         {d0[1]},  [r0,:32], r1
1135         vqmovun.s16     d5,  q10
1136         vst1.32         {d1[1]},  [r0,:32], r1
1137         vst1.32         {d4[0]},  [r0,:32], r1
1138         vst1.32         {d5[0]},  [r0,:32], r1
1139         vst1.32         {d4[1]},  [r0,:32], r1
1140         vst1.32         {d5[1]},  [r0,:32]
1141         bx              lr
1142 endfunc
1143
1144 function ff_vc1_inv_trans_4x4_dc_neon, export=1
1145         ldrsh           r2, [r2]              @ int dc = block[0];
1146
1147         vld1.32         {d0[]},   [r0,:32], r1
1148         vld1.32         {d1[]},   [r0,:32], r1
1149         vld1.32         {d0[1]},  [r0,:32], r1
1150         vld1.32         {d1[1]},  [r0,:32], r1
1151
1152         add             r2, r2, r2, lsl #4    @ dc = (17 * dc +  4) >> 3;
1153
1154         sub             r0,  r0,  r1, lsl #2  @ restore r0 to original value
1155
1156         add             r2, r2, #4
1157         asr             r2, r2, #3
1158
1159         add             r2, r2, r2, lsl #4    @ dc = (17 * dc + 64) >> 7;
1160         add             r2, r2, #64
1161         asr             r2, r2, #7
1162
1163         vdup.16         q1,  r2               @ dc
1164
1165         vaddw.u8        q2,  q1,  d0
1166         vaddw.u8        q3,  q1,  d1
1167         vqmovun.s16     d0,  q2
1168         vst1.32         {d0[0]},  [r0,:32], r1
1169         vqmovun.s16     d1,  q3
1170         vst1.32         {d1[0]},  [r0,:32], r1
1171         vst1.32         {d0[1]},  [r0,:32], r1
1172         vst1.32         {d1[1]},  [r0,:32]
1173         bx              lr
1174 endfunc