[FFmpeg-cvslog] swresample/arm: cosmetic fixes

Matthieu Bouron git at videolan.org
Fri Jan 13 22:26:19 EET 2017


ffmpeg | branch: master | Matthieu Bouron <matthieu.bouron at gmail.com> | Mon Jan  9 17:22:40 2017 +0100| [e109c54a697b6cbd2a5b27cb9e8df2729e73351c] | committer: Matthieu Bouron

swresample/arm: cosmetic fixes

> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=e109c54a697b6cbd2a5b27cb9e8df2729e73351c
---

 libswresample/arm/resample.S      | 32 ++++++++++++++++----------------
 libswresample/arm/resample_init.c | 12 ++++++------
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/libswresample/arm/resample.S b/libswresample/arm/resample.S
index c231301..3ce7623 100644
--- a/libswresample/arm/resample.S
+++ b/libswresample/arm/resample.S
@@ -22,9 +22,9 @@
 
 function ff_resample_common_apply_filter_x4_float_neon, export=1
     vmov.f32            q0, #0.0                                       @ accumulator
-1:  vld1.32             {q1}, [r1]!                                    @ src
-    vld1.32             {q2}, [r2]!                                    @ filter
-    vmla.f32            q0, q1, q2                                     @ accumulator += src + {0..3} * filter + {0..3}
+1:  vld1.32             {q1}, [r1]!                                    @ src[0..3]
+    vld1.32             {q2}, [r2]!                                    @ filter[0..3]
+    vmla.f32            q0, q1, q2                                     @ accumulator += src[0..3] * filter[0..3]
     subs                r3, #4                                         @ filter_length -= 4
     bgt                 1b                                             @ loop until filter_length
     vpadd.f32           d0, d0, d1                                     @ pair adding of the 4x32-bit accumulated values
@@ -35,12 +35,12 @@ endfunc
 
 function ff_resample_common_apply_filter_x8_float_neon, export=1
     vmov.f32            q0, #0.0                                       @ accumulator
-1:  vld1.32             {q1}, [r1]!                                    @ src
-    vld1.32             {q2}, [r2]!                                    @ filter
-    vld1.32             {q8}, [r1]!                                    @ src
-    vld1.32             {q9}, [r2]!                                    @ filter
-    vmla.f32            q0, q1, q2                                     @ accumulator += src + {0..3} * filter + {0..3}
-    vmla.f32            q0, q8, q9                                     @ accumulator += src + {4..7} * filter + {4..7}
+1:  vld1.32             {q1}, [r1]!                                    @ src[0..3]
+    vld1.32             {q2}, [r2]!                                    @ filter[0..3]
+    vld1.32             {q8}, [r1]!                                    @ src[4..7]
+    vld1.32             {q9}, [r2]!                                    @ filter[4..7]
+    vmla.f32            q0, q1, q2                                     @ accumulator += src[0..3] * filter[0..3]
+    vmla.f32            q0, q8, q9                                     @ accumulator += src[4..7] * filter[4..7]
     subs                r3, #8                                         @ filter_length -= 8
     bgt                 1b                                             @ loop until filter_length
     vpadd.f32           d0, d0, d1                                     @ pair adding of the 4x32-bit accumulated values
@@ -51,9 +51,9 @@ endfunc
 
 function ff_resample_common_apply_filter_x4_s16_neon, export=1
     vmov.s32            q0, #0                                         @ accumulator
-1:  vld1.16             {d2}, [r1]!                                    @ src
-    vld1.16             {d4}, [r2]!                                    @ filter
-    vmlal.s16           q0, d2, d4                                     @ accumulator += src + {0..3} * filter + {0..3}
+1:  vld1.16             {d2}, [r1]!                                    @ src[0..3]
+    vld1.16             {d4}, [r2]!                                    @ filter[0..3]
+    vmlal.s16           q0, d2, d4                                     @ accumulator += src[0..3] * filter[0..3]
     subs                r3, #4                                         @ filter_length -= 4
     bgt                 1b                                             @ loop until filter_length
     vpadd.s32           d0, d0, d1                                     @ pair adding of the 4x32-bit accumulated values
@@ -64,10 +64,10 @@ endfunc
 
 function ff_resample_common_apply_filter_x8_s16_neon, export=1
     vmov.s32            q0, #0                                         @ accumulator
-1:  vld1.16             {q1}, [r1]!                                    @ src
-    vld1.16             {q2}, [r2]!                                    @ filter
-    vmlal.s16           q0, d2, d4                                     @ accumulator += src + {0..3} * filter + {0..3}
-    vmlal.s16           q0, d3, d5                                     @ accumulator += src + {4..7} * filter + {4..7}
+1:  vld1.16             {q1}, [r1]!                                    @ src[0..7]
+    vld1.16             {q2}, [r2]!                                    @ filter[0..7]
+    vmlal.s16           q0, d2, d4                                     @ accumulator += src[0..3] * filter[0..3]
+    vmlal.s16           q0, d3, d5                                     @ accumulator += src[4..7] * filter[4..7]
     subs                r3, #8                                         @ filter_length -= 8
     bgt                 1b                                             @ loop until filter_length
     vpadd.s32           d0, d0, d1                                     @ pair adding of the 4x32-bit accumulated values
diff --git a/libswresample/arm/resample_init.c b/libswresample/arm/resample_init.c
index e334a27..09b9766 100644
--- a/libswresample/arm/resample_init.c
+++ b/libswresample/arm/resample_init.c
@@ -42,8 +42,8 @@ static int ff_resample_common_##TYPE##_neon(ResampleContext *c, void *dest, cons
     DELEM *dst = dest;                                                                            \
     const DELEM *src = source;                                                                    \
     int dst_index;                                                                                \
-    int index= c->index;                                                                          \
-    int frac= c->frac;                                                                            \
+    int index = c->index;                                                                         \
+    int frac = c->frac;                                                                           \
     int sample_index = 0;                                                                         \
     int x4_aligned_filter_length = c->filter_length & ~3;                                         \
     int x8_aligned_filter_length = c->filter_length & ~7;                                         \
@@ -56,7 +56,7 @@ static int ff_resample_common_##TYPE##_neon(ResampleContext *c, void *dest, cons
     for (dst_index = 0; dst_index < n; dst_index++) {                                             \
         FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * index;                     \
                                                                                                   \
-        FELEM2 val=0;                                                                             \
+        FELEM2 val = 0;                                                                             \
         int i = 0;                                                                                \
         if (x8_aligned_filter_length >= 8) {                                                      \
             ff_resample_common_apply_filter_x8_##TYPE##_neon(&val, &src[sample_index],            \
@@ -86,9 +86,9 @@ static int ff_resample_common_##TYPE##_neon(ResampleContext *c, void *dest, cons
         }                                                                                         \
     }                                                                                             \
                                                                                                   \
-    if(update_ctx){                                                                               \
-        c->frac= frac;                                                                            \
-        c->index= index;                                                                          \
+    if (update_ctx) {                                                                             \
+        c->frac = frac;                                                                           \
+        c->index = index;                                                                         \
     }                                                                                             \
                                                                                                   \
     return sample_index;                                                                          \



More information about the ffmpeg-cvslog mailing list