]>
Commit | Line | Data |
---|---|---|
85571bc7 FB |
1 | /* |
2 | * QEMU Mixing engine | |
3 | * | |
1d14ffa9 | 4 | * Copyright (c) 2004-2005 Vassili Karpov (malc) |
85571bc7 FB |
5 | * Copyright (c) 1998 Fabrice Bellard |
6 | * | |
7 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
8 | * of this software and associated documentation files (the "Software"), to deal | |
9 | * in the Software without restriction, including without limitation the rights | |
10 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
11 | * copies of the Software, and to permit persons to whom the Software is | |
12 | * furnished to do so, subject to the following conditions: | |
13 | * | |
14 | * The above copyright notice and this permission notice shall be included in | |
15 | * all copies or substantial portions of the Software. | |
16 | * | |
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
20 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
21 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
22 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
23 | * THE SOFTWARE. | |
24 | */ | |
6086a565 | 25 | #include "qemu/osdep.h" |
58369e22 | 26 | #include "qemu/bswap.h" |
3d4d16f4 | 27 | #include "qemu/error-report.h" |
87ecb68b | 28 | #include "audio.h" |
85571bc7 | 29 | |
1d14ffa9 FB |
30 | #define AUDIO_CAP "mixeng" |
31 | #include "audio_int.h" | |
32 | ||
1d14ffa9 FB |
33 | /* 8 bit */ |
34 | #define ENDIAN_CONVERSION natural | |
35 | #define ENDIAN_CONVERT(v) (v) | |
36 | ||
37 | /* Signed 8 bit */ | |
a2885387 RPM |
38 | #define BSIZE 8 |
39 | #define ITYPE int | |
1d14ffa9 FB |
40 | #define IN_MIN SCHAR_MIN |
41 | #define IN_MAX SCHAR_MAX | |
85571bc7 | 42 | #define SIGNED |
1d14ffa9 | 43 | #define SHIFT 8 |
85571bc7 FB |
44 | #include "mixeng_template.h" |
45 | #undef SIGNED | |
46 | #undef IN_MAX | |
47 | #undef IN_MIN | |
a2885387 RPM |
48 | #undef BSIZE |
49 | #undef ITYPE | |
1d14ffa9 | 50 | #undef SHIFT |
85571bc7 | 51 | |
1d14ffa9 | 52 | /* Unsigned 8 bit */ |
a2885387 RPM |
53 | #define BSIZE 8 |
54 | #define ITYPE uint | |
85571bc7 FB |
55 | #define IN_MIN 0 |
56 | #define IN_MAX UCHAR_MAX | |
1d14ffa9 | 57 | #define SHIFT 8 |
85571bc7 FB |
58 | #include "mixeng_template.h" |
59 | #undef IN_MAX | |
60 | #undef IN_MIN | |
a2885387 RPM |
61 | #undef BSIZE |
62 | #undef ITYPE | |
1d14ffa9 FB |
63 | #undef SHIFT |
64 | ||
65 | #undef ENDIAN_CONVERT | |
66 | #undef ENDIAN_CONVERSION | |
85571bc7 | 67 | |
1d14ffa9 | 68 | /* Signed 16 bit */ |
a2885387 RPM |
69 | #define BSIZE 16 |
70 | #define ITYPE int | |
85571bc7 FB |
71 | #define IN_MIN SHRT_MIN |
72 | #define IN_MAX SHRT_MAX | |
73 | #define SIGNED | |
1d14ffa9 FB |
74 | #define SHIFT 16 |
75 | #define ENDIAN_CONVERSION natural | |
76 | #define ENDIAN_CONVERT(v) (v) | |
85571bc7 | 77 | #include "mixeng_template.h" |
1d14ffa9 FB |
78 | #undef ENDIAN_CONVERT |
79 | #undef ENDIAN_CONVERSION | |
80 | #define ENDIAN_CONVERSION swap | |
81 | #define ENDIAN_CONVERT(v) bswap16 (v) | |
82 | #include "mixeng_template.h" | |
83 | #undef ENDIAN_CONVERT | |
84 | #undef ENDIAN_CONVERSION | |
85571bc7 FB |
85 | #undef SIGNED |
86 | #undef IN_MAX | |
87 | #undef IN_MIN | |
a2885387 RPM |
88 | #undef BSIZE |
89 | #undef ITYPE | |
1d14ffa9 | 90 | #undef SHIFT |
85571bc7 | 91 | |
f941aa25 | 92 | /* Unsigned 16 bit */ |
a2885387 RPM |
93 | #define BSIZE 16 |
94 | #define ITYPE uint | |
85571bc7 FB |
95 | #define IN_MIN 0 |
96 | #define IN_MAX USHRT_MAX | |
1d14ffa9 FB |
97 | #define SHIFT 16 |
98 | #define ENDIAN_CONVERSION natural | |
99 | #define ENDIAN_CONVERT(v) (v) | |
100 | #include "mixeng_template.h" | |
101 | #undef ENDIAN_CONVERT | |
102 | #undef ENDIAN_CONVERSION | |
103 | #define ENDIAN_CONVERSION swap | |
104 | #define ENDIAN_CONVERT(v) bswap16 (v) | |
85571bc7 | 105 | #include "mixeng_template.h" |
1d14ffa9 FB |
106 | #undef ENDIAN_CONVERT |
107 | #undef ENDIAN_CONVERSION | |
85571bc7 FB |
108 | #undef IN_MAX |
109 | #undef IN_MIN | |
a2885387 RPM |
110 | #undef BSIZE |
111 | #undef ITYPE | |
1d14ffa9 | 112 | #undef SHIFT |
85571bc7 | 113 | |
f941aa25 | 114 | /* Signed 32 bit */ |
a2885387 RPM |
115 | #define BSIZE 32 |
116 | #define ITYPE int | |
f941aa25 TS |
117 | #define IN_MIN INT32_MIN |
118 | #define IN_MAX INT32_MAX | |
119 | #define SIGNED | |
120 | #define SHIFT 32 | |
121 | #define ENDIAN_CONVERSION natural | |
122 | #define ENDIAN_CONVERT(v) (v) | |
123 | #include "mixeng_template.h" | |
124 | #undef ENDIAN_CONVERT | |
125 | #undef ENDIAN_CONVERSION | |
126 | #define ENDIAN_CONVERSION swap | |
127 | #define ENDIAN_CONVERT(v) bswap32 (v) | |
128 | #include "mixeng_template.h" | |
129 | #undef ENDIAN_CONVERT | |
130 | #undef ENDIAN_CONVERSION | |
131 | #undef SIGNED | |
132 | #undef IN_MAX | |
133 | #undef IN_MIN | |
a2885387 RPM |
134 | #undef BSIZE |
135 | #undef ITYPE | |
f941aa25 TS |
136 | #undef SHIFT |
137 | ||
ad483a51 | 138 | /* Unsigned 32 bit */ |
a2885387 RPM |
139 | #define BSIZE 32 |
140 | #define ITYPE uint | |
f941aa25 TS |
141 | #define IN_MIN 0 |
142 | #define IN_MAX UINT32_MAX | |
143 | #define SHIFT 32 | |
144 | #define ENDIAN_CONVERSION natural | |
145 | #define ENDIAN_CONVERT(v) (v) | |
146 | #include "mixeng_template.h" | |
147 | #undef ENDIAN_CONVERT | |
148 | #undef ENDIAN_CONVERSION | |
149 | #define ENDIAN_CONVERSION swap | |
150 | #define ENDIAN_CONVERT(v) bswap32 (v) | |
151 | #include "mixeng_template.h" | |
152 | #undef ENDIAN_CONVERT | |
153 | #undef ENDIAN_CONVERSION | |
154 | #undef IN_MAX | |
155 | #undef IN_MIN | |
a2885387 RPM |
156 | #undef BSIZE |
157 | #undef ITYPE | |
f941aa25 TS |
158 | #undef SHIFT |
159 | ||
160 | t_sample *mixeng_conv[2][2][2][3] = { | |
85571bc7 FB |
161 | { |
162 | { | |
1d14ffa9 FB |
163 | { |
164 | conv_natural_uint8_t_to_mono, | |
f941aa25 TS |
165 | conv_natural_uint16_t_to_mono, |
166 | conv_natural_uint32_t_to_mono | |
1d14ffa9 FB |
167 | }, |
168 | { | |
169 | conv_natural_uint8_t_to_mono, | |
f941aa25 TS |
170 | conv_swap_uint16_t_to_mono, |
171 | conv_swap_uint32_t_to_mono, | |
1d14ffa9 | 172 | } |
85571bc7 FB |
173 | }, |
174 | { | |
1d14ffa9 FB |
175 | { |
176 | conv_natural_int8_t_to_mono, | |
f941aa25 TS |
177 | conv_natural_int16_t_to_mono, |
178 | conv_natural_int32_t_to_mono | |
1d14ffa9 FB |
179 | }, |
180 | { | |
181 | conv_natural_int8_t_to_mono, | |
f941aa25 TS |
182 | conv_swap_int16_t_to_mono, |
183 | conv_swap_int32_t_to_mono | |
1d14ffa9 | 184 | } |
85571bc7 FB |
185 | } |
186 | }, | |
187 | { | |
188 | { | |
1d14ffa9 FB |
189 | { |
190 | conv_natural_uint8_t_to_stereo, | |
f941aa25 TS |
191 | conv_natural_uint16_t_to_stereo, |
192 | conv_natural_uint32_t_to_stereo | |
1d14ffa9 FB |
193 | }, |
194 | { | |
195 | conv_natural_uint8_t_to_stereo, | |
f941aa25 TS |
196 | conv_swap_uint16_t_to_stereo, |
197 | conv_swap_uint32_t_to_stereo | |
1d14ffa9 | 198 | } |
85571bc7 FB |
199 | }, |
200 | { | |
1d14ffa9 FB |
201 | { |
202 | conv_natural_int8_t_to_stereo, | |
f941aa25 TS |
203 | conv_natural_int16_t_to_stereo, |
204 | conv_natural_int32_t_to_stereo | |
1d14ffa9 FB |
205 | }, |
206 | { | |
207 | conv_natural_int8_t_to_stereo, | |
f941aa25 TS |
208 | conv_swap_int16_t_to_stereo, |
209 | conv_swap_int32_t_to_stereo, | |
1d14ffa9 | 210 | } |
85571bc7 FB |
211 | } |
212 | } | |
213 | }; | |
214 | ||
f941aa25 | 215 | f_sample *mixeng_clip[2][2][2][3] = { |
85571bc7 FB |
216 | { |
217 | { | |
1d14ffa9 FB |
218 | { |
219 | clip_natural_uint8_t_from_mono, | |
f941aa25 TS |
220 | clip_natural_uint16_t_from_mono, |
221 | clip_natural_uint32_t_from_mono | |
1d14ffa9 FB |
222 | }, |
223 | { | |
224 | clip_natural_uint8_t_from_mono, | |
f941aa25 TS |
225 | clip_swap_uint16_t_from_mono, |
226 | clip_swap_uint32_t_from_mono | |
1d14ffa9 | 227 | } |
85571bc7 FB |
228 | }, |
229 | { | |
1d14ffa9 FB |
230 | { |
231 | clip_natural_int8_t_from_mono, | |
f941aa25 TS |
232 | clip_natural_int16_t_from_mono, |
233 | clip_natural_int32_t_from_mono | |
1d14ffa9 FB |
234 | }, |
235 | { | |
236 | clip_natural_int8_t_from_mono, | |
f941aa25 TS |
237 | clip_swap_int16_t_from_mono, |
238 | clip_swap_int32_t_from_mono | |
1d14ffa9 | 239 | } |
85571bc7 FB |
240 | } |
241 | }, | |
242 | { | |
243 | { | |
1d14ffa9 FB |
244 | { |
245 | clip_natural_uint8_t_from_stereo, | |
f941aa25 TS |
246 | clip_natural_uint16_t_from_stereo, |
247 | clip_natural_uint32_t_from_stereo | |
1d14ffa9 FB |
248 | }, |
249 | { | |
250 | clip_natural_uint8_t_from_stereo, | |
f941aa25 TS |
251 | clip_swap_uint16_t_from_stereo, |
252 | clip_swap_uint32_t_from_stereo | |
1d14ffa9 | 253 | } |
85571bc7 FB |
254 | }, |
255 | { | |
1d14ffa9 FB |
256 | { |
257 | clip_natural_int8_t_from_stereo, | |
f941aa25 TS |
258 | clip_natural_int16_t_from_stereo, |
259 | clip_natural_int32_t_from_stereo | |
1d14ffa9 FB |
260 | }, |
261 | { | |
262 | clip_natural_int8_t_from_stereo, | |
f941aa25 TS |
263 | clip_swap_int16_t_from_stereo, |
264 | clip_swap_int32_t_from_stereo | |
1d14ffa9 | 265 | } |
85571bc7 FB |
266 | } |
267 | } | |
268 | }; | |
269 | ||
ed2a4a79 | 270 | #ifdef FLOAT_MIXENG |
dd381319 VR |
271 | #define CONV_NATURAL_FLOAT(x) (x) |
272 | #define CLIP_NATURAL_FLOAT(x) (x) | |
ed2a4a79 | 273 | #else |
9c61fcc8 VR |
274 | /* macros to map [-1.f, 1.f] <-> [INT32_MIN, INT32_MAX + 1] */ |
275 | static const float float_scale = (int64_t)INT32_MAX + 1; | |
dd381319 | 276 | #define CONV_NATURAL_FLOAT(x) ((x) * float_scale) |
ed2a4a79 KZ |
277 | |
278 | #ifdef RECIPROCAL | |
9c61fcc8 | 279 | static const float float_scale_reciprocal = 1.f / ((int64_t)INT32_MAX + 1); |
dd381319 | 280 | #define CLIP_NATURAL_FLOAT(x) ((x) * float_scale_reciprocal) |
ed2a4a79 | 281 | #else |
dd381319 | 282 | #define CLIP_NATURAL_FLOAT(x) ((x) / float_scale) |
ed2a4a79 KZ |
283 | #endif |
284 | #endif | |
285 | ||
286 | static void conv_natural_float_to_mono(struct st_sample *dst, const void *src, | |
287 | int samples) | |
180b044f VR |
288 | { |
289 | float *in = (float *)src; | |
180b044f VR |
290 | |
291 | while (samples--) { | |
dd381319 | 292 | dst->r = dst->l = CONV_NATURAL_FLOAT(*in++); |
ed2a4a79 KZ |
293 | dst++; |
294 | } | |
295 | } | |
296 | ||
297 | static void conv_natural_float_to_stereo(struct st_sample *dst, const void *src, | |
298 | int samples) | |
299 | { | |
300 | float *in = (float *)src; | |
301 | ||
302 | while (samples--) { | |
dd381319 VR |
303 | dst->l = CONV_NATURAL_FLOAT(*in++); |
304 | dst->r = CONV_NATURAL_FLOAT(*in++); | |
180b044f VR |
305 | dst++; |
306 | } | |
307 | } | |
308 | ||
ed2a4a79 KZ |
309 | t_sample *mixeng_conv_float[2] = { |
310 | conv_natural_float_to_mono, | |
311 | conv_natural_float_to_stereo, | |
312 | }; | |
313 | ||
314 | static void clip_natural_float_from_mono(void *dst, const struct st_sample *src, | |
315 | int samples) | |
316 | { | |
317 | float *out = (float *)dst; | |
318 | ||
319 | while (samples--) { | |
33a93bae | 320 | *out++ = CLIP_NATURAL_FLOAT(src->l + src->r); |
ed2a4a79 KZ |
321 | src++; |
322 | } | |
323 | } | |
324 | ||
325 | static void clip_natural_float_from_stereo( | |
326 | void *dst, const struct st_sample *src, int samples) | |
180b044f VR |
327 | { |
328 | float *out = (float *)dst; | |
180b044f VR |
329 | |
330 | while (samples--) { | |
dd381319 VR |
331 | *out++ = CLIP_NATURAL_FLOAT(src->l); |
332 | *out++ = CLIP_NATURAL_FLOAT(src->r); | |
180b044f VR |
333 | src++; |
334 | } | |
335 | } | |
3d4d16f4 | 336 | |
ed2a4a79 KZ |
337 | f_sample *mixeng_clip_float[2] = { |
338 | clip_natural_float_from_mono, | |
339 | clip_natural_float_from_stereo, | |
340 | }; | |
341 | ||
e709d2ac | 342 | void audio_sample_to_uint64(const void *samples, int pos, |
3d4d16f4 PD |
343 | uint64_t *left, uint64_t *right) |
344 | { | |
3d4d16f4 PD |
345 | #ifdef FLOAT_MIXENG |
346 | error_report( | |
347 | "Coreaudio and floating point samples are not supported by replay yet"); | |
348 | abort(); | |
349 | #else | |
832061a2 AO |
350 | const struct st_sample *sample = samples; |
351 | sample += pos; | |
3d4d16f4 PD |
352 | *left = sample->l; |
353 | *right = sample->r; | |
354 | #endif | |
355 | } | |
356 | ||
357 | void audio_sample_from_uint64(void *samples, int pos, | |
358 | uint64_t left, uint64_t right) | |
359 | { | |
3d4d16f4 PD |
360 | #ifdef FLOAT_MIXENG |
361 | error_report( | |
362 | "Coreaudio and floating point samples are not supported by replay yet"); | |
363 | abort(); | |
364 | #else | |
832061a2 AO |
365 | struct st_sample *sample = samples; |
366 | sample += pos; | |
3d4d16f4 PD |
367 | sample->l = left; |
368 | sample->r = right; | |
369 | #endif | |
370 | } | |
371 | ||
85571bc7 FB |
372 | /* |
373 | * August 21, 1998 | |
374 | * Copyright 1998 Fabrice Bellard. | |
375 | * | |
cb8d4c8f | 376 | * [Rewrote completely the code of Lance Norskog And Sundry |
85571bc7 FB |
377 | * Contributors with a more efficient algorithm.] |
378 | * | |
379 | * This source code is freely redistributable and may be used for | |
1d14ffa9 FB |
380 | * any purpose. This copyright notice must be maintained. |
381 | * Lance Norskog And Sundry Contributors are not responsible for | |
382 | * the consequences of using this software. | |
85571bc7 FB |
383 | */ |
384 | ||
385 | /* | |
386 | * Sound Tools rate change effect file. | |
387 | */ | |
388 | /* | |
389 | * Linear Interpolation. | |
390 | * | |
391 | * The use of fractional increment allows us to use no buffer. It | |
392 | * avoid the problems at the end of the buffer we had with the old | |
393 | * method which stored a possibly big buffer of size | |
394 | * lcm(in_rate,out_rate). | |
395 | * | |
396 | * Limited to 16 bit samples and sampling frequency <= 65535 Hz. If | |
397 | * the input & output frequencies are equal, a delay of one sample is | |
398 | * introduced. Limited to processing 32-bit count worth of samples. | |
399 | * | |
400 | * 1 << FRAC_BITS evaluating to zero in several places. Changed with | |
401 | * an (unsigned long) cast to make it safe. MarkMLl 2/1/99 | |
402 | */ | |
403 | ||
404 | /* Private data */ | |
c0fe3827 | 405 | struct rate { |
85571bc7 FB |
406 | uint64_t opos; |
407 | uint64_t opos_inc; | |
408 | uint32_t ipos; /* position in the input stream (integer) */ | |
1ea879e5 | 409 | struct st_sample ilast; /* last sample in the input stream */ |
c0fe3827 | 410 | }; |
85571bc7 FB |
411 | |
412 | /* | |
413 | * Prepare processing. | |
414 | */ | |
415 | void *st_rate_start (int inrate, int outrate) | |
416 | { | |
25bf0c2d | 417 | struct rate *rate = g_new0(struct rate, 1); |
85571bc7 FB |
418 | |
419 | rate->opos = 0; | |
420 | ||
421 | /* increment */ | |
1d14ffa9 | 422 | rate->opos_inc = ((uint64_t) inrate << 32) / outrate; |
85571bc7 FB |
423 | |
424 | rate->ipos = 0; | |
425 | rate->ilast.l = 0; | |
426 | rate->ilast.r = 0; | |
427 | return rate; | |
428 | } | |
429 | ||
1d14ffa9 FB |
430 | #define NAME st_rate_flow_mix |
431 | #define OP(a, b) a += b | |
432 | #include "rate_template.h" | |
85571bc7 | 433 | |
1d14ffa9 FB |
434 | #define NAME st_rate_flow |
435 | #define OP(a, b) a = b | |
436 | #include "rate_template.h" | |
85571bc7 FB |
437 | |
438 | void st_rate_stop (void *opaque) | |
439 | { | |
7267c094 | 440 | g_free (opaque); |
85571bc7 | 441 | } |
1d14ffa9 | 442 | |
a9ea5678 VR |
443 | /** |
444 | * st_rate_frames_out() - returns the number of frames the resampling code | |
445 | * generates from frames_in frames | |
446 | * | |
447 | * @opaque: pointer to struct rate | |
448 | * @frames_in: number of frames | |
449 | * | |
450 | * When upsampling, there may be more than one correct result. In this case, | |
451 | * the function returns the maximum number of output frames the resampling | |
452 | * code can generate. | |
453 | */ | |
454 | uint32_t st_rate_frames_out(void *opaque, uint32_t frames_in) | |
455 | { | |
456 | struct rate *rate = opaque; | |
457 | uint64_t opos_end, opos_delta; | |
458 | uint32_t ipos_end; | |
459 | uint32_t frames_out; | |
460 | ||
461 | if (rate->opos_inc == 1ULL << 32) { | |
462 | return frames_in; | |
463 | } | |
464 | ||
465 | /* no output frame without at least one input frame */ | |
466 | if (!frames_in) { | |
467 | return 0; | |
468 | } | |
469 | ||
470 | /* last frame read was at rate->ipos - 1 */ | |
471 | ipos_end = rate->ipos - 1 + frames_in; | |
472 | opos_end = (uint64_t)ipos_end << 32; | |
473 | ||
474 | /* last frame written was at rate->opos - rate->opos_inc */ | |
475 | if (opos_end + rate->opos_inc <= rate->opos) { | |
476 | return 0; | |
477 | } | |
478 | opos_delta = opos_end - rate->opos + rate->opos_inc; | |
479 | frames_out = opos_delta / rate->opos_inc; | |
480 | ||
481 | return opos_delta % rate->opos_inc ? frames_out : frames_out - 1; | |
482 | } | |
483 | ||
1a01df3d VR |
484 | /** |
485 | * st_rate_frames_in() - returns the number of frames needed to | |
486 | * get frames_out frames after resampling | |
487 | * | |
488 | * @opaque: pointer to struct rate | |
489 | * @frames_out: number of frames | |
490 | * | |
491 | * When downsampling, there may be more than one correct result. In this | |
492 | * case, the function returns the maximum number of input frames needed. | |
493 | */ | |
494 | uint32_t st_rate_frames_in(void *opaque, uint32_t frames_out) | |
495 | { | |
496 | struct rate *rate = opaque; | |
497 | uint64_t opos_start, opos_end; | |
498 | uint32_t ipos_start, ipos_end; | |
499 | ||
500 | if (rate->opos_inc == 1ULL << 32) { | |
501 | return frames_out; | |
502 | } | |
503 | ||
504 | if (frames_out) { | |
505 | opos_start = rate->opos; | |
506 | ipos_start = rate->ipos; | |
507 | } else { | |
508 | uint64_t offset; | |
509 | ||
510 | /* add offset = ceil(opos_inc) to opos and ipos to avoid an underflow */ | |
511 | offset = (rate->opos_inc + (1ULL << 32) - 1) & ~((1ULL << 32) - 1); | |
512 | opos_start = rate->opos + offset; | |
513 | ipos_start = rate->ipos + (offset >> 32); | |
514 | } | |
515 | /* last frame written was at opos_start - rate->opos_inc */ | |
516 | opos_end = opos_start - rate->opos_inc + rate->opos_inc * frames_out; | |
517 | ipos_end = (opos_end >> 32) + 1; | |
518 | ||
519 | /* last frame read was at ipos_start - 1 */ | |
520 | return ipos_end + 1 > ipos_start ? ipos_end + 1 - ipos_start : 0; | |
521 | } | |
522 | ||
1ea879e5 | 523 | void mixeng_clear (struct st_sample *buf, int len) |
1d14ffa9 | 524 | { |
1ea879e5 | 525 | memset (buf, 0, len * sizeof (struct st_sample)); |
1d14ffa9 | 526 | } |
00e07679 MW |
527 | |
528 | void mixeng_volume (struct st_sample *buf, int len, struct mixeng_volume *vol) | |
529 | { | |
00e07679 MW |
530 | if (vol->mute) { |
531 | mixeng_clear (buf, len); | |
532 | return; | |
533 | } | |
534 | ||
535 | while (len--) { | |
536 | #ifdef FLOAT_MIXENG | |
537 | buf->l = buf->l * vol->l; | |
538 | buf->r = buf->r * vol->r; | |
539 | #else | |
540 | buf->l = (buf->l * vol->l) >> 32; | |
541 | buf->r = (buf->r * vol->r) >> 32; | |
542 | #endif | |
543 | buf += 1; | |
544 | } | |
00e07679 | 545 | } |