?  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_71.c
blobf5b8eb2d80ad249ba9dbcd01da496c5e9fec2171
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 *StartPoints
36 ** APTR Unused
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 ( (long) ( (unsigned long) ( offset & 0xffffffffULL ) >> 17) )
64
65 LONG
66 AddByte71( ADDARGS )
67 {
68 BYTE *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;
81 }
82 else
83 {
84 startpoint = src[ offseti - 1 ] << 8;
85 }
86
87 endpoint = src[ offseti ] << 8;
88
89 startpoint += (((endpoint - startpoint) * offsetf ) >> 15);
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[ 0 ] += ScaleLeft * startpoint;
101 dst[ 1 ] += ScaleRight * startpoint;
102 dst += 8;
103
104 offset += Add;
105 }
106
107 *StartPointLeft = endpoint;
108
109 *Dst = dst;
110 *Offset = offset;
111
112 return i;
113 }
114
115 LONG
116 AddBytes71( ADDARGS )
117 {
118 BYTE *src = Src;
119 LONG *dst = *Dst;
120 Fixed64 offset = *Offset;
121 int i;
122 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
123 LONG lastpointL, lastpointR;
124
125 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
126
127 for( i = 0; i < Samples; i++)
128 {
129 if( offseti == FirstOffsetI ) {
130 startpointL = *StartPointLeft;
131 startpointR = *StartPointRight;
132 }
133 else
134 {
135 startpointL = src[ offseti * 2 + 0 - 2 ] << 8;
136 startpointR = src[ offseti * 2 + 1 - 2 ] << 8;
137 }
138
139 endpointL = src[ offseti * 2 + 0 ] << 8;
140 endpointR = src[ offseti * 2 + 1 ] << 8;
141
142 startpointL += (((endpointL - startpointL) * offsetf ) >> 15);
143 startpointR += (((endpointR - startpointR) * offsetf ) >> 15);
144
145 if( StopAtZero &&
146 ( ( lastpointL < 0 && startpointL >= 0 ) ||
147 ( lastpointR < 0 && startpointR >= 0 ) ||
148 ( lastpointL > 0 && startpointL <= 0 ) ||
149 ( lastpointR > 0 && startpointR <= 0 ) ) )
150 {
151 break;
152 }
153
154 lastpointL = startpointL;
155 lastpointR = startpointR;
156
157 dst[ 0 ] += ScaleLeft * startpointL;
158 dst[ 1 ] += ScaleRight * startpointR;
159 dst += 8;
160
161 offset += Add;
162 }
163
164 *StartPointLeft = endpointL;
165 *StartPointRight = endpointR;
166
167 *Dst = dst;
168 *Offset = offset;
169
170 return i;
171 }
172 LONG
173 AddWord71( ADDARGS )
174 {
175 WORD *src = Src;
176 LONG *dst = *Dst;
177 Fixed64 offset = *Offset;
178 int i;
179 LONG startpoint, endpoint = 0; // Make compiler happy
180 LONG lastpoint;
181
182 lastpoint = 0; // 0 doesn't affect the StopAtZero code
183
184 for( i = 0; i < Samples; i++)
185 {
186 if( offseti == FirstOffsetI ) {
187 startpoint = *StartPointLeft;
188 }
189 else
190 {
191 startpoint = src[ offseti - 1 ];
192 }
193
194 endpoint = src[ offseti ];
195
196 startpoint += (((endpoint - startpoint) * offsetf ) >> 15);
197
198 if( StopAtZero &&
199 ( ( lastpoint < 0 && startpoint >= 0 ) ||
200 ( lastpoint > 0 && startpoint <= 0 ) ) )
201 {
202 break;
203 }
204
205 lastpoint = startpoint;
206
207 dst[ 0 ] += ScaleLeft * startpoint;
208 dst[ 1 ] += ScaleRight * startpoint;
209 dst += 8;
210
211 offset += Add;
212 }
213
214 *StartPointLeft = endpoint;
215
216 *Dst = dst;
217 *Offset = offset;
218
219 return i;
220 }
221
222
223 LONG
224 AddWords71( ADDARGS )
225 {
226 WORD *src = Src;
227 LONG *dst = *Dst;
228 Fixed64 offset = *Offset;
229 int i;
230 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
231 LONG lastpointL, lastpointR;
232
233 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
234
235 for( i = 0; i < Samples; i++)
236 {
237 if( offseti == FirstOffsetI ) {
238 startpointL = *StartPointLeft;
239 startpointR = *StartPointRight;
240 }
241 else
242 {
243 startpointL = src[ offseti * 2 + 0 - 2 ];
244 startpointR = src[ offseti * 2 + 1 - 2 ];
245 }
246
247 endpointL = src[ offseti * 2 + 0 ];
248 endpointR = src[ offseti * 2 + 1 ];
249
250 startpointL += (((endpointL - startpointL) * offsetf ) >> 15);
251 startpointR += (((endpointR - startpointR) * offsetf ) >> 15);
252
253 if( StopAtZero &&
254 ( ( lastpointL < 0 && startpointL >= 0 ) ||
255 ( lastpointR < 0 && startpointR >= 0 ) ||
256 ( lastpointL > 0 && startpointL <= 0 ) ||
257 ( lastpointR > 0 && startpointR <= 0 ) ) )
258 {
259 break;
260 }
261
262 lastpointL = startpointL;
263 lastpointR = startpointR;
264
265 dst[ 0 ] += ScaleLeft * startpointL;
266 dst[ 1 ] += ScaleRight * startpointR;
267 dst += 8;
268
269 offset += Add;
270 }
271
272 *StartPointLeft = endpointL;
273 *StartPointRight = endpointR;
274
275 *Dst = dst;
276 *Offset = offset;
277
278 return i;
279 }
280
281 #undef offseti
282 #undef offsetf
283
284 /*****************************************************************************/
285
286 #define offseti ( (long) ( offset >> 32 ) )
287
288 #define offsetf ( offset & 0xffffffffULL )
289
290 LONG
291 AddLong71( ADDARGS )
292 {
293 LONG *src = Src;
294 LONG *dst = *Dst;
295 Fixed64 offset = *Offset;
296 int i;
297 LONG startpoint, endpoint = 0; // Make compiler happy
298 LONG lastpoint;
299
300 lastpoint = 0; // 0 doesn't affect the StopAtZero code
301
302 for( i = 0; i < Samples; i++)
303 {
304 if( offseti == FirstOffsetI ) {
305 startpoint = *StartPointLeft << 16;
306 }
307 else
308 {
309 startpoint = src[ offseti - 1 ];
310 }
311
312 endpoint = src[ offseti ];
313
314 startpoint += (LONG) (((LONGLONG) (endpoint - startpoint) * offsetf ) >> 32);
315
316 if( StopAtZero &&
317 ( ( lastpoint < 0 && startpoint >= 0 ) ||
318 ( lastpoint > 0 && startpoint <= 0 ) ) )
319 {
320 break;
321 }
322
323 lastpoint = startpoint;
324
325 dst[ 0 ] += (LONG) ( ( (LONGLONG) ScaleLeft * startpoint ) >> 16 );
326 dst[ 1 ] += (LONG) ( ( (LONGLONG) ScaleRight * startpoint ) >> 16 );
327 dst += 8;
328
329 offset += Add;
330 }
331
332 *StartPointLeft = endpoint >> 16;
333
334 *Dst = dst;
335 *Offset = offset;
336
337 return i;
338 }
339
340
341 LONG
342 AddLongs71( ADDARGS )
343 {
344 LONG *src = Src;
345 LONG *dst = *Dst;
346 Fixed64 offset = *Offset;
347 int i;
348 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
349 LONG lastpointL, lastpointR;
350
351 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
352
353 for( i = 0; i < Samples; i++)
354 {
355 if( offseti == FirstOffsetI ) {
356 startpointL = *StartPointLeft << 16;
357 startpointR = *StartPointRight << 16;
358 }
359 else
360 {
361 startpointL = src[ offseti * 2 + 0 - 2 ];
362 startpointR = src[ offseti * 2 + 1 - 2 ];
363 }
364
365 endpointL = src[ offseti * 2 + 0 ];
366 endpointR = src[ offseti * 2 + 1 ];
367
368 startpointL += (LONG) (((LONGLONG) (endpointL - startpointL) * offsetf ) >> 32);
369 startpointR += (LONG) (((LONGLONG) (endpointR - startpointR) * offsetf ) >> 32);
370
371 if( StopAtZero &&
372 ( ( lastpointL < 0 && startpointL >= 0 ) ||
373 ( lastpointR < 0 && startpointR >= 0 ) ||
374 ( lastpointL > 0 && startpointL <= 0 ) ||
375 ( lastpointR > 0 && startpointR <= 0 ) ) )
376 {
377 break;
378 }
379
380 lastpointL = startpointL;
381 lastpointR = startpointR;
382
383 dst[ 0 ] += (LONG) ( ( (LONGLONG) ScaleLeft * startpointL ) >> 16 );
384 dst[ 1 ] += (LONG) ( ( (LONGLONG) ScaleRight * startpointR ) >> 16 );
385 dst += 8;
386
387 offset += Add;
388 }
389
390 *StartPointLeft = endpointL >> 16;
391 *StartPointRight = endpointR >> 16;
392
393 *Dst = dst;
394 *Offset = offset;
395
396 return i;
397 }
398
399
400 LONG
401 Add7171( ADDARGS71 )
402 {
403 LONG *src = Src;
404 LONG *dst = *Dst;
405 Fixed64 offset = *Offset;
406 int i;
407 LONG startpointL, startpointR;
408 LONG startpointRL, startpointRR;
409 LONG startpointSL, startpointSR;
410 LONG startpointC, startpointLFE;
411 LONG endpointL = 0, endpointR = 0; // Make compiler happy
412 LONG endpointRL = 0, endpointRR = 0; // Make compiler happy
413 LONG endpointSL = 0, endpointSR = 0; // Make compiler happy
414 LONG endpointC = 0, endpointLFE = 0; // Make compiler happy
415 LONG lastpointL, lastpointR;
416 LONG scale_mono = ( ScaleLeft + ScaleRight ) / 2;
417
418 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
419
420 for( i = 0; i < Samples; i++)
421 {
422 if( offseti == FirstOffsetI ) {
423 startpointL = StartPoints[ CD_L ] << 16;
424 startpointR = StartPoints[ CD_R ] << 16;
425 startpointRL = StartPoints[ CD_RL ] << 16;
426 startpointRR = StartPoints[ CD_RR ] << 16;
427 startpointSL = StartPoints[ CD_SL ] << 16;
428 startpointSR = StartPoints[ CD_SR ] << 16;
429 startpointC = StartPoints[ CD_C ] << 16;
430 startpointLFE = StartPoints[ CD_LFE ] << 16;
431 }
432 else
433 {
434 startpointL = src[ offseti * 8 + 0 - 8 ];
435 startpointR = src[ offseti * 8 + 1 - 8 ];
436 startpointRL = src[ offseti * 8 + 2 - 8 ];
437 startpointRR = src[ offseti * 8 + 3 - 8 ];
438 startpointSL = src[ offseti * 8 + 4 - 8 ];
439 startpointSR = src[ offseti * 8 + 5 - 8 ];
440 startpointC = src[ offseti * 8 + 6 - 8 ];
441 startpointLFE = src[ offseti * 8 + 7 - 8 ];
442 }
443
444 endpointL = src[ offseti * 8 + 0 ];
445 endpointR = src[ offseti * 8 + 1 ];
446 endpointRL = src[ offseti * 8 + 2 ];
447 endpointRR = src[ offseti * 8 + 3 ];
448 endpointSL = src[ offseti * 8 + 4 ];
449 endpointSR = src[ offseti * 8 + 5 ];
450 endpointC = src[ offseti * 8 + 6 ];
451 endpointLFE = src[ offseti * 8 + 7 ];
452
453 startpointL += (LONG) (((LONGLONG) (endpointL - startpointL) * offsetf ) >> 32);
454 startpointR += (LONG) (((LONGLONG) (endpointR - startpointR) * offsetf ) >> 32);
455 startpointRL += (LONG) (((LONGLONG) (endpointRL - startpointRL) * offsetf ) >> 32);
456 startpointRR += (LONG) (((LONGLONG) (endpointRR - startpointRR) * offsetf ) >> 32);
457 startpointSL += (LONG) (((LONGLONG) (endpointSL - startpointSL) * offsetf ) >> 32);
458 startpointSR += (LONG) (((LONGLONG) (endpointSR - startpointSR) * offsetf ) >> 32);
459 startpointC += (LONG) (((LONGLONG) (endpointC - startpointC) * offsetf ) >> 32);
460 startpointLFE += (LONG) (((LONGLONG) (endpointLFE - startpointLFE) * offsetf ) >> 32);
461
462 if( StopAtZero &&
463 ( ( lastpointL < 0 && startpointL >= 0 ) ||
464 ( lastpointR < 0 && startpointR >= 0 ) ||
465 ( lastpointL > 0 && startpointL <= 0 ) ||
466 ( lastpointR > 0 && startpointR <= 0 ) ) )
467 {
468 break;
469 }
470
471 lastpointL = startpointL;
472 lastpointR = startpointR;
473
474 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointL ) >> 16 );
475 *dst++ += (LONG) ( ( (LONGLONG) ScaleRight * startpointR ) >> 16 );
476 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointRL ) >> 16 );
477 *dst++ += (LONG) ( ( (LONGLONG) ScaleRight * startpointRR ) >> 16 );
478 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointSL ) >> 16 );
479 *dst++ += (LONG) ( ( (LONGLONG) ScaleRight * startpointSR ) >> 16 );
480 *dst++ += (LONG) ( ( (LONGLONG) scale_mono * startpointC ) >> 16 );
481 *dst++ += (LONG) ( ( (LONGLONG) scale_mono * startpointLFE ) >> 16 );
482
483 offset += Add;
484 }
485
486 StartPoints[ CD_L ] = endpointL >> 16;
487 StartPoints[ CD_R ] = endpointR >> 16;
488 StartPoints[ CD_RL ] = endpointRL >> 16;
489 StartPoints[ CD_RR ] = endpointRR >> 16;
490 StartPoints[ CD_SL ] = endpointSL >> 16;
491 StartPoints[ CD_SR ] = endpointSR >> 16;
492 StartPoints[ CD_C ] = endpointC >> 16;
493 StartPoints[ CD_LFE ] = endpointLFE >> 16;
494
495 *Dst = dst;
496 *Offset = offset;
497
498 return i;
499 }
500
501 #undef offseti
502 #undef offsetf
503
504
505 /*****************************************************************************/
506
507 /* Backward mixing code */
508
509 #define offseti ( (long) ( offset >> 32 ) )
510
511 #define offsetf ( (long) ( 32768 - ( (unsigned long) ( offset & 0xffffffffULL ) >> 17 ) ) )
512
513 LONG
514 AddByte71B( ADDARGS )
515 {
516 BYTE *src = Src;
517 LONG *dst = *Dst;
518 Fixed64 offset = *Offset;
519 int i;
520 LONG startpoint, endpoint = 0; // Make compiler happy
521 LONG lastpoint;
522
523 lastpoint = 0; // 0 doesn't affect the StopAtZero code
524
525 for( i = 0; i < Samples; i++)
526 {
527 if( offseti == FirstOffsetI ) {
528 startpoint = *StartPointLeft;
529 }
530 else
531 {
532 startpoint = src[ offseti + 1 ] << 8;
533 }
534
535 endpoint = src[ offseti ] << 8;
536
537 startpoint += (((endpoint - startpoint) * offsetf ) >> 15);
538
539 if( StopAtZero &&
540 ( ( lastpoint < 0 && startpoint >= 0 ) ||
541 ( lastpoint > 0 && startpoint <= 0 ) ) )
542 {
543 break;
544 }
545
546 lastpoint = startpoint;
547
548 dst[ 0 ] += ScaleLeft * startpoint;
549 dst[ 1 ] += ScaleRight * startpoint;
550 dst += 8;
551
552 offset -= Add;
553 }
554
555 *StartPointLeft = endpoint;
556
557 *Dst = dst;
558 *Offset = offset;
559
560 return i;
561 }
562
563 LONG
564 AddBytes71B( ADDARGS )
565 {
566 BYTE *src = Src;
567 LONG *dst = *Dst;
568 Fixed64 offset = *Offset;
569 int i;
570 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
571 LONG lastpointL, lastpointR;
572
573 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
574
575 for( i = 0; i < Samples; i++)
576 {
577 if( offseti == FirstOffsetI ) {
578 startpointL = *StartPointLeft;
579 startpointR = *StartPointRight;
580 }
581 else
582 {
583 startpointL = src[ offseti * 2 + 0 + 2 ] << 8;
584 startpointR = src[ offseti * 2 + 1 + 2 ] << 8;
585 }
586
587 endpointL = src[ offseti * 2 + 0 ] << 8;
588 endpointR = src[ offseti * 2 + 1 ] << 8;
589
590 startpointL += (((endpointL - startpointL) * offsetf ) >> 15);
591 startpointR += (((endpointR - startpointR) * offsetf ) >> 15);
592
593 if( StopAtZero &&
594 ( ( lastpointL < 0 && startpointL >= 0 ) ||
595 ( lastpointR < 0 && startpointR >= 0 ) ||
596 ( lastpointL > 0 && startpointL <= 0 ) ||
597 ( lastpointR > 0 && startpointR <= 0 ) ) )
598 {
599 break;
600 }
601
602 lastpointL = startpointL;
603 lastpointR = startpointR;
604
605 dst[ 0 ] += ScaleLeft * startpointL;
606 dst[ 1 ] += ScaleRight * startpointR;
607 dst += 8;
608
609 offset -= Add;
610 }
611
612 *StartPointLeft = endpointL;
613 *StartPointRight = endpointR;
614
615 *Dst = dst;
616 *Offset = offset;
617
618 return i;
619 }
620
621
622 LONG
623 AddWord71B( ADDARGS )
624 {
625 WORD *src = Src;
626 LONG *dst = *Dst;
627 Fixed64 offset = *Offset;
628 int i;
629 LONG startpoint, endpoint = 0; // Make compiler happy
630 LONG lastpoint;
631
632 lastpoint = 0; // 0 doesn't affect the StopAtZero code
633
634 for( i = 0; i < Samples; i++)
635 {
636 if( offseti == FirstOffsetI ) {
637 startpoint = *StartPointLeft;
638 }
639 else
640 {
641 startpoint = src[ offseti + 1 ];
642 }
643
644 endpoint = src[ offseti ];
645
646 startpoint += (((endpoint - startpoint) * offsetf ) >> 15);
647
648 if( StopAtZero &&
649 ( ( lastpoint < 0 && startpoint >= 0 ) ||
650 ( lastpoint > 0 && startpoint <= 0 ) ) )
651 {
652 break;
653 }
654
655 lastpoint = startpoint;
656
657 dst[ 0 ] += ScaleLeft * startpoint;
658 dst[ 1 ] += ScaleRight * startpoint;
659 dst += 8;
660
661 offset -= Add;
662 }
663
664 *StartPointLeft = endpoint;
665
666 *Dst = dst;
667 *Offset = offset;
668
669 return i;
670 }
671
672
673 LONG
674 AddWords71B( ADDARGS )
675 {
676 WORD *src = Src;
677 LONG *dst = *Dst;
678 Fixed64 offset = *Offset;
679 int i;
680 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
681 LONG lastpointL, lastpointR;
682
683 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
684
685 for( i = 0; i < Samples; i++)
686 {
687 if( offseti == FirstOffsetI ) {
688 startpointL = *StartPointLeft;
689 startpointR = *StartPointRight;
690 }
691 else
692 {
693 startpointL = src[ offseti * 2 + 0 + 2 ];
694 startpointR = src[ offseti * 2 + 1 + 2 ];
695 }
696
697 endpointL = src[ offseti * 2 + 0 ];
698 endpointR = src[ offseti * 2 + 1 ];
699
700 startpointL += (((endpointL - startpointL) * offsetf ) >> 15);
701 startpointR += (((endpointR - startpointR) * offsetf ) >> 15);
702
703 if( StopAtZero &&
704 ( ( lastpointL < 0 && startpointL >= 0 ) ||
705 ( lastpointR < 0 && startpointR >= 0 ) ||
706 ( lastpointL > 0 && startpointL <= 0 ) ||
707 ( lastpointR > 0 && startpointR <= 0 ) ) )
708 {
709 break;
710 }
711
712 lastpointL = startpointL;
713 lastpointR = startpointR;
714
715 dst[ 0 ] += ScaleLeft * startpointL;
716 dst[ 1 ] += ScaleRight * startpointR;
717 dst += 8;
718
719 offset -= Add;
720 }
721
722 *StartPointLeft = endpointL;
723 *StartPointRight = endpointR;
724
725 *Dst = dst;
726 *Offset = offset;
727
728 return i;
729 }
730
731 #undef offseti
732 #undef offsetf
733
734 /*****************************************************************************/
735
736 #define offseti ( (long) ( offset >> 32 ) )
737
738 #define offsetf ( (long) ( 32768 - ( (unsigned long) ( offset & 0xffffffffULL ) >> 17 ) ) )
739
740 LONG
741 AddLong71B( ADDARGS )
742 {
743 LONG *src = Src;
744 LONG *dst = *Dst;
745 Fixed64 offset = *Offset;
746 int i;
747 LONG startpoint, endpoint = 0; // Make compiler happy
748 LONG lastpoint;
749
750 lastpoint = 0; // 0 doesn't affect the StopAtZero code
751
752 for( i = 0; i < Samples; i++)
753 {
754 if( offseti == FirstOffsetI ) {
755 startpoint = *StartPointLeft << 16;
756 }
757 else
758 {
759 startpoint = src[ offseti + 1 ];
760 }
761
762 endpoint = src[ offseti ];
763
764 startpoint += (LONG) (((LONGLONG) (endpoint - startpoint) * offsetf ) >> 32);
765
766 if( StopAtZero &&
767 ( ( lastpoint < 0 && startpoint >= 0 ) ||
768 ( lastpoint > 0 && startpoint <= 0 ) ) )
769 {
770 break;
771 }
772
773 lastpoint = startpoint;
774
775 dst[ 0 ] += (LONG) ( ( (LONGLONG) ScaleLeft * startpoint ) >> 16 );
776 dst[ 1 ] += (LONG) ( ( (LONGLONG) ScaleRight * startpoint ) >> 16 );
777 dst += 8;
778
779 offset -= Add;
780 }
781
782 *StartPointLeft = endpoint >> 16;
783
784 *Dst = dst;
785 *Offset = offset;
786
787 return i;
788 }
789
790
791 LONG
792 AddLongs71B( ADDARGS )
793 {
794 LONG *src = Src;
795 LONG *dst = *Dst;
796 Fixed64 offset = *Offset;
797 int i;
798 LONG startpointL, startpointR, endpointL = 0, endpointR = 0; // Make compiler happy
799 LONG lastpointL, lastpointR;
800
801 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
802
803 for( i = 0; i < Samples; i++)
804 {
805 if( offseti == FirstOffsetI ) {
806 startpointL = *StartPointLeft << 16;
807 startpointR = *StartPointRight << 16;
808 }
809 else
810 {
811 startpointL = src[ offseti * 2 + 0 + 2 ];
812 startpointR = src[ offseti * 2 + 1 + 2 ];
813 }
814
815 endpointL = src[ offseti * 2 + 0 ];
816 endpointR = src[ offseti * 2 + 1 ];
817
818 startpointL += (LONG) (((LONGLONG) (endpointL - startpointL) * offsetf ) >> 32);
819 startpointR += (LONG) (((LONGLONG) (endpointR - startpointR) * offsetf ) >> 32);
820
821 if( StopAtZero &&
822 ( ( lastpointL < 0 && startpointL >= 0 ) ||
823 ( lastpointR < 0 && startpointR >= 0 ) ||
824 ( lastpointL > 0 && startpointL <= 0 ) ||
825 ( lastpointR > 0 && startpointR <= 0 ) ) )
826 {
827 break;
828 }
829
830 lastpointL = startpointL;
831 lastpointR = startpointR;
832
833 dst[ 0 ] += (LONG) ( ( (LONGLONG) ScaleLeft * startpointL ) >> 16 );
834 dst[ 1 ] += (LONG) ( ( (LONGLONG) ScaleRight * startpointR ) >> 16 );
835 dst += 8;
836
837 offset -= Add;
838 }
839
840 *StartPointLeft = endpointL >> 16;
841 *StartPointRight = endpointR >> 16;
842
843 *Dst = dst;
844 *Offset = offset;
845
846 return i;
847 }
848
849
850 LONG
851 Add7171B( ADDARGS71 )
852 {
853 LONG *src = Src;
854 LONG *dst = *Dst;
855 Fixed64 offset = *Offset;
856 int i;
857 LONG startpointL, startpointR;
858 LONG startpointRL, startpointRR;
859 LONG startpointSL, startpointSR;
860 LONG startpointC, startpointLFE;
861 LONG endpointL = 0, endpointR = 0; // Make compiler happy
862 LONG endpointRL = 0, endpointRR = 0; // Make compiler happy
863 LONG endpointSL = 0, endpointSR = 0; // Make compiler happy
864 LONG endpointC = 0, endpointLFE = 0; // Make compiler happy
865 LONG lastpointL, lastpointR;
866 LONG scale_mono = ( ScaleLeft + ScaleRight ) / 2;
867
868 lastpointL = lastpointR = 0; // 0 doesn't affect the StopAtZero code
869
870 for( i = 0; i < Samples; i++)
871 {
872 if( offseti == FirstOffsetI ) {
873 startpointL = StartPoints[ CD_L ] << 16;
874 startpointR = StartPoints[ CD_R ] << 16;
875 startpointRL = StartPoints[ CD_RL ] << 16;
876 startpointRR = StartPoints[ CD_RR ] << 16;
877 startpointSL = StartPoints[ CD_SL ] << 16;
878 startpointSR = StartPoints[ CD_SR ] << 16;
879 startpointC = StartPoints[ CD_C ] << 16;
880 startpointLFE = StartPoints[ CD_LFE ] << 16;
881 }
882 else
883 {
884 startpointL = src[ offseti * 8 + 0 + 8 ];
885 startpointR = src[ offseti * 8 + 1 + 8 ];
886 startpointRL = src[ offseti * 8 + 2 + 8 ];
887 startpointRR = src[ offseti * 8 + 3 + 8 ];
888 startpointSL = src[ offseti * 8 + 4 + 8 ];
889 startpointSR = src[ offseti * 8 + 5 + 8 ];
890 startpointC = src[ offseti * 8 + 6 + 8 ];
891 startpointLFE = src[ offseti * 8 + 7 + 8 ];
892 }
893
894 endpointL = src[ offseti * 8 + 0 ];
895 endpointR = src[ offseti * 8 + 1 ];
896 endpointRL = src[ offseti * 8 + 2 ];
897 endpointRR = src[ offseti * 8 + 3 ];
898 endpointSL = src[ offseti * 8 + 4 ];
899 endpointSR = src[ offseti * 8 + 5 ];
900 endpointC = src[ offseti * 8 + 6 ];
901 endpointLFE = src[ offseti * 8 + 7 ];
902
903 startpointL += (LONG) (((LONGLONG) (endpointL - startpointL) * offsetf ) >> 32);
904 startpointR += (LONG) (((LONGLONG) (endpointR - startpointR) * offsetf ) >> 32);
905 startpointRL += (LONG) (((LONGLONG) (endpointRL - startpointRL) * offsetf ) >> 32);
906 startpointRR += (LONG) (((LONGLONG) (endpointRR - startpointRR) * offsetf ) >> 32);
907 startpointSL += (LONG) (((LONGLONG) (endpointSL - startpointSL) * offsetf ) >> 32);
908 startpointSR += (LONG) (((LONGLONG) (endpointSR - startpointSR) * offsetf ) >> 32);
909 startpointC += (LONG) (((LONGLONG) (endpointC - startpointC) * offsetf ) >> 32);
910 startpointLFE += (LONG) (((LONGLONG) (endpointLFE - startpointLFE) * offsetf ) >> 32);
911
912 if( StopAtZero &&
913 ( ( lastpointL < 0 && startpointL >= 0 ) ||
914 ( lastpointR < 0 && startpointR >= 0 ) ||
915 ( lastpointL > 0 && startpointL <= 0 ) ||
916 ( lastpointR > 0 && startpointR <= 0 ) ) )
917 {
918 break;
919 }
920
921 lastpointL = startpointL;
922 lastpointR = startpointR;
923
924 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointL ) >> 16 );
925 *dst++ += (LONG) ( ( (LONGLONG) ScaleRight * startpointR ) >> 16 );
926 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointRL ) >> 16 );
927 *dst++ += (LONG) ( ( (LONGLONG) ScaleRight * startpointRR ) >> 16 );
928 *dst++ += (LONG) ( ( (LONGLONG) ScaleLeft * startpointSL ) >> 16 );
929 *dst++ += (LONG) ( ( (LONGLONG) ScaleRight * startpointSR ) >> 16 );
930 *dst++ += (LONG) ( ( (LONGLONG) scale_mono * startpointC ) >> 16 );
931 *dst++ += (LONG) ( ( (LONGLONG) scale_mono * startpointLFE ) >> 16 );
932
933 offset -= Add;
934 }
935
936 StartPoints[ CD_L ] = endpointL >> 16;
937 StartPoints[ CD_R ] = endpointR >> 16;
938 StartPoints[ CD_RL ] = endpointRL >> 16;
939 StartPoints[ CD_RR ] = endpointRR >> 16;
940 StartPoints[ CD_SL ] = endpointSL >> 16;
941 StartPoints[ CD_SR ] = endpointSR >> 16;
942 StartPoints[ CD_C ] = endpointC >> 16;
943 StartPoints[ CD_LFE ] = endpointLFE >> 16;
944
945 *Dst = dst;
946 *Offset = offset;
947
948 return i;
949 }
950
951 #undef offseti
952 #undef offsetf
Mirror of AROS' svn.