Sync opus codec to upstream git

Sync opus codec to upstream commit
02fed471a4568852d6618e041c4f2af0d7730ee2 (August 30 2013)

This brings in a lot of optimizations but also makes the diff
between our codec and the upstream much smaller as most of our
optimizations have been upstreamed or supeceded.

Speedups across the board for CELT mode files:

        64kbps      128kbps
H300    9.82MHz     15.48MHz
c200	4.86MHz     9.63MHz
fuze v1 10.32MHz    15.92MHz

For the silk mode test file (16kbps) arm targets get a speedup
of about 2MHz while the H300 is 7.8MHz slower, likely because it's
now using the pseudostack more rather than the real stack which
is in iram. Patches to get around that are upcomming.

Change-Id: Ifecf963e461c51ac42e09dac1e91bc4bc3b12fa3

1 files changed, 7 insertions, 55 deletions

diff --git a/lib/rbcodec/codecs/libopus/celt/fixed_generic.h b/lib/rbcodec/codecs/libopus/celt/fixed_generic.h
index 28a1598d3e..0e77976e83 100644
--- a/lib/rbcodec/codecs/libopus/celt/fixed_generic.h
+++ b/lib/rbcodec/codecs/libopus/celt/fixed_generic.h
@@ -42,64 +42,12 @@
 /** 16x32 multiplication, followed by a 16-bit shift right (round-to-nearest). Results fits in 32 bits */
 #define MULT16_32_P16(a,b) ADD32(MULT16_16((a),SHR((b),16)), PSHR(MULT16_16((a),((b)&0x0000ffff)),16))
 
-#if defined(CPU_COLDFIRE)
-static inline int32_t MULT16_32_Q15(int32_t a, int32_t b)
-{
-  int32_t r;
-  asm volatile ("mac.l %[a], %[b], %%acc0;"
-                "movclr.l %%acc0, %[r];"
-                : [r] "=r" (r)
-                : [a] "r" (a<<16), [b] "r" (b)
-                : "cc");
-  return r;
-}
-
-#elif defined(CPU_ARM)
-static inline int32_t MULT16_32_Q15(int32_t a, int32_t b)
-{
-  int32_t lo, hi;
-  asm volatile("smull %[lo], %[hi], %[b], %[a] \n\t"
-               "mov %[lo], %[lo], lsr #15 \n\t"
-               "orr %[hi], %[lo], %[hi], lsl #17 \n\t"
-               : [lo] "=&r" (lo), [hi] "=&r" (hi)
-               : [a] "r" (a), [b] "r" (b) );
-  return(hi);
-}
-
-#else
 /** 16x32 multiplication, followed by a 15-bit shift right. Results fits in 32 bits */
 #define MULT16_32_Q15(a,b) ADD32(SHL(MULT16_16((a),SHR((b),16)),1), SHR(MULT16_16SU((a),((b)&0x0000ffff)),15))
-#endif
 
-#if defined(CPU_COLDFIRE)
-static inline int32_t MULT32_32_Q31(int32_t a, int32_t b)
-{
-  int32_t r;
-  asm volatile ("mac.l %[a], %[b], %%acc0;"
-                "movclr.l %%acc0, %[r];"
-                : [r] "=r" (r)
-                : [a] "r" (a), [b] "r" (b)
-                : "cc");
-  return r;
-}
-
-#elif defined(CPU_ARM)
-static inline int32_t MULT32_32_Q31(int32_t a, int32_t b)
-{
-  int32_t lo, hi;
-  asm volatile("smull %[lo], %[hi], %[a], %[b] \n\t"
-               "mov %[lo], %[lo], lsr #31 \n\t"
-               "orr %[hi], %[lo], %[hi], lsl #1 \n\t"
-               : [lo] "=&r" (lo), [hi] "=&r" (hi)
-               : [a] "r" (a), [b] "r" (b) );
-  return(hi);
-}
-
-#else
 /** 32x32 multiplication, followed by a 31-bit shift right. Results fits in 32 bits */
-//#define MULT32_32_Q31(a,b) ADD32(ADD32(SHL(MULT16_16(SHR((a),16),SHR((b),16)),1), SHR(MULT16_16SU(SHR((a),16),((b)&0x0000ffff)),15)), SHR(MULT16_16SU(SHR((b),16),((a)&0x0000ffff)),15))
-#define MULT32_32_Q31(a,b) (opus_val32)((((int64_t)(a)) * ((int64_t)(b)))>>31)
-#endif
+#define MULT32_32_Q31(a,b) ADD32(ADD32(SHL(MULT16_16(SHR((a),16),SHR((b),16)),1), SHR(MULT16_16SU(SHR((a),16),((b)&0x0000ffff)),15)), SHR(MULT16_16SU(SHR((b),16),((a)&0x0000ffff)),15))
+
 /** Compile-time conversion of float constant to 16-bit value */
 #define QCONST16(x,bits) ((opus_val16)(.5+(x)*(((opus_val32)1)<<(bits))))
 
@@ -136,6 +84,8 @@ static inline int32_t MULT32_32_Q31(int32_t a, int32_t b)
 #define PSHR(a,shift) (SHR((a)+((EXTEND32(1)<<((shift))>>1)),shift))
 #define SATURATE(x,a) (((x)>(a) ? (a) : (x)<-(a) ? -(a) : (x)))
 
+#define SATURATE16(x) (EXTRACT16((x)>32767 ? 32767 : (x)<-32768 ? -32768 : (x)))
+
 /** Shift by a and round-to-neareast 32-bit value. Result is a 16-bit value */
 #define ROUND16(x,a) (EXTRACT16(PSHR32((x),(a))))
 /** Divide by two */
@@ -160,7 +110,9 @@ static inline int32_t MULT32_32_Q31(int32_t a, int32_t b)
 
 /** 16x16 multiply-add where the result fits in 32 bits */
 #define MAC16_16(c,a,b) (ADD32((c),MULT16_16((a),(b))))
-/** 16x32 multiply-add, followed by a 15-bit shift right. Results fits in 32 bits */
+/** 16x32 multiply, followed by a 15-bit shift right and 32-bit add.
+    b must fit in 31 bits.
+    Result fits in 32 bits. */
 #define MAC16_32_Q15(c,a,b) ADD32(c,ADD32(MULT16_16((a),SHR((b),15)), SHR(MULT16_16((a),((b)&0x00007fff)),15)))
 
 #define MULT16_16_Q11_32(a,b) (SHR(MULT16_16((a),(b)),11))