Mercurial > mplayer.hg
annotate mp3lib/decod386.c @ 15533:ddf15d233d58
Do not switch to audio tracks whose codec private data differs from the main audio track's as this will most likely result in messed up audio output. Patch by Michael Behrisch <list () behrisch ! de>
author | mosu |
---|---|
date | Sat, 21 May 2005 06:50:08 +0000 |
parents | 07e7a572bd84 |
children | e7a129082fda |
rev | line source |
---|---|
15167
07e7a572bd84
Mark modified imported files as such to comply with (L)GPL ¡ø2a.
diego
parents:
13188
diff
changeset
|
1 /* |
07e7a572bd84
Mark modified imported files as such to comply with (L)GPL ¡ø2a.
diego
parents:
13188
diff
changeset
|
2 * Modified for use with MPlayer, for details see the CVS changelog at |
07e7a572bd84
Mark modified imported files as such to comply with (L)GPL ¡ø2a.
diego
parents:
13188
diff
changeset
|
3 * http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/ |
07e7a572bd84
Mark modified imported files as such to comply with (L)GPL ¡ø2a.
diego
parents:
13188
diff
changeset
|
4 * $Id$ |
07e7a572bd84
Mark modified imported files as such to comply with (L)GPL ¡ø2a.
diego
parents:
13188
diff
changeset
|
5 */ |
07e7a572bd84
Mark modified imported files as such to comply with (L)GPL ¡ø2a.
diego
parents:
13188
diff
changeset
|
6 |
1 | 7 /* |
8 * Mpeg Layer-1,2,3 audio decoder | |
9 * ------------------------------ | |
10 * copyright (c) 1995,1996,1997 by Michael Hipp, All rights reserved. | |
11 * See also 'README' | |
12 * | |
13 * slighlty optimized for machines without autoincrement/decrement. | |
14 * The performance is highly compiler dependend. Maybe | |
15 * the decode.c version for 'normal' processor may be faster | |
16 * even for Intel processors. | |
17 */ | |
18 | |
19 | |
1318
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
20 #include "../config.h" |
1 | 21 |
1318
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
22 #if 0 |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
23 /* old WRITE_SAMPLE */ |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
24 /* is portable */ |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
25 #define WRITE_SAMPLE(samples,sum,clip) { \ |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
26 if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \ |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
27 else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; }\ |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
28 else { *(samples) = sum; } \ |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
29 } |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
30 #else |
1 | 31 /* new WRITE_SAMPLE */ |
1318
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
32 |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
33 /* |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
34 * should be the same as the "old WRITE_SAMPLE" macro above, but uses |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
35 * some tricks to avoid double->int conversions and floating point compares. |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
36 * |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
37 * Here's how it works: |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
38 * ((((65536.0 * 65536.0 * 16)+(65536.0 * 0.5))* 65536.0)) is |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
39 * 0x0010000080000000LL in hex. It computes 0x0010000080000000LL + sum |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
40 * as a double IEEE fp value and extracts the low-order 32-bits from the |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
41 * IEEE fp representation stored in memory. The 2^56 bit in the constant |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
42 * is intended to force the bits of "sum" into the least significant bits |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
43 * of the double mantissa. After an integer substraction of 0x80000000 |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
44 * we have the original double value "sum" converted to an 32-bit int value. |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
45 * |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
46 * (Is that really faster than the clean and simple old version of the macro?) |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
47 */ |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
48 |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
49 /* |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
50 * On a SPARC cpu, we fetch the low-order 32-bit from the second 32-bit |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
51 * word of the double fp value stored in memory. On an x86 cpu, we fetch it |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
52 * from the first 32-bit word. |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
53 * I'm not sure if the WORDS_BIGENDIAN feature test covers all possible memory |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
54 * layouts of double floating point values an all cpu architectures. If |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
55 * it doesn't work for you, just enable the "old WRITE_SAMPLE" macro. |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
56 */ |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
57 #if WORDS_BIGENDIAN |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
58 #define MANTISSA_OFFSET 1 |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
59 #else |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
60 #define MANTISSA_OFFSET 0 |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
61 #endif |
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
62 |
1 | 63 /* sizeof(int) == 4 */ |
64 #define WRITE_SAMPLE(samples,sum,clip) { \ | |
7299
131497b1f6ad
- GCC 3.x (SPARC) is too clever for the double->int conversion trick used in
jkeil
parents:
4321
diff
changeset
|
65 union { double dtemp; int itemp[2]; } u; int v; \ |
131497b1f6ad
- GCC 3.x (SPARC) is too clever for the double->int conversion trick used in
jkeil
parents:
4321
diff
changeset
|
66 u.dtemp = ((((65536.0 * 65536.0 * 16)+(65536.0 * 0.5))* 65536.0)) + (sum);\ |
131497b1f6ad
- GCC 3.x (SPARC) is too clever for the double->int conversion trick used in
jkeil
parents:
4321
diff
changeset
|
67 v = u.itemp[MANTISSA_OFFSET] - 0x80000000; \ |
1 | 68 if( v > 32767) { *(samples) = 0x7fff; (clip)++; } \ |
69 else if( v < -32768) { *(samples) = -0x8000; (clip)++; } \ | |
70 else { *(samples) = v; } \ | |
71 } | |
1318
2052e18abd9d
mp3 audio decoding didn't work on big-endian architectures
jkeil
parents:
1258
diff
changeset
|
72 #endif |
1 | 73 |
74 | |
75 /* | |
76 #define WRITE_SAMPLE(samples,sum,clip) { \ | |
77 double dtemp; int v; \ | |
78 dtemp = ((((65536.0 * 65536.0 * 16)+(65536.0 * 0.5))* 65536.0)) + (sum);\ | |
79 v = ((*(int *)&dtemp) - 0x80000000); \ | |
80 if( v > 32767) { *(samples) = 0x7fff; (clip)++; } \ | |
81 else if( v < -32768) { *(samples) = -0x8000; (clip)++; } \ | |
82 else { *(samples) = v; } \ | |
83 } | |
84 */ | |
85 | |
13188 | 86 static int synth_1to1(real *bandPtr,int channel,unsigned char *out,int *pnt); |
87 | |
1 | 88 static int synth_1to1_mono(real *bandPtr,unsigned char *samples,int *pnt) |
89 { | |
90 short samples_tmp[64]; | |
91 short *tmp1 = samples_tmp; | |
92 int i,ret; | |
93 int pnt1 = 0; | |
94 | |
95 ret = synth_1to1(bandPtr,0,(unsigned char *) samples_tmp,&pnt1); | |
96 samples += *pnt; | |
97 | |
98 for(i=0;i<32;i++) { | |
99 *( (short *) samples) = *tmp1; | |
100 samples += 2; | |
101 tmp1 += 2; | |
102 } | |
103 *pnt += 64; | |
104 | |
105 return ret; | |
106 } | |
107 | |
108 | |
109 static int synth_1to1_mono2stereo(real *bandPtr,unsigned char *samples,int *pnt) | |
110 { | |
111 int i,ret; | |
112 | |
113 ret = synth_1to1(bandPtr,0,samples,pnt); | |
114 samples = samples + *pnt - 128; | |
115 | |
116 for(i=0;i<32;i++) { | |
117 ((short *)samples)[1] = ((short *)samples)[0]; | |
118 samples+=4; | |
119 } | |
120 | |
121 return ret; | |
122 } | |
123 | |
12134 | 124 static synth_func_t synth_func; |
1245
03b7e2955a20
Added newest MMX-optimized decore which speedups decoding at least on 13% for any cpu.
nick
parents:
787
diff
changeset
|
125 |
4321 | 126 #if defined(CAN_COMPILE_X86_ASM) |
13188 | 127 int synth_1to1_MMX( real *bandPtr,int channel,short * samples) |
1245
03b7e2955a20
Added newest MMX-optimized decore which speedups decoding at least on 13% for any cpu.
nick
parents:
787
diff
changeset
|
128 { |
1942
853be3ebe862
Eeeh I need some sleep, accidently commited a wrong version of the files that had other changes, too.
atmos4
parents:
1941
diff
changeset
|
129 static short buffs[2][2][0x110]; |
853be3ebe862
Eeeh I need some sleep, accidently commited a wrong version of the files that had other changes, too.
atmos4
parents:
1941
diff
changeset
|
130 static int bo = 1; |
853be3ebe862
Eeeh I need some sleep, accidently commited a wrong version of the files that had other changes, too.
atmos4
parents:
1941
diff
changeset
|
131 synth_1to1_MMX_s(bandPtr, channel, samples, (short *) buffs, &bo); |
1245
03b7e2955a20
Added newest MMX-optimized decore which speedups decoding at least on 13% for any cpu.
nick
parents:
787
diff
changeset
|
132 return 0; |
1258 | 133 } |
134 #endif | |
9002 | 135 |
136 #ifdef HAVE_ALTIVEC | |
137 #define dct64_base(a,b,c) if(gCpuCaps.hasAltiVec) dct64_altivec(a,b,c); else dct64(a,b,c) | |
138 #else /* HAVE_ALTIVEC */ | |
139 #define dct64_base(a,b,c) dct64(a,b,c) | |
140 #endif /* HAVE_ALTIVEC */ | |
141 | |
1 | 142 static int synth_1to1(real *bandPtr,int channel,unsigned char *out,int *pnt) |
143 { | |
144 static real buffs[2][2][0x110]; | |
145 static const int step = 2; | |
146 static int bo = 1; | |
147 short *samples = (short *) (out + *pnt); | |
148 real *b0,(*buf)[0x110]; | |
149 int clip = 0; | |
150 int bo1; | |
8543 | 151 |
152 *pnt += 128; | |
153 | |
4149 | 154 /* optimized for x86 */ |
4321 | 155 #if defined(CAN_COMPILE_X86_ASM) |
1245
03b7e2955a20
Added newest MMX-optimized decore which speedups decoding at least on 13% for any cpu.
nick
parents:
787
diff
changeset
|
156 if ( synth_func ) |
787 | 157 { |
8543 | 158 // printf("Calling %p, bandPtr=%p channel=%d samples=%p\n",synth_func,bandPtr,channel,samples); |
159 // FIXME: synth_func() may destroy EBP, don't rely on stack contents!!! | |
160 return (*synth_func)( bandPtr,channel,samples); | |
736 | 161 } |
1258 | 162 #endif |
1 | 163 if(!channel) { /* channel=0 */ |
164 bo--; | |
165 bo &= 0xf; | |
166 buf = buffs[0]; | |
167 } | |
168 else { | |
169 samples++; | |
170 buf = buffs[1]; | |
171 } | |
172 | |
173 if(bo & 0x1) { | |
174 b0 = buf[0]; | |
175 bo1 = bo; | |
9002 | 176 dct64_base(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr); |
1 | 177 } |
178 else { | |
179 b0 = buf[1]; | |
180 bo1 = bo+1; | |
9002 | 181 dct64_base(buf[0]+bo,buf[1]+bo+1,bandPtr); |
1 | 182 } |
183 | |
184 { | |
185 register int j; | |
8560
1320f1b3229d
fixing that f*cking linker 'bug' e.g. naming config with libmp3lame
alex
parents:
8543
diff
changeset
|
186 real *window = mp3lib_decwin + 16 - bo1; |
1 | 187 |
188 for (j=16;j;j--,b0+=0x10,window+=0x20,samples+=step) | |
189 { | |
190 real sum; | |
191 sum = window[0x0] * b0[0x0]; | |
192 sum -= window[0x1] * b0[0x1]; | |
193 sum += window[0x2] * b0[0x2]; | |
194 sum -= window[0x3] * b0[0x3]; | |
195 sum += window[0x4] * b0[0x4]; | |
196 sum -= window[0x5] * b0[0x5]; | |
197 sum += window[0x6] * b0[0x6]; | |
198 sum -= window[0x7] * b0[0x7]; | |
199 sum += window[0x8] * b0[0x8]; | |
200 sum -= window[0x9] * b0[0x9]; | |
201 sum += window[0xA] * b0[0xA]; | |
202 sum -= window[0xB] * b0[0xB]; | |
203 sum += window[0xC] * b0[0xC]; | |
204 sum -= window[0xD] * b0[0xD]; | |
205 sum += window[0xE] * b0[0xE]; | |
206 sum -= window[0xF] * b0[0xF]; | |
207 | |
208 WRITE_SAMPLE(samples,sum,clip); | |
209 } | |
210 | |
211 { | |
212 real sum; | |
213 sum = window[0x0] * b0[0x0]; | |
214 sum += window[0x2] * b0[0x2]; | |
215 sum += window[0x4] * b0[0x4]; | |
216 sum += window[0x6] * b0[0x6]; | |
217 sum += window[0x8] * b0[0x8]; | |
218 sum += window[0xA] * b0[0xA]; | |
219 sum += window[0xC] * b0[0xC]; | |
220 sum += window[0xE] * b0[0xE]; | |
221 WRITE_SAMPLE(samples,sum,clip); | |
222 b0-=0x10,window-=0x20,samples+=step; | |
223 } | |
224 window += bo1<<1; | |
225 | |
226 for (j=15;j;j--,b0-=0x10,window-=0x20,samples+=step) | |
227 { | |
228 real sum; | |
229 sum = -window[-0x1] * b0[0x0]; | |
230 sum -= window[-0x2] * b0[0x1]; | |
231 sum -= window[-0x3] * b0[0x2]; | |
232 sum -= window[-0x4] * b0[0x3]; | |
233 sum -= window[-0x5] * b0[0x4]; | |
234 sum -= window[-0x6] * b0[0x5]; | |
235 sum -= window[-0x7] * b0[0x6]; | |
236 sum -= window[-0x8] * b0[0x7]; | |
237 sum -= window[-0x9] * b0[0x8]; | |
238 sum -= window[-0xA] * b0[0x9]; | |
239 sum -= window[-0xB] * b0[0xA]; | |
240 sum -= window[-0xC] * b0[0xB]; | |
241 sum -= window[-0xD] * b0[0xC]; | |
242 sum -= window[-0xE] * b0[0xD]; | |
243 sum -= window[-0xF] * b0[0xE]; | |
244 sum -= window[-0x0] * b0[0xF]; | |
245 | |
246 WRITE_SAMPLE(samples,sum,clip); | |
247 } | |
248 } | |
249 | |
250 return clip; | |
251 | |
252 } | |
253 | |
12291
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
254 #ifdef USE_FAKE_MONO |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
255 static int synth_1to1_l(real *bandPtr,int channel,unsigned char *out,int *pnt) |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
256 { |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
257 int i,ret; |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
258 |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
259 ret = synth_1to1(bandPtr,channel,out,pnt); |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
260 out = out + *pnt - 128; |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
261 |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
262 for(i=0;i<32;i++) { |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
263 ((short *)out)[1] = ((short *)out)[0]; |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
264 out+=4; |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
265 } |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
266 |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
267 return ret; |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
268 } |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
269 |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
270 static int synth_1to1_r(real *bandPtr,int channel,unsigned char *out,int *pnt) |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
271 { |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
272 int i,ret; |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
273 |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
274 ret = synth_1to1(bandPtr,channel,out,pnt); |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
275 out = out + *pnt - 128; |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
276 |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
277 for(i=0;i<32;i++) { |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
278 ((short *)out)[0] = ((short *)out)[1]; |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
279 out+=4; |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
280 } |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
281 |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
282 return ret; |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
283 } |
4e6f75467d64
reorder funcs to avoid warnings/errors (gccs are nowadays are more pickier about code than gcc2.95 with -ansi)
alex
parents:
12134
diff
changeset
|
284 #endif |