Mercurial > libavcodec.hg

comparison liba52/downmix.c @ 1072:68d0a38bd802 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
* sync with main liba52 sources
author kabi
date Tue, 18 Feb 2003 11:48:57 +0000
parents dd4f4c3d7171
children e101d1cffec6
comparison
equal deleted inserted replaced
1071:0a48dd404167 1072:68d0a38bd802
1 /* 1 /*
2 * downmix.c 2 * downmix.c
3 * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org> 3 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
4 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca> 4 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
5 * 5 *
6 * This file is part of a52dec, a free ATSC A-52 stream decoder. 6 * This file is part of a52dec, a free ATSC A-52 stream decoder.
7 * See http://liba52.sourceforge.net/ for updates. 7 * See http://liba52.sourceforge.net/ for updates.
8 * 8 *
19 * You should have received a copy of the GNU General Public License 19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software 20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */ 22 */
23 23
24 #include "config.h"
25
26 #include <string.h>
27 #include <inttypes.h>
28
24 #include "a52.h" 29 #include "a52.h"
25 #include "a52_internal.h" 30 #include "a52_internal.h"
26 31
27 #define CONVERT(acmod,output) (((output) << 3) + (acmod)) 32 #define CONVERT(acmod,output) (((output) << 3) + (acmod))
28 33
29 int a52_downmix_init (int input, int flags, sample_t * level, 34 int a52_downmix_init (int input, int flags, level_t * level,
30 sample_t clev, sample_t slev) 35 level_t clev, level_t slev)
31 { 36 {
32 static uint8_t table[11][8] = { 37 static uint8_t table[11][8] = {
33 {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO, 38 {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO,
34 A52_STEREO, A52_STEREO, A52_STEREO, A52_STEREO}, 39 A52_STEREO, A52_STEREO, A52_STEREO, A52_STEREO},
35 {A52_MONO, A52_MONO, A52_MONO, A52_MONO, 40 {A52_MONO, A52_MONO, A52_MONO, A52_MONO,
59 if (output > A52_DOLBY) 64 if (output > A52_DOLBY)
60 return -1; 65 return -1;
61 66
62 output = table[output][input & 7]; 67 output = table[output][input & 7];
63 68
64 if ((output == A52_STEREO) && 69 if (output == A52_STEREO &&
65 ((input == A52_DOLBY) || ((input == A52_3F) && (clev == LEVEL_3DB)))) 70 (input == A52_DOLBY || (input == A52_3F && clev == LEVEL (LEVEL_3DB))))
66 output = A52_DOLBY; 71 output = A52_DOLBY;
67 72
68 if (flags & A52_ADJUST_LEVEL) 73 if (flags & A52_ADJUST_LEVEL) {
74 level_t adjust;
75
69 switch (CONVERT (input & 7, output)) { 76 switch (CONVERT (input & 7, output)) {
70 77
71 case CONVERT (A52_3F, A52_MONO): 78 case CONVERT (A52_3F, A52_MONO):
72 *level *= LEVEL_3DB / (1 + clev); 79 adjust = DIV (LEVEL_3DB, LEVEL (1) + clev);
73 break; 80 break;
74 81
75 case CONVERT (A52_STEREO, A52_MONO): 82 case CONVERT (A52_STEREO, A52_MONO):
76 case CONVERT (A52_2F2R, A52_2F1R): 83 case CONVERT (A52_2F2R, A52_2F1R):
77 case CONVERT (A52_3F2R, A52_3F1R): 84 case CONVERT (A52_3F2R, A52_3F1R):
78 level_3db: 85 level_3db:
79 *level *= LEVEL_3DB; 86 adjust = LEVEL (LEVEL_3DB);
80 break; 87 break;
81 88
82 case CONVERT (A52_3F2R, A52_2F1R): 89 case CONVERT (A52_3F2R, A52_2F1R):
83 if (clev < LEVEL_PLUS3DB - 1) 90 if (clev < LEVEL (LEVEL_PLUS3DB - 1))
84 goto level_3db; 91 goto level_3db;
85 /* break thru */ 92 /* break thru */
86 case CONVERT (A52_3F, A52_STEREO): 93 case CONVERT (A52_3F, A52_STEREO):
87 case CONVERT (A52_3F1R, A52_2F1R): 94 case CONVERT (A52_3F1R, A52_2F1R):
88 case CONVERT (A52_3F1R, A52_2F2R): 95 case CONVERT (A52_3F1R, A52_2F2R):
89 case CONVERT (A52_3F2R, A52_2F2R): 96 case CONVERT (A52_3F2R, A52_2F2R):
90 *level /= 1 + clev; 97 adjust = DIV (1, LEVEL (1) + clev);
91 break; 98 break;
92 99
93 case CONVERT (A52_2F1R, A52_MONO): 100 case CONVERT (A52_2F1R, A52_MONO):
94 *level *= LEVEL_PLUS3DB / (2 + slev); 101 adjust = DIV (LEVEL_PLUS3DB, LEVEL (2) + slev);
95 break; 102 break;
96 103
97 case CONVERT (A52_2F1R, A52_STEREO): 104 case CONVERT (A52_2F1R, A52_STEREO):
98 case CONVERT (A52_3F1R, A52_3F): 105 case CONVERT (A52_3F1R, A52_3F):
99 *level /= 1 + slev * LEVEL_3DB; 106 adjust = DIV (1, LEVEL (1) + MUL_C (slev, LEVEL_3DB));
100 break; 107 break;
101 108
102 case CONVERT (A52_3F1R, A52_MONO): 109 case CONVERT (A52_3F1R, A52_MONO):
103 *level *= LEVEL_3DB / (1 + clev + 0.5 * slev); 110 adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + MUL_C (slev, 0.5));
104 break; 111 break;
105 112
106 case CONVERT (A52_3F1R, A52_STEREO): 113 case CONVERT (A52_3F1R, A52_STEREO):
107 *level /= 1 + clev + slev * LEVEL_3DB; 114 adjust = DIV (1, LEVEL (1) + clev + MUL_C (slev, LEVEL_3DB));
108 break; 115 break;
109 116
110 case CONVERT (A52_2F2R, A52_MONO): 117 case CONVERT (A52_2F2R, A52_MONO):
111 *level *= LEVEL_3DB / (1 + slev); 118 adjust = DIV (LEVEL_3DB, LEVEL (1) + slev);
112 break; 119 break;
113 120
114 case CONVERT (A52_2F2R, A52_STEREO): 121 case CONVERT (A52_2F2R, A52_STEREO):
115 case CONVERT (A52_3F2R, A52_3F): 122 case CONVERT (A52_3F2R, A52_3F):
116 *level /= 1 + slev; 123 adjust = DIV (1, LEVEL (1) + slev);
117 break; 124 break;
118 125
119 case CONVERT (A52_3F2R, A52_MONO): 126 case CONVERT (A52_3F2R, A52_MONO):
120 *level *= LEVEL_3DB / (1 + clev + slev); 127 adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + slev);
121 break; 128 break;
122 129
123 case CONVERT (A52_3F2R, A52_STEREO): 130 case CONVERT (A52_3F2R, A52_STEREO):
124 *level /= 1 + clev + slev; 131 adjust = DIV (1, LEVEL (1) + clev + slev);
125 break; 132 break;
126 133
127 case CONVERT (A52_MONO, A52_DOLBY): 134 case CONVERT (A52_MONO, A52_DOLBY):
128 *level *= LEVEL_PLUS3DB; 135 adjust = LEVEL (LEVEL_PLUS3DB);
129 break; 136 break;
130 137
131 case CONVERT (A52_3F, A52_DOLBY): 138 case CONVERT (A52_3F, A52_DOLBY):
132 case CONVERT (A52_2F1R, A52_DOLBY): 139 case CONVERT (A52_2F1R, A52_DOLBY):
133 *level *= 1 / (1 + LEVEL_3DB); 140 adjust = LEVEL (1 / (1 + LEVEL_3DB));
134 break; 141 break;
135 142
136 case CONVERT (A52_3F1R, A52_DOLBY): 143 case CONVERT (A52_3F1R, A52_DOLBY):
137 case CONVERT (A52_2F2R, A52_DOLBY): 144 case CONVERT (A52_2F2R, A52_DOLBY):
138 *level *= 1 / (1 + 2 * LEVEL_3DB); 145 adjust = LEVEL (1 / (1 + 2 * LEVEL_3DB));
139 break; 146 break;
140 147
141 case CONVERT (A52_3F2R, A52_DOLBY): 148 case CONVERT (A52_3F2R, A52_DOLBY):
142 *level *= 1 / (1 + 3 * LEVEL_3DB); 149 adjust = LEVEL (1 / (1 + 3 * LEVEL_3DB));
143 break; 150 break;
151
152 default:
153 return output;
144 } 154 }
145 155
156 *level = MUL_L (*level, adjust);
157 }
158
146 return output; 159 return output;
147 } 160 }
148 161
149 int a52_downmix_coeff (sample_t * coeff, int acmod, int output, sample_t level, 162 int a52_downmix_coeff (level_t * coeff, int acmod, int output, level_t level,
150 sample_t clev, sample_t slev) 163 level_t clev, level_t slev)
151 { 164 {
165 level_t level_3db;
166
167 level_3db = MUL_C (level, LEVEL_3DB);
168
152 switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) { 169 switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
153 170
154 case CONVERT (A52_CHANNEL, A52_CHANNEL): 171 case CONVERT (A52_CHANNEL, A52_CHANNEL):
155 case CONVERT (A52_MONO, A52_MONO): 172 case CONVERT (A52_MONO, A52_MONO):
156 case CONVERT (A52_STEREO, A52_STEREO): 173 case CONVERT (A52_STEREO, A52_STEREO):
162 case CONVERT (A52_STEREO, A52_DOLBY): 179 case CONVERT (A52_STEREO, A52_DOLBY):
163 coeff[0] = coeff[1] = coeff[2] = coeff[3] = coeff[4] = level; 180 coeff[0] = coeff[1] = coeff[2] = coeff[3] = coeff[4] = level;
164 return 0; 181 return 0;
165 182
166 case CONVERT (A52_CHANNEL, A52_MONO): 183 case CONVERT (A52_CHANNEL, A52_MONO):
167 coeff[0] = coeff[1] = level * LEVEL_6DB; 184 coeff[0] = coeff[1] = MUL_C (level, LEVEL_6DB);
168 return 3; 185 return 3;
169 186
170 case CONVERT (A52_STEREO, A52_MONO): 187 case CONVERT (A52_STEREO, A52_MONO):
171 coeff[0] = coeff[1] = level * LEVEL_3DB; 188 coeff[0] = coeff[1] = level_3db;
172 return 3; 189 return 3;
173 190
174 case CONVERT (A52_3F, A52_MONO): 191 case CONVERT (A52_3F, A52_MONO):
175 coeff[0] = coeff[2] = level * LEVEL_3DB; 192 coeff[0] = coeff[2] = level_3db;
176 coeff[1] = level * clev * LEVEL_PLUS3DB; 193 coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
177 return 7; 194 return 7;
178 195
179 case CONVERT (A52_2F1R, A52_MONO): 196 case CONVERT (A52_2F1R, A52_MONO):
180 coeff[0] = coeff[1] = level * LEVEL_3DB; 197 coeff[0] = coeff[1] = level_3db;
181 coeff[2] = level * slev * LEVEL_3DB; 198 coeff[2] = MUL_L (level_3db, slev);
182 return 7; 199 return 7;
183 200
184 case CONVERT (A52_2F2R, A52_MONO): 201 case CONVERT (A52_2F2R, A52_MONO):
185 coeff[0] = coeff[1] = level * LEVEL_3DB; 202 coeff[0] = coeff[1] = level_3db;
186 coeff[2] = coeff[3] = level * slev * LEVEL_3DB; 203 coeff[2] = coeff[3] = MUL_L (level_3db, slev);
187 return 15; 204 return 15;
188 205
189 case CONVERT (A52_3F1R, A52_MONO): 206 case CONVERT (A52_3F1R, A52_MONO):
190 coeff[0] = coeff[2] = level * LEVEL_3DB; 207 coeff[0] = coeff[2] = level_3db;
191 coeff[1] = level * clev * LEVEL_PLUS3DB; 208 coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
192 coeff[3] = level * slev * LEVEL_3DB; 209 coeff[3] = MUL_L (level_3db, slev);
193 return 15; 210 return 15;
194 211
195 case CONVERT (A52_3F2R, A52_MONO): 212 case CONVERT (A52_3F2R, A52_MONO):
196 coeff[0] = coeff[2] = level * LEVEL_3DB; 213 coeff[0] = coeff[2] = level_3db;
197 coeff[1] = level * clev * LEVEL_PLUS3DB; 214 coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
198 coeff[3] = coeff[4] = level * slev * LEVEL_3DB; 215 coeff[3] = coeff[4] = MUL_L (level_3db, slev);
199 return 31; 216 return 31;
200 217
201 case CONVERT (A52_MONO, A52_DOLBY): 218 case CONVERT (A52_MONO, A52_DOLBY):
202 coeff[0] = level * LEVEL_3DB; 219 coeff[0] = level_3db;
203 return 0; 220 return 0;
204 221
205 case CONVERT (A52_3F, A52_DOLBY): 222 case CONVERT (A52_3F, A52_DOLBY):
206 clev = LEVEL_3DB; 223 coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
224 coeff[1] = level_3db;
225 return 7;
226
207 case CONVERT (A52_3F, A52_STEREO): 227 case CONVERT (A52_3F, A52_STEREO):
208 case CONVERT (A52_3F1R, A52_2F1R): 228 case CONVERT (A52_3F1R, A52_2F1R):
209 case CONVERT (A52_3F2R, A52_2F2R): 229 case CONVERT (A52_3F2R, A52_2F2R):
210 coeff[0] = coeff[2] = coeff[3] = coeff[4] = level; 230 coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
211 coeff[1] = level * clev; 231 coeff[1] = MUL_L (level, clev);
212 return 7; 232 return 7;
213 233
214 case CONVERT (A52_2F1R, A52_DOLBY): 234 case CONVERT (A52_2F1R, A52_DOLBY):
215 slev = 1; 235 coeff[0] = coeff[1] = level;
236 coeff[2] = level_3db;
237 return 7;
238
216 case CONVERT (A52_2F1R, A52_STEREO): 239 case CONVERT (A52_2F1R, A52_STEREO):
217 coeff[0] = coeff[1] = level; 240 coeff[0] = coeff[1] = level;
218 coeff[2] = level * slev * LEVEL_3DB; 241 coeff[2] = MUL_L (level_3db, slev);
219 return 7; 242 return 7;
220 243
221 case CONVERT (A52_3F1R, A52_DOLBY): 244 case CONVERT (A52_3F1R, A52_DOLBY):
222 clev = LEVEL_3DB; 245 coeff[0] = coeff[2] = level;
223 slev = 1; 246 coeff[1] = coeff[3] = level_3db;
247 return 15;
248
224 case CONVERT (A52_3F1R, A52_STEREO): 249 case CONVERT (A52_3F1R, A52_STEREO):
225 coeff[0] = coeff[2] = level; 250 coeff[0] = coeff[2] = level;
226 coeff[1] = level * clev; 251 coeff[1] = MUL_L (level, clev);
227 coeff[3] = level * slev * LEVEL_3DB; 252 coeff[3] = MUL_L (level_3db, slev);
228 return 15; 253 return 15;
229 254
230 case CONVERT (A52_2F2R, A52_DOLBY): 255 case CONVERT (A52_2F2R, A52_DOLBY):
231 slev = LEVEL_3DB; 256 coeff[0] = coeff[1] = level;
257 coeff[2] = coeff[3] = level_3db;
258 return 15;
259
232 case CONVERT (A52_2F2R, A52_STEREO): 260 case CONVERT (A52_2F2R, A52_STEREO):
233 coeff[0] = coeff[1] = level; 261 coeff[0] = coeff[1] = level;
234 coeff[2] = coeff[3] = level * slev; 262 coeff[2] = coeff[3] = MUL_L (level, slev);
235 return 15; 263 return 15;
236 264
237 case CONVERT (A52_3F2R, A52_DOLBY): 265 case CONVERT (A52_3F2R, A52_DOLBY):
238 clev = LEVEL_3DB; 266 coeff[0] = coeff[2] = level;
267 coeff[1] = coeff[3] = coeff[4] = level_3db;
268 return 31;
269
239 case CONVERT (A52_3F2R, A52_2F1R): 270 case CONVERT (A52_3F2R, A52_2F1R):
240 slev = LEVEL_3DB; 271 coeff[0] = coeff[2] = level;
272 coeff[1] = MUL_L (level, clev);
273 coeff[3] = coeff[4] = level_3db;
274 return 31;
275
241 case CONVERT (A52_3F2R, A52_STEREO): 276 case CONVERT (A52_3F2R, A52_STEREO):
242 coeff[0] = coeff[2] = level; 277 coeff[0] = coeff[2] = level;
243 coeff[1] = level * clev; 278 coeff[1] = MUL_L (level, clev);
244 coeff[3] = coeff[4] = level * slev; 279 coeff[3] = coeff[4] = MUL_L (level, slev);
245 return 31; 280 return 31;
246 281
247 case CONVERT (A52_3F1R, A52_3F): 282 case CONVERT (A52_3F1R, A52_3F):
248 coeff[0] = coeff[1] = coeff[2] = level; 283 coeff[0] = coeff[1] = coeff[2] = level;
249 coeff[3] = level * slev * LEVEL_3DB; 284 coeff[3] = MUL_L (level_3db, slev);
250 return 13; 285 return 13;
251 286
252 case CONVERT (A52_3F2R, A52_3F): 287 case CONVERT (A52_3F2R, A52_3F):
253 coeff[0] = coeff[1] = coeff[2] = level; 288 coeff[0] = coeff[1] = coeff[2] = level;
254 coeff[3] = coeff[4] = level * slev; 289 coeff[3] = coeff[4] = MUL_L (level, slev);
255 return 29; 290 return 29;
256 291
257 case CONVERT (A52_2F2R, A52_2F1R): 292 case CONVERT (A52_2F2R, A52_2F1R):
258 coeff[0] = coeff[1] = level; 293 coeff[0] = coeff[1] = level;
259 coeff[2] = coeff[3] = level * LEVEL_3DB; 294 coeff[2] = coeff[3] = level_3db;
260 return 12; 295 return 12;
261 296
262 case CONVERT (A52_3F2R, A52_3F1R): 297 case CONVERT (A52_3F2R, A52_3F1R):
263 coeff[0] = coeff[1] = coeff[2] = level; 298 coeff[0] = coeff[1] = coeff[2] = level;
264 coeff[3] = coeff[4] = level * LEVEL_3DB; 299 coeff[3] = coeff[4] = level_3db;
265 return 24; 300 return 24;
266 301
267 case CONVERT (A52_2F1R, A52_2F2R): 302 case CONVERT (A52_2F1R, A52_2F2R):
268 coeff[0] = coeff[1] = level; 303 coeff[0] = coeff[1] = level;
269 coeff[2] = level * LEVEL_3DB; 304 coeff[2] = level_3db;
270 return 0; 305 return 0;
271 306
272 case CONVERT (A52_3F1R, A52_2F2R): 307 case CONVERT (A52_3F1R, A52_2F2R):
273 coeff[0] = coeff[2] = level; 308 coeff[0] = coeff[2] = level;
274 coeff[1] = level * clev; 309 coeff[1] = MUL_L (level, clev);
275 coeff[3] = level * LEVEL_3DB; 310 coeff[3] = level_3db;
276 return 7; 311 return 7;
277 312
278 case CONVERT (A52_3F1R, A52_3F2R): 313 case CONVERT (A52_3F1R, A52_3F2R):
279 coeff[0] = coeff[1] = coeff[2] = level; 314 coeff[0] = coeff[1] = coeff[2] = level;
280 coeff[3] = level * LEVEL_3DB; 315 coeff[3] = level_3db;
281 return 0; 316 return 0;
282 317
283 case CONVERT (A52_CHANNEL, A52_CHANNEL1): 318 case CONVERT (A52_CHANNEL, A52_CHANNEL1):
284 coeff[0] = level; 319 coeff[0] = level;
285 coeff[1] = 0; 320 coeff[1] = 0;
297 static void mix2to1 (sample_t * dest, sample_t * src, sample_t bias) 332 static void mix2to1 (sample_t * dest, sample_t * src, sample_t bias)
298 { 333 {
299 int i; 334 int i;
300 335
301 for (i = 0; i < 256; i++) 336 for (i = 0; i < 256; i++)
302 dest[i] += src[i] + bias; 337 dest[i] += BIAS (src[i]);
303 } 338 }
304 339
305 static void mix3to1 (sample_t * samples, sample_t bias) 340 static void mix3to1 (sample_t * samples, sample_t bias)
306 { 341 {
307 int i; 342 int i;
308 343
309 for (i = 0; i < 256; i++) 344 for (i = 0; i < 256; i++)
310 samples[i] += samples[i + 256] + samples[i + 512] + bias; 345 samples[i] += BIAS (samples[i + 256] + samples[i + 512]);
311 } 346 }
312 347
313 static void mix4to1 (sample_t * samples, sample_t bias) 348 static void mix4to1 (sample_t * samples, sample_t bias)
314 { 349 {
315 int i; 350 int i;
316 351
317 for (i = 0; i < 256; i++) 352 for (i = 0; i < 256; i++)
318 samples[i] += (samples[i + 256] + samples[i + 512] + 353 samples[i] += BIAS (samples[i + 256] + samples[i + 512] +
319 samples[i + 768] + bias); 354 samples[i + 768]);
320 } 355 }
321 356
322 static void mix5to1 (sample_t * samples, sample_t bias) 357 static void mix5to1 (sample_t * samples, sample_t bias)
323 { 358 {
324 int i; 359 int i;
325 360
326 for (i = 0; i < 256; i++) 361 for (i = 0; i < 256; i++)
327 samples[i] += (samples[i + 256] + samples[i + 512] + 362 samples[i] += BIAS (samples[i + 256] + samples[i + 512] +
328 samples[i + 768] + samples[i + 1024] + bias); 363 samples[i + 768] + samples[i + 1024]);
329 } 364 }
330 365
331 static void mix3to2 (sample_t * samples, sample_t bias) 366 static void mix3to2 (sample_t * samples, sample_t bias)
332 { 367 {
333 int i; 368 int i;
334 sample_t common; 369 sample_t common;
335 370
336 for (i = 0; i < 256; i++) { 371 for (i = 0; i < 256; i++) {
337 common = samples[i + 256] + bias; 372 common = BIAS (samples[i + 256]);
338 samples[i] += common; 373 samples[i] += common;
339 samples[i + 256] = samples[i + 512] + common; 374 samples[i + 256] = samples[i + 512] + common;
340 } 375 }
341 } 376 }
342 377
344 { 379 {
345 int i; 380 int i;
346 sample_t common; 381 sample_t common;
347 382
348 for (i = 0; i < 256; i++) { 383 for (i = 0; i < 256; i++) {
349 common = right[i + 256] + bias; 384 common = BIAS (right[i + 256]);
350 left[i] += common; 385 left[i] += common;
351 right[i] += common; 386 right[i] += common;
352 } 387 }
353 } 388 }
354 389
357 int i; 392 int i;
358 sample_t surround; 393 sample_t surround;
359 394
360 for (i = 0; i < 256; i++) { 395 for (i = 0; i < 256; i++) {
361 surround = samples[i + 512]; 396 surround = samples[i + 512];
362 samples[i] += bias - surround; 397 samples[i] += BIAS (-surround);
363 samples[i + 256] += bias + surround; 398 samples[i + 256] += BIAS (surround);
364 } 399 }
365 } 400 }
366 401
367 static void mix31to2 (sample_t * samples, sample_t bias) 402 static void mix31to2 (sample_t * samples, sample_t bias)
368 { 403 {
369 int i; 404 int i;
370 sample_t common; 405 sample_t common;
371 406
372 for (i = 0; i < 256; i++) { 407 for (i = 0; i < 256; i++) {
373 common = samples[i + 256] + samples[i + 768] + bias; 408 common = BIAS (samples[i + 256] + samples[i + 768]);
374 samples[i] += common; 409 samples[i] += common;
375 samples[i + 256] = samples[i + 512] + common; 410 samples[i + 256] = samples[i + 512] + common;
376 } 411 }
377 } 412 }
378 413
380 { 415 {
381 int i; 416 int i;
382 sample_t common, surround; 417 sample_t common, surround;
383 418
384 for (i = 0; i < 256; i++) { 419 for (i = 0; i < 256; i++) {
385 common = samples[i + 256] + bias; 420 common = BIAS (samples[i + 256]);
386 surround = samples[i + 768]; 421 surround = samples[i + 768];
387 samples[i] += common - surround; 422 samples[i] += common - surround;
388 samples[i + 256] = samples[i + 512] + common + surround; 423 samples[i + 256] = samples[i + 512] + common + surround;
389 } 424 }
390 } 425 }
394 int i; 429 int i;
395 sample_t surround; 430 sample_t surround;
396 431
397 for (i = 0; i < 256; i++) { 432 for (i = 0; i < 256; i++) {
398 surround = samples[i + 512] + samples[i + 768]; 433 surround = samples[i + 512] + samples[i + 768];
399 samples[i] += bias - surround; 434 samples[i] += BIAS (-surround);
400 samples[i + 256] += bias + surround; 435 samples[i + 256] += BIAS (surround);
401 } 436 }
402 } 437 }
403 438
404 static void mix32to2 (sample_t * samples, sample_t bias) 439 static void mix32to2 (sample_t * samples, sample_t bias)
405 { 440 {
406 int i; 441 int i;
407 sample_t common; 442 sample_t common;
408 443
409 for (i = 0; i < 256; i++) { 444 for (i = 0; i < 256; i++) {
410 common = samples[i + 256] + bias; 445 common = BIAS (samples[i + 256]);
411 samples[i] += common + samples[i + 768]; 446 samples[i] += common + samples[i + 768];
412 samples[i + 256] = common + samples[i + 512] + samples[i + 1024]; 447 samples[i + 256] = common + samples[i + 512] + samples[i + 1024];
413 } 448 }
414 } 449 }
415 450
417 { 452 {
418 int i; 453 int i;
419 sample_t common, surround; 454 sample_t common, surround;
420 455
421 for (i = 0; i < 256; i++) { 456 for (i = 0; i < 256; i++) {
422 common = samples[i + 256] + bias; 457 common = BIAS (samples[i + 256]);
423 surround = samples[i + 768] + samples[i + 1024]; 458 surround = samples[i + 768] + samples[i + 1024];
424 samples[i] += common - surround; 459 samples[i] += common - surround;
425 samples[i + 256] = samples[i + 512] + common + surround; 460 samples[i + 256] = samples[i + 512] + common + surround;
426 } 461 }
427 } 462 }
429 static void move2to1 (sample_t * src, sample_t * dest, sample_t bias) 464 static void move2to1 (sample_t * src, sample_t * dest, sample_t bias)
430 { 465 {
431 int i; 466 int i;
432 467
433 for (i = 0; i < 256; i++) 468 for (i = 0; i < 256; i++)
434 dest[i] = src[i] + src[i + 256] + bias; 469 dest[i] = BIAS (src[i] + src[i + 256]);
435 } 470 }
436 471
437 static void zero (sample_t * samples) 472 static void zero (sample_t * samples)
438 { 473 {
439 int i; 474 int i;
441 for (i = 0; i < 256; i++) 476 for (i = 0; i < 256; i++)
442 samples[i] = 0; 477 samples[i] = 0;
443 } 478 }
444 479
445 void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias, 480 void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
446 sample_t clev, sample_t slev) 481 level_t clev, level_t slev)
447 { 482 {
448 switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) { 483 switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
449 484
450 case CONVERT (A52_CHANNEL, A52_CHANNEL2): 485 case CONVERT (A52_CHANNEL, A52_CHANNEL2):
451 memcpy (samples, samples + 256, 256 * sizeof (sample_t)); 486 memcpy (samples, samples + 256, 256 * sizeof (sample_t));
576 memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t)); 611 memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
577 memcpy (samples + 768, samples + 1024, 256 * sizeof (sample_t)); 612 memcpy (samples + 768, samples + 1024, 256 * sizeof (sample_t));
578 break; 613 break;
579 614
580 case CONVERT (A52_3F1R, A52_3F2R): 615 case CONVERT (A52_3F1R, A52_3F2R):
581 memcpy (samples + 1027, samples + 768, 256 * sizeof (sample_t)); 616 memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
582 break; 617 break;
583 } 618 }
584 } 619 }
585 620
586 void a52_upmix (sample_t * samples, int acmod, int output) 621 void a52_upmix (sample_t * samples, int acmod, int output)