libvpx: Pull from upstream

source/libvpx/vpx_dsp/arm/idct16x16_add_neon.asm

 ;
 ;  Copyright (c) 2013 The WebM project authors. All Rights Reserved.
 ;
 ;  Use of this source code is governed by a BSD-style license
 ;  that can be found in the LICENSE file in the root of the source
 ;  tree. An additional intellectual property rights grant can be found
 ;  in the file PATENTS.  All contributing project authors may
 ;  be found in the AUTHORS file in the root of the source tree.
 ;
 
-    EXPORT  |vp9_idct16x16_256_add_neon_pass1|
-    EXPORT  |vp9_idct16x16_256_add_neon_pass2|
-    EXPORT  |vp9_idct16x16_10_add_neon_pass1|
-    EXPORT  |vp9_idct16x16_10_add_neon_pass2|
+    EXPORT  |vpx_idct16x16_256_add_neon_pass1|
+    EXPORT  |vpx_idct16x16_256_add_neon_pass2|
+    EXPORT  |vpx_idct16x16_10_add_neon_pass1|
+    EXPORT  |vpx_idct16x16_10_add_neon_pass2|
     ARM
     REQUIRE8
     PRESERVE8
 
     AREA ||.text||, CODE, READONLY, ALIGN=2
 
     ; Transpose a 8x8 16bit data matrix. Datas are loaded in q8-q15.
     MACRO
     TRANSPOSE8X8
     vswp            d17, d24
     vswp            d23, d30
     vswp            d21, d28
     vswp            d19, d26
     vtrn.32         q8, q10
     vtrn.32         q9, q11
     vtrn.32         q12, q14
     vtrn.32         q13, q15
     vtrn.16         q8, q9
     vtrn.16         q10, q11
     vtrn.16         q12, q13
     vtrn.16         q14, q15
     MEND
 
     AREA    Block, CODE, READONLY ; name this block of code
-;void |vp9_idct16x16_256_add_neon_pass1|(int16_t *input,
+;void |vpx_idct16x16_256_add_neon_pass1|(int16_t *input,
 ;                                          int16_t *output, int output_stride)
 ;
 ; r0  int16_t input
 ; r1  int16_t *output
 ; r2  int  output_stride)
 
 ; idct16 stage1 - stage6 on all the elements loaded in q8-q15. The output
 ; will be stored back into q8-q15 registers. This function will touch q0-q7
 ; registers and use them as buffer during calculation.
-|vp9_idct16x16_256_add_neon_pass1| PROC
+|vpx_idct16x16_256_add_neon_pass1| PROC
 
     ; TODO(hkuang): Find a better way to load the elements.
     ; load elements of 0, 2, 4, 6, 8, 10, 12, 14 into q8 - q15
     vld2.s16        {q8,q9}, [r0]!
     vld2.s16        {q9,q10}, [r0]!
     vld2.s16        {q10,q11}, [r0]!
     vld2.s16        {q11,q12}, [r0]!
     vld2.s16        {q12,q13}, [r0]!
     vld2.s16        {q13,q14}, [r0]!
     vld2.s16        {q14,q15}, [r0]!
@@ skipping 206 matching lines @@
     vst1.64         {d24}, [r1], r2
     vst1.64         {d25}, [r1], r2
     vst1.64         {d26}, [r1], r2
     vst1.64         {d27}, [r1], r2
     vst1.64         {d28}, [r1], r2
     vst1.64         {d29}, [r1], r2
     vst1.64         {d30}, [r1], r2
     vst1.64         {d31}, [r1], r2
 
     bx              lr
-    ENDP  ; |vp9_idct16x16_256_add_neon_pass1|
+    ENDP  ; |vpx_idct16x16_256_add_neon_pass1|
 
-;void vp9_idct16x16_256_add_neon_pass2(int16_t *src,
+;void vpx_idct16x16_256_add_neon_pass2(int16_t *src,
 ;                                        int16_t *output,
 ;                                        int16_t *pass1Output,
 ;                                        int16_t skip_adding,
 ;                                        uint8_t *dest,
 ;                                        int dest_stride)
 ;
 ; r0  int16_t *src
 ; r1  int16_t *output,
 ; r2  int16_t *pass1Output,
 ; r3  int16_t skip_adding,
 ; r4  uint8_t *dest,
 ; r5  int dest_stride)
 
 ; idct16 stage1 - stage7 on all the elements loaded in q8-q15. The output
 ; will be stored back into q8-q15 registers. This function will touch q0-q7
 ; registers and use them as buffer during calculation.
-|vp9_idct16x16_256_add_neon_pass2| PROC
+|vpx_idct16x16_256_add_neon_pass2| PROC
     push            {r3-r9}
 
     ; TODO(hkuang): Find a better way to load the elements.
     ; load elements of 1, 3, 5, 7, 9, 11, 13, 15 into q8 - q15
     vld2.s16        {q8,q9}, [r0]!
     vld2.s16        {q9,q10}, [r0]!
     vld2.s16        {q10,q11}, [r0]!
     vld2.s16        {q11,q12}, [r0]!
     vld2.s16        {q12,q13}, [r0]!
     vld2.s16        {q13,q14}, [r0]!
@@ skipping 471 matching lines @@
     vst1.64         {d9}, [r1], r5
     vst1.64         {d10}, [r1], r3
     vst1.64         {d11}, [r1], r5
     vst1.64         {d28}, [r1], r3
     vst1.64         {d29}, [r1], r5
     vst1.64         {d30}, [r1], r3
     vst1.64         {d31}, [r1], r5
 end_idct16x16_pass2
     pop             {r3-r9}
     bx              lr
-    ENDP  ; |vp9_idct16x16_256_add_neon_pass2|
+    ENDP  ; |vpx_idct16x16_256_add_neon_pass2|
 
-;void |vp9_idct16x16_10_add_neon_pass1|(int16_t *input,
+;void |vpx_idct16x16_10_add_neon_pass1|(int16_t *input,
 ;                                             int16_t *output, int output_stride)
 ;
 ; r0  int16_t input
 ; r1  int16_t *output
 ; r2  int  output_stride)
 
 ; idct16 stage1 - stage6 on all the elements loaded in q8-q15. The output
 ; will be stored back into q8-q15 registers. This function will touch q0-q7
 ; registers and use them as buffer during calculation.
-|vp9_idct16x16_10_add_neon_pass1| PROC
+|vpx_idct16x16_10_add_neon_pass1| PROC
 
     ; TODO(hkuang): Find a better way to load the elements.
     ; load elements of 0, 2, 4, 6, 8, 10, 12, 14 into q8 - q15
     vld2.s16        {q8,q9}, [r0]!
     vld2.s16        {q9,q10}, [r0]!
     vld2.s16        {q10,q11}, [r0]!
     vld2.s16        {q11,q12}, [r0]!
     vld2.s16        {q12,q13}, [r0]!
     vld2.s16        {q13,q14}, [r0]!
     vld2.s16        {q14,q15}, [r0]!
@@ skipping 88 matching lines @@
     vst1.64         {d24}, [r1], r2
     vst1.64         {d25}, [r1], r2
     vst1.64         {d26}, [r1], r2
     vst1.64         {d27}, [r1], r2
     vst1.64         {d28}, [r1], r2
     vst1.64         {d29}, [r1], r2
     vst1.64         {d30}, [r1], r2
     vst1.64         {d31}, [r1], r2
 
     bx              lr
-    ENDP  ; |vp9_idct16x16_10_add_neon_pass1|
+    ENDP  ; |vpx_idct16x16_10_add_neon_pass1|
 
-;void vp9_idct16x16_10_add_neon_pass2(int16_t *src,
+;void vpx_idct16x16_10_add_neon_pass2(int16_t *src,
 ;                                           int16_t *output,
 ;                                           int16_t *pass1Output,
 ;                                           int16_t skip_adding,
 ;                                           uint8_t *dest,
 ;                                           int dest_stride)
 ;
 ; r0  int16_t *src
 ; r1  int16_t *output,
 ; r2  int16_t *pass1Output,
 ; r3  int16_t skip_adding,
 ; r4  uint8_t *dest,
 ; r5  int dest_stride)
 
 ; idct16 stage1 - stage7 on all the elements loaded in q8-q15. The output
 ; will be stored back into q8-q15 registers. This function will touch q0-q7
 ; registers and use them as buffer during calculation.
-|vp9_idct16x16_10_add_neon_pass2| PROC
+|vpx_idct16x16_10_add_neon_pass2| PROC
     push            {r3-r9}
 
     ; TODO(hkuang): Find a better way to load the elements.
     ; load elements of 1, 3, 5, 7, 9, 11, 13, 15 into q8 - q15
     vld2.s16        {q8,q9}, [r0]!
     vld2.s16        {q9,q10}, [r0]!
     vld2.s16        {q10,q11}, [r0]!
     vld2.s16        {q11,q12}, [r0]!
     vld2.s16        {q12,q13}, [r0]!
     vld2.s16        {q13,q14}, [r0]!
@@ skipping 230 matching lines @@
     vst1.64         {d9}, [r1], r5
     vst1.64         {d10}, [r1], r3
     vst1.64         {d11}, [r1], r5
     vst1.64         {d28}, [r1], r3
     vst1.64         {d29}, [r1], r5
     vst1.64         {d30}, [r1], r3
     vst1.64         {d31}, [r1], r5
 end_idct10_16x16_pass2
     pop             {r3-r9}
     bx              lr
-    ENDP  ; |vp9_idct16x16_10_add_neon_pass2|
+    ENDP  ; |vpx_idct16x16_10_add_neon_pass2|
     END