workbench/devs/AHI/Device/addroutines_lofi.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 /* Forward mixing code */
  30
  31 #define offseti ( (long) ( offset >> 32 ) )
  32
  33 LONG
  34 AddLofiByteMono( ADDARGS )
  35 {
  36   BYTE    *src    = Src;
  37   WORD    *dst    = *Dst;
  38   Fixed64  offset = *Offset;
  39   int      i;
  40   LONG     lastpoint, sample;
  41
  42   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
  43
  44   for( i = 0; i < Samples; i++)
  45   {
  46     sample = src[ offseti ] << 8;
  47
  48     if( StopAtZero &&
  49         ( ( lastpoint < 0 && sample >= 0 ) ||
  50           ( lastpoint > 0 && sample <= 0 ) ) )
  51     {
  52       break;
  53     }
  54
  55     lastpoint = sample;
  56
  57     *dst++ += ( ScaleLeft * sample ) >> 16;
  58
  59     offset += Add;
  60   }
  61
  62   *Dst    = dst;
  63   *Offset = offset;
  64
  65   return i;
  66 }
  67
  68
  69 LONG
  70 AddLofiByteStereo( ADDARGS )
  71 {
  72   BYTE    *src    = Src;
  73   WORD    *dst    = *Dst;
  74   Fixed64  offset = *Offset;
  75   int      i;
  76   LONG     lastpoint, sample;
  77
  78   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
  79
  80   for( i = 0; i < Samples; i++)
  81   {
  82     sample = src[ offseti ] << 8;
  83
  84     if( StopAtZero &&
  85         ( ( lastpoint < 0 && sample >= 0 ) ||
  86           ( lastpoint > 0 && sample <= 0 ) ) )
  87     {
  88       break;
  89     }
  90
  91     lastpoint = sample;
  92
  93     *dst++ += ( ScaleLeft * sample ) >> 16;
  94     *dst++ += ( ScaleRight * sample ) >> 16;
  95
  96     offset += Add;
  97   }
  98
  99   *Dst    = dst;
 100   *Offset = offset;
 101
 102   return i;
 103 }
 104
 105
 106 LONG
 107 AddLofiBytesMono( ADDARGS )
 108 {
 109   BYTE    *src    = Src;
 110   WORD    *dst    = *Dst;
 111   Fixed64  offset = *Offset;
 112   int      i;
 113   LONG     lastpointL, lastpointR, sampleL, sampleR;
 114
 115   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
 116
 117   for( i = 0; i < Samples; i++)
 118   {
 119     sampleL = src[ offseti * 2 + 0 ] << 8;
 120     sampleR = src[ offseti * 2 + 1 ] << 8;
 121
 122     if( StopAtZero &&
 123         ( ( lastpointL < 0 && sampleL >= 0 ) ||
 124           ( lastpointR < 0 && sampleR >= 0 ) ||
 125           ( lastpointL > 0 && sampleL <= 0 ) ||
 126           ( lastpointR > 0 && sampleR <= 0 ) ) )
 127     {
 128       break;
 129     }
 130
 131     lastpointL = sampleL;
 132     lastpointR = sampleR;
 133
 134     *dst++ += ( ScaleLeft * sampleL + ScaleRight * sampleR ) >> 16;
 135
 136     offset += Add;
 137   }
 138
 139   *Dst    = dst;
 140   *Offset = offset;
 141
 142   return i;
 143 }
 144
 145
 146 LONG
 147 AddLofiBytesStereo( ADDARGS )
 148 {
 149   BYTE    *src    = Src;
 150   WORD    *dst    = *Dst;
 151   Fixed64  offset = *Offset;
 152   int      i;
 153   LONG     lastpointL, lastpointR, sampleL, sampleR;
 154
 155   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
 156
 157   for( i = 0; i < Samples; i++)
 158   {
 159     sampleL = src[ offseti * 2 + 0 ] << 8;
 160     sampleR = src[ offseti * 2 + 1 ] << 8;
 161
 162     if( StopAtZero &&
 163         ( ( lastpointL < 0 && sampleL >= 0 ) ||
 164           ( lastpointR < 0 && sampleR >= 0 ) ||
 165           ( lastpointL > 0 && sampleL <= 0 ) ||
 166           ( lastpointR > 0 && sampleR <= 0 ) ) )
 167     {
 168       break;
 169     }
 170
 171     lastpointL = sampleL;
 172     lastpointR = sampleR;
 173
 174     *dst++ += ( ScaleLeft * sampleL ) >> 16;
 175     *dst++ += ( ScaleRight * sampleR ) >> 16;
 176
 177     offset += Add;
 178   }
 179
 180   *Dst    = dst;
 181   *Offset = offset;
 182
 183   return i;
 184 }
 185
 186
 187 LONG
 188 AddLofiWordMono( ADDARGS )
 189 {
 190   WORD    *src    = Src;
 191   WORD    *dst    = *Dst;
 192   Fixed64  offset = *Offset;
 193   int      i;
 194   LONG     lastpoint, sample;
 195
 196   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
 197
 198   for( i = 0; i < Samples; i++)
 199   {
 200     sample = src[ offseti ];
 201
 202     if( StopAtZero &&
 203         ( ( lastpoint < 0 && sample >= 0 ) ||
 204           ( lastpoint > 0 && sample <= 0 ) ) )
 205     {
 206       break;
 207     }
 208
 209     lastpoint = sample;
 210
 211     *dst++ += ( ScaleLeft * sample ) >> 16;
 212
 213     offset += Add;
 214   }
 215
 216   *Dst    = dst;
 217   *Offset = offset;
 218
 219   return i;
 220 }
 221
 222
 223 LONG
 224 AddLofiWordStereo( ADDARGS )
 225 {
 226   WORD    *src    = Src;
 227   WORD    *dst    = *Dst;
 228   Fixed64  offset = *Offset;
 229   int      i;
 230   LONG     lastpoint, sample;
 231
 232   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
 233
 234   for( i = 0; i < Samples; i++)
 235   {
 236     sample = src[ offseti ];
 237
 238     if( StopAtZero &&
 239         ( ( lastpoint < 0 && sample >= 0 ) ||
 240           ( lastpoint > 0 && sample <= 0 ) ) )
 241     {
 242       break;
 243     }
 244
 245     lastpoint = sample;
 246
 247     *dst++ += ( ScaleLeft * sample ) >> 16;
 248     *dst++ += ( ScaleRight * sample ) >> 16;
 249
 250     offset += Add;
 251   }
 252
 253   *Dst    = dst;
 254   *Offset = offset;
 255
 256   return i;
 257 }
 258
 259 LONG
 260 AddLofiWordsMono( ADDARGS )
 261 {
 262   WORD    *src    = Src;
 263   WORD    *dst    = *Dst;
 264   Fixed64  offset = *Offset;
 265   int      i;
 266   LONG     lastpointL, lastpointR, sampleL, sampleR;
 267
 268   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
 269
 270   for( i = 0; i < Samples; i++)
 271   {
 272     sampleL = src[ offseti * 2 + 0 ];
 273     sampleR = src[ offseti * 2 + 1 ];
 274
 275     if( StopAtZero &&
 276         ( ( lastpointL < 0 && sampleL >= 0 ) ||
 277           ( lastpointR < 0 && sampleR >= 0 ) ||
 278           ( lastpointL > 0 && sampleL <= 0 ) ||
 279           ( lastpointR > 0 && sampleR <= 0 ) ) )
 280     {
 281       break;
 282     }
 283
 284     lastpointL = sampleL;
 285     lastpointR = sampleR;
 286
 287     *dst++ += ( ScaleLeft * sampleL + ScaleRight * sampleR ) >> 16;
 288
 289     offset += Add;
 290   }
 291
 292   *Dst    = dst;
 293   *Offset = offset;
 294
 295   return i;
 296 }
 297
 298
 299 LONG
 300 AddLofiWordsStereo( ADDARGS )
 301 {
 302   WORD    *src    = Src;
 303   WORD    *dst    = *Dst;
 304   Fixed64  offset = *Offset;
 305   int      i;
 306   LONG     lastpointL, lastpointR, sampleL, sampleR;
 307
 308   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
 309
 310   for( i = 0; i < Samples; i++)
 311   {
 312     sampleL = src[ offseti * 2 + 0 ];
 313     sampleR = src[ offseti * 2 + 1 ];
 314
 315     if( StopAtZero &&
 316         ( ( lastpointL < 0 && sampleL >= 0 ) ||
 317           ( lastpointR < 0 && sampleR >= 0 ) ||
 318           ( lastpointL > 0 && sampleL <= 0 ) ||
 319           ( lastpointR > 0 && sampleR <= 0 ) ) )
 320     {
 321       break;
 322     }
 323
 324     lastpointL = sampleL;
 325     lastpointR = sampleR;
 326
 327     *dst++ += ( ScaleLeft * sampleL ) >> 16;
 328     *dst++ += ( ScaleRight * sampleR ) >> 16;
 329
 330     offset += Add;
 331   }
 332
 333   *Dst    = dst;
 334   *Offset = offset;
 335
 336   return i;
 337 }
 338
 339 /*****************************************************************************/
 340
 341 /* Backward mixing code */
 342
 343 LONG
 344 AddLofiByteMonoB( ADDARGS )
 345 {
 346   BYTE    *src    = Src;
 347   WORD    *dst    = *Dst;
 348   Fixed64  offset = *Offset;
 349   int      i;
 350   LONG     lastpoint, sample;
 351
 352   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
 353
 354   for( i = 0; i < Samples; i++)
 355   {
 356     sample = src[ offseti ] << 8;
 357
 358     if( StopAtZero &&
 359         ( ( lastpoint < 0 && sample >= 0 ) ||
 360           ( lastpoint > 0 && sample <= 0 ) ) )
 361     {
 362       break;
 363     }
 364
 365     lastpoint = sample;
 366
 367     *dst++ += ( ScaleLeft * sample ) >> 16;
 368
 369     offset -= Add;
 370   }
 371
 372   *Dst    = dst;
 373   *Offset = offset;
 374
 375   return i;
 376 }
 377
 378
 379 LONG
 380 AddLofiByteStereoB( ADDARGS )
 381 {
 382   BYTE    *src    = Src;
 383   WORD    *dst    = *Dst;
 384   Fixed64  offset = *Offset;
 385   int      i;
 386   LONG     lastpoint, sample;
 387
 388   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
 389
 390   for( i = 0; i < Samples; i++)
 391   {
 392     sample = src[ offseti ] << 8;
 393
 394     if( StopAtZero &&
 395         ( ( lastpoint < 0 && sample >= 0 ) ||
 396           ( lastpoint > 0 && sample <= 0 ) ) )
 397     {
 398       break;
 399     }
 400
 401     lastpoint = sample;
 402
 403     *dst++ += ( ScaleLeft * sample ) >> 16;
 404     *dst++ += ( ScaleRight * sample ) >> 16;
 405
 406     offset -= Add;
 407   }
 408
 409   *Dst    = dst;
 410   *Offset = offset;
 411
 412   return i;
 413 }
 414
 415
 416 LONG
 417 AddLofiBytesMonoB( ADDARGS )
 418 {
 419   BYTE    *src    = Src;
 420   WORD    *dst    = *Dst;
 421   Fixed64  offset = *Offset;
 422   int      i;
 423   LONG     lastpointL, lastpointR, sampleL, sampleR;
 424
 425   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
 426
 427   for( i = 0; i < Samples; i++)
 428   {
 429     sampleL = src[ offseti * 2 + 0 ] << 8;
 430     sampleR = src[ offseti * 2 + 1 ] << 8;
 431
 432     if( StopAtZero &&
 433         ( ( lastpointL < 0 && sampleL >= 0 ) ||
 434           ( lastpointR < 0 && sampleR >= 0 ) ||
 435           ( lastpointL > 0 && sampleL <= 0 ) ||
 436           ( lastpointR > 0 && sampleR <= 0 ) ) )
 437     {
 438       break;
 439     }
 440
 441     lastpointL = sampleL;
 442     lastpointR = sampleR;
 443
 444     *dst++ += ( ScaleLeft * sampleL + ScaleRight * sampleR ) >> 16;
 445
 446     offset -= Add;
 447   }
 448
 449   *Dst    = dst;
 450   *Offset = offset;
 451
 452   return i;
 453 }
 454
 455
 456 LONG
 457 AddLofiBytesStereoB( ADDARGS )
 458 {
 459   BYTE    *src    = Src;
 460   WORD    *dst    = *Dst;
 461   Fixed64  offset = *Offset;
 462   int      i;
 463   LONG     lastpointL, lastpointR, sampleL, sampleR;
 464
 465   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
 466
 467   for( i = 0; i < Samples; i++)
 468   {
 469     sampleL = src[ offseti * 2 + 0 ] << 8;
 470     sampleR = src[ offseti * 2 + 1 ] << 8;
 471
 472     if( StopAtZero &&
 473         ( ( lastpointL < 0 && sampleL >= 0 ) ||
 474           ( lastpointR < 0 && sampleR >= 0 ) ||
 475           ( lastpointL > 0 && sampleL <= 0 ) ||
 476           ( lastpointR > 0 && sampleR <= 0 ) ) )
 477     {
 478       break;
 479     }
 480
 481     lastpointL = sampleL;
 482     lastpointR = sampleR;
 483
 484     *dst++ += ( ScaleLeft * sampleL ) >> 16;
 485     *dst++ += ( ScaleRight * sampleR ) >> 16;
 486
 487     offset -= Add;
 488   }
 489
 490   *Dst    = dst;
 491   *Offset = offset;
 492
 493   return i;
 494 }
 495
 496
 497 LONG
 498 AddLofiWordMonoB( ADDARGS )
 499 {
 500   WORD    *src    = Src;
 501   WORD    *dst    = *Dst;
 502   Fixed64  offset = *Offset;
 503   int      i;
 504   LONG     lastpoint, sample;
 505
 506   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
 507
 508   for( i = 0; i < Samples; i++)
 509   {
 510     sample = src[ offseti ];
 511
 512     if( StopAtZero &&
 513         ( ( lastpoint < 0 && sample >= 0 ) ||
 514           ( lastpoint > 0 && sample <= 0 ) ) )
 515     {
 516       break;
 517     }
 518
 519     lastpoint = sample;
 520
 521     *dst++ += ( ScaleLeft * sample ) >> 16;
 522
 523     offset -= Add;
 524   }
 525
 526   *Dst    = dst;
 527   *Offset = offset;
 528
 529   return i;
 530 }
 531
 532
 533 LONG
 534 AddLofiWordStereoB( ADDARGS )
 535 {
 536   WORD    *src    = Src;
 537   WORD    *dst    = *Dst;
 538   Fixed64  offset = *Offset;
 539   int      i;
 540   LONG     lastpoint, sample;
 541
 542   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
 543
 544   for( i = 0; i < Samples; i++)
 545   {
 546     sample = src[ offseti ];
 547
 548     if( StopAtZero &&
 549         ( ( lastpoint < 0 && sample >= 0 ) ||
 550           ( lastpoint > 0 && sample <= 0 ) ) )
 551     {
 552       break;
 553     }
 554
 555     lastpoint = sample;
 556
 557     *dst++ += ( ScaleLeft * sample ) >> 16;
 558     *dst++ += ( ScaleRight * sample ) >> 16;
 559
 560     offset -= Add;
 561   }
 562
 563   *Dst    = dst;
 564   *Offset = offset;
 565
 566   return i;
 567 }
 568
 569
 570 LONG
 571 AddLofiWordsMonoB( ADDARGS )
 572 {
 573   WORD    *src    = Src;
 574   WORD    *dst    = *Dst;
 575   Fixed64  offset = *Offset;
 576   int      i;
 577   LONG     lastpointL, lastpointR, sampleL, sampleR;
 578
 579   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
 580
 581   for( i = 0; i < Samples; i++)
 582   {
 583     sampleL = src[ offseti * 2 + 0 ];
 584     sampleR = src[ offseti * 2 + 1 ];
 585
 586     if( StopAtZero &&
 587         ( ( lastpointL < 0 && sampleL >= 0 ) ||
 588           ( lastpointR < 0 && sampleR >= 0 ) ||
 589           ( lastpointL > 0 && sampleL <= 0 ) ||
 590           ( lastpointR > 0 && sampleR <= 0 ) ) )
 591     {
 592       break;
 593     }
 594
 595     lastpointL = sampleL;
 596     lastpointR = sampleR;
 597
 598     *dst++ += ( ScaleLeft * sampleL + ScaleRight * sampleR ) >> 16;
 599
 600     offset -= Add;
 601   }
 602
 603   *Dst    = dst;
 604   *Offset = offset;
 605
 606   return i;
 607 }
 608
 609
 610 LONG
 611 AddLofiWordsStereoB( ADDARGS )
 612 {
 613   WORD    *src    = Src;
 614   WORD    *dst    = *Dst;
 615   Fixed64  offset = *Offset;
 616   int      i;
 617   LONG     lastpointL, lastpointR, sampleL, sampleR;
 618
 619   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
 620
 621   for( i = 0; i < Samples; i++)
 622   {
 623     sampleL = src[ offseti * 2 + 0 ];
 624     sampleR = src[ offseti * 2 + 1 ];
 625
 626     if( StopAtZero &&
 627         ( ( lastpointL < 0 && sampleL >= 0 ) ||
 628           ( lastpointR < 0 && sampleR >= 0 ) ||
 629           ( lastpointL > 0 && sampleL <= 0 ) ||
 630           ( lastpointR > 0 && sampleR <= 0 ) ) )
 631     {
 632       break;
 633     }
 634
 635     lastpointL = sampleL;
 636     lastpointR = sampleR;
 637
 638     *dst++ += ( ScaleLeft * sampleL ) >> 16;
 639     *dst++ += ( ScaleRight * sampleR ) >> 16;
 640
 641     offset -= Add;
 642   }
 643
 644   *Dst    = dst;
 645   *Offset = offset;
 646
 647   return i;
 648 }
 649
 650 /*****************************************************************************/