?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
grub2: bring back build of aros-side grub2 tools
[AROS.git] / workbench / devs / AHI / Device / addroutines_32bit.c
blobd3c367a0074d1e60856e8a6cc379da16bda9b853
1 /*
2 AHI - Hardware independent audio subsystem
3 Copyright (C) 1996-2005 Martin Blom <martin@blom.org>
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public
7 License as published by the Free Software Foundation; either
8 version 2 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public
16 License along with this library; if not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330, Cambridge,
18 MA 02139, USA.
19 */
20
21 #include <config.h>
22
23 #include "addroutines.h"
24
25 typedef long long LONGLONG;
26
27 /******************************************************************************
28 ** Add-Routines ***************************************************************
29 ******************************************************************************/
30
31 /*
32 ** LONG Samples
33 ** LONG ScaleLeft
34 ** LONG ScaleRight
35 ** LONG *StartPointLeft
36 ** LONG *StartPointRight
37 ** void *Src
38 ** void **Dst
39 ** LONG FirstOffsetI
40 ** Fixed64 *Offset
41 ** Fixed64 Add
42 ** BOOL StopAtZero
43 */
44
45 /*
46
47 Notes:
48
49 The fraction offset is divided by two in order to make sure that the
50 calculation of linearsample fits a LONG (0 =< offsetf <= 32767).
51
52 The routines could be faster, of course. One idea is to split the for loop
53 into two loops in order to eliminate the FirstOffsetI test in the second loop.
54
55 */
56
57 /*****************************************************************************/
58
59 /* Forward mixing code */
60
61 #define offseti ( (long) ( offset >> 32 ) )
62
63 #define offsetf ( offset & 0xffffffffULL )
64
65 LONG
66 AddLongMono( ADDARGS )
67 {
68 LONG *src = Src;
69 LONG *dst = *Dst;
70 Fixed64 offset = *Offset;
71 int i;
72 LONG startpoint, endpoint = 0; // Make compiler happy
73 LONG lastpoint;
74
75 lastpoint = 0; // 0 doesn't affect the StopAtZero code
76
77 for( i = 0; i < Samples; i++)
78 {
79 if( offseti == FirstOffsetI ) {
80 startpoint = *StartPointLeft << 16;
81 }
82 else
83 {
84 startpoint = src[ offseti - 1 ];
85 }
86
87 endpoint = src[ offseti ];
88
89 startpoint += (LONG) (((LONGLONG) (endpoint - startpoint) * offsetf ) >> 32);
90
91 if( StopAtZero &&
92 ( ( lastpoint < 0 && startpoint >= 0 ) ||
93 ( lastpoint > 0 && startpoint <= 0 ) ) )
94 {
95 break;
96 }
97
98 lastpoint = startpoint;
99
100 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpoint ) >> 16 );
101
102 offset += Add;
103 }
104
105 *StartPointLeft = endpoint >> 16;
106
107 *Dst = dst;
108 *Offset = offset;
109
110 return i;
111 }
112
113
114 LONG
115 AddLongStereo( ADDARGS )
116 {
117 LONG *src = Src;
118 LONG *dst = *Dst;
119 Fixed64 offset = *Offset;
120 int i;
121 LONG startpoint, endpoint = 0; // Make compiler happy
122 LONG lastpoint;
123
124 lastpoint = 0; // 0 doesn't affect the StopAtZero code
125
126 for( i = 0; i < Samples; i++)
127 {
128 if( offseti == FirstOffsetI ) {
129 startpoint = *StartPointLeft << 16;
130 }
131 else
132 {
133 startpoint = src[ offseti - 1 ];
134 }
135
136 endpoint = src[ offseti ];
137
138 startpoint += (LONG) (((LONGLONG) (endpoint - startpoint) * offsetf ) >> 32);
139
140 if( StopAtZero &&
141 ( ( lastpoint < 0 && startpoint >= 0 ) ||
142 ( lastpoint > 0 && startpoint <= 0 ) ) )
143 {
144 break;
145 }
146
147 lastpoint = startpoint;
148
149 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpoint ) >> 16 );
150 *dst++ += (LONG) ( ( (LONGLONG) ScaleRight * startpoint ) >> 16 );
151
152 offset += Add;
153 }
154
155 *StartPointLeft = endpoint >> 16;
156
157 *Dst = dst;
158 *Offset = offset;
159
160 return i;
161 }
162
163 LONG
164 AddLongsMono( ADDARGS )
165 {
166 LONG *src = Src;
167 LONG *dst = *Dst;
168 Fixed64 offset = *Offset;
169 int i;
170 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
171 LONG lastpointL, lastpointR;
172
173 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
174
175 for( i = 0; i < Samples; i++)
176 {
177 if( offseti == FirstOffsetI ) {
178 startpointL = *StartPointLeft << 16;
179 startpointR = *StartPointRight << 16;
180 }
181 else
182 {
183 startpointL = src[ offseti * 2 + 0 - 2 ];
184 startpointR = src[ offseti * 2 + 1 - 2 ];
185 }
186
187 endpointL = src[ offseti * 2 + 0 ];
188 endpointR = src[ offseti * 2 + 1 ];
189
190 startpointL += (LONG) (((LONGLONG) (endpointL - startpointL) * offsetf ) >> 32);
191 startpointR += (LONG) (((LONGLONG) (endpointR - startpointR) * offsetf ) >> 32);
192
193 if( StopAtZero &&
194 ( ( lastpointL < 0 && startpointL >= 0 ) ||
195 ( lastpointR < 0 && startpointR >= 0 ) ||
196 ( lastpointL > 0 && startpointL <= 0 ) ||
197 ( lastpointR > 0 && startpointR <= 0 ) ) )
198 {
199 break;
200 }
201
202 lastpointL = startpointL;
203 lastpointR = startpointR;
204
205 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointL ) >> 16 )
206 + (LONG) ( ( (LONGLONG) ScaleRight * startpointR ) >> 16 );
207
208 offset += Add;
209 }
210
211 *StartPointLeft = endpointL >> 16;
212 *StartPointRight = endpointR >> 16;
213
214 *Dst = dst;
215 *Offset = offset;
216
217 return i;
218 }
219
220
221 LONG
222 AddLongsStereo( ADDARGS )
223 {
224 LONG *src = Src;
225 LONG *dst = *Dst;
226 Fixed64 offset = *Offset;
227 int i;
228 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
229 LONG lastpointL, lastpointR;
230
231 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
232
233 for( i = 0; i < Samples; i++)
234 {
235 if( offseti == FirstOffsetI ) {
236 startpointL = *StartPointLeft << 16;
237 startpointR = *StartPointRight << 16;
238 }
239 else
240 {
241 startpointL = src[ offseti * 2 + 0 - 2 ];
242 startpointR = src[ offseti * 2 + 1 - 2 ];
243 }
244
245 endpointL = src[ offseti * 2 + 0 ];
246 endpointR = src[ offseti * 2 + 1 ];
247
248 startpointL += (LONG) (((LONGLONG) (endpointL - startpointL) * offsetf ) >> 32);
249 startpointR += (LONG) (((LONGLONG) (endpointR - startpointR) * offsetf ) >> 32);
250
251 if( StopAtZero &&
252 ( ( lastpointL < 0 && startpointL >= 0 ) ||
253 ( lastpointR < 0 && startpointR >= 0 ) ||
254 ( lastpointL > 0 && startpointL <= 0 ) ||
255 ( lastpointR > 0 && startpointR <= 0 ) ) )
256 {
257 break;
258 }
259
260 lastpointL = startpointL;
261 lastpointR = startpointR;
262
263 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointL ) >> 16 );
264 *dst++ += (LONG) ( ( (LONGLONG) ScaleRight * startpointR ) >> 16 );
265
266 offset += Add;
267 }
268
269 *StartPointLeft = endpointL >> 16;
270 *StartPointRight = endpointR >> 16;
271
272 *Dst = dst;
273 *Offset = offset;
274
275 return i;
276 }
277
278
279 LONG
280 Add71Mono( ADDARGS )
281 {
282 LONG *src = Src;
283 LONG *dst = *Dst;
284 Fixed64 offset = *Offset;
285 int i;
286 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
287 LONG lastpointL, lastpointR;
288
289 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
290
291 for( i = 0; i < Samples; i++)
292 {
293 if( offseti == FirstOffsetI ) {
294 startpointL = *StartPointLeft << 16;
295 startpointR = *StartPointRight << 16;
296 }
297 else
298 {
299 startpointL = src[ offseti * 8 + 0 - 8 ];
300 startpointR = src[ offseti * 8 + 1 - 8 ];
301 }
302
303 endpointL = src[ offseti * 8 + 0 ];
304 endpointR = src[ offseti * 8 + 1 ];
305
306 startpointL += (LONG) (((LONGLONG) (endpointL - startpointL) * offsetf ) >> 32);
307 startpointR += (LONG) (((LONGLONG) (endpointR - startpointR) * offsetf ) >> 32);
308
309 if( StopAtZero &&
310 ( ( lastpointL < 0 && startpointL >= 0 ) ||
311 ( lastpointR < 0 && startpointR >= 0 ) ||
312 ( lastpointL > 0 && startpointL <= 0 ) ||
313 ( lastpointR > 0 && startpointR <= 0 ) ) )
314 {
315 break;
316 }
317
318 lastpointL = startpointL;
319 lastpointR = startpointR;
320
321 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointL ) >> 16 )
322 + (LONG) ( ( (LONGLONG) ScaleRight * startpointR ) >> 16 );
323
324 offset += Add;
325 }
326
327 *StartPointLeft = endpointL >> 16;
328 *StartPointRight = endpointR >> 16;
329
330 *Dst = dst;
331 *Offset = offset;
332
333 return i;
334 }
335
336
337 LONG
338 Add71Stereo( ADDARGS )
339 {
340 LONG *src = Src;
341 LONG *dst = *Dst;
342 Fixed64 offset = *Offset;
343 int i;
344 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
345 LONG lastpointL, lastpointR;
346
347 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
348
349 for( i = 0; i < Samples; i++)
350 {
351 if( offseti == FirstOffsetI ) {
352 startpointL = *StartPointLeft << 16;
353 startpointR = *StartPointRight << 16;
354 }
355 else
356 {
357 startpointL = src[ offseti * 8 + 0 - 8 ];
358 startpointR = src[ offseti * 8 + 1 - 8 ];
359 }
360
361 endpointL = src[ offseti * 8 + 0 ];
362 endpointR = src[ offseti * 8 + 1 ];
363
364 startpointL += (LONG) (((LONGLONG) (endpointL - startpointL) * offsetf ) >> 32);
365 startpointR += (LONG) (((LONGLONG) (endpointR - startpointR) * offsetf ) >> 32);
366
367 if( StopAtZero &&
368 ( ( lastpointL < 0 && startpointL >= 0 ) ||
369 ( lastpointR < 0 && startpointR >= 0 ) ||
370 ( lastpointL > 0 && startpointL <= 0 ) ||
371 ( lastpointR > 0 && startpointR <= 0 ) ) )
372 {
373 break;
374 }
375
376 lastpointL = startpointL;
377 lastpointR = startpointR;
378
379 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointL ) >> 16 );
380 *dst++ += (LONG) ( ( (LONGLONG) ScaleRight * startpointR ) >> 16 );
381
382 offset += Add;
383 }
384
385 *StartPointLeft = endpointL >> 16;
386 *StartPointRight = endpointR >> 16;
387
388 *Dst = dst;
389 *Offset = offset;
390
391 return i;
392 }
393
394 /*****************************************************************************/
395
396 /* Lofi mixing code */
397
398 LONG
399 AddLofiLongMono( ADDARGS )
400 {
401 LONG *src = Src;
402 WORD *dst = *Dst;
403 Fixed64 offset = *Offset;
404 int i;
405 LONG lastpoint, sample;
406
407 lastpoint = 0; // 0 doesn't affect the StopAtZero code
408
409 for( i = 0; i < Samples; i++)
410 {
411 sample = src[ offseti ] >> 16;
412
413 if( StopAtZero &&
414 ( ( lastpoint < 0 && sample >= 0 ) ||
415 ( lastpoint > 0 && sample <= 0 ) ) )
416 {
417 break;
418 }
419
420 lastpoint = sample;
421
422 *dst++ += ( ScaleLeft * sample ) >> 16;
423
424 offset += Add;
425 }
426
427 *Dst = dst;
428 *Offset = offset;
429
430 return i;
431 }
432
433
434 LONG
435 AddLofiLongStereo( ADDARGS )
436 {
437 LONG *src = Src;
438 WORD *dst = *Dst;
439 Fixed64 offset = *Offset;
440 int i;
441 LONG lastpoint, sample;
442
443 lastpoint = 0; // 0 doesn't affect the StopAtZero code
444
445 for( i = 0; i < Samples; i++)
446 {
447 sample = src[ offseti ] >> 16;;
448
449 if( StopAtZero &&
450 ( ( lastpoint < 0 && sample >= 0 ) ||
451 ( lastpoint > 0 && sample <= 0 ) ) )
452 {
453 break;
454 }
455
456 lastpoint = sample;
457
458 *dst++ += ( ScaleLeft * sample ) >> 16;
459 *dst++ += ( ScaleRight * sample ) >> 16;
460
461 offset += Add;
462 }
463
464 *Dst = dst;
465 *Offset = offset;
466
467 return i;
468 }
469
470 LONG
471 AddLofiLongsMono( ADDARGS )
472 {
473 LONG *src = Src;
474 WORD *dst = *Dst;
475 Fixed64 offset = *Offset;
476 int i;
477 LONG lastpointL, lastpointR, sampleL, sampleR;
478
479 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
480
481 for( i = 0; i < Samples; i++)
482 {
483 sampleL = src[ offseti * 2 + 0 ] >> 16;;
484 sampleR = src[ offseti * 2 + 1 ] >> 16;;
485
486 if( StopAtZero &&
487 ( ( lastpointL < 0 && sampleL >= 0 ) ||
488 ( lastpointR < 0 && sampleR >= 0 ) ||
489 ( lastpointL > 0 && sampleL <= 0 ) ||
490 ( lastpointR > 0 && sampleR <= 0 ) ) )
491 {
492 break;
493 }
494
495 lastpointL = sampleL;
496 lastpointR = sampleR;
497
498 *dst++ += ( ScaleLeft * sampleL + ScaleRight * sampleR ) >> 16;
499
500 offset += Add;
501 }
502
503 *Dst = dst;
504 *Offset = offset;
505
506 return i;
507 }
508
509
510 LONG
511 AddLofiLongsStereo( ADDARGS )
512 {
513 LONG *src = Src;
514 WORD *dst = *Dst;
515 Fixed64 offset = *Offset;
516 int i;
517 LONG lastpointL, lastpointR, sampleL, sampleR;
518
519 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
520
521 for( i = 0; i < Samples; i++)
522 {
523 sampleL = src[ offseti * 2 + 0 ] >> 16;;
524 sampleR = src[ offseti * 2 + 1 ] >> 16;;
525
526 if( StopAtZero &&
527 ( ( lastpointL < 0 && sampleL >= 0 ) ||
528 ( lastpointR < 0 && sampleR >= 0 ) ||
529 ( lastpointL > 0 && sampleL <= 0 ) ||
530 ( lastpointR > 0 && sampleR <= 0 ) ) )
531 {
532 break;
533 }
534
535 lastpointL = sampleL;
536 lastpointR = sampleR;
537
538 *dst++ += ( ScaleLeft * sampleL ) >> 16;
539 *dst++ += ( ScaleRight * sampleR ) >> 16;
540
541 offset += Add;
542 }
543
544 *Dst = dst;
545 *Offset = offset;
546
547 return i;
548 }
549
550
551
552 #undef offsetf
553
554 /*****************************************************************************/
555
556 /* Backward mixing code */
557
558 #define offsetf ( (long) ( 32768 - ( (unsigned long) ( offset & 0xffffffffULL ) >> 17 ) ) )
559
560 LONG
561 AddLongMonoB( ADDARGS )
562 {
563 LONG *src = Src;
564 LONG *dst = *Dst;
565 Fixed64 offset = *Offset;
566 int i;
567 LONG startpoint, endpoint = 0; // Make compiler happy
568 LONG lastpoint;
569
570 lastpoint = 0; // 0 doesn't affect the StopAtZero code
571
572 for( i = 0; i < Samples; i++)
573 {
574 if( offseti == FirstOffsetI ) {
575 startpoint = *StartPointLeft << 16;
576 }
577 else
578 {
579 startpoint = src[ offseti + 1 ];
580 }
581
582 endpoint = src[ offseti ];
583
584 startpoint += (LONG) (((LONGLONG) (endpoint - startpoint) * offsetf ) >> 32);
585
586 if( StopAtZero &&
587 ( ( lastpoint < 0 && startpoint >= 0 ) ||
588 ( lastpoint > 0 && startpoint <= 0 ) ) )
589 {
590 break;
591 }
592
593 lastpoint = startpoint;
594
595 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpoint ) >> 16 );
596
597 offset -= Add;
598 }
599
600 *StartPointLeft = endpoint >> 16;
601
602 *Dst = dst;
603 *Offset = offset;
604
605 return i;
606 }
607
608
609 LONG
610 AddLongStereoB( ADDARGS )
611 {
612 LONG *src = Src;
613 LONG *dst = *Dst;
614 Fixed64 offset = *Offset;
615 int i;
616 LONG startpoint, endpoint = 0; // Make compiler happy
617 LONG lastpoint;
618
619 lastpoint = 0; // 0 doesn't affect the StopAtZero code
620
621 for( i = 0; i < Samples; i++)
622 {
623 if( offseti == FirstOffsetI ) {
624 startpoint = *StartPointLeft << 16;
625 }
626 else
627 {
628 startpoint = src[ offseti + 1 ];
629 }
630
631 endpoint = src[ offseti ];
632
633 startpoint += (LONG) (((LONGLONG) (endpoint - startpoint) * offsetf ) >> 32);
634
635 if( StopAtZero &&
636 ( ( lastpoint < 0 && startpoint >= 0 ) ||
637 ( lastpoint > 0 && startpoint <= 0 ) ) )
638 {
639 break;
640 }
641
642 lastpoint = startpoint;
643
644 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpoint ) >> 16 );
645 *dst++ += (LONG) ( ( (LONGLONG) ScaleRight * startpoint ) >> 16 );
646
647 offset -= Add;
648 }
649
650 *StartPointLeft = endpoint >> 16;
651
652 *Dst = dst;
653 *Offset = offset;
654
655 return i;
656 }
657
658
659 LONG
660 AddLongsMonoB( ADDARGS )
661 {
662 LONG *src = Src;
663 LONG *dst = *Dst;
664 Fixed64 offset = *Offset;
665 int i;
666 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
667 LONG lastpointL, lastpointR;
668
669 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
670
671 for( i = 0; i < Samples; i++)
672 {
673 if( offseti == FirstOffsetI ) {
674 startpointL = *StartPointLeft << 16;
675 startpointR = *StartPointRight << 16;
676 }
677 else
678 {
679 startpointL = src[ offseti * 2 + 0 + 2 ];
680 startpointR = src[ offseti * 2 + 1 + 2 ];
681 }
682
683 endpointL = src[ offseti * 2 + 0 ];
684 endpointR = src[ offseti * 2 + 1 ];
685
686 startpointL += (LONG) (((LONGLONG) (endpointL - startpointL) * offsetf ) >> 32);
687 startpointR += (LONG) (((LONGLONG) (endpointR - startpointR) * offsetf ) >> 32);
688
689 if( StopAtZero &&
690 ( ( lastpointL < 0 && startpointL >= 0 ) ||
691 ( lastpointR < 0 && startpointR >= 0 ) ||
692 ( lastpointL > 0 && startpointL <= 0 ) ||
693 ( lastpointR > 0 && startpointR <= 0 ) ) )
694 {
695 break;
696 }
697
698 lastpointL = startpointL;
699 lastpointR = startpointR;
700
701 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointL ) >> 16 ) +
702 (LONG) ( ( (LONGLONG) ScaleRight * startpointR ) >> 16 );
703
704 offset -= Add;
705 }
706
707 *StartPointLeft = endpointL >> 16;
708 *StartPointRight = endpointR >> 16;
709
710 *Dst = dst;
711 *Offset = offset;
712
713 return i;
714 }
715
716
717 LONG
718 AddLongsStereoB( ADDARGS )
719 {
720 LONG *src = Src;
721 LONG *dst = *Dst;
722 Fixed64 offset = *Offset;
723 int i;
724 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
725 LONG lastpointL, lastpointR;
726
727 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
728
729 for( i = 0; i < Samples; i++)
730 {
731 if( offseti == FirstOffsetI ) {
732 startpointL = *StartPointLeft << 16;
733 startpointR = *StartPointRight << 16;
734 }
735 else
736 {
737 startpointL = src[ offseti * 2 + 0 + 2 ];
738 startpointR = src[ offseti * 2 + 1 + 2 ];
739 }
740
741 endpointL = src[ offseti * 2 + 0 ];
742 endpointR = src[ offseti * 2 + 1 ];
743
744 startpointL += (LONG) (((LONGLONG) (endpointL - startpointL) * offsetf ) >> 32);
745 startpointR += (LONG) (((LONGLONG) (endpointR - startpointR) * offsetf ) >> 32);
746
747 if( StopAtZero &&
748 ( ( lastpointL < 0 && startpointL >= 0 ) ||
749 ( lastpointR < 0 && startpointR >= 0 ) ||
750 ( lastpointL > 0 && startpointL <= 0 ) ||
751 ( lastpointR > 0 && startpointR <= 0 ) ) )
752 {
753 break;
754 }
755
756 lastpointL = startpointL;
757 lastpointR = startpointR;
758
759 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointL ) >> 16 );
760 *dst++ += (LONG) ( ( (LONGLONG) ScaleRight * startpointR ) >> 16 );
761
762 offset -= Add;
763 }
764
765 *StartPointLeft = endpointL >> 16;
766 *StartPointRight = endpointR >> 16;
767
768 *Dst = dst;
769 *Offset = offset;
770
771 return i;
772 }
773
774
775 LONG
776 Add71MonoB( ADDARGS )
777 {
778 LONG *src = Src;
779 LONG *dst = *Dst;
780 Fixed64 offset = *Offset;
781 int i;
782 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
783 LONG lastpointL, lastpointR;
784
785 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
786
787 for( i = 0; i < Samples; i++)
788 {
789 if( offseti == FirstOffsetI ) {
790 startpointL = *StartPointLeft << 16;
791 startpointR = *StartPointRight << 16;
792 }
793 else
794 {
795 startpointL = src[ offseti * 8 + 0 + 8 ];
796 startpointR = src[ offseti * 8 + 1 + 8 ];
797 }
798
799 endpointL = src[ offseti * 8 + 0 ];
800 endpointR = src[ offseti * 8 + 1 ];
801
802 startpointL += (LONG) (((LONGLONG) (endpointL - startpointL) * offsetf ) >> 32);
803 startpointR += (LONG) (((LONGLONG) (endpointR - startpointR) * offsetf ) >> 32);
804
805 if( StopAtZero &&
806 ( ( lastpointL < 0 && startpointL >= 0 ) ||
807 ( lastpointR < 0 && startpointR >= 0 ) ||
808 ( lastpointL > 0 && startpointL <= 0 ) ||
809 ( lastpointR > 0 && startpointR <= 0 ) ) )
810 {
811 break;
812 }
813
814 lastpointL = startpointL;
815 lastpointR = startpointR;
816
817 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointL ) >> 16 ) +
818 (LONG) ( ( (LONGLONG) ScaleRight * startpointR ) >> 16 );
819
820 offset -= Add;
821 }
822
823 *StartPointLeft = endpointL >> 16;
824 *StartPointRight = endpointR >> 16;
825
826 *Dst = dst;
827 *Offset = offset;
828
829 return i;
830 }
831
832
833 LONG
834 Add71StereoB( ADDARGS )
835 {
836 LONG *src = Src;
837 LONG *dst = *Dst;
838 Fixed64 offset = *Offset;
839 int i;
840 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
841 LONG lastpointL, lastpointR;
842
843 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
844
845 for( i = 0; i < Samples; i++)
846 {
847 if( offseti == FirstOffsetI ) {
848 startpointL = *StartPointLeft << 16;
849 startpointR = *StartPointRight << 16;
850 }
851 else
852 {
853 startpointL = src[ offseti * 8 + 0 + 8 ];
854 startpointR = src[ offseti * 8 + 1 + 8 ];
855 }
856
857 endpointL = src[ offseti * 8 + 0 ];
858 endpointR = src[ offseti * 8 + 1 ];
859
860 startpointL += (LONG) (((LONGLONG) (endpointL - startpointL) * offsetf ) >> 32);
861 startpointR += (LONG) (((LONGLONG) (endpointR - startpointR) * offsetf ) >> 32);
862
863 if( StopAtZero &&
864 ( ( lastpointL < 0 && startpointL >= 0 ) ||
865 ( lastpointR < 0 && startpointR >= 0 ) ||
866 ( lastpointL > 0 && startpointL <= 0 ) ||
867 ( lastpointR > 0 && startpointR <= 0 ) ) )
868 {
869 break;
870 }
871
872 lastpointL = startpointL;
873 lastpointR = startpointR;
874
875 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointL ) >> 16 );
876 *dst++ += (LONG) ( ( (LONGLONG) ScaleRight * startpointR ) >> 16 );
877
878 offset -= Add;
879 }
880
881 *StartPointLeft = endpointL >> 16;
882 *StartPointRight = endpointR >> 16;
883
884 *Dst = dst;
885 *Offset = offset;
886
887 return i;
888 }
889
890
891 /*****************************************************************************/
892
893 /* Lofi mixing code */
894
895 LONG
896 AddLofiLongMonoB( ADDARGS )
897 {
898 LONG *src = Src;
899 WORD *dst = *Dst;
900 Fixed64 offset = *Offset;
901 int i;
902 LONG lastpoint, sample;
903
904 lastpoint = 0; // 0 doesn't affect the StopAtZero code
905
906 for( i = 0; i < Samples; i++)
907 {
908 sample = src[ offseti ] >> 16;;
909
910 if( StopAtZero &&
911 ( ( lastpoint < 0 && sample >= 0 ) ||
912 ( lastpoint > 0 && sample <= 0 ) ) )
913 {
914 break;
915 }
916
917 lastpoint = sample;
918
919 *dst++ += ( ScaleLeft * sample ) >> 16;
920
921 offset -= Add;
922 }
923
924 *Dst = dst;
925 *Offset = offset;
926
927 return i;
928 }
929
930
931 LONG
932 AddLofiLongStereoB( ADDARGS )
933 {
934 LONG *src = Src;
935 WORD *dst = *Dst;
936 Fixed64 offset = *Offset;
937 int i;
938 LONG lastpoint, sample;
939
940 lastpoint = 0; // 0 doesn't affect the StopAtZero code
941
942 for( i = 0; i < Samples; i++)
943 {
944 sample = src[ offseti ] >> 16;;
945
946 if( StopAtZero &&
947 ( ( lastpoint < 0 && sample >= 0 ) ||
948 ( lastpoint > 0 && sample <= 0 ) ) )
949 {
950 break;
951 }
952
953 lastpoint = sample;
954
955 *dst++ += ( ScaleLeft * sample ) >> 16;
956 *dst++ += ( ScaleRight * sample ) >> 16;
957
958 offset -= Add;
959 }
960
961 *Dst = dst;
962 *Offset = offset;
963
964 return i;
965 }
966
967
968 LONG
969 AddLofiLongsMonoB( ADDARGS )
970 {
971 LONG *src = Src;
972 WORD *dst = *Dst;
973 Fixed64 offset = *Offset;
974 int i;
975 LONG lastpointL, lastpointR, sampleL, sampleR;
976
977 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
978
979 for( i = 0; i < Samples; i++)
980 {
981 sampleL = src[ offseti * 2 + 0 ] >> 16;;
982 sampleR = src[ offseti * 2 + 1 ] >> 16;;
983
984 if( StopAtZero &&
985 ( ( lastpointL < 0 && sampleL >= 0 ) ||
986 ( lastpointR < 0 && sampleR >= 0 ) ||
987 ( lastpointL > 0 && sampleL <= 0 ) ||
988 ( lastpointR > 0 && sampleR <= 0 ) ) )
989 {
990 break;
991 }
992
993 lastpointL = sampleL;
994 lastpointR = sampleR;
995
996 *dst++ += ( ScaleLeft * sampleL + ScaleRight * sampleR ) >> 16;
997
998 offset -= Add;
999 }
1000
1001 *Dst = dst;
1002 *Offset = offset;
1003
1004 return i;
1005 }
1006
1007
1008 LONG
1009 AddLofiLongsStereoB( ADDARGS )
1010 {
1011 LONG *src = Src;
1012 WORD *dst = *Dst;
1013 Fixed64 offset = *Offset;
1014 int i;
1015 LONG lastpointL, lastpointR, sampleL, sampleR;
1016
1017 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
1018
1019 for( i = 0; i < Samples; i++)
1020 {
1021 sampleL = src[ offseti * 2 + 0 ] >> 16;;
1022 sampleR = src[ offseti * 2 + 1 ] >> 16;;
1023
1024 if( StopAtZero &&
1025 ( ( lastpointL < 0 && sampleL >= 0 ) ||
1026 ( lastpointR < 0 && sampleR >= 0 ) ||
1027 ( lastpointL > 0 && sampleL <= 0 ) ||
1028 ( lastpointR > 0 && sampleR <= 0 ) ) )
1029 {
1030 break;
1031 }
1032
1033 lastpointL = sampleL;
1034 lastpointR = sampleR;
1035
1036 *dst++ += ( ScaleLeft * sampleL ) >> 16;
1037 *dst++ += ( ScaleRight * sampleR ) >> 16;
1038
1039 offset -= Add;
1040 }
1041
1042 *Dst = dst;
1043 *Offset = offset;
1044
1045 return i;
1046 }
1047
1048
1049 #undef offseti
1050 #undef offsetf
1051
1052 /*****************************************************************************/
Mirror of AROS' svn.