workbench/devs/AHI/Device/addroutines_hifi.c

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