summaryrefslogtreecommitdiff
path: root/apps/codecs
diff options
context:
space:
mode:
authorThom Johansen <thomj@rockbox.org>2007-08-30 11:41:05 +0000
committerThom Johansen <thomj@rockbox.org>2007-08-30 11:41:05 +0000
commit953348f1ba4845984980ad71b05c17d4ded84b30 (patch)
tree728605bcacc89b221e71065d0d092d1b06132799 /apps/codecs
parentc7b3f8be9b1ea505463c3d8ba17740af36c6df2c (diff)
downloadrockbox-953348f1ba4845984980ad71b05c17d4ded84b30.tar.gz
rockbox-953348f1ba4845984980ad71b05c17d4ded84b30.zip
FS #7166. Musepack optimizations and cleanups. Huge speedup on ARM. Note that all ARM (Ipod/Sansa/Gigabeat) targets will now play back Musepack files with somewhat reduced accuracy. Please get in touch via forums or Flyspray if you've got sample files where this is very apparent. Most users should hear no difference.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@14531 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps/codecs')
-rw-r--r--apps/codecs/libmusepack/Makefile8
-rw-r--r--apps/codecs/libmusepack/math.h350
-rw-r--r--apps/codecs/libmusepack/requant.c4
-rw-r--r--apps/codecs/libmusepack/synth_filter.c874
-rw-r--r--apps/codecs/mpc.c4
5 files changed, 723 insertions, 517 deletions
diff --git a/apps/codecs/libmusepack/Makefile b/apps/codecs/libmusepack/Makefile
index e50769719b..a70d33644a 100644
--- a/apps/codecs/libmusepack/Makefile
+++ b/apps/codecs/libmusepack/Makefile
@@ -14,7 +14,13 @@ ifdef APPEXTRA
14 INCLUDES += $(patsubst %,-I$(APPSDIR)/%,$(subst :, ,$(APPEXTRA))) 14 INCLUDES += $(patsubst %,-I$(APPSDIR)/%,$(subst :, ,$(APPEXTRA)))
15endif 15endif
16 16
17MUSEPACKOPTS = -O2 17# libmusepack is faster on ARM-targets with -O1 instead of -O2
18ifeq ($(CPU),arm)
19 MUSEPACKOPTS += -O1
20else
21 MUSEPACKOPTS += -O2
22endif
23
18CFLAGS = $(INCLUDES) $(GCCOPTS) $(TARGET_INC) $(MUSEPACKOPTS) $(TARGET) \ 24CFLAGS = $(INCLUDES) $(GCCOPTS) $(TARGET_INC) $(MUSEPACKOPTS) $(TARGET) \
19$(EXTRA_DEFINES) -DMEM=${MEMORYSIZE} $(PROFILE_OPTS) 25$(EXTRA_DEFINES) -DMEM=${MEMORYSIZE} $(PROFILE_OPTS)
20 26
diff --git a/apps/codecs/libmusepack/math.h b/apps/codecs/libmusepack/math.h
index f9e9d08b08..a015d45cbb 100644
--- a/apps/codecs/libmusepack/math.h
+++ b/apps/codecs/libmusepack/math.h
@@ -44,174 +44,192 @@
44 44
45#ifdef MPC_FIXED_POINT 45#ifdef MPC_FIXED_POINT
46 46
47 #ifdef _WIN32_WCE
48 #include <cmnintrin.h>
49 #define MPC_HAVE_MULHIGH
50 #endif
51
52 #define MPC_FIXED_POINT_SCALE_SHIFT (MPC_FIXED_POINT_SHIFT + MPC_FIXED_POINT_FRACTPART)
53 #define MPC_FIXED_POINT_SCALE (1 << (MPC_FIXED_POINT_SCALE_SHIFT - 1))
54 //in fixedpoint mode, results in decode output buffer are in -MPC_FIXED_POINT_SCALE ... MPC_FIXED_POINT_SCALE range
55
56 #define MPC_FIXED_POINT_FRACTPART 14
57 typedef mpc_int32_t MPC_SAMPLE_FORMAT;
58 typedef mpc_int64_t MPC_SAMPLE_FORMAT_MULTIPLY;
59
60 #define MAKE_MPC_SAMPLE(X) (MPC_SAMPLE_FORMAT)((double)(X) * (double)(((mpc_int64_t)1)<<MPC_FIXED_POINT_FRACTPART))
61 #define MAKE_MPC_SAMPLE_EX(X,Y) (MPC_SAMPLE_FORMAT)((double)(X) * (double)(((mpc_int64_t)1)<<(Y)))
62
63 #define MPC_SHR_RND(X, Y) ((X+(1<<(Y-1)))>>Y)
64
65 #if defined(CPU_COLDFIRE)
66
67 #define MPC_MULTIPLY(X,Y) mpc_multiply((X), (Y))
68 #define MPC_MULTIPLY_EX(X,Y,Z) mpc_multiply_ex((X), (Y), (Z))
69
70 static inline MPC_SAMPLE_FORMAT mpc_multiply(MPC_SAMPLE_FORMAT x,
71 MPC_SAMPLE_FORMAT y)
72 {
73 MPC_SAMPLE_FORMAT t1, t2;
74 asm volatile (
75 "mac.l %[x],%[y],%%acc0\n" /* multiply */
76 "mulu.l %[y],%[x] \n" /* get lower half, avoid emac stall */
77 "movclr.l %%acc0,%[t1] \n" /* get higher half */
78 "moveq.l #17,%[t2] \n"
79 "asl.l %[t2],%[t1] \n" /* hi <<= 17, plus one free */
80 "moveq.l #14,%[t2] \n"
81 "lsr.l %[t2],%[x] \n" /* (unsigned)lo >>= 14 */
82 "or.l %[x],%[t1] \n" /* combine result */
83 : /* outputs */
84 [t1]"=&d"(t1),
85 [t2]"=&d"(t2),
86 [x] "+d" (x)
87 : /* inputs */
88 [y] "d" (y)
89 );
90 return t1;
91 }
92
93 static inline MPC_SAMPLE_FORMAT mpc_multiply_ex(MPC_SAMPLE_FORMAT x,
94 MPC_SAMPLE_FORMAT y,
95 unsigned shift)
96 {
97 MPC_SAMPLE_FORMAT t1, t2;
98 asm volatile (
99 "mac.l %[x],%[y],%%acc0\n" /* multiply */
100 "mulu.l %[y],%[x] \n" /* get lower half, avoid emac stall */
101 "movclr.l %%acc0,%[t1] \n" /* get higher half */
102 "moveq.l #31,%[t2] \n"
103 "sub.l %[sh],%[t2] \n" /* t2 = 31 - shift */
104 "ble.s 1f \n"
105 "asl.l %[t2],%[t1] \n" /* hi <<= 31 - shift */
106 "lsr.l %[sh],%[x] \n" /* (unsigned)lo >>= shift */
107 "or.l %[x],%[t1] \n" /* combine result */
108 "bra.s 2f \n"
109 "1: \n"
110 "neg.l %[t2] \n" /* t2 = shift - 31 */
111 "asr.l %[t2],%[t1] \n" /* hi >>= t2 */
112 "2: \n"
113 : /* outputs */
114 [t1]"=&d"(t1),
115 [t2]"=&d"(t2),
116 [x] "+d" (x)
117 : /* inputs */
118 [y] "d" (y),
119 [sh]"d" (shift)
120 );
121 return t1;
122 }
123 #elif defined(CPU_ARM)
124 // borrowed and adapted from libMAD
125 #define MPC_MULTIPLY(X,Y) \
126 ({ \
127 MPC_SAMPLE_FORMAT low; \
128 MPC_SAMPLE_FORMAT high; \
129 asm volatile ( /* will calculate: result = (X*Y)>>14 */ \
130 "smull %0,%1,%2,%3 \n\t" /* multiply with result %0 [0..31], %1 [32..63] */ \
131 "mov %0, %0, lsr #14 \n\t" /* %0 = %0 >> 14 */ \
132 "orr %0, %0, %1, lsl #18 \n\t"/* result = %0 OR (%1 << 18) */ \
133 : "=&r"(low), "=&r" (high) \
134 : "r"(X),"r"(Y)); \
135 low; \
136 })
137
138 // borrowed and adapted from libMAD
139 #define MPC_MULTIPLY_EX(X,Y,Z) \
140 ({ \
141 MPC_SAMPLE_FORMAT low; \
142 MPC_SAMPLE_FORMAT high; \
143 asm volatile ( /* will calculate: result = (X*Y)>>Z */ \
144 "smull %0,%1,%2,%3 \n\t" /* multiply with result %0 [0..31], %1 [32..63] */ \
145 "mov %0, %0, lsr %4 \n\t" /* %0 = %0 >> Z */ \
146 "orr %0, %0, %1, lsl %5 \n\t" /* result = %0 OR (%1 << (32-Z)) */ \
147 : "=&r"(low), "=&r" (high) \
148 : "r"(X),"r"(Y),"r"(Z),"r"(32-Z)); \
149 low; \
150 })
151 #else /* libmusepack standard */
152
153 #define MPC_MULTIPLY_NOTRUNCATE(X,Y) \
154 (((MPC_SAMPLE_FORMAT_MULTIPLY)(X) * (MPC_SAMPLE_FORMAT_MULTIPLY)(Y)) >> MPC_FIXED_POINT_FRACTPART)
155
156 #define MPC_MULTIPLY_EX_NOTRUNCATE(X,Y,Z) \
157 (((MPC_SAMPLE_FORMAT_MULTIPLY)(X) * (MPC_SAMPLE_FORMAT_MULTIPLY)(Y)) >> (Z))
158
159 #ifdef _DEBUG
160 static inline MPC_SAMPLE_FORMAT MPC_MULTIPLY(MPC_SAMPLE_FORMAT item1,MPC_SAMPLE_FORMAT item2)
161 {
162 MPC_SAMPLE_FORMAT_MULTIPLY temp = MPC_MULTIPLY_NOTRUNCATE(item1,item2);
163 assert(temp == (MPC_SAMPLE_FORMAT_MULTIPLY)(MPC_SAMPLE_FORMAT)temp);
164 return (MPC_SAMPLE_FORMAT)temp;
165 }
166
167 static inline MPC_SAMPLE_FORMAT MPC_MULTIPLY_EX(MPC_SAMPLE_FORMAT item1,MPC_SAMPLE_FORMAT item2,unsigned shift)
168 {
169 MPC_SAMPLE_FORMAT_MULTIPLY temp = MPC_MULTIPLY_EX_NOTRUNCATE(item1,item2,shift);
170 assert(temp == (MPC_SAMPLE_FORMAT_MULTIPLY)(MPC_SAMPLE_FORMAT)temp);
171 return (MPC_SAMPLE_FORMAT)temp;
172 }
173 #else
174 #define MPC_MULTIPLY(X,Y) ((MPC_SAMPLE_FORMAT)MPC_MULTIPLY_NOTRUNCATE(X,Y))
175 #define MPC_MULTIPLY_EX(X,Y,Z) ((MPC_SAMPLE_FORMAT)MPC_MULTIPLY_EX_NOTRUNCATE(X,Y,Z))
176 #endif
177
178 #endif
179
180 #ifdef MPC_HAVE_MULHIGH
181 #define MPC_MULTIPLY_FRACT(X,Y) _MulHigh(X,Y)
182 #else
183 #if defined(CPU_COLDFIRE)
184 /* loses one bit of accuracy. The rest of the macros won't be as easy as this... */
185 #define MPC_MULTIPLY_FRACT(X,Y) \
186 ({ \
187 MPC_SAMPLE_FORMAT t; \
188 asm volatile ( \
189 "mac.l %[A], %[B], %%acc0\n\t" \
190 "movclr.l %%acc0, %[t]\n\t" \
191 "asr.l #1, %[t]\n\t" \
192 : [t] "=d" (t) \
193 : [A] "r" ((X)), [B] "r" ((Y))); \
194 t; \
195 })
196 #elif defined(CPU_ARM)
197 // borrowed and adapted from libMAD
198 #define MPC_MULTIPLY_FRACT(X,Y) \
199 ({ \
200 MPC_SAMPLE_FORMAT low; \
201 MPC_SAMPLE_FORMAT high; \
202 asm volatile ( /* will calculate: result = (X*Y)>>32 */ \
203 "smull %0,%1,%2,%3 \n\t" /* multiply with result %0 [0..31], %1 [32..63] */ \
204 : "=&r"(low), "=&r" (high) /* result = %1 [32..63], saves the >>32 */ \
205 : "r"(X),"r"(Y)); \
206 high; \
207 })
208 #else
209 #define MPC_MULTIPLY_FRACT(X,Y) MPC_MULTIPLY_EX(X,Y,32)
210 #endif
211 #endif
212
213 #define MPC_MAKE_FRACT_CONST(X) (MPC_SAMPLE_FORMAT)((X) * (double)(((mpc_int64_t)1)<<32) )
214
215 #define MPC_MULTIPLY_FLOAT_INT(X,Y) ((X)*(Y))
47 216
48#ifdef _WIN32_WCE
49
50#include <cmnintrin.h>
51
52#define MPC_HAVE_MULHIGH
53
54#endif
55
56
57#define MPC_FIXED_POINT_SCALE_SHIFT (MPC_FIXED_POINT_SHIFT + MPC_FIXED_POINT_FRACTPART)
58#define MPC_FIXED_POINT_SCALE (1 << (MPC_FIXED_POINT_SCALE_SHIFT - 1))
59
60
61//in fixedpoint mode, results in decode output buffer are in -MPC_FIXED_POINT_SCALE ... MPC_FIXED_POINT_SCALE range
62
63#define MPC_FIXED_POINT_FRACTPART 14
64typedef mpc_int32_t MPC_SAMPLE_FORMAT;
65
66typedef mpc_int64_t MPC_SAMPLE_FORMAT_MULTIPLY;
67
68#define MAKE_MPC_SAMPLE(X) (MPC_SAMPLE_FORMAT)((double)(X) * (double)(((mpc_int64_t)1)<<MPC_FIXED_POINT_FRACTPART))
69#define MAKE_MPC_SAMPLE_EX(X,Y) (MPC_SAMPLE_FORMAT)((double)(X) * (double)(((mpc_int64_t)1)<<(Y)))
70
71#if defined(CPU_COLDFIRE)
72
73#define MPC_MULTIPLY(X,Y) mpc_multiply((X), (Y))
74#define MPC_MULTIPLY_EX(X,Y,Z) mpc_multiply_ex((X), (Y), (Z))
75
76static inline MPC_SAMPLE_FORMAT mpc_multiply(MPC_SAMPLE_FORMAT x,
77 MPC_SAMPLE_FORMAT y)
78{
79 MPC_SAMPLE_FORMAT t1, t2;
80 asm volatile (
81 "mac.l %[x],%[y],%%acc0\n" /* multiply */
82 "mulu.l %[y],%[x] \n" /* get lower half, avoid emac stall */
83 "movclr.l %%acc0,%[t1] \n" /* get higher half */
84 "moveq.l #17,%[t2] \n"
85 "asl.l %[t2],%[t1] \n" /* hi <<= 17, plus one free */
86 "moveq.l #14,%[t2] \n"
87 "lsr.l %[t2],%[x] \n" /* (unsigned)lo >>= 14 */
88 "or.l %[x],%[t1] \n" /* combine result */
89 : /* outputs */
90 [t1]"=&d"(t1),
91 [t2]"=&d"(t2),
92 [x] "+d" (x)
93 : /* inputs */
94 [y] "d" (y)
95 );
96 return t1;
97}
98
99static inline MPC_SAMPLE_FORMAT mpc_multiply_ex(MPC_SAMPLE_FORMAT x,
100 MPC_SAMPLE_FORMAT y,
101 unsigned shift)
102{
103 MPC_SAMPLE_FORMAT t1, t2;
104 asm volatile (
105 "mac.l %[x],%[y],%%acc0\n" /* multiply */
106 "mulu.l %[y],%[x] \n" /* get lower half, avoid emac stall */
107 "movclr.l %%acc0,%[t1] \n" /* get higher half */
108 "moveq.l #31,%[t2] \n"
109 "sub.l %[sh],%[t2] \n" /* t2 = 31 - shift */
110 "ble.s 1f \n"
111 "asl.l %[t2],%[t1] \n" /* hi <<= 31 - shift */
112 "lsr.l %[sh],%[x] \n" /* (unsigned)lo >>= shift */
113 "or.l %[x],%[t1] \n" /* combine result */
114 "bra.s 2f \n"
115 "1: \n"
116 "neg.l %[t2] \n" /* t2 = shift - 31 */
117 "asr.l %[t2],%[t1] \n" /* hi >>= t2 */
118 "2: \n"
119 : /* outputs */
120 [t1]"=&d"(t1),
121 [t2]"=&d"(t2),
122 [x] "+d" (x)
123 : /* inputs */
124 [y] "d" (y),
125 [sh]"d" (shift)
126 );
127 return t1;
128}
129#else /* libmusepack standard */
130
131#define MPC_MULTIPLY_NOTRUNCATE(X,Y) \
132 (((MPC_SAMPLE_FORMAT_MULTIPLY)(X) * (MPC_SAMPLE_FORMAT_MULTIPLY)(Y)) >> MPC_FIXED_POINT_FRACTPART)
133
134#define MPC_MULTIPLY_EX_NOTRUNCATE(X,Y,Z) \
135 (((MPC_SAMPLE_FORMAT_MULTIPLY)(X) * (MPC_SAMPLE_FORMAT_MULTIPLY)(Y)) >> (Z))
136
137#ifdef _DEBUG
138static inline MPC_SAMPLE_FORMAT MPC_MULTIPLY(MPC_SAMPLE_FORMAT item1,MPC_SAMPLE_FORMAT item2)
139{
140 MPC_SAMPLE_FORMAT_MULTIPLY temp = MPC_MULTIPLY_NOTRUNCATE(item1,item2);
141 assert(temp == (MPC_SAMPLE_FORMAT_MULTIPLY)(MPC_SAMPLE_FORMAT)temp);
142 return (MPC_SAMPLE_FORMAT)temp;
143}
144
145static inline MPC_SAMPLE_FORMAT MPC_MULTIPLY_EX(MPC_SAMPLE_FORMAT item1,MPC_SAMPLE_FORMAT item2,unsigned shift)
146{
147 MPC_SAMPLE_FORMAT_MULTIPLY temp = MPC_MULTIPLY_EX_NOTRUNCATE(item1,item2,shift);
148 assert(temp == (MPC_SAMPLE_FORMAT_MULTIPLY)(MPC_SAMPLE_FORMAT)temp);
149 return (MPC_SAMPLE_FORMAT)temp;
150}
151#else
152#define MPC_MULTIPLY(X,Y) ((MPC_SAMPLE_FORMAT)MPC_MULTIPLY_NOTRUNCATE(X,Y))
153#define MPC_MULTIPLY_EX(X,Y,Z) ((MPC_SAMPLE_FORMAT)MPC_MULTIPLY_EX_NOTRUNCATE(X,Y,Z))
154#endif
155
156#endif
157
158#ifdef MPC_HAVE_MULHIGH
159#define MPC_MULTIPLY_FRACT(X,Y) _MulHigh(X,Y)
160#else
161#if defined(CPU_COLDFIRE)
162/* loses one bit of accuracy.
163 the rest of the macros won't be as easy as this... */
164#define MPC_MULTIPLY_FRACT(X,Y) \
165 ({ \
166 MPC_SAMPLE_FORMAT t; \
167 asm volatile ( \
168 "mac.l %[A], %[B], %%acc0\n\t" \
169 "movclr.l %%acc0, %[t]\n\t" \
170 "asr.l #1, %[t]\n\t" \
171 : [t] "=d" (t) \
172 : [A] "r" ((X)), [B] "r" ((Y))); \
173 t; \
174 })
175#else 217#else
176#define MPC_MULTIPLY_FRACT(X,Y) MPC_MULTIPLY_EX(X,Y,32) 218 //in floating-point mode, decoded samples are in -1...1 range
177#endif 219
178#endif 220 typedef float MPC_SAMPLE_FORMAT;
179 221
180#define MPC_MAKE_FRACT_CONST(X) (MPC_SAMPLE_FORMAT)((X) * (double)(((mpc_int64_t)1)<<32) ) 222 #define MAKE_MPC_SAMPLE(X) ((MPC_SAMPLE_FORMAT)(X))
181#define MPC_MULTIPLY_FRACT_CONST(X,Y) MPC_MULTIPLY_FRACT(X,MPC_MAKE_FRACT_CONST(Y)) 223 #define MAKE_MPC_SAMPLE_EX(X,Y) ((MPC_SAMPLE_FORMAT)(X))
182#define MPC_MULTIPLY_FRACT_CONST_FIX(X,Y,Z) ( MPC_MULTIPLY_FRACT(X,MPC_MAKE_FRACT_CONST( Y / (1<<(Z)) )) << (Z) ) 224
183#define MPC_MULTIPLY_FRACT_CONST_SHR(X,Y,Z) MPC_MULTIPLY_FRACT(X,MPC_MAKE_FRACT_CONST( Y / (1<<(Z)) )) 225 #define MPC_MULTIPLY_FRACT(X,Y) ((X)*(Y))
184 226 #define MPC_MAKE_FRACT_CONST(X) (X)
185#define MPC_MULTIPLY_FLOAT_INT(X,Y) ((X)*(Y)) 227
186#define MPC_SCALE_CONST(X,Y,Z) MPC_MULTIPLY_EX(X,MAKE_MPC_SAMPLE_EX(Y,Z),(Z)) 228 #define MPC_MULTIPLY_FLOAT_INT(X,Y) ((X)*(Y))
187#define MPC_SCALE_CONST_SHL(X,Y,Z,S) MPC_MULTIPLY_EX(X,MAKE_MPC_SAMPLE_EX(Y,Z),(Z)-(S)) 229 #define MPC_MULTIPLY(X,Y) ((X)*(Y))
188#define MPC_SCALE_CONST_SHR(X,Y,Z,S) MPC_MULTIPLY_EX(X,MAKE_MPC_SAMPLE_EX(Y,Z),(Z)+(S)) 230 #define MPC_MULTIPLY_EX(X,Y,Z) ((X)*(Y))
189#define MPC_SHR(X,Y) ((X)>>(Y)) 231
190#define MPC_SHL(X,Y) ((X)<<(Y)) 232 #define MPC_SHR_RND(X, Y) (X)
191
192#else
193
194//in floating-point mode, decoded samples are in -1...1 range
195
196typedef float MPC_SAMPLE_FORMAT;
197
198#define MAKE_MPC_SAMPLE(X) ((MPC_SAMPLE_FORMAT)(X))
199#define MAKE_MPC_SAMPLE_EX(X,Y) ((MPC_SAMPLE_FORMAT)(X))
200
201#define MPC_MULTIPLY_FRACT(X,Y) ((X)*(Y))
202#define MPC_MAKE_FRACT_CONST(X) (X)
203#define MPC_MULTIPLY_FRACT_CONST(X,Y) MPC_MULTPLY_FRACT(X,MPC_MAKE_FRACT_CONST(Y))
204#define MPC_MULTIPLY_FRACT_CONST_SHR(X,Y,Z) MPC_MULTIPLY_FRACT(X,MPC_MAKE_FRACT_CONST( Y ))
205#define MPC_MULTIPLY_FRACT_CONST_FIX(X,Y,Z) MPC_MULTIPLY_FRACT(X,MPC_MAKE_FRACT_CONST( Y ))
206
207#define MPC_MULTIPLY_FLOAT_INT(X,Y) ((X)*(Y))
208#define MPC_MULTIPLY(X,Y) ((X)*(Y))
209#define MPC_MULTIPLY_EX(X,Y,Z) ((X)*(Y))
210#define MPC_SCALE_CONST(X,Y,Z) ((X)*(Y))
211#define MPC_SCALE_CONST_SHL(X,Y,Z,S) ((X)*(Y))
212#define MPC_SCALE_CONST_SHR(X,Y,Z,S) ((X)*(Y))
213#define MPC_SHR(X,Y) (X)
214#define MPC_SHL(X,Y) (X)
215 233
216#endif 234#endif
217 235
diff --git a/apps/codecs/libmusepack/requant.c b/apps/codecs/libmusepack/requant.c
index a72a165786..6b77585d32 100644
--- a/apps/codecs/libmusepack/requant.c
+++ b/apps/codecs/libmusepack/requant.c
@@ -53,8 +53,8 @@ const mpc_uint32_t Res_bit [18] = {
53const MPC_SAMPLE_FORMAT __Cc [1 + 18] = { 53const MPC_SAMPLE_FORMAT __Cc [1 + 18] = {
54 _(111.285962475327f), // 32768/2/255*sqrt(3) 54 _(111.285962475327f), // 32768/2/255*sqrt(3)
55 _(65536.000000000000f), _(21845.333333333332f), _(13107.200000000001f), _(9362.285714285713f), 55 _(65536.000000000000f), _(21845.333333333332f), _(13107.200000000001f), _(9362.285714285713f),
56 _(7281.777777777777f), _(4369.066666666666f), _(2114.064516129032f), _(1040.253968253968f), 56 _(7281.777777777777f), _(4369.066666666666f), _(2114.064516129032f), _(1040.253968253968f),
57 _(516.031496062992f), _(257.003921568627f), _(128.250489236790f), _(64.062561094819f), 57 _(516.031496062992f), _(257.003921568627f), _(128.250489236790f), _(64.062561094819f),
58 _(32.015632633121f), _(16.003907203907f), _(8.000976681723f), _(4.000244155527f), 58 _(32.015632633121f), _(16.003907203907f), _(8.000976681723f), _(4.000244155527f),
59 _(2.000061037018f), _(1.000015259021f) 59 _(2.000061037018f), _(1.000015259021f)
60}; 60};
diff --git a/apps/codecs/libmusepack/synth_filter.c b/apps/codecs/libmusepack/synth_filter.c
index 0dabe59150..eca23804c5 100644
--- a/apps/codecs/libmusepack/synth_filter.c
+++ b/apps/codecs/libmusepack/synth_filter.c
@@ -39,19 +39,51 @@
39#include "musepack.h" 39#include "musepack.h"
40#include "internal.h" 40#include "internal.h"
41 41
42/* S E T T I N G S */
43// choose speed vs. accuracy for MPC_FIXED_POINT
44// speed-setting will increase decoding speed on ARM only (+20%), loss of accuracy equals about 5 dB SNR (15bit output precision)
45// to not use the speed-optimization -> comment OPTIMIZE_FOR_SPEED
46#if defined(MPC_FIXED_POINT)
47 #if defined(CPU_COLDFIRE)
48 // do nothing
49 #elif defined(CPU_ARM)
50 #define OPTIMIZE_FOR_SPEED
51 #else
52 #define OPTIMIZE_FOR_SPEED
53 #endif
54#else
55 // do nothing
56#endif
57
42/* C O N S T A N T S */ 58/* C O N S T A N T S */
43#undef _ 59#undef _
44 60
45#define MPC_FIXED_POINT_SYNTH_FIX 2 61#if defined(MPC_FIXED_POINT)
46 62 #if defined(OPTIMIZE_FOR_SPEED)
47#ifdef MPC_FIXED_POINT 63 // round to +/- 2^14 as pre-shift before 32=32x32-multiply
48#define _(value) MPC_MAKE_FRACT_CONST((double)value/(double)(0x40000)) 64 #define _(value) (MPC_SHR_RND(value, 3))
65
66 // round to +/- 2^17 as pre-shift before 32=32x32-multiply
67 #define MPC_V_PRESHIFT(X) MPC_SHR_RND(X, 14)
68 #else
69 // saturate to +/- 2^31 (= value << (31-17)), D-values are +/- 2^17
70 #define _(value) (value << (14))
71
72 // do not perform pre-shift
73 #define MPC_V_PRESHIFT(X) (X)
74 #endif
49#else 75#else
50#define _(value) MAKE_MPC_SAMPLE((double)value/(double)(0x10000)) 76 // IMPORTANT: internal scaling is somehow strange for floating point, therefore we scale the coefficients Di_opt
77 // by the correct amount to have proper scaled output
78 #define _(value) MAKE_MPC_SAMPLE((double)value*(double)(0x1000))
79
80 // do not perform pre-shift
81 #define MPC_V_PRESHIFT(X) (X)
51#endif 82#endif
52 83
53 84// Di_opt coefficients are +/- 2^17
54static const MPC_SAMPLE_FORMAT Di_opt [32] [16] ICONST_ATTR = { 85static const MPC_SAMPLE_FORMAT Di_opt [32] [16] ICONST_ATTR = {
86 /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */
55 { _( 0), _( -29), _( 213), _( -459), _( 2037), _(-5153), _( 6574), _(-37489), _(75038), _(37489), _(6574), _( 5153), _(2037), _( 459), _(213), _(29) }, 87 { _( 0), _( -29), _( 213), _( -459), _( 2037), _(-5153), _( 6574), _(-37489), _(75038), _(37489), _(6574), _( 5153), _(2037), _( 459), _(213), _(29) },
56 { _( -1), _( -31), _( 218), _( -519), _( 2000), _(-5517), _( 5959), _(-39336), _(74992), _(35640), _(7134), _( 4788), _(2063), _( 401), _(208), _(26) }, 88 { _( -1), _( -31), _( 218), _( -519), _( 2000), _(-5517), _( 5959), _(-39336), _(74992), _(35640), _(7134), _( 4788), _(2063), _( 401), _(208), _(26) },
57 { _( -1), _( -35), _( 222), _( -581), _( 1952), _(-5879), _( 5288), _(-41176), _(74856), _(33791), _(7640), _( 4425), _(2080), _( 347), _(202), _(24) }, 89 { _( -1), _( -35), _( 222), _( -581), _( 1952), _(-5879), _( 5288), _(-41176), _(74856), _(33791), _(7640), _( 4425), _(2080), _( 347), _(202), _(24) },
@@ -88,363 +120,513 @@ static const MPC_SAMPLE_FORMAT Di_opt [32] [16] ICONST_ATTR = {
88 120
89#undef _ 121#undef _
90 122
91static void Calculate_New_V ( const MPC_SAMPLE_FORMAT * Sample, MPC_SAMPLE_FORMAT * V ) 123// V-coefficients were expanded (<<) by V_COEFFICIENT_EXPAND
124#define V_COEFFICIENT_EXPAND 27
125
126#if defined(MPC_FIXED_POINT)
127 #if defined(OPTIMIZE_FOR_SPEED)
128 // define 32=32x32-multiplication for DCT-coefficients with samples, vcoef will be pre-shifted on creation
129 // samples are rounded to +/- 2^19 as pre-shift before 32=32x32-multiply
130 #define MPC_MULTIPLY_V(sample, vcoef) ( MPC_SHR_RND(sample, 12) * vcoef )
131
132 // round to +/- 2^16 as pre-shift before 32=32x32-multiply
133 #define MPC_MAKE_INVCOS(value) (MPC_SHR_RND(value, 15))
134 #else
135 // define 64=32x32-multiplication for DCT-coefficients with samples. Via usage of MPC_FRACT highly optimized assembler might be used
136 // MULTIPLY_FRACT will do >>32 after multiplication, as V-coef were expanded by V_COEFFICIENT_EXPAND we'll correct this on the result.
137 // Will loose 5bit accuracy on result in fract part without effect on final audio result
138 #define MPC_MULTIPLY_V(sample, vcoef) ( (MPC_MULTIPLY_FRACT(sample, vcoef)) << (32-V_COEFFICIENT_EXPAND) )
139
140 // directly use accurate 32bit-coefficients
141 #define MPC_MAKE_INVCOS(value) (value)
142 #endif
143#else
144 // for floating point use the standard multiplication macro
145 #define MPC_MULTIPLY_V(sample, vcoef) ( MPC_MULTIPLY(sample, vcoef) )
146
147 // downscale the accurate 32bit-coefficients and convert to float
148 #define MPC_MAKE_INVCOS(value) MAKE_MPC_SAMPLE((double)value/(double)(1<<V_COEFFICIENT_EXPAND))
149#endif
150
151// define constants for DCT-synthesis
152// INVCOSxx = (0.5 / cos(xx*PI/64)) << 27, <<27 to saturate to +/- 2^31
153#define INVCOS01 MPC_MAKE_INVCOS( 67189797)
154#define INVCOS02 MPC_MAKE_INVCOS( 67433575)
155#define INVCOS03 MPC_MAKE_INVCOS( 67843164)
156#define INVCOS04 MPC_MAKE_INVCOS( 68423604)
157#define INVCOS05 MPC_MAKE_INVCOS( 69182167)
158#define INVCOS06 MPC_MAKE_INVCOS( 70128577)
159#define INVCOS07 MPC_MAKE_INVCOS( 71275330)
160#define INVCOS08 MPC_MAKE_INVCOS( 72638111)
161#define INVCOS09 MPC_MAKE_INVCOS( 74236348)
162#define INVCOS10 MPC_MAKE_INVCOS( 76093940)
163#define INVCOS11 MPC_MAKE_INVCOS( 78240207)
164#define INVCOS12 MPC_MAKE_INVCOS( 80711144)
165#define INVCOS13 MPC_MAKE_INVCOS( 83551089)
166#define INVCOS14 MPC_MAKE_INVCOS( 86814950)
167#define INVCOS15 MPC_MAKE_INVCOS( 90571242)
168#define INVCOS16 MPC_MAKE_INVCOS( 94906266)
169#define INVCOS17 MPC_MAKE_INVCOS( 99929967)
170#define INVCOS18 MPC_MAKE_INVCOS( 105784321)
171#define INVCOS19 MPC_MAKE_INVCOS( 112655602)
172#define INVCOS20 MPC_MAKE_INVCOS( 120792764)
173#define INVCOS21 MPC_MAKE_INVCOS( 130535899)
174#define INVCOS22 MPC_MAKE_INVCOS( 142361749)
175#define INVCOS23 MPC_MAKE_INVCOS( 156959571)
176#define INVCOS24 MPC_MAKE_INVCOS( 175363913)
177#define INVCOS25 MPC_MAKE_INVCOS( 199201203)
178#define INVCOS26 MPC_MAKE_INVCOS( 231182936)
179#define INVCOS27 MPC_MAKE_INVCOS( 276190692)
180#define INVCOS28 MPC_MAKE_INVCOS( 343988688)
181#define INVCOS29 MPC_MAKE_INVCOS( 457361460)
182#define INVCOS30 MPC_MAKE_INVCOS( 684664578)
183#define INVCOS31 MPC_MAKE_INVCOS(1367679739)
184
185static inline void
186mpc_calculate_new_V ( const MPC_SAMPLE_FORMAT * Sample, MPC_SAMPLE_FORMAT * V )
92{ 187{
93 // Calculating new V-buffer values for left channel 188 // Calculating new V-buffer values for left channel
94 // calculate new V-values (ISO-11172-3, p. 39) 189 // calculate new V-values (ISO-11172-3, p. 39)
95 // based upon fast-MDCT algorithm by Byeong Gi Lee 190 // based upon fast-MDCT algorithm by Byeong Gi Lee
96 /*static*/ MPC_SAMPLE_FORMAT A00, A01, A02, A03, A04, A05, A06, A07, A08, A09, A10, A11, A12, A13, A14, A15; 191 MPC_SAMPLE_FORMAT A[16];
97 /*static*/ MPC_SAMPLE_FORMAT B00, B01, B02, B03, B04, B05, B06, B07, B08, B09, B10, B11, B12, B13, B14, B15; 192 MPC_SAMPLE_FORMAT B[16];
98 MPC_SAMPLE_FORMAT tmp; 193 MPC_SAMPLE_FORMAT tmp;
99 194
100 A00 = Sample[ 0] + Sample[31]; 195 A[ 0] = Sample[ 0] + Sample[31];
101 A01 = Sample[ 1] + Sample[30]; 196 A[ 1] = Sample[ 1] + Sample[30];
102 A02 = Sample[ 2] + Sample[29]; 197 A[ 2] = Sample[ 2] + Sample[29];
103 A03 = Sample[ 3] + Sample[28]; 198 A[ 3] = Sample[ 3] + Sample[28];
104 A04 = Sample[ 4] + Sample[27]; 199 A[ 4] = Sample[ 4] + Sample[27];
105 A05 = Sample[ 5] + Sample[26]; 200 A[ 5] = Sample[ 5] + Sample[26];
106 A06 = Sample[ 6] + Sample[25]; 201 A[ 6] = Sample[ 6] + Sample[25];
107 A07 = Sample[ 7] + Sample[24]; 202 A[ 7] = Sample[ 7] + Sample[24];
108 A08 = Sample[ 8] + Sample[23]; 203 A[ 8] = Sample[ 8] + Sample[23];
109 A09 = Sample[ 9] + Sample[22]; 204 A[ 9] = Sample[ 9] + Sample[22];
110 A10 = Sample[10] + Sample[21]; 205 A[10] = Sample[10] + Sample[21];
111 A11 = Sample[11] + Sample[20]; 206 A[11] = Sample[11] + Sample[20];
112 A12 = Sample[12] + Sample[19]; 207 A[12] = Sample[12] + Sample[19];
113 A13 = Sample[13] + Sample[18]; 208 A[13] = Sample[13] + Sample[18];
114 A14 = Sample[14] + Sample[17]; 209 A[14] = Sample[14] + Sample[17];
115 A15 = Sample[15] + Sample[16]; 210 A[15] = Sample[15] + Sample[16];
116 211 // 16 adds
117 B00 = A00 + A15; 212
118 B01 = A01 + A14; 213 B[ 0] = A[ 0] + A[15];
119 B02 = A02 + A13; 214 B[ 1] = A[ 1] + A[14];
120 B03 = A03 + A12; 215 B[ 2] = A[ 2] + A[13];
121 B04 = A04 + A11; 216 B[ 3] = A[ 3] + A[12];
122 B05 = A05 + A10; 217 B[ 4] = A[ 4] + A[11];
123 B06 = A06 + A09; 218 B[ 5] = A[ 5] + A[10];
124 B07 = A07 + A08;; 219 B[ 6] = A[ 6] + A[ 9];
125 B08 = MPC_SCALE_CONST((A00 - A15) , 0.5024192929f , 31); 220 B[ 7] = A[ 7] + A[ 8];;
126 B09 = MPC_SCALE_CONST((A01 - A14) , 0.5224986076f , 31); 221 B[ 8] = MPC_MULTIPLY_V((A[ 0] - A[15]), INVCOS02);
127 B10 = MPC_SCALE_CONST((A02 - A13) , 0.5669440627f , 31); 222 B[ 9] = MPC_MULTIPLY_V((A[ 1] - A[14]), INVCOS06);
128 B11 = MPC_SCALE_CONST((A03 - A12) , 0.6468217969f , 31); 223 B[10] = MPC_MULTIPLY_V((A[ 2] - A[13]), INVCOS10);
129 B12 = MPC_SCALE_CONST((A04 - A11) , 0.7881546021f , 31); 224 B[11] = MPC_MULTIPLY_V((A[ 3] - A[12]), INVCOS14);
130 B13 = MPC_SCALE_CONST((A05 - A10) , 1.0606776476f , 30); 225 B[12] = MPC_MULTIPLY_V((A[ 4] - A[11]), INVCOS18);
131 B14 = MPC_SCALE_CONST((A06 - A09) , 1.7224471569f , 30); 226 B[13] = MPC_MULTIPLY_V((A[ 5] - A[10]), INVCOS22);
132 B15 = MPC_SCALE_CONST((A07 - A08) , 5.1011486053f , 28); 227 B[14] = MPC_MULTIPLY_V((A[ 6] - A[ 9]), INVCOS26);
133 228 B[15] = MPC_MULTIPLY_V((A[ 7] - A[ 8]), INVCOS30);
134 A00 = B00 + B07; 229 // 8 adds, 8 subs, 8 muls, 8 shifts
135 A01 = B01 + B06; 230
136 A02 = B02 + B05; 231 A[ 0] = B[ 0] + B[ 7];
137 A03 = B03 + B04; 232 A[ 1] = B[ 1] + B[ 6];
138 A04 = MPC_SCALE_CONST((B00 - B07) , 0.5097956061f , 31); 233 A[ 2] = B[ 2] + B[ 5];
139 A05 = MPC_SCALE_CONST((B01 - B06) , 0.6013448834f , 31); 234 A[ 3] = B[ 3] + B[ 4];
140 A06 = MPC_SCALE_CONST((B02 - B05) , 0.8999761939f , 31); 235 A[ 4] = MPC_MULTIPLY_V((B[ 0] - B[ 7]), INVCOS04);
141 A07 = MPC_SCALE_CONST((B03 - B04) , 2.5629155636f , 29); 236 A[ 5] = MPC_MULTIPLY_V((B[ 1] - B[ 6]), INVCOS12);
142 A08 = B08 + B15; 237 A[ 6] = MPC_MULTIPLY_V((B[ 2] - B[ 5]), INVCOS20);
143 A09 = B09 + B14; 238 A[ 7] = MPC_MULTIPLY_V((B[ 3] - B[ 4]), INVCOS28);
144 A10 = B10 + B13; 239 A[ 8] = B[ 8] + B[15];
145 A11 = B11 + B12; 240 A[ 9] = B[ 9] + B[14];
146 A12 = MPC_SCALE_CONST((B08 - B15) , 0.5097956061f , 31); 241 A[10] = B[10] + B[13];
147 A13 = MPC_SCALE_CONST((B09 - B14) , 0.6013448834f , 31); 242 A[11] = B[11] + B[12];
148 A14 = MPC_SCALE_CONST((B10 - B13) , 0.8999761939f , 31); 243 A[12] = MPC_MULTIPLY_V((B[ 8] - B[15]), INVCOS04);
149 A15 = MPC_SCALE_CONST((B11 - B12) , 2.5629155636f , 29); 244 A[13] = MPC_MULTIPLY_V((B[ 9] - B[14]), INVCOS12);
150 245 A[14] = MPC_MULTIPLY_V((B[10] - B[13]), INVCOS20);
151 B00 = A00 + A03; 246 A[15] = MPC_MULTIPLY_V((B[11] - B[12]), INVCOS28);
152 B01 = A01 + A02; 247 // 8 adds, 8 subs, 8 muls, 8 shifts
153 B02 = MPC_MULTIPLY_FRACT_CONST_FIX((A00 - A03) , 0.5411961079f , 1); 248
154 B03 = MPC_MULTIPLY_FRACT_CONST_FIX((A01 - A02) , 1.3065630198f , 2); 249 B[ 0] = A[ 0] + A[ 3];
155 B04 = A04 + A07; 250 B[ 1] = A[ 1] + A[ 2];
156 B05 = A05 + A06; 251 B[ 2] = MPC_MULTIPLY_V((A[ 0] - A[ 3]), INVCOS08);
157 B06 = MPC_MULTIPLY_FRACT_CONST_FIX((A04 - A07) , 0.5411961079f , 1); 252 B[ 3] = MPC_MULTIPLY_V((A[ 1] - A[ 2]), INVCOS24);
158 B07 = MPC_MULTIPLY_FRACT_CONST_FIX((A05 - A06) , 1.3065630198f , 2); 253 B[ 4] = A[ 4] + A[ 7];
159 B08 = A08 + A11; 254 B[ 5] = A[ 5] + A[ 6];
160 B09 = A09 + A10; 255 B[ 6] = MPC_MULTIPLY_V((A[ 4] - A[ 7]), INVCOS08);
161 B10 = MPC_MULTIPLY_FRACT_CONST_FIX((A08 - A11) , 0.5411961079f , 1); 256 B[ 7] = MPC_MULTIPLY_V((A[ 5] - A[ 6]), INVCOS24);
162 B11 = MPC_MULTIPLY_FRACT_CONST_FIX((A09 - A10) , 1.3065630198f , 2); 257 B[ 8] = A[ 8] + A[11];
163 B12 = A12 + A15; 258 B[ 9] = A[ 9] + A[10];
164 B13 = A13 + A14; 259 B[10] = MPC_MULTIPLY_V((A[ 8] - A[11]), INVCOS08);
165 B14 = MPC_MULTIPLY_FRACT_CONST_FIX((A12 - A15) , 0.5411961079f , 1); 260 B[11] = MPC_MULTIPLY_V((A[ 9] - A[10]), INVCOS24);
166 B15 = MPC_MULTIPLY_FRACT_CONST_FIX((A13 - A14) , 1.3065630198f , 2); 261 B[12] = A[12] + A[15];
167 262 B[13] = A[13] + A[14];
168 A00 = B00 + B01; 263 B[14] = MPC_MULTIPLY_V((A[12] - A[15]), INVCOS08);
169 A01 = MPC_MULTIPLY_FRACT_CONST_FIX((B00 - B01) , 0.7071067691f , 1); 264 B[15] = MPC_MULTIPLY_V((A[13] - A[14]), INVCOS24);
170 A02 = B02 + B03; 265 // 8 adds, 8 subs, 8 muls, 8 shifts
171 A03 = MPC_MULTIPLY_FRACT_CONST_FIX((B02 - B03) , 0.7071067691f , 1); 266
172 A04 = B04 + B05; 267 A[ 0] = B[ 0] + B[ 1];
173 A05 = MPC_MULTIPLY_FRACT_CONST_FIX((B04 - B05) , 0.7071067691f , 1); 268 A[ 1] = MPC_MULTIPLY_V((B[ 0] - B[ 1]), INVCOS16);
174 A06 = B06 + B07; 269 A[ 2] = B[ 2] + B[ 3];
175 A07 = MPC_MULTIPLY_FRACT_CONST_FIX((B06 - B07) , 0.7071067691f , 1); 270 A[ 3] = MPC_MULTIPLY_V((B[ 2] - B[ 3]), INVCOS16);
176 A08 = B08 + B09; 271 A[ 4] = B[ 4] + B[ 5];
177 A09 = MPC_MULTIPLY_FRACT_CONST_FIX((B08 - B09) , 0.7071067691f , 1); 272 A[ 5] = MPC_MULTIPLY_V((B[ 4] - B[ 5]), INVCOS16);
178 A10 = B10 + B11; 273 A[ 6] = B[ 6] + B[ 7];
179 A11 = MPC_MULTIPLY_FRACT_CONST_FIX((B10 - B11) , 0.7071067691f , 1); 274 A[ 7] = MPC_MULTIPLY_V((B[ 6] - B[ 7]), INVCOS16);
180 A12 = B12 + B13; 275 A[ 8] = B[ 8] + B[ 9];
181 A13 = MPC_MULTIPLY_FRACT_CONST_FIX((B12 - B13) , 0.7071067691f , 1); 276 A[ 9] = MPC_MULTIPLY_V((B[ 8] - B[ 9]), INVCOS16);
182 A14 = B14 + B15; 277 A[10] = B[10] + B[11];
183 A15 = MPC_MULTIPLY_FRACT_CONST_FIX((B14 - B15) , 0.7071067691f , 1); 278 A[11] = MPC_MULTIPLY_V((B[10] - B[11]), INVCOS16);
184 279 A[12] = B[12] + B[13];
185 V[48] = -A00; 280 A[13] = MPC_MULTIPLY_V((B[12] - B[13]), INVCOS16);
186 V[ 0] = A01; 281 A[14] = B[14] + B[15];
187 V[40] = -A02 - (V[ 8] = A03); 282 A[15] = MPC_MULTIPLY_V((B[14] - B[15]), INVCOS16);
188 V[36] = -((V[ 4] = A05 + (V[12] = A07)) + A06); 283 // 8 adds, 8 subs, 8 muls, 8 shifts
189 V[44] = - A04 - A06 - A07; 284
190 V[ 6] = (V[10] = A11 + (V[14] = A15)) + A13; 285 // multiple used expressions: -(A[12] + A[14] + A[15])
191 V[38] = (V[34] = -(V[ 2] = A09 + A13 + A15) - A14) + A09 - A10 - A11; 286 V[48] = -A[ 0];
192 V[46] = (tmp = -(A12 + A14 + A15)) - A08; 287 V[ 0] = A[ 1];
193 V[42] = tmp - A10 - A11; 288 V[40] = -A[ 2] - (V[ 8] = A[ 3]);
194 289 V[36] = -((V[ 4] = A[ 5] + (V[12] = A[ 7])) + A[ 6]);
195 A00 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 0] - Sample[31]) , 0.5006030202f , MPC_FIXED_POINT_SYNTH_FIX); 290 V[44] = - A[ 4] - A[ 6] - A[ 7];
196 A01 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 1] - Sample[30]) , 0.5054709315f , MPC_FIXED_POINT_SYNTH_FIX); 291 V[ 6] = (V[10] = A[11] + (V[14] = A[15])) + A[13];
197 A02 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 2] - Sample[29]) , 0.5154473186f , MPC_FIXED_POINT_SYNTH_FIX); 292 V[38] = (V[34] = -(V[ 2] = A[ 9] + A[13] + A[15]) - A[14]) + A[ 9] - A[10] - A[11];
198 A03 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 3] - Sample[28]) , 0.5310425758f , MPC_FIXED_POINT_SYNTH_FIX); 293 V[46] = (tmp = -(A[12] + A[14] + A[15])) - A[ 8];
199 A04 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 4] - Sample[27]) , 0.5531039238f , MPC_FIXED_POINT_SYNTH_FIX); 294 V[42] = tmp - A[10] - A[11];
200 A05 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 5] - Sample[26]) , 0.5829349756f , MPC_FIXED_POINT_SYNTH_FIX); 295 // 9 adds, 9 subs
201 A06 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 6] - Sample[25]) , 0.6225041151f , MPC_FIXED_POINT_SYNTH_FIX); 296
202 A07 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 7] - Sample[24]) , 0.6748083234f , MPC_FIXED_POINT_SYNTH_FIX); 297 A[ 0] = MPC_MULTIPLY_V((Sample[ 0] - Sample[31]), INVCOS01);
203 A08 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 8] - Sample[23]) , 0.7445362806f , MPC_FIXED_POINT_SYNTH_FIX); 298 A[ 1] = MPC_MULTIPLY_V((Sample[ 1] - Sample[30]), INVCOS03);
204 A09 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[ 9] - Sample[22]) , 0.8393496275f , MPC_FIXED_POINT_SYNTH_FIX); 299 A[ 2] = MPC_MULTIPLY_V((Sample[ 2] - Sample[29]), INVCOS05);
205 A10 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[10] - Sample[21]) , 0.9725682139f , MPC_FIXED_POINT_SYNTH_FIX); 300 A[ 3] = MPC_MULTIPLY_V((Sample[ 3] - Sample[28]), INVCOS07);
206#if MPC_FIXED_POINT_SYNTH_FIX>=2 301 A[ 4] = MPC_MULTIPLY_V((Sample[ 4] - Sample[27]), INVCOS09);
207 A11 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[11] - Sample[20]) , 1.1694399118f , MPC_FIXED_POINT_SYNTH_FIX); 302 A[ 5] = MPC_MULTIPLY_V((Sample[ 5] - Sample[26]), INVCOS11);
208 A12 = MPC_MULTIPLY_FRACT_CONST_SHR((Sample[12] - Sample[19]) , 1.4841645956f , MPC_FIXED_POINT_SYNTH_FIX); 303 A[ 6] = MPC_MULTIPLY_V((Sample[ 6] - Sample[25]), INVCOS13);
209#else 304 A[ 7] = MPC_MULTIPLY_V((Sample[ 7] - Sample[24]), INVCOS15);
210 A11 = MPC_SCALE_CONST_SHR ((Sample[11] - Sample[20]) , 1.1694399118f , 30, MPC_FIXED_POINT_SYNTH_FIX); 305 A[ 8] = MPC_MULTIPLY_V((Sample[ 8] - Sample[23]), INVCOS17);
211 A12 = MPC_SCALE_CONST_SHR ((Sample[12] - Sample[19]) , 1.4841645956f , 30, MPC_FIXED_POINT_SYNTH_FIX); 306 A[ 9] = MPC_MULTIPLY_V((Sample[ 9] - Sample[22]), INVCOS19);
212#endif 307 A[10] = MPC_MULTIPLY_V((Sample[10] - Sample[21]), INVCOS21);
213 A13 = MPC_SCALE_CONST_SHR ((Sample[13] - Sample[18]) , 2.0577809811f , 29, MPC_FIXED_POINT_SYNTH_FIX); 308 A[11] = MPC_MULTIPLY_V((Sample[11] - Sample[20]), INVCOS23);
214 A14 = MPC_SCALE_CONST_SHR ((Sample[14] - Sample[17]) , 3.4076085091f , 29, MPC_FIXED_POINT_SYNTH_FIX); 309 A[12] = MPC_MULTIPLY_V((Sample[12] - Sample[19]), INVCOS25);
215 A15 = MPC_SCALE_CONST_SHR ((Sample[15] - Sample[16]) , 10.1900081635f, 27 ,MPC_FIXED_POINT_SYNTH_FIX); 310 A[13] = MPC_MULTIPLY_V((Sample[13] - Sample[18]), INVCOS27);
216 311 A[14] = MPC_MULTIPLY_V((Sample[14] - Sample[17]), INVCOS29);
217 B00 = A00 + A15; 312 A[15] = MPC_MULTIPLY_V((Sample[15] - Sample[16]), INVCOS31);
218 B01 = A01 + A14; 313 // 16 subs, 16 muls, 16 shifts
219 B02 = A02 + A13; 314
220 B03 = A03 + A12; 315 B[ 0] = A[ 0] + A[15];
221 B04 = A04 + A11; 316 B[ 1] = A[ 1] + A[14];
222 B05 = A05 + A10; 317 B[ 2] = A[ 2] + A[13];
223 B06 = A06 + A09; 318 B[ 3] = A[ 3] + A[12];
224 B07 = A07 + A08; 319 B[ 4] = A[ 4] + A[11];
225 B08 = MPC_SCALE_CONST((A00 - A15) , 0.5024192929f , 31); 320 B[ 5] = A[ 5] + A[10];
226 B09 = MPC_SCALE_CONST((A01 - A14) , 0.5224986076f , 31); 321 B[ 6] = A[ 6] + A[ 9];
227 B10 = MPC_SCALE_CONST((A02 - A13) , 0.5669440627f , 31); 322 B[ 7] = A[ 7] + A[ 8];
228 B11 = MPC_SCALE_CONST((A03 - A12) , 0.6468217969f , 31); 323 B[ 8] = MPC_MULTIPLY_V((A[ 0] - A[15]), INVCOS02);
229 B12 = MPC_SCALE_CONST((A04 - A11) , 0.7881546021f , 31); 324 B[ 9] = MPC_MULTIPLY_V((A[ 1] - A[14]), INVCOS06);
230 B13 = MPC_SCALE_CONST((A05 - A10) , 1.0606776476f , 30); 325 B[10] = MPC_MULTIPLY_V((A[ 2] - A[13]), INVCOS10);
231 B14 = MPC_SCALE_CONST((A06 - A09) , 1.7224471569f , 30); 326 B[11] = MPC_MULTIPLY_V((A[ 3] - A[12]), INVCOS14);
232 B15 = MPC_SCALE_CONST((A07 - A08) , 5.1011486053f , 28); 327 B[12] = MPC_MULTIPLY_V((A[ 4] - A[11]), INVCOS18);
233 328 B[13] = MPC_MULTIPLY_V((A[ 5] - A[10]), INVCOS22);
234 A00 = B00 + B07; 329 B[14] = MPC_MULTIPLY_V((A[ 6] - A[ 9]), INVCOS26);
235 A01 = B01 + B06; 330 B[15] = MPC_MULTIPLY_V((A[ 7] - A[ 8]), INVCOS30);
236 A02 = B02 + B05; 331 // 8 adds, 8 subs, 8 muls, 8 shift
237 A03 = B03 + B04; 332
238 A04 = MPC_SCALE_CONST((B00 - B07) , 0.5097956061f , 31); 333 A[ 0] = B[ 0] + B[ 7];
239 A05 = MPC_SCALE_CONST((B01 - B06) , 0.6013448834f , 31); 334 A[ 1] = B[ 1] + B[ 6];
240 A06 = MPC_SCALE_CONST((B02 - B05) , 0.8999761939f , 31); 335 A[ 2] = B[ 2] + B[ 5];
241 A07 = MPC_SCALE_CONST((B03 - B04) , 2.5629155636f , 29); 336 A[ 3] = B[ 3] + B[ 4];
242 A08 = B08 + B15; 337 A[ 4] = MPC_MULTIPLY_V((B[ 0] - B[ 7]), INVCOS04);
243 A09 = B09 + B14; 338 A[ 5] = MPC_MULTIPLY_V((B[ 1] - B[ 6]), INVCOS12);
244 A10 = B10 + B13; 339 A[ 6] = MPC_MULTIPLY_V((B[ 2] - B[ 5]), INVCOS20);
245 A11 = B11 + B12; 340 A[ 7] = MPC_MULTIPLY_V((B[ 3] - B[ 4]), INVCOS28);
246 A12 = MPC_SCALE_CONST((B08 - B15) , 0.5097956061f , 31); 341 A[ 8] = B[ 8] + B[15];
247 A13 = MPC_SCALE_CONST((B09 - B14) , 0.6013448834f , 31); 342 A[ 9] = B[ 9] + B[14];
248 A14 = MPC_SCALE_CONST((B10 - B13) , 0.8999761939f , 31); 343 A[10] = B[10] + B[13];
249 A15 = MPC_SCALE_CONST((B11 - B12) , 2.5629155636f , 29); 344 A[11] = B[11] + B[12];
250 345 A[12] = MPC_MULTIPLY_V((B[ 8] - B[15]), INVCOS04);
251 B00 = A00 + A03; 346 A[13] = MPC_MULTIPLY_V((B[ 9] - B[14]), INVCOS12);
252 B01 = A01 + A02; 347 A[14] = MPC_MULTIPLY_V((B[10] - B[13]), INVCOS20);
253 B02 = MPC_SCALE_CONST((A00 - A03) , 0.5411961079f , 31); 348 A[15] = MPC_MULTIPLY_V((B[11] - B[12]), INVCOS28);
254 B03 = MPC_SCALE_CONST((A01 - A02) , 1.3065630198f , 30); 349 // 8 adds, 8 subs, 8 muls, 8 shift
255 B04 = A04 + A07; 350
256 B05 = A05 + A06; 351 B[ 0] = A[ 0] + A[ 3];
257 B06 = MPC_SCALE_CONST((A04 - A07) , 0.5411961079f , 31); 352 B[ 1] = A[ 1] + A[ 2];
258 B07 = MPC_SCALE_CONST((A05 - A06) , 1.3065630198f , 30); 353 B[ 2] = MPC_MULTIPLY_V((A[ 0] - A[ 3]), INVCOS08);
259 B08 = A08 + A11; 354 B[ 3] = MPC_MULTIPLY_V((A[ 1] - A[ 2]), INVCOS24);
260 B09 = A09 + A10; 355 B[ 4] = A[ 4] + A[ 7];
261 B10 = MPC_SCALE_CONST((A08 - A11) , 0.5411961079f , 31); 356 B[ 5] = A[ 5] + A[ 6];
262 B11 = MPC_SCALE_CONST((A09 - A10) , 1.3065630198f , 30); 357 B[ 6] = MPC_MULTIPLY_V((A[ 4] - A[ 7]), INVCOS08);
263 B12 = A12 + A15; 358 B[ 7] = MPC_MULTIPLY_V((A[ 5] - A[ 6]), INVCOS24);
264 B13 = A13 + A14; 359 B[ 8] = A[ 8] + A[11];
265 B14 = MPC_SCALE_CONST((A12 - A15) , 0.5411961079f , 31); 360 B[ 9] = A[ 9] + A[10];
266 B15 = MPC_SCALE_CONST((A13 - A14) , 1.3065630198f , 30); 361 B[10] = MPC_MULTIPLY_V((A[ 8] - A[11]), INVCOS08);
267 362 B[11] = MPC_MULTIPLY_V((A[ 9] - A[10]), INVCOS24);
268 A00 = MPC_SHL(B00 + B01, MPC_FIXED_POINT_SYNTH_FIX); 363 B[12] = A[12] + A[15];
269 A01 = MPC_SCALE_CONST_SHL((B00 - B01) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX); 364 B[13] = A[13] + A[14];
270 A02 = MPC_SHL(B02 + B03, MPC_FIXED_POINT_SYNTH_FIX); 365 B[14] = MPC_MULTIPLY_V((A[12] - A[15]), INVCOS08);
271 A03 = MPC_SCALE_CONST_SHL((B02 - B03) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX); 366 B[15] = MPC_MULTIPLY_V((A[13] - A[14]), INVCOS24);
272 A04 = MPC_SHL(B04 + B05, MPC_FIXED_POINT_SYNTH_FIX); 367 // 8 adds, 8 subs, 8 muls, 8 shift
273 A05 = MPC_SCALE_CONST_SHL((B04 - B05) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX); 368
274 A06 = MPC_SHL(B06 + B07, MPC_FIXED_POINT_SYNTH_FIX); 369 A[ 0] = B[ 0] + B[ 1];
275 A07 = MPC_SCALE_CONST_SHL((B06 - B07) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX); 370 A[ 1] = MPC_MULTIPLY_V((B[ 0] - B[ 1]), INVCOS16);
276 A08 = MPC_SHL(B08 + B09, MPC_FIXED_POINT_SYNTH_FIX); 371 A[ 2] = B[ 2] + B[ 3];
277 A09 = MPC_SCALE_CONST_SHL((B08 - B09) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX); 372 A[ 3] = MPC_MULTIPLY_V((B[ 2] - B[ 3]), INVCOS16);
278 A10 = MPC_SHL(B10 + B11, MPC_FIXED_POINT_SYNTH_FIX); 373 A[ 4] = B[ 4] + B[ 5];
279 A11 = MPC_SCALE_CONST_SHL((B10 - B11) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX); 374 A[ 5] = MPC_MULTIPLY_V((B[ 4] - B[ 5]), INVCOS16);
280 A12 = MPC_SHL(B12 + B13, MPC_FIXED_POINT_SYNTH_FIX); 375 A[ 6] = B[ 6] + B[ 7];
281 A13 = MPC_SCALE_CONST_SHL((B12 - B13) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX); 376 A[ 7] = MPC_MULTIPLY_V((B[ 6] - B[ 7]), INVCOS16);
282 A14 = MPC_SHL(B14 + B15, MPC_FIXED_POINT_SYNTH_FIX); 377 A[ 8] = B[ 8] + B[ 9];
283 A15 = MPC_SCALE_CONST_SHL((B14 - B15) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX); 378 A[ 9] = MPC_MULTIPLY_V((B[ 8] - B[ 9]), INVCOS16);
284 379 A[10] = B[10] + B[11];
285 // mehrfach verwendete Ausdrücke: A04+A06+A07, A09+A13+A15 380 A[11] = MPC_MULTIPLY_V((B[10] - B[11]), INVCOS16);
286 V[ 5] = (V[11] = (V[13] = A07 + (V[15] = A15)) + A11) + A05 + A13; 381 A[12] = B[12] + B[13];
287 V[ 7] = (V[ 9] = A03 + A11 + A15) + A13; 382 A[13] = MPC_MULTIPLY_V((B[12] - B[13]), INVCOS16);
288 V[33] = -(V[ 1] = A01 + A09 + A13 + A15) - A14; 383 A[14] = B[14] + B[15];
289 V[35] = -(V[ 3] = A05 + A07 + A09 + A13 + A15) - A06 - A14; 384 A[15] = MPC_MULTIPLY_V((B[14] - B[15]), INVCOS16);
290 V[37] = (tmp = -(A10 + A11 + A13 + A14 + A15)) - A05 - A06 - A07; 385 // 8 adds, 8 subs, 8 muls, 8 shift
291 V[39] = tmp - A02 - A03; // abhängig vom Befehl drüber 386
292 V[41] = (tmp += A13 - A12) - A02 - A03; // abhängig vom Befehl 2 drüber 387 // multiple used expressions: A[ 4]+A[ 6]+A[ 7], A[ 9]+A[13]+A[15]
293 V[43] = tmp - A04 - A06 - A07; // abhängig von Befehlen 1 und 3 drüber 388 V[ 5] = (V[11] = (V[13] = A[ 7] + (V[15] = A[15])) + A[11]) + A[ 5] + A[13];
294 V[47] = (tmp = -(A08 + A12 + A14 + A15)) - A00; 389 V[ 7] = (V[ 9] = A[ 3] + A[11] + A[15]) + A[13];
295 V[45] = tmp - A04 - A06 - A07; // abhängig vom Befehl drüber 390 V[33] = -(V[ 1] = A[ 1] + A[ 9] + A[13] + A[15]) - A[14];
296 391 V[35] = -(V[ 3] = A[ 5] + A[ 7] + A[ 9] + A[13] + A[15]) - A[ 6] - A[14];
297 V[32] = -V[ 0]; 392 V[37] = (tmp = -(A[10] + A[11] + A[13] + A[14] + A[15])) - A[ 5] - A[ 6] - A[ 7];
298 V[31] = -V[ 1]; 393 V[39] = tmp - A[ 2] - A[ 3];
299 V[30] = -V[ 2]; 394 V[41] = (tmp += A[13] - A[12]) - A[ 2] - A[ 3];
300 V[29] = -V[ 3]; 395 V[43] = tmp - A[ 4] - A[ 6] - A[ 7];
301 V[28] = -V[ 4]; 396 V[47] = (tmp = -(A[ 8] + A[12] + A[14] + A[15])) - A[ 0];
302 V[27] = -V[ 5]; 397 V[45] = tmp - A[ 4] - A[ 6] - A[ 7];
303 V[26] = -V[ 6]; 398 // 22 adds, 18 subs
304 V[25] = -V[ 7]; 399
305 V[24] = -V[ 8]; 400 V[32] = -(V[ 0] = MPC_V_PRESHIFT(V[ 0]));
306 V[23] = -V[ 9]; 401 V[31] = -(V[ 1] = MPC_V_PRESHIFT(V[ 1]));
307 V[22] = -V[10]; 402 V[30] = -(V[ 2] = MPC_V_PRESHIFT(V[ 2]));
308 V[21] = -V[11]; 403 V[29] = -(V[ 3] = MPC_V_PRESHIFT(V[ 3]));
309 V[20] = -V[12]; 404 V[28] = -(V[ 4] = MPC_V_PRESHIFT(V[ 4]));
310 V[19] = -V[13]; 405 V[27] = -(V[ 5] = MPC_V_PRESHIFT(V[ 5]));
311 V[18] = -V[14]; 406 V[26] = -(V[ 6] = MPC_V_PRESHIFT(V[ 6]));
312 V[17] = -V[15]; 407 V[25] = -(V[ 7] = MPC_V_PRESHIFT(V[ 7]));
313 408 V[24] = -(V[ 8] = MPC_V_PRESHIFT(V[ 8]));
314 V[63] = V[33]; 409 V[23] = -(V[ 9] = MPC_V_PRESHIFT(V[ 9]));
315 V[62] = V[34]; 410 V[22] = -(V[10] = MPC_V_PRESHIFT(V[10]));
316 V[61] = V[35]; 411 V[21] = -(V[11] = MPC_V_PRESHIFT(V[11]));
317 V[60] = V[36]; 412 V[20] = -(V[12] = MPC_V_PRESHIFT(V[12]));
318 V[59] = V[37]; 413 V[19] = -(V[13] = MPC_V_PRESHIFT(V[13]));
319 V[58] = V[38]; 414 V[18] = -(V[14] = MPC_V_PRESHIFT(V[14]));
320 V[57] = V[39]; 415 V[17] = -(V[15] = MPC_V_PRESHIFT(V[15]));
321 V[56] = V[40]; 416 // 16 adds, 16 shifts (OPTIMIZE_FOR_SPEED only)
322 V[55] = V[41]; 417
323 V[54] = V[42]; 418 V[63] = (V[33] = MPC_V_PRESHIFT(V[33]));
324 V[53] = V[43]; 419 V[62] = (V[34] = MPC_V_PRESHIFT(V[34]));
325 V[52] = V[44]; 420 V[61] = (V[35] = MPC_V_PRESHIFT(V[35]));
326 V[51] = V[45]; 421 V[60] = (V[36] = MPC_V_PRESHIFT(V[36]));
327 V[50] = V[46]; 422 V[59] = (V[37] = MPC_V_PRESHIFT(V[37]));
328 V[49] = V[47]; 423 V[58] = (V[38] = MPC_V_PRESHIFT(V[38]));
424 V[57] = (V[39] = MPC_V_PRESHIFT(V[39]));
425 V[56] = (V[40] = MPC_V_PRESHIFT(V[40]));
426 V[55] = (V[41] = MPC_V_PRESHIFT(V[41]));
427 V[54] = (V[42] = MPC_V_PRESHIFT(V[42]));
428 V[53] = (V[43] = MPC_V_PRESHIFT(V[43]));
429 V[52] = (V[44] = MPC_V_PRESHIFT(V[44]));
430 V[51] = (V[45] = MPC_V_PRESHIFT(V[45]));
431 V[50] = (V[46] = MPC_V_PRESHIFT(V[46]));
432 V[49] = (V[47] = MPC_V_PRESHIFT(V[47]));
433 V[48] = (V[48] = MPC_V_PRESHIFT(V[48]));
434 // 16 adds, 16 shifts (OPTIMIZE_FOR_SPEED only)
435
436 // OPTIMIZE_FOR_SPEED total: 143 adds, 107 subs, 80 muls, 112 shifts
437 // total: 111 adds, 107 subs, 80 muls, 80 shifts
438}
439
440static inline void
441mpc_decoder_windowing_D(MPC_SAMPLE_FORMAT * Data, const MPC_SAMPLE_FORMAT * V)
442{
443 const MPC_SAMPLE_FORMAT *D = (const MPC_SAMPLE_FORMAT *) &Di_opt;
444 mpc_int32_t k;
445
446 #if defined(OPTIMIZE_FOR_SPEED)
447 #if defined(CPU_ARM)
448 // 32=32x32-multiply assembler for ARM
449 for ( k = 0; k < 32; k++, V++ )
450 {
451 asm volatile (
452 "ldmia %[D]!, { r0-r3 } \n\t"
453 "ldr r4, [%[V]] \n\t"
454 "mul r5, r0, r4 \n\t"
455 "ldr r4, [%[V], #96*4] \n\t"
456 "mla r5, r1, r4, r5 \n\t"
457 "ldr r4, [%[V], #128*4] \n\t"
458 "mla r5, r2, r4, r5 \n\t"
459 "ldr r4, [%[V], #224*4] \n\t"
460 "mla r5, r3, r4, r5 \n\t"
461
462 "ldmia %[D]!, { r0-r3 } \n\t"
463 "ldr r4, [%[V], #256*4] \n\t"
464 "mla r5, r0, r4, r5 \n\t"
465 "ldr r4, [%[V], #352*4] \n\t"
466 "mla r5, r1, r4, r5 \n\t"
467 "ldr r4, [%[V], #384*4] \n\t"
468 "mla r5, r2, r4, r5 \n\t"
469 "ldr r4, [%[V], #480*4] \n\t"
470 "mla r5, r3, r4, r5 \n\t"
471
472 "ldmia %[D]!, { r0-r3 } \n\t"
473 "ldr r4, [%[V], #512*4] \n\t"
474 "mla r5, r0, r4, r5 \n\t"
475 "ldr r4, [%[V], #608*4] \n\t"
476 "mla r5, r1, r4, r5 \n\t"
477 "ldr r4, [%[V], #640*4] \n\t"
478 "mla r5, r2, r4, r5 \n\t"
479 "ldr r4, [%[V], #736*4] \n\t"
480 "mla r5, r3, r4, r5 \n\t"
481
482 "ldmia %[D]!, { r0-r3 } \n\t"
483 "ldr r4, [%[V], #768*4] \n\t"
484 "mla r5, r0, r4, r5 \n\t"
485 "ldr r4, [%[V], #864*4] \n\t"
486 "mla r5, r1, r4, r5 \n\t"
487 "ldr r4, [%[V], #896*4] \n\t"
488 "mla r5, r2, r4, r5 \n\t"
489 "ldr r4, [%[V], #992*4] \n\t"
490 "mla r5, r3, r4, r5 \n\t"
491 "str r5, [%[Data]], #4 \n"
492 : [Data] "+r" (Data), [D] "+r" (D)
493 : [V] "r" (V)
494 : "r0", "r1", "r2", "r3", "r4", "r5");
495 }
496 #else
497 // 32=32x32-multiply (FIXED_POINT)
498 for ( k = 0; k < 32; k++, D += 16, V++ )
499 {
500 *Data = V[ 0]*D[ 0] + V[ 96]*D[ 1] + V[128]*D[ 2] + V[224]*D[ 3]
501 + V[256]*D[ 4] + V[352]*D[ 5] + V[384]*D[ 6] + V[480]*D[ 7]
502 + V[512]*D[ 8] + V[608]*D[ 9] + V[640]*D[10] + V[736]*D[11]
503 + V[768]*D[12] + V[864]*D[13] + V[896]*D[14] + V[992]*D[15];
504 Data += 1;
505 // total: 16 muls, 15 adds
506 }
507 #endif
508 #else
509 #if defined(CPU_COLDFIRE)
510 // 64=32x32-multiply assembler for Coldfire
511 for ( k = 0; k < 32; k++, D += 16, V++ )
512 {
513 asm volatile (
514 "movem.l (%[D]), %%d0-%%d3 \n\t"
515 "move.l (%[V]), %%a5 \n\t"
516 "mac.l %%d0, %%a5, (96*4, %[V]), %%a5, %%acc0 \n\t"
517 "mac.l %%d1, %%a5, (128*4, %[V]), %%a5, %%acc0\n\t"
518 "mac.l %%d2, %%a5, (224*4, %[V]), %%a5, %%acc0\n\t"
519 "mac.l %%d3, %%a5, (256*4, %[V]), %%a5, %%acc0\n\t"
520 "movem.l (4*4, %[D]), %%d0-%%d3 \n\t"
521 "mac.l %%d0, %%a5, (352*4, %[V]), %%a5, %%acc0\n\t"
522 "mac.l %%d1, %%a5, (384*4, %[V]), %%a5, %%acc0\n\t"
523 "mac.l %%d2, %%a5, (480*4, %[V]), %%a5, %%acc0\n\t"
524 "mac.l %%d3, %%a5, (512*4, %[V]), %%a5, %%acc0\n\t"
525 "movem.l (8*4, %[D]), %%d0-%%d3 \n\t"
526 "mac.l %%d0, %%a5, (608*4, %[V]), %%a5, %%acc0\n\t"
527 "mac.l %%d1, %%a5, (640*4, %[V]), %%a5, %%acc0\n\t"
528 "mac.l %%d2, %%a5, (736*4, %[V]), %%a5, %%acc0\n\t"
529 "mac.l %%d3, %%a5, (768*4, %[V]), %%a5, %%acc0\n\t"
530 "movem.l (12*4, %[D]), %%d0-%%d3 \n\t"
531 "mac.l %%d0, %%a5, (864*4, %[V]), %%a5, %%acc0\n\t"
532 "mac.l %%d1, %%a5, (896*4, %[V]), %%a5, %%acc0\n\t"
533 "mac.l %%d2, %%a5, (992*4, %[V]), %%a5, %%acc0\n\t"
534 "mac.l %%d3, %%a5, %%acc0 \n\t"
535 "movclr.l %%acc0, %%d0 \n\t"
536 "move.l %%d0, (%[Data])+ \n"
537 : [Data] "+a" (Data)
538 : [V] "a" (V), [D] "a" (D)
539 : "d0", "d1", "d2", "d3", "a5");
540 }
541 #elif defined(CPU_ARM)
542 // 64=32x32-multiply assembler for ARM
543 for ( k = 0; k < 32; k++, V++ )
544 {
545 asm volatile (
546 "ldmia %[D]!, { r0-r3 } \n\t"
547 "ldr r4, [%[V]] \n\t"
548 "smull r5, r6, r0, r4 \n\t"
549 "ldr r4, [%[V], #96*4] \n\t"
550 "smlal r5, r6, r1, r4 \n\t"
551 "ldr r4, [%[V], #128*4] \n\t"
552 "smlal r5, r6, r2, r4 \n\t"
553 "ldr r4, [%[V], #224*4] \n\t"
554 "smlal r5, r6, r3, r4 \n\t"
555
556 "ldmia %[D]!, { r0-r3 } \n\t"
557 "ldr r4, [%[V], #256*4] \n\t"
558 "smlal r5, r6, r0, r4 \n\t"
559 "ldr r4, [%[V], #352*4] \n\t"
560 "smlal r5, r6, r1, r4 \n\t"
561 "ldr r4, [%[V], #384*4] \n\t"
562 "smlal r5, r6, r2, r4 \n\t"
563 "ldr r4, [%[V], #480*4] \n\t"
564 "smlal r5, r6, r3, r4 \n\t"
565
566 "ldmia %[D]!, { r0-r3 } \n\t"
567 "ldr r4, [%[V], #512*4] \n\t"
568 "smlal r5, r6, r0, r4 \n\t"
569 "ldr r4, [%[V], #608*4] \n\t"
570 "smlal r5, r6, r1, r4 \n\t"
571 "ldr r4, [%[V], #640*4] \n\t"
572 "smlal r5, r6, r2, r4 \n\t"
573 "ldr r4, [%[V], #736*4] \n\t"
574 "smlal r5, r6, r3, r4 \n\t"
575
576 "ldmia %[D]!, { r0-r3 } \n\t"
577 "ldr r4, [%[V], #768*4] \n\t"
578 "smlal r5, r6, r0, r4 \n\t"
579 "ldr r4, [%[V], #864*4] \n\t"
580 "smlal r5, r6, r1, r4 \n\t"
581 "ldr r4, [%[V], #896*4] \n\t"
582 "smlal r5, r6, r2, r4 \n\t"
583 "ldr r4, [%[V], #992*4] \n\t"
584 "smlal r5, r6, r3, r4 \n\t"
585 "mov r4, r6, lsl #1 \n\t"
586 "orr r4, r4, r5, lsr #31\n\t"
587 "str r4, [%[Data]], #4 \n"
588 : [Data] "+r" (Data), [D] "+r" (D)
589 : [V] "r" (V)
590 : "r0", "r1", "r2", "r3", "r4", "r5", "r6");
591 }
592 #else
593 // 64=64x64-multiply (FIXED_POINT) or float=float*float (!FIXED_POINT) in C
594 for ( k = 0; k < 32; k++, D += 16, V++ )
595 {
596 *Data = MPC_MULTIPLY_EX(V[ 0],D[ 0],31) + MPC_MULTIPLY_EX(V[ 96],D[ 1],31) + MPC_MULTIPLY_EX(V[128],D[ 2],31) + MPC_MULTIPLY_EX(V[224],D[ 3],31)
597 + MPC_MULTIPLY_EX(V[256],D[ 4],31) + MPC_MULTIPLY_EX(V[352],D[ 5],31) + MPC_MULTIPLY_EX(V[384],D[ 6],31) + MPC_MULTIPLY_EX(V[480],D[ 7],31)
598 + MPC_MULTIPLY_EX(V[512],D[ 8],31) + MPC_MULTIPLY_EX(V[608],D[ 9],31) + MPC_MULTIPLY_EX(V[640],D[10],31) + MPC_MULTIPLY_EX(V[736],D[11],31)
599 + MPC_MULTIPLY_EX(V[768],D[12],31) + MPC_MULTIPLY_EX(V[864],D[13],31) + MPC_MULTIPLY_EX(V[896],D[14],31) + MPC_MULTIPLY_EX(V[992],D[15],31);
600 Data += 1;
601 // total: 16 muls, 15 adds, 16 shifts
602 }
603 #endif
604 #endif
329} 605}
330 606
331static void Synthese_Filter_float_internal(MPC_SAMPLE_FORMAT * OutData,MPC_SAMPLE_FORMAT * V,const MPC_SAMPLE_FORMAT * Y) 607static void
608mpc_full_synthesis_filter(MPC_SAMPLE_FORMAT *OutData, MPC_SAMPLE_FORMAT *V, const MPC_SAMPLE_FORMAT *Y)
332{ 609{
333 mpc_uint32_t n; 610 mpc_uint32_t n;
334 for ( n = 0; n < 36; n++, Y += 32 ) { 611
335 V -= 64; 612 if (NULL != OutData)
336 Calculate_New_V ( Y, V ); 613 {
337 if (OutData != NULL) 614 for ( n = 0; n < 36; n++, Y += 32, OutData += 32 )
338 { 615 {
339 MPC_SAMPLE_FORMAT * Data = OutData; 616 V -= 64;
340 const MPC_SAMPLE_FORMAT * D = (const MPC_SAMPLE_FORMAT *) &Di_opt; 617 mpc_calculate_new_V ( Y, V );
341 mpc_int32_t k; 618 mpc_decoder_windowing_D( OutData, V);
342 //mpc_int32_t tmp;
343
344
345
346 #if defined(CPU_COLDFIRE)
347 for ( k = 0; k < 32; k++, D += 16, V++ ) {
348 asm volatile (
349 "movem.l (%[D]), %%d0-%%d3 \n\t"
350 "move.l (%[V]), %%a5 \n\t"
351 "mac.l %%d0, %%a5, (96*4, %[V]), %%a5, %%acc0 \n\t"
352 "mac.l %%d1, %%a5, (128*4, %[V]), %%a5, %%acc0\n\t"
353 "mac.l %%d2, %%a5, (224*4, %[V]), %%a5, %%acc0\n\t"
354 "mac.l %%d3, %%a5, (256*4, %[V]), %%a5, %%acc0\n\t"
355 "movem.l (4*4, %[D]), %%d0-%%d3 \n\t"
356 "mac.l %%d0, %%a5, (352*4, %[V]), %%a5, %%acc0\n\t"
357 "mac.l %%d1, %%a5, (384*4, %[V]), %%a5, %%acc0\n\t"
358 "mac.l %%d2, %%a5, (480*4, %[V]), %%a5, %%acc0\n\t"
359 "mac.l %%d3, %%a5, (512*4, %[V]), %%a5, %%acc0\n\t"
360 "movem.l (8*4, %[D]), %%d0-%%d3 \n\t"
361 "mac.l %%d0, %%a5, (608*4, %[V]), %%a5, %%acc0\n\t"
362 "mac.l %%d1, %%a5, (640*4, %[V]), %%a5, %%acc0\n\t"
363 "mac.l %%d2, %%a5, (736*4, %[V]), %%a5, %%acc0\n\t"
364 "mac.l %%d3, %%a5, (768*4, %[V]), %%a5, %%acc0\n\t"
365 "movem.l (12*4, %[D]), %%d0-%%d3 \n\t"
366 "mac.l %%d0, %%a5, (864*4, %[V]), %%a5, %%acc0\n\t"
367 "mac.l %%d1, %%a5, (896*4, %[V]), %%a5, %%acc0\n\t"
368 "mac.l %%d2, %%a5, (992*4, %[V]), %%a5, %%acc0\n\t"
369 "mac.l %%d3, %%a5, %%acc0 \n\t"
370 "movclr.l %%acc0, %%d0 \n\t"
371 "move.l %%d0, (%[Data])+ \n"
372 : [Data] "+a" (Data)
373 : [V] "a" (V), [D] "a" (D)
374 : "d0", "d1", "d2", "d3", "a5");
375 #elif defined(CPU_ARM)
376 for ( k = 0; k < 32; k++, V++ ) {
377 asm volatile (
378 "ldmia %[D]!, { r0-r3 } \n\t"
379 "ldr r4, [%[V]] \n\t"
380 "smull r5, r6, r0, r4 \n\t"
381 "ldr r4, [%[V], #96*4] \n\t"
382 "smlal r5, r6, r1, r4 \n\t"
383 "ldr r4, [%[V], #128*4] \n\t"
384 "smlal r5, r6, r2, r4 \n\t"
385 "ldr r4, [%[V], #224*4] \n\t"
386 "smlal r5, r6, r3, r4 \n\t"
387
388 "ldmia %[D]!, { r0-r3 } \n\t"
389 "ldr r4, [%[V], #256*4] \n\t"
390 "smlal r5, r6, r0, r4 \n\t"
391 "ldr r4, [%[V], #352*4] \n\t"
392 "smlal r5, r6, r1, r4 \n\t"
393 "ldr r4, [%[V], #384*4] \n\t"
394 "smlal r5, r6, r2, r4 \n\t"
395 "ldr r4, [%[V], #480*4] \n\t"
396 "smlal r5, r6, r3, r4 \n\t"
397
398 "ldmia %[D]!, { r0-r3 } \n\t"
399 "ldr r4, [%[V], #512*4] \n\t"
400 "smlal r5, r6, r0, r4 \n\t"
401 "ldr r4, [%[V], #608*4] \n\t"
402 "smlal r5, r6, r1, r4 \n\t"
403 "ldr r4, [%[V], #640*4] \n\t"
404 "smlal r5, r6, r2, r4 \n\t"
405 "ldr r4, [%[V], #736*4] \n\t"
406 "smlal r5, r6, r3, r4 \n\t"
407
408 "ldmia %[D]!, { r0-r3 } \n\t"
409 "ldr r4, [%[V], #768*4] \n\t"
410 "smlal r5, r6, r0, r4 \n\t"
411 "ldr r4, [%[V], #864*4] \n\t"
412 "smlal r5, r6, r1, r4 \n\t"
413 "ldr r4, [%[V], #896*4] \n\t"
414 "smlal r5, r6, r2, r4 \n\t"
415 "ldr r4, [%[V], #992*4] \n\t"
416 "smlal r5, r6, r3, r4 \n\t"
417 "mov r4, r6, lsl #1 \n\t"
418 "orr r4, r4, r5, lsr #31\n\t"
419 "str r4, [%[Data]], #4 \n"
420 : [Data] "+r" (Data), [D] "+r" (D)
421 : [V] "r" (V)
422 : "r0", "r1", "r2", "r3", "r4", "r5", "r6");
423 #else
424 for ( k = 0; k < 32; k++, D += 16, V++ ) {
425 *Data = MPC_SHL(
426 MPC_MULTIPLY_FRACT(V[ 0],D[ 0]) + MPC_MULTIPLY_FRACT(V[ 96],D[ 1]) + MPC_MULTIPLY_FRACT(V[128],D[ 2]) + MPC_MULTIPLY_FRACT(V[224],D[ 3])
427 + MPC_MULTIPLY_FRACT(V[256],D[ 4]) + MPC_MULTIPLY_FRACT(V[352],D[ 5]) + MPC_MULTIPLY_FRACT(V[384],D[ 6]) + MPC_MULTIPLY_FRACT(V[480],D[ 7])
428 + MPC_MULTIPLY_FRACT(V[512],D[ 8]) + MPC_MULTIPLY_FRACT(V[608],D[ 9]) + MPC_MULTIPLY_FRACT(V[640],D[10]) + MPC_MULTIPLY_FRACT(V[736],D[11])
429 + MPC_MULTIPLY_FRACT(V[768],D[12]) + MPC_MULTIPLY_FRACT(V[864],D[13]) + MPC_MULTIPLY_FRACT(V[896],D[14]) + MPC_MULTIPLY_FRACT(V[992],D[15])
430 , 1);
431
432 Data += 1;
433 #endif
434 }
435 V -= 32;//bleh
436 OutData+=32;
437 } 619 }
438 } 620 }
439} 621}
440 622
441void 623void
442mpc_decoder_synthese_filter_float(mpc_decoder *d, MPC_SAMPLE_FORMAT* OutData) 624mpc_decoder_synthese_filter_float(mpc_decoder *d, MPC_SAMPLE_FORMAT *OutData)
443{ 625{
444 /********* left channel ********/ 626 /********* left channel ********/
445 memmove(d->V_L + MPC_V_MEM, d->V_L, 960 * sizeof(MPC_SAMPLE_FORMAT) ); 627 memmove(d->V_L + MPC_V_MEM, d->V_L, 960 * sizeof(MPC_SAMPLE_FORMAT) );
446 628
447 Synthese_Filter_float_internal( 629 mpc_full_synthesis_filter(
448 OutData, 630 OutData,
449 (MPC_SAMPLE_FORMAT *)(d->V_L + MPC_V_MEM), 631 (MPC_SAMPLE_FORMAT *)(d->V_L + MPC_V_MEM),
450 (MPC_SAMPLE_FORMAT *)(d->Y_L [0])); 632 (MPC_SAMPLE_FORMAT *)(d->Y_L [0]));
@@ -452,7 +634,7 @@ mpc_decoder_synthese_filter_float(mpc_decoder *d, MPC_SAMPLE_FORMAT* OutData)
452 /******** right channel ********/ 634 /******** right channel ********/
453 memmove(d->V_R + MPC_V_MEM, d->V_R, 960 * sizeof(MPC_SAMPLE_FORMAT) ); 635 memmove(d->V_R + MPC_V_MEM, d->V_R, 960 * sizeof(MPC_SAMPLE_FORMAT) );
454 636
455 Synthese_Filter_float_internal( 637 mpc_full_synthesis_filter(
456 (OutData == NULL ? NULL : OutData + MPC_FRAME_LENGTH), 638 (OutData == NULL ? NULL : OutData + MPC_FRAME_LENGTH),
457 (MPC_SAMPLE_FORMAT *)(d->V_R + MPC_V_MEM), 639 (MPC_SAMPLE_FORMAT *)(d->V_R + MPC_V_MEM),
458 (MPC_SAMPLE_FORMAT *)(d->Y_R [0])); 640 (MPC_SAMPLE_FORMAT *)(d->Y_R [0]));
diff --git a/apps/codecs/mpc.c b/apps/codecs/mpc.c
index 122cb22025..8143e04f71 100644
--- a/apps/codecs/mpc.c
+++ b/apps/codecs/mpc.c
@@ -64,8 +64,8 @@ mpc_bool_t canseek_impl(void *data)
64} 64}
65 65
66MPC_SAMPLE_FORMAT sample_buffer[MPC_DECODER_BUFFER_LENGTH] 66MPC_SAMPLE_FORMAT sample_buffer[MPC_DECODER_BUFFER_LENGTH]
67IBSS_ATTR_MPC_SAMPLE_BUF; 67 IBSS_ATTR_MPC_SAMPLE_BUF;
68mpc_uint32_t seek_table[10000]; 68mpc_uint32_t seek_table[10000];
69 69
70/* this is the codec entry point */ 70/* this is the codec entry point */
71enum codec_status codec_main(void) 71enum codec_status codec_main(void)
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-02 20:37:46 +0000