Index: apps/codecs/libatrac/SOURCES
===================================================================
--- apps/codecs/libatrac/SOURCES	(revision 22519)
+++ apps/codecs/libatrac/SOURCES	(working copy)
@@ -1,2 +1,5 @@
 atrac3.c
+#if defined(CPU_ARM)
+atrac3_arm.S
+#endif
 ../lib/ffmpeg_bitstream.c
Index: apps/codecs/libatrac/fixp_math.h
===================================================================
--- apps/codecs/libatrac/fixp_math.h	(revision 22519)
+++ apps/codecs/libatrac/fixp_math.h	(working copy)
@@ -10,28 +10,77 @@
 
 /* Fixed point math routines for use in atrac3.c */
 
-static inline int32_t fixmul16(int32_t x, int32_t y)
-{
-    int64_t temp;
-    temp = x;
-    temp *= y;
+#if defined(CPU_ARM)
+    #define fixmul16(X,Y) \
+     ({ \
+        int32_t low; \
+        int32_t high; \
+        asm volatile (                   /* calculates: result = (X*Y)>>16 */ \
+           "smull  %0,%1,%2,%3 \n\t"     /* 64 = 32x32 multiply */ \
+           "mov %0, %0, lsr #16 \n\t"    /* %0 = %0 >> 16 */ \
+           "orr %0, %0, %1, lsl #16 \n\t"/* result = %0 OR (%1 << 16) */ \
+           : "=&r"(low), "=&r" (high) \
+           : "r"(X),"r"(Y)); \
+        low; \
+     })
+     
+    #define fixmul31(X,Y) \
+     ({ \
+        int32_t low; \
+        int32_t high; \
+        asm volatile (                   /* calculates: result = (X*Y)>>31 */ \
+           "smull  %0,%1,%2,%3 \n\t"     /* 64 = 32x32 multiply */ \
+           "mov %1, %1, lsl #1 \n\t"     /* loose one bit of precision */ \
+           : "=&r"(low), "=&r" (high) \
+           : "r"(X),"r"(Y)); \
+        high; \
+     })
+     
+    #define fixmul32(X,Y) \
+     ({ \
+        int32_t low; \
+        int32_t high; \
+        asm volatile (                   /* calculates: result = (X*Y)>>32 */ \
+           "smull  %0,%1,%2,%3 \n\t"     /* 64 = 32x32 multiply */ \
+           : "=&r"(low), "=&r" (high) \
+           : "r"(X),"r"(Y)); \
+        high; \
+     })
+#else
+    static inline int32_t fixmul16(int32_t x, int32_t y)
+    {
+        int64_t temp;
+        temp = x;
+        temp *= y;
+    
+        temp >>= 16;
+    
+        return (int32_t)temp;
+    }
+    
+    static inline int32_t fixmul31(int32_t x, int32_t y)
+    {
+        int64_t temp;
+        temp = x;
+        temp *= y;
+    
+        temp >>= 31;        //16+31-16 = 31 bits
+    
+        return (int32_t)temp;
+    }
+    
+    static inline int32_t fixmul32(int32_t x, int32_t y)
+    {
+        int64_t temp;
+        temp = x;
+        temp *= y;
+    
+        temp >>= 32;        //16+31-16 = 31 bits
+    
+        return (int32_t)temp;
+    }
+#endif
 
-    temp >>= 16;
-
-    return (int32_t)temp;
-}
-
-static inline int32_t fixmul31(int32_t x, int32_t y)
-{
-    int64_t temp;
-    temp = x;
-    temp *= y;
-
-    temp >>= 31;        //16+31-16 = 31 bits
-
-    return (int32_t)temp;
-}
-
 static inline int32_t fixdiv16(int32_t x, int32_t y)
 {
     int64_t temp;
Index: apps/codecs/libatrac/atrac3_arm.S
===================================================================
--- apps/codecs/libatrac/atrac3_arm.S	(revision 0)
+++ apps/codecs/libatrac/atrac3_arm.S	(revision 0)
@@ -0,0 +1,140 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id: 
+ *
+ * Copyright (C) 2009 by Andree Buschmann
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+    .section .text, "ax", %progbits
+
+/****************************************************************************
+ * void atrac3_iqmf_matrixing(int32_t *dest, 
+ *                            int32_t *inlo, 
+ *                            int32_t *inhi, 
+ *                            unsigned int count);
+ * 
+ * Matrixing step within iqmf of atrac3 synthesis. Reference implementation:
+ *
+ * for(i=0; i<counter; i+=2){
+ *      dest[2*i+0] = inlo[i  ] + inhi[i  ];
+ *      dest[2*i+1] = inlo[i  ] - inhi[i  ];
+ *      dest[2*i+2] = inlo[i+1] + inhi[i+1];
+ *      dest[2*i+3] = inlo[i+1] - inhi[i+1];
+ * }
+ * Note: r12 is a scratch register and can be used without restorage.
+ ****************************************************************************/
+    .align  2
+    .global atrac3_iqmf_matrixing
+    .type   atrac3_iqmf_matrixing, %function
+
+atrac3_iqmf_matrixing:
+    /* r0 = dest */
+    /* r1 = inlo */
+    /* r2 = inhi */
+    /* r3 = counter */
+    stmfd   sp!, {r4-r9, lr}       /* save non-scratch registers */
+    
+.iqmf_matrixing_loop:
+    ldmia r1!, { r4, r6, r8, r12}   /* load inlo[0...3] */
+    ldmia r2!, { r5, r7, r9, lr }   /* load inhi[0...3] */
+    add   r4, r4, r5                /* r4  = inlo[0] + inhi[0] */
+    sub   r5, r4, r5, asl #1        /* r5  = inlo[0] - inhi[0] */
+    add   r6, r6, r7                /* r6  = inlo[1] + inhi[1] */
+    sub   r7, r6, r7, asl #1        /* r7  = inlo[1] - inhi[1] */
+    add   r8, r8, r9                /* r8  = inlo[2] + inhi[2] */
+    sub   r9, r8, r9, asl #1        /* r9  = inlo[2] - inhi[2] */
+    add   r12, r12, lr              /* r12 = inlo[3] + inhi[3] */
+    sub   lr , r12, lr, asl #1      /* lr  = inlo[3] - inhi[3] */
+    stmia r0!, {r4-r9, r12, lr}     /* store results to dest */
+    subs r3, r3, #4                 /* counter -= 4 */
+    bgt .iqmf_matrixing_loop
+    
+    ldmfd   sp!, {r4-r9, pc}       /* restore registers */
+
+.atrac3_iqmf_matrixing_end:
+    .size   atrac3_iqmf_matrixing,.atrac3_iqmf_matrixing_end-atrac3_iqmf_matrixing
+
+    
+/****************************************************************************
+ * atrac3_iqmf_dewindowing(int32_t *out,
+ *                         int32_t *in,
+ *                         int32_t *win,
+ *                         unsigned int nIn);
+ * 
+ * Dewindowing step within iqmf of atrac3 synthesis. Reference implementation:
+ *
+ * for (j = nIn; j != 0; j--) {
+ *          s1 = fixmul32(in[0], win[0]);
+ *          s2 = fixmul32(in[1], win[1]);
+ *          for (i = 2; i < 48; i += 2) {
+ *              s1 += fixmul32(in[i  ], win[i  ]);
+ *              s2 += fixmul32(in[i+1], win[i+1]);
+ *          }
+ *          out[0] = s2 << 1;
+ *          out[1] = s1 << 1;
+ *          in += 2;
+ *          out += 2;
+ *      }
+ * Note: r12 is a scratch register and can be used without restorage.
+ ****************************************************************************/
+    .align  2
+    .global atrac3_iqmf_dewindowing
+    .type   atrac3_iqmf_dewindowing, %function
+    
+atrac3_iqmf_dewindowing:
+    /* r0 = dest */
+    /* r1 = input samples */
+    /* r2 = window coefficients */
+    /* r3 = counter */
+    stmfd   sp!, {r4-r10, lr}       /* save non-scratch registers */
+    
+.iqmf_dewindow_outer_loop:          /* outer loop 0...counter-1 */
+
+    ldmia r1!, {r5, r6}             /* load in[0..1] */
+    ldmia r2!, {r7, r8}             /* load win[0..1] */
+    smull lr , r10, r5, r7          /* s1 = in[0] * win[0] */
+    smull r12, r9 , r6, r8          /* s2 = in[1] * win[1] */
+
+    mov r4, #46                     /* r4 = 46 */
+.iqmf_dewindow_inner_loop:          /* inner loop i=2...48 */
+    ldmia r1!, {r5, r6}             /* load in[i...i+1] */
+    ldmia r2!, {r7, r8}             /* load win[i...i+1] */
+    smlal lr , r10, r5, r7          /* s1 = in[i  ] * win[i  ] */
+    smlal r12, r9 , r6, r8          /* s2 = in[i+1] * win[i+1] */
+
+    subs r4, r4, #2                 /* inner loop -= 2*/
+    bgt .iqmf_dewindow_inner_loop
+#if 0    
+    mov   r10, r10, asl #1          /* s1 << 1 */
+    mov   r9 , r9 , asl #1          /* s2 << 1 */
+#else
+    mov   lr , lr , lsr #16
+    orr   r10, lr , r10, lsl #16    /* s1 */
+    mov   r12, r12, lsr #16
+    orr   r9 , r12, r9 , lsl #16    /* s2 */
+#endif
+    stmia r0!, {r9, r10}            /* store result out[0]=s2, out[1]=s1 */
+    sub   r1, r1, #184              /* roll back 64 entries = 184 bytes */
+    sub   r2, r2, #192              /* roll back 48 entries = 192 bytes = win[0] */
+
+    subs r3, r3, #1                 /* outer loop -= 1 */
+    bgt .iqmf_dewindow_outer_loop
+    
+    ldmfd   sp!, {r4-r10, pc}       /* restore registers */
+    
+.atrac3_iqmf_dewindowing_end:
+    .size   atrac3_iqmf_dewindowing,.atrac3_iqmf_dewindowing_end-atrac3_iqmf_dewindowing

Property changes on: apps/codecs/libatrac/atrac3_arm.S
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:keywords
   + Author Date Id Revision

Index: apps/codecs/libatrac/atrac3.c
===================================================================
--- apps/codecs/libatrac/atrac3.c	(revision 22519)
+++ apps/codecs/libatrac/atrac3.c	(working copy)
@@ -67,7 +67,83 @@
 static int32_t          qmf_window[48] IBSS_ATTR;
 static VLC              spectral_coeff_tab[7];
 static channel_unit     channel_units[2];
+
 /**
+ * Matrixing within quadrature mirror synthesis filter.
+ *
+ * @param p3        output buffer
+ * @param inlo      lower part of spectrum
+ * @param inhi      higher part of spectrum
+ * @param nIn       size of spectrum buffer
+ */
+ 
+#if defined(CPU_ARM)
+    extern void 
+    atrac3_iqmf_matrixing(int32_t *p3,
+                          int32_t *inlo,
+                          int32_t *inhi,
+                          unsigned int nIn);
+#else
+    static inline void
+    atrac3_iqmf_matrixing(int32_t *p3,
+                          int32_t *inlo,
+                          int32_t *inhi,
+                          unsigned int nIn)
+    {
+        for(i=0; i<nIn; i+=2){
+            p3[2*i+0] = inlo[i  ] + inhi[i  ];
+            p3[2*i+1] = inlo[i  ] - inhi[i  ];
+            p3[2*i+2] = inlo[i+1] + inhi[i+1];
+            p3[2*i+3] = inlo[i+1] - inhi[i+1];
+        }
+    }
+#endif
+
+/**
+ * Matrixing within quadrature mirror synthesis filter.
+ *
+ * @param out       output buffer
+ * @param in        input buffer
+ * @param win       windowing coefficients
+ * @param nIn       size of spectrum buffer
+ */
+ 
+#if defined(CPU_ARM)
+    extern void
+    atrac3_iqmf_dewindowing(int32_t *out,
+                            int32_t *in,
+                            int32_t *win,
+                            unsigned int nIn);
+#else
+    static inline void
+    atrac3_iqmf_dewindowing(int32_t *out,
+                            int32_t *in,
+                            int32_t *win,
+                            unsigned int nIn)
+    {
+        int32_t i, j, s1, s2;
+        
+        for (j = nIn; j != 0; j--) {
+            /* i=0 */
+            s1 = fixmul16(in[0], win[0]);
+            s2 = fixmul16(in[1], win[1]);
+    
+            /* i=2..46 */
+            for (i = 2; i < 48; i += 2) {
+                s1 += fixmul16(in[i  ], win[i  ]);
+                s2 += fixmul16(in[i+1], win[i+1]);
+            }
+    
+            out[0] = s2 << 1; /* Compensate for using fixmul31 instead of the */
+            out[1] = s1 << 1; /* correct usage of fixmul32. Saves 46 shifts. */
+    
+            in += 2;
+            out += 2;
+        }
+    }
+#endif
+
+/**
  * Quadrature mirror synthesis filter.
  *
  * @param inlo      lower part of spectrum
@@ -77,42 +153,19 @@
  * @param delayBuf  delayBuf buffer
  * @param temp      temp buffer
  */
+ 
 static void iqmf (int32_t *inlo, int32_t *inhi, unsigned int nIn, int32_t *pOut, int32_t *delayBuf, int32_t *temp)
 {
-    unsigned int   i, j;
-    int32_t   *p1, *p3;
-
+    /* Restore the delay buffer */
     memcpy(temp, delayBuf, 46*sizeof(int32_t));
 
-    p3 = temp + 46;
+    /* loop1: matrixing */
+    atrac3_iqmf_matrixing(temp + 46, inlo, inhi, nIn);
 
-    /* loop1 */
-    for(i=0; i<nIn; i+=2){
-        p3[2*i+0] = inlo[i  ] + inhi[i  ];
-        p3[2*i+1] = inlo[i  ] - inhi[i  ];
-        p3[2*i+2] = inlo[i+1] + inhi[i+1];
-        p3[2*i+3] = inlo[i+1] - inhi[i+1];
-    }
+    /* loop2: dewindowing */
+    atrac3_iqmf_dewindowing(pOut, temp, qmf_window, nIn);
 
-    /* loop2 */
-    p1 = temp;
-    for (j = nIn; j != 0; j--) {
-        int32_t s1 = 0;
-        int32_t s2 = 0;
-
-        for (i = 0; i < 48; i += 2) {
-            s1 += fixmul31(p1[i], qmf_window[i]);
-            s2 += fixmul31(p1[i+1], qmf_window[i+1]);
-        }
-
-        pOut[0] = s2;
-        pOut[1] = s1;
-
-        p1 += 2;
-        pOut += 2;
-    }
-
-    /* Update the delay buffer. */
+    /* Save the delay buffer */
     memcpy(delayBuf, temp + (nIn << 1), 46*sizeof(int32_t));
 }
 
@@ -148,7 +201,6 @@
     /* Windowing. */
     for(i = 0; i<512; i++)
         pOutput[i] = fixmul31(pOutput[i], window_lookup[i]);
-
 }
 
 
@@ -192,11 +244,21 @@
     /* mdct window had been generated and saved as a lookup table in atrac3data_fixed.h */
 
     /* Generate the QMF window. */
+    /* AB: unused
     for (i=0 ; i<24; i++) {
         s = qmf_48tap_half_fix[i] << 1;
         qmf_window[i] = s;
         qmf_window[47 - i] = s;
     }
+    */
+    
+    /* AB: set up qmf_window with 16 bit precision */
+    for (i=0 ; i<24; i++) {
+        s = qmf_48tap_half_fix[i] << 1;
+        qmf_window[i]      = s >> 15;
+        qmf_window[47 - i] = s >> 15;
+    }
+    
 }
 
 /**