workbench/devs/AHI/Device/mixer.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 <string.h>
  24 #include <stddef.h>
  25
  26 #include <dos/dos.h>
  27 #include <dos/dostags.h>
  28 #include <exec/memory.h>
  29
  30 #include <proto/dos.h>
  31 #include <proto/exec.h>
  32 #include <proto/utility.h>
  33 #define __NOLIBBASE__
  34 #define __NOGLOBALIFACE__
  35 #include <proto/ahi.h>
  36 #undef  __NOLIBBASE__
  37 #undef  __NOGLOBALIFACE__
  38
  39 #include "ahi_def.h"
  40
  41 #include "addroutines.h"
  42 #include "debug.h"
  43 #include "dsp.h"
  44 #include "header.h"
  45 #include "misc.h"
  46 #include "mixer.h"
  47 #include "sound.h"
  48
  49 #if defined( ENABLE_WARPUP )
  50 # include "warpup.h"
  51 #endif
  52
  53 #define min(a,b) (((a)<(b))?(a):(b))
  54 #define max(a,b) (((a)>(b))?(a):(b))
  55
  56 /******************************************************************************
  57 ** Prototypes *****************************************************************
  58 ******************************************************************************/
  59
  60 void
  61 CallSoundHook( struct AHIPrivAudioCtrl *audioctrl,
  62                void* arg )
  63 {
  64   switch( MixBackend )
  65   {
  66     case MB_NATIVE:
  67       CallHookPkt( audioctrl->ac.ahiac_SoundFunc,
  68                    audioctrl,
  69                    arg );
  70       break;
  71
  72 #if defined( ENABLE_WARPUP )
  73     case MB_WARPUP:
  74       WarpUpCallSoundHook( audioctrl, arg );
  75       break;
  76 #endif
  77   }
  78 }
  79
  80
  81 void
  82 MixerFunc( struct Hook*             hook,
  83            struct AHIPrivAudioCtrl* audioctrl,
  84            void*                    dst )
  85 {
  86   switch( MixBackend )
  87   {
  88     case MB_NATIVE:
  89       Mix( hook, audioctrl, dst );
  90       DoMasterVolume( dst, audioctrl );
  91       DoOutputBuffer( dst, audioctrl );
  92       DoChannelInfo( audioctrl );
  93       break;
  94
  95 #if defined( ENABLE_WARPUP )
  96     case MB_WARPUP:
  97       WarpUpCallMixer( audioctrl, dst );
  98       DoOutputBuffer( dst, audioctrl );
  99       DoChannelInfo( audioctrl );
 100       break;
 101 #endif
 102   }
 103 }
 104
 105
 106 /******************************************************************************
 107 ** InitMixroutine *************************************************************
 108 ******************************************************************************/
 109
 110 // This function is used to initialize the mixer routine (called from
 111 // AHI_AllocAudio()).
 112
 113 BOOL
 114 InitMixroutine( struct AHIPrivAudioCtrl *audioctrl )
 115 {
 116   BOOL rc = FALSE;
 117
 118   // Allocate and initialize the AHIChannelData structures
 119   // This structure could be accessed from from interrupts!
 120
 121   ULONG data_flags = MEMF_ANY;
 122
 123   switch( MixBackend )
 124   {
 125     case MB_NATIVE:
 126       data_flags = MEMF_PUBLIC | MEMF_CLEAR;
 127       break;
 128
 129 #if defined( ENABLE_WARPUP )
 130     case MB_WARPUP:
 131       // Non-cached from both the PPC and m68k side
 132       data_flags = MEMF_PUBLIC | MEMF_CLEAR | MEMF_CHIP;
 133       break;
 134 #endif
 135   }
 136
 137   audioctrl->ahiac_ChannelDatas = AHIAllocVec(
 138       audioctrl->ac.ahiac_Channels * sizeof( struct AHIChannelData ),
 139       data_flags );
 140
 141   // Allocate and initialize the AHISoundData structures
 142   // This structure could be accessed from from interrupts!
 143
 144   audioctrl->ahiac_SoundDatas = AHIAllocVec(
 145       audioctrl->ac.ahiac_Sounds * sizeof( struct AHISoundData ),
 146       data_flags );
 147
 148   // Now link the list and fill in the channel number for each structure.
 149
 150   if( audioctrl->ahiac_ChannelDatas != NULL
 151       && audioctrl->ahiac_SoundDatas != NULL )
 152   {
 153     struct AHIChannelData *cd;
 154     struct AHISoundData   *sd;
 155     int                    i;
 156
 157     cd = audioctrl->ahiac_ChannelDatas;
 158
 159     audioctrl->ahiac_WetList = cd;
 160     audioctrl->ahiac_DryList = NULL;
 161
 162     for(i = 0; i < audioctrl->ac.ahiac_Channels - 1; i++)
 163     {
 164       // Set Channel No
 165       cd->cd_ChannelNo = i;
 166
 167       // Set link to next channel
 168       cd->cd_Succ = cd + 1;
 169       cd++;
 170     }
 171
 172     // Set the last No
 173     cd->cd_ChannelNo = i;
 174
 175     // Clear the last link;
 176     cd->cd_Succ = NULL;
 177
 178
 179     sd = audioctrl->ahiac_SoundDatas;
 180
 181     for( i = 0; i < audioctrl->ac.ahiac_Sounds; i++)
 182     {
 183       sd->sd_Type = AHIST_NOTYPE;
 184       sd++;
 185     }
 186   }
 187
 188
 189   switch( MixBackend )
 190   {
 191     case MB_NATIVE:
 192       rc = TRUE;
 193       break;
 194
 195 #if defined( ENABLE_WARPUP )
 196     case MB_WARPUP:
 197       rc = WarpUpInit( audioctrl );
 198       break;
 199 #endif
 200   }
 201
 202   return rc;
 203 }
 204
 205
 206 /******************************************************************************
 207 ** CleanUpMixroutine **********************************************************
 208 ******************************************************************************/
 209
 210 // This function is used to clean up after the mixer routine (called from
 211 // AHI_FreeAudio()).
 212
 213 void
 214 CleanUpMixroutine( struct AHIPrivAudioCtrl *audioctrl )
 215 {
 216   switch( MixBackend )
 217   {
 218     case MB_NATIVE:
 219       break;
 220
 221 #if defined( ENABLE_WARPUP )
 222     case MB_WARPUP:
 223       WarpUpCleanUp( audioctrl );
 224       break;
 225 #endif
 226   }
 227
 228   AHIFreeVec( audioctrl->ahiac_SoundDatas );
 229   audioctrl->ahiac_SoundDatas = NULL;
 230
 231   AHIFreeVec( audioctrl->ahiac_ChannelDatas );
 232   audioctrl->ahiac_ChannelDatas = NULL;
 233 }
 234
 235
 236 /******************************************************************************
 237 ** SelectAddRoutine ***********************************************************
 238 ******************************************************************************/
 239
 240 // This routine gets called each time there is reason to believe that a new
 241 // add-routine should be used (new sound selected, volume changed,
 242 // mastervolume changed)
 243
 244 // Based on VolumeLeft, VolumeRight and SampleType, fill in ScaleLeft,
 245 // ScaleRight and AddRoutine.
 246
 247 void
 248 SelectAddRoutine ( Fixed     VolumeLeft,
 249                    Fixed     VolumeRight,
 250                    ULONG     SampleType,
 251                    struct    AHIPrivAudioCtrl *audioctrl,
 252                    LONG     *ScaleLeft,
 253                    LONG     *ScaleRight,
 254                    ADDFUNC **AddRoutine )
 255
 256 {
 257   // This version only cares about the sample format and does not use any
 258   // optimized add-routines.
 259
 260   // Scale the volume
 261
 262   VolumeLeft  = VolumeLeft  * (audioctrl->ahiac_MasterVolume >> 8) /
 263                               (audioctrl->ahiac_Channels2 << 8);
 264
 265   VolumeRight = VolumeRight * (audioctrl->ahiac_MasterVolume >> 8) /
 266                               (audioctrl->ahiac_Channels2 << 8);
 267
 268   // First, select HiFi or LoFi...
 269
 270   if( audioctrl->ac.ahiac_Flags & AHIACF_HIFI )
 271   {
 272
 273     // Then, check the output format...
 274
 275     switch(audioctrl->ac.ahiac_BuffType)
 276     {
 277
 278       case AHIST_M32S:
 279
 280         // ...and then the source format.
 281
 282         switch(SampleType)
 283         {
 284           case AHIST_M8S:
 285           case AHIST_BW|AHIST_M8S:
 286             *ScaleLeft  = VolumeLeft + VolumeRight;
 287             *ScaleRight = 0;
 288             if(SampleType & AHIST_BW)
 289               *AddRoutine = AddByteMonoBPtr;
 290             else
 291               *AddRoutine = AddByteMonoPtr;
 292             break;
 293
 294           case AHIST_S8S:
 295           case AHIST_BW|AHIST_S8S:
 296             *ScaleLeft  = VolumeLeft;
 297             *ScaleRight = VolumeRight;
 298             if(SampleType & AHIST_BW)
 299               *AddRoutine = AddBytesMonoBPtr;
 300             else
 301               *AddRoutine = AddBytesMonoPtr;
 302             break;
 303
 304           case AHIST_M16S:
 305           case AHIST_BW|AHIST_M16S:
 306             *ScaleLeft  = VolumeLeft + VolumeRight;
 307             *ScaleRight = 0;
 308             if(SampleType & AHIST_BW)
 309               *AddRoutine = AddWordMonoBPtr;
 310             else
 311               *AddRoutine = AddWordMonoPtr;
 312             break;
 313
 314           case AHIST_S16S:
 315           case AHIST_BW|AHIST_S16S:
 316             *ScaleLeft  = VolumeLeft;
 317             *ScaleRight = VolumeRight;
 318             if(SampleType & AHIST_BW)
 319               *AddRoutine = AddWordsMonoBPtr;
 320             else
 321               *AddRoutine = AddWordsMonoPtr;
 322             break;
 323
 324           case AHIST_M32S:
 325           case AHIST_BW|AHIST_M32S:
 326             *ScaleLeft  = VolumeLeft + VolumeRight;
 327             *ScaleRight = 0;
 328             if(SampleType & AHIST_BW)
 329               *AddRoutine = AddLongMonoBPtr;
 330             else
 331               *AddRoutine = AddLongMonoPtr;
 332             break;
 333
 334           case AHIST_S32S:
 335           case AHIST_BW|AHIST_S32S:
 336             *ScaleLeft  = VolumeLeft;
 337             *ScaleRight = VolumeRight;
 338             if(SampleType & AHIST_BW)
 339               *AddRoutine = AddLongsMonoBPtr;
 340             else
 341               *AddRoutine = AddLongsMonoPtr;
 342             break;
 343
 344           case AHIST_L7_1:
 345           case AHIST_BW|AHIST_L7_1:
 346             *ScaleLeft  = VolumeLeft;
 347             *ScaleRight = VolumeRight;
 348             if(SampleType & AHIST_BW)
 349               *AddRoutine = Add71MonoBPtr;
 350             else
 351               *AddRoutine = Add71MonoPtr;
 352             break;
 353
 354           default:
 355             *ScaleLeft  = 0;
 356             *ScaleRight = 0;
 357             *AddRoutine = NULL;
 358             break;
 359         }
 360         break;
 361
 362       case AHIST_S32S:
 363
 364         // ...and then the source format.
 365
 366         switch(SampleType)
 367         {
 368           case AHIST_M8S:
 369           case AHIST_BW|AHIST_M8S:
 370             *ScaleLeft  = VolumeLeft;
 371             *ScaleRight = VolumeRight;
 372             if(SampleType & AHIST_BW)
 373               *AddRoutine = AddByteStereoBPtr;
 374             else
 375               *AddRoutine = AddByteStereoPtr;
 376             break;
 377
 378           case AHIST_S8S:
 379           case AHIST_BW|AHIST_S8S:
 380             *ScaleLeft  = VolumeLeft;
 381             *ScaleRight = VolumeRight;
 382             if(SampleType & AHIST_BW)
 383               *AddRoutine = AddBytesStereoBPtr;
 384             else
 385               *AddRoutine = AddBytesStereoPtr;
 386             break;
 387
 388           case AHIST_M16S:
 389           case AHIST_BW|AHIST_M16S:
 390             *ScaleLeft  = VolumeLeft;
 391             *ScaleRight = VolumeRight;
 392             if(SampleType & AHIST_BW)
 393               *AddRoutine = AddWordStereoBPtr;
 394             else
 395               *AddRoutine = AddWordStereoPtr;
 396             break;
 397
 398           case AHIST_S16S:
 399           case AHIST_BW|AHIST_S16S:
 400             *ScaleLeft  = VolumeLeft;
 401             *ScaleRight = VolumeRight;
 402             if(SampleType & AHIST_BW)
 403               *AddRoutine = AddWordsStereoBPtr;
 404             else
 405               *AddRoutine = AddWordsStereoPtr;
 406             break;
 407
 408           case AHIST_M32S:
 409           case AHIST_BW|AHIST_M32S:
 410             *ScaleLeft  = VolumeLeft;
 411             *ScaleRight = VolumeRight;
 412             if(SampleType & AHIST_BW)
 413               *AddRoutine = AddLongStereoBPtr;
 414             else
 415               *AddRoutine = AddLongStereoPtr;
 416             break;
 417
 418           case AHIST_S32S:
 419           case AHIST_BW|AHIST_S32S:
 420             *ScaleLeft  = VolumeLeft;
 421             *ScaleRight = VolumeRight;
 422             if(SampleType & AHIST_BW)
 423               *AddRoutine = AddLongsStereoBPtr;
 424             else
 425               *AddRoutine = AddLongsStereoPtr;
 426             break;
 427
 428           case AHIST_L7_1:
 429           case AHIST_BW|AHIST_L7_1:
 430             *ScaleLeft  = VolumeLeft;
 431             *ScaleRight = VolumeRight;
 432             if(SampleType & AHIST_BW)
 433               *AddRoutine = Add71StereoBPtr;
 434             else
 435               *AddRoutine = Add71StereoPtr;
 436             break;
 437
 438           default:
 439             *ScaleLeft  = 0;
 440             *ScaleRight = 0;
 441             *AddRoutine = NULL;
 442             break;
 443         }
 444         break;
 445
 446       case AHIST_L7_1:
 447
 448         // ...and then the source format.
 449
 450         switch(SampleType)
 451         {
 452           case AHIST_M8S:
 453           case AHIST_BW|AHIST_M8S:
 454             *ScaleLeft  = VolumeLeft;
 455             *ScaleRight = VolumeRight;
 456             if(SampleType & AHIST_BW)
 457               *AddRoutine = AddByte71BPtr;
 458             else
 459               *AddRoutine = AddByte71Ptr;
 460             break;
 461
 462           case AHIST_S8S:
 463           case AHIST_BW|AHIST_S8S:
 464             *ScaleLeft  = VolumeLeft;
 465             *ScaleRight = VolumeRight;
 466             if(SampleType & AHIST_BW)
 467               *AddRoutine = AddBytes71BPtr;
 468             else
 469               *AddRoutine = AddBytes71Ptr;
 470             break;
 471
 472           case AHIST_M16S:
 473           case AHIST_BW|AHIST_M16S:
 474             *ScaleLeft  = VolumeLeft;
 475             *ScaleRight = VolumeRight;
 476             if(SampleType & AHIST_BW)
 477               *AddRoutine = AddWord71BPtr;
 478             else
 479               *AddRoutine = AddWord71Ptr;
 480             break;
 481
 482           case AHIST_S16S:
 483           case AHIST_BW|AHIST_S16S:
 484             *ScaleLeft  = VolumeLeft;
 485             *ScaleRight = VolumeRight;
 486             if(SampleType & AHIST_BW)
 487               *AddRoutine = AddWords71BPtr;
 488             else
 489               *AddRoutine = AddWords71Ptr;
 490             break;
 491
 492           case AHIST_M32S:
 493           case AHIST_BW|AHIST_M32S:
 494             *ScaleLeft  = VolumeLeft;
 495             *ScaleRight = VolumeRight;
 496             if(SampleType & AHIST_BW)
 497               *AddRoutine = AddLong71BPtr;
 498             else
 499               *AddRoutine = AddLong71Ptr;
 500             break;
 501
 502           case AHIST_S32S:
 503           case AHIST_BW|AHIST_S32S:
 504             *ScaleLeft  = VolumeLeft;
 505             *ScaleRight = VolumeRight;
 506             if(SampleType & AHIST_BW)
 507               *AddRoutine = AddLongs71BPtr;
 508             else
 509               *AddRoutine = AddLongs71Ptr;
 510             break;
 511
 512           case AHIST_L7_1:
 513           case AHIST_BW|AHIST_L7_1:
 514             *ScaleLeft  = VolumeLeft;
 515             *ScaleRight = VolumeRight;
 516             if(SampleType & AHIST_BW)
 517               *AddRoutine = Add7171BPtr;
 518             else
 519               *AddRoutine = Add7171Ptr;
 520             break;
 521
 522           default:
 523             *ScaleLeft  = 0;
 524             *ScaleRight = 0;
 525             *AddRoutine = NULL;
 526             break;
 527         }
 528         break;
 529
 530       default:
 531         *ScaleLeft  = 0;
 532         *ScaleRight = 0;
 533         *AddRoutine = NULL;
 534         break;
 535     }
 536   }
 537   else
 538   {
 539
 540     // Then, check the output format...
 541
 542     switch(audioctrl->ac.ahiac_BuffType)
 543     {
 544
 545       case AHIST_M16S:
 546
 547         // ...and then the source format.
 548
 549         switch(SampleType)
 550         {
 551           case AHIST_M8S:
 552           case AHIST_BW|AHIST_M8S:
 553             *ScaleLeft  = VolumeLeft + VolumeRight;
 554             *ScaleRight = 0;
 555             if(SampleType & AHIST_BW)
 556               *AddRoutine = AddLofiByteMonoBPtr;
 557             else
 558               *AddRoutine = AddLofiByteMonoPtr;
 559             break;
 560
 561           case AHIST_S8S:
 562           case AHIST_BW|AHIST_S8S:
 563             *ScaleLeft  = VolumeLeft;
 564             *ScaleRight = VolumeRight;
 565             if(SampleType & AHIST_BW)
 566               *AddRoutine = AddLofiBytesMonoBPtr;
 567             else
 568               *AddRoutine = AddLofiBytesMonoPtr;
 569             break;
 570
 571           case AHIST_M16S:
 572           case AHIST_BW|AHIST_M16S:
 573             *ScaleLeft  = VolumeLeft + VolumeRight;
 574             *ScaleRight = 0;
 575             if(SampleType & AHIST_BW)
 576               *AddRoutine = AddLofiWordMonoBPtr;
 577             else
 578               *AddRoutine = AddLofiWordMonoPtr;
 579             break;
 580
 581           case AHIST_S16S:
 582           case AHIST_BW|AHIST_S16S:
 583             *ScaleLeft  = VolumeLeft;
 584             *ScaleRight = VolumeRight;
 585             if(SampleType & AHIST_BW)
 586               *AddRoutine = AddLofiWordsMonoBPtr;
 587             else
 588               *AddRoutine = AddLofiWordsMonoPtr;
 589             break;
 590
 591           case AHIST_M32S:
 592           case AHIST_BW|AHIST_M32S:
 593             *ScaleLeft  = VolumeLeft + VolumeRight;
 594             *ScaleRight = 0;
 595             if(SampleType & AHIST_BW)
 596               *AddRoutine = AddLofiLongMonoBPtr;
 597             else
 598               *AddRoutine = AddLofiLongMonoPtr;
 599             break;
 600
 601           case AHIST_S32S:
 602           case AHIST_BW|AHIST_S32S:
 603             *ScaleLeft  = VolumeLeft;
 604             *ScaleRight = VolumeRight;
 605             if(SampleType & AHIST_BW)
 606               *AddRoutine = AddLofiLongsMonoBPtr;
 607             else
 608               *AddRoutine = AddLofiLongsMonoPtr;
 609             break;
 610
 611           default:
 612             *ScaleLeft  = 0;
 613             *ScaleRight = 0;
 614             *AddRoutine = NULL;
 615             break;
 616         }
 617         break;
 618
 619       case AHIST_S16S:
 620
 621         // ...and then the source format.
 622
 623         switch(SampleType)
 624         {
 625           case AHIST_M8S:
 626           case AHIST_BW|AHIST_M8S:
 627             *ScaleLeft  = VolumeLeft;
 628             *ScaleRight = VolumeRight;
 629             if(SampleType & AHIST_BW)
 630               *AddRoutine = AddLofiByteStereoBPtr;
 631             else
 632               *AddRoutine = AddLofiByteStereoPtr;
 633             break;
 634
 635           case AHIST_S8S:
 636           case AHIST_BW|AHIST_S8S:
 637             *ScaleLeft  = VolumeLeft;
 638             *ScaleRight = VolumeRight;
 639             if(SampleType & AHIST_BW)
 640               *AddRoutine = AddLofiBytesStereoBPtr;
 641             else
 642               *AddRoutine = AddLofiBytesStereoPtr;
 643             break;
 644
 645           case AHIST_M16S:
 646           case AHIST_BW|AHIST_M16S:
 647             *ScaleLeft  = VolumeLeft;
 648             *ScaleRight = VolumeRight;
 649             if(SampleType & AHIST_BW)
 650               *AddRoutine = AddLofiWordStereoBPtr;
 651             else
 652               *AddRoutine = AddLofiWordStereoPtr;
 653             break;
 654
 655           case AHIST_S16S:
 656           case AHIST_BW|AHIST_S16S:
 657             *ScaleLeft  = VolumeLeft;
 658             *ScaleRight = VolumeRight;
 659             if(SampleType & AHIST_BW)
 660               *AddRoutine = AddLofiWordsStereoBPtr;
 661             else
 662               *AddRoutine = AddLofiWordsStereoPtr;
 663             break;
 664
 665           case AHIST_M32S:
 666           case AHIST_BW|AHIST_M32S:
 667             *ScaleLeft  = VolumeLeft;
 668             *ScaleRight = VolumeRight;
 669             if(SampleType & AHIST_BW)
 670               *AddRoutine = AddLofiLongStereoBPtr;
 671             else
 672               *AddRoutine = AddLofiLongStereoPtr;
 673             break;
 674
 675           case AHIST_S32S:
 676           case AHIST_BW|AHIST_S32S:
 677             *ScaleLeft  = VolumeLeft;
 678             *ScaleRight = VolumeRight;
 679             if(SampleType & AHIST_BW)
 680               *AddRoutine = AddLofiLongsStereoBPtr;
 681             else
 682               *AddRoutine = AddLofiLongsStereoPtr;
 683             break;
 684
 685           default:
 686             *ScaleLeft  = 0;
 687             *ScaleRight = 0;
 688             *AddRoutine = NULL;
 689             break;
 690         }
 691         break;
 692
 693       default:
 694         *ScaleLeft  = 0;
 695         *ScaleRight = 0;
 696         *AddRoutine = NULL;
 697         break;
 698     }
 699   }
 700 }
 701
 702
 703 /******************************************************************************
 704 ** Mix ************************************************************************
 705 ******************************************************************************/
 706
 707 // This is the function that the driver calls each time it want more data
 708 // to play.
 709
 710 void
 711 Mix( struct Hook*             unused_Hook,
 712      struct AHIPrivAudioCtrl* audioctrl,
 713      void*                    dst )
 714 {
 715   struct AHIChannelData *cd;
 716   void                  *dstptr;
 717   LONG                   samplesleft;
 718
 719   /* Clear the buffer */
 720
 721   memset( dst, 0, audioctrl->ahiac_BuffSizeNow );
 722   /* Mix the samples */
 723
 724   audioctrl->ahiac_WetOrDry = AHIEDM_WET;
 725
 726   cd = audioctrl->ahiac_WetList;
 727
 728   while(TRUE)
 729   {
 730     while(cd != NULL) // .nextchannel
 731     {
 732       samplesleft = audioctrl->ac.ahiac_BuffSamples;
 733       dstptr      = dst;
 734
 735       while(TRUE) // .contchannel
 736       {
 737         LONG samples;
 738         LONG processed;
 739
 740         /* Call Sound Hook */
 741
 742         if(cd->cd_EOS)
 743         {
 744           cd->cd_EOS = FALSE;
 745           if(audioctrl->ac.ahiac_SoundFunc != NULL)
 746           {
 747             CallSoundHook( audioctrl, &cd->cd_ChannelNo );
 748           }
 749         }
 750
 751         processed = 0;
 752
 753         if( cd->cd_AntiClickCount > 0 && cd->cd_FreqOK && cd->cd_SoundOK )
 754         {
 755           // Sound is ok and we're looking for a zero-crossing.
 756
 757           LONG try_samples;
 758
 759           samples     = min( samplesleft, cd->cd_Samples );
 760           try_samples = min( samples, cd->cd_AntiClickCount );
 761
 762           if( try_samples > 0 )
 763           {
 764             cd->cd_TempStartPointL   = cd->cd_StartPointL;
 765             cd->cd_TempStartPointR   = cd->cd_StartPointR;
 766             cd->cd_TempStartPointRL  = cd->cd_StartPointRL;
 767             cd->cd_TempStartPointRR  = cd->cd_StartPointRR;
 768             cd->cd_TempStartPointSL  = cd->cd_StartPointSL;
 769             cd->cd_TempStartPointSR  = cd->cd_StartPointSR;
 770             cd->cd_TempStartPointC   = cd->cd_StartPointC;
 771             cd->cd_TempStartPointLFE = cd->cd_StartPointLFE;
 772
 773             processed = ((ADDFUNC *) cd->cd_AddRoutine)( try_samples,
 774                                                          cd->cd_ScaleLeft,
 775                                                          cd->cd_ScaleRight,
 776                                                         &cd->cd_TempStartPointL,
 777                                                         &cd->cd_TempStartPointR,
 778                                                          cd->cd_DataStart,
 779                                                         &dstptr,
 780                                                          cd->cd_FirstOffsetI,
 781                                                          cd->cd_Add,
 782                                                         &cd->cd_Offset,
 783                                                          TRUE );
 784
 785             cd->cd_Samples -= processed;
 786             samplesleft    -= processed;
 787           }
 788           else
 789           {
 790             processed = 0;
 791           }
 792
 793           if( processed != try_samples ||             // Found zero-crossing
 794               try_samples <= cd->cd_AntiClickCount )  // End-of-sound or
 795                                                       // max delay reached
 796           {
 797             // We either found a zero-crossing, looked as far as
 798             // we were allowed to or reached the end of sound.
 799
 800             // To be perfect, the we should not run this code if the
 801             // end-of-sound was reached. Instead, since cd_Samples is zero
 802             // and the second cd_AddRoutine call below will have no effect,
 803             // we should just go onand the cd_Next#? variables will be copied
 804             // instead. However, that requires two sets of delay variables:
 805             // The one we have now and one delayed set of "next" variables.
 806             // I might do that another time, but not today...
 807
 808             // Now start the delayed sound.
 809
 810             if( cd->cd_VolDelayed )
 811             {
 812               cd->cd_VolDelayed = FALSE;
 813               cd->cd_VolumeLeft  = cd->cd_DelayedVolumeLeft;
 814               cd->cd_VolumeRight = cd->cd_DelayedVolumeRight;
 815               cd->cd_ScaleLeft   = cd->cd_DelayedScaleLeft;
 816               cd->cd_ScaleRight  = cd->cd_DelayedScaleRight;
 817               cd->cd_AddRoutine  = cd->cd_DelayedAddRoutine;
 818             }
 819
 820             if( cd->cd_FreqDelayed )
 821             {
 822               cd->cd_FreqDelayed = FALSE;
 823               cd->cd_FreqOK      = cd->cd_DelayedFreqOK;
 824               cd->cd_Add         = cd->cd_DelayedAdd;
 825
 826               // Since we have advanced, cd_Samples must be recalculated!
 827               cd->cd_Samples     = CalcSamples( cd->cd_Add,
 828                                                 cd->cd_Type,
 829                                                 cd->cd_LastOffset,
 830                                                 cd->cd_Offset );
 831             }
 832
 833             if( cd->cd_SoundDelayed )
 834             {
 835               cd->cd_SoundDelayed = FALSE;
 836
 837               cd->cd_SoundOK       = cd->cd_DelayedSoundOK;
 838
 839               cd->cd_StartPointL   = 0;
 840               cd->cd_StartPointR   = 0;
 841
 842               cd->cd_Offset        = cd->cd_DelayedOffset;
 843               cd->cd_FirstOffsetI  = cd->cd_DelayedFirstOffsetI;
 844               cd->cd_LastOffset    = cd->cd_DelayedLastOffset;
 845               cd->cd_DataStart     = cd->cd_DelayedDataStart;
 846
 847               cd->cd_Type          = cd->cd_DelayedType;
 848               cd->cd_AddRoutine    = cd->cd_DelayedAddRoutine;
 849
 850               cd->cd_Samples       = cd->cd_DelayedSamples;
 851
 852               cd->cd_ScaleLeft     = cd->cd_DelayedScaleLeft;
 853               cd->cd_ScaleRight    = cd->cd_DelayedScaleRight;
 854               cd->cd_AddRoutine    = cd->cd_DelayedAddRoutine;
 855             }
 856           }
 857
 858           if( cd->cd_VolDelayed || cd->cd_FreqDelayed || cd->cd_SoundDelayed )
 859           {
 860             cd->cd_AntiClickCount -= processed;
 861           }
 862           else
 863           {
 864             cd->cd_AntiClickCount = 0;
 865           }
 866         }
 867
 868         if( cd->cd_FreqOK && cd->cd_SoundOK )
 869         {
 870           // Sound is still ok, let's rock'n roll.
 871
 872           samples = min( samplesleft, cd->cd_Samples );
 873
 874           if( samples > 0 )
 875           {
 876             cd->cd_TempStartPointL   = cd->cd_StartPointL;
 877             cd->cd_TempStartPointR   = cd->cd_StartPointR;
 878             cd->cd_TempStartPointRL  = cd->cd_StartPointRL;
 879             cd->cd_TempStartPointRR  = cd->cd_StartPointRR;
 880             cd->cd_TempStartPointSL  = cd->cd_StartPointSL;
 881             cd->cd_TempStartPointSR  = cd->cd_StartPointSR;
 882             cd->cd_TempStartPointC   = cd->cd_StartPointC;
 883             cd->cd_TempStartPointLFE = cd->cd_StartPointLFE;
 884
 885             processed = ((ADDFUNC *) cd->cd_AddRoutine)( samples,
 886                                                          cd->cd_ScaleLeft,
 887                                                          cd->cd_ScaleRight,
 888                                                         &cd->cd_TempStartPointL,
 889                                                         &cd->cd_TempStartPointR,
 890                                                          cd->cd_DataStart,
 891                                                         &dstptr,
 892                                                          cd->cd_FirstOffsetI,
 893                                                          cd->cd_Add,
 894                                                         &cd->cd_Offset,
 895                                                          FALSE );
 896             cd->cd_Samples -= processed;
 897             samplesleft    -= processed;
 898           }
 899
 900           if( cd->cd_Samples == 0 )
 901           {
 902             /* Linear interpol. stuff */
 903
 904             ULONG lo = (ULONG) (cd->cd_LastOffset >> 32);
 905
 906             switch( cd->cd_Type ) {
 907
 908               case AHIST_M8S:
 909                 cd->cd_StartPointL = ((BYTE*) cd->cd_DataStart)[ lo ] << 8;
 910                 break;
 911
 912               case AHIST_S8S:
 913                 cd->cd_StartPointL = ((BYTE*) cd->cd_DataStart)[ lo*2+0 ] << 8;
 914                 cd->cd_StartPointR = ((BYTE*) cd->cd_DataStart)[ lo*2+1 ] << 8;
 915                 break;
 916
 917               case AHIST_M16S:
 918                 cd->cd_StartPointL = ((WORD*) cd->cd_DataStart)[ lo ];
 919                 break;
 920
 921               case AHIST_S16S:
 922                 cd->cd_StartPointL = ((WORD*) cd->cd_DataStart)[ lo*2+0 ];
 923                 cd->cd_StartPointR = ((WORD*) cd->cd_DataStart)[ lo*2+1 ];
 924                 break;
 925
 926               case AHIST_M32S:
 927                 cd->cd_StartPointL = ((LONG*) cd->cd_DataStart)[ lo ] >> 16;
 928                 break;
 929
 930               case AHIST_S32S:
 931                 cd->cd_StartPointL = ((LONG*) cd->cd_DataStart)[ lo*2+0 ] >> 16;
 932                 cd->cd_StartPointR = ((LONG*) cd->cd_DataStart)[ lo*2+1 ] >> 16;
 933                 break;
 934             }
 935
 936 //          This old code is totally fucked up ... Why didn't anybody
 937 //          complain?!
 938 //            cd->cd_StartPointL = cd->cd_TempStartPointL;
 939 //            cd->cd_StartPointR = cd->cd_TempStartPointR;
 940
 941 /*          KPrintF( "cd->cd_StartPointL=%08lx, cd->cd_StartPointR=%08lx\n", */
 942 /*                   cd->cd_StartPointL, cd->cd_StartPointR ); */
 943             /*
 944             ** Offset always points OUTSIDE the sample after this
 945             ** call.  Ie, if we read a sample at offset (Offset.I)
 946             ** now, it does not belong to the sample just played.
 947             ** This is true for both backward and forward mixing.
 948             */
 949
 950 /*          KPrintF( "cd->cd_Add=0x%08lx:%08lx\n", */
 951 /*                   (ULONG) (cd->cd_Add >> 32), (ULONG) cd->cd_Add ); */
 952 /*          KPrintF( "cd->cd_Offset=0x%08lx:%08lx, " */
 953 /*                   "cd->cd_LastOffset=0x%08lx:%08lx," */
 954 /*                   "cd->cd_FirstOffset=%08lx\n", */
 955 /*                   (ULONG) (cd->cd_Offset >> 32), (ULONG) cd->cd_Offset, */
 956 /*                   (ULONG) (cd->cd_LastOffset >> 32), (ULONG) cd->cd_LastOffset, */
 957 /*                   cd->cd_FirstOffsetI ); */
 958
 959             /* What we do now is to calculate how much futher we have
 960                advanced. */
 961
 962               cd->cd_Offset -= cd->cd_LastOffset + 1;
 963
 964 /*          KPrintF( "cd->cd_Offset=0x%08lx:%08lx, " */
 965 /*                   "cd->cd_LastOffset=0x%08lx:%08lx," */
 966 /*                   "cd->cd_FirstOffset=%08lx\n", */
 967 /*                   (ULONG) (cd->cd_Offset >> 32), (ULONG) cd->cd_Offset, */
 968 /*                   (ULONG) (cd->cd_LastOffset >> 32), (ULONG) cd->cd_LastOffset, */
 969 /*                   cd->cd_FirstOffsetI ); */
 970
 971             /*
 972             ** Offset should now be added to the NEXT Offset. Offset
 973             ** is positive of the sample was mixed forwards, and
 974             ** negative if the sample was mixed backwards.  There is
 975             ** one catch, however.  If the direction is about to
 976             ** change now, Offset should instead be SUBTRACTED.
 977             ** Let's check:
 978             */
 979
 980             if( (cd->cd_Type ^ cd->cd_NextType) & AHIST_BW )
 981             {
 982               cd->cd_Offset = -cd->cd_Offset;
 983             }
 984
 985             cd->cd_Offset += cd->cd_NextOffset;
 986
 987 //            cd->cd_FirstOffsetI = cd->cd_Offset >> 32;
 988             cd->cd_FirstOffsetI = cd->cd_NextOffset >> 32;
 989
 990 /*          KPrintF( "cd->cd_Offset=0x%08lx:%08lx, " */
 991 /*                   "cd->cd_LastOffset=0x%08lx:%08lx," */
 992 /*                   "cd->cd_FirstOffset=%08lx\n", */
 993 /*                   (ULONG) (cd->cd_Offset >> 32), (ULONG) cd->cd_Offset, */
 994 /*                   (ULONG) (cd->cd_LastOffset >> 32), (ULONG) cd->cd_LastOffset, */
 995 /*                   cd->cd_FirstOffsetI ); */
 996             /*
 997             ** But what if the next sample is so short that we just
 998             ** passed it!?  Here is the nice part.  CalcSamples
 999             ** checks this, and sets cd_Samples to 0 in that case.
1000             ** And the add routines doesn't do anything when asked to
1001             ** mix 0 samples.  Assume we have passed a sample with 4
1002             ** samples, and the next one is only 3.  CalcSamples
1003             ** returns 0.  The (ADDFUNC) call above does not do
1004             ** anything at all, OffsetI is still 4.  Now we subtract
1005             ** LastOffsetI, which is 3.  Result:  We have passed the
1006             ** sample with 1.  And guess what?  That's in range.
1007             */
1008
1009             /* Now, let's copy the rest of the cd_Next#? stuff... */
1010
1011             cd->cd_FreqOK        = cd->cd_NextFreqOK;
1012             cd->cd_SoundOK       = cd->cd_NextSoundOK;
1013             cd->cd_Add           = cd->cd_NextAdd;
1014             cd->cd_DataStart     = cd->cd_NextDataStart;
1015             cd->cd_LastOffset    = cd->cd_NextLastOffset;
1016             cd->cd_ScaleLeft     = cd->cd_NextScaleLeft;
1017             cd->cd_ScaleRight    = cd->cd_NextScaleRight;
1018             cd->cd_AddRoutine    = cd->cd_NextAddRoutine;
1019             cd->cd_VolumeLeft    = cd->cd_NextVolumeLeft;
1020             cd->cd_VolumeRight   = cd->cd_NextVolumeRight;
1021             cd->cd_Type          = cd->cd_NextType;
1022
1023             cd->cd_Samples = CalcSamples( cd->cd_Add,
1024                                           cd->cd_Type,
1025                                           cd->cd_LastOffset,
1026                                           cd->cd_Offset );
1027
1028             /* Also update all cd_Delayed#? stuff */
1029
1030             if( !cd->cd_VolDelayed )
1031             {
1032               cd->cd_DelayedVolumeLeft    = cd->cd_NextVolumeLeft;
1033               cd->cd_DelayedVolumeRight   = cd->cd_NextVolumeRight;
1034             }
1035
1036             if( !cd->cd_FreqDelayed )
1037             {
1038               cd->cd_DelayedFreqOK        = cd->cd_NextFreqOK;
1039               cd->cd_DelayedAdd           = cd->cd_NextAdd;
1040             }
1041
1042             if( !cd->cd_SoundDelayed )
1043             {
1044               cd->cd_DelayedSoundOK       = cd->cd_NextSoundOK;
1045               cd->cd_DelayedOffset        = cd->cd_NextOffset;
1046               cd->cd_DelayedFirstOffsetI  = cd->cd_FirstOffsetI;  // See above
1047               cd->cd_DelayedLastOffset    = cd->cd_NextLastOffset;
1048               cd->cd_DelayedType          = cd->cd_NextType;
1049               cd->cd_DelayedDataStart     = cd->cd_NextDataStart;
1050             }
1051
1052             if( !cd->cd_VolDelayed && !cd->cd_SoundDelayed )
1053             {
1054               cd->cd_DelayedScaleLeft     = cd->cd_NextScaleLeft;
1055               cd->cd_DelayedScaleRight    = cd->cd_NextScaleRight;
1056               cd->cd_DelayedAddRoutine    = cd->cd_NextAddRoutine;
1057             }
1058
1059             if( !cd->cd_FreqDelayed && !cd->cd_SoundDelayed )
1060             {
1061               cd->cd_DelayedSamples       = cd->cd_Samples;
1062             }
1063
1064             cd->cd_EOS = TRUE;      // signal End-Of-Sample
1065             continue;               // .contchannel (same channel, new sound)
1066           }
1067         } // FreqOK && SoundOK
1068         break; // .contchannel
1069
1070       } // while(TRUE)
1071
1072       cd = cd->cd_Succ;
1073     } // while(cd)
1074
1075     if(audioctrl->ahiac_WetOrDry == AHIEDM_WET)
1076     {
1077       audioctrl->ahiac_WetOrDry = AHIEDM_DRY;
1078
1079       /*** AHIET_DSPECHO ***/
1080       if(audioctrl->ahiac_EffDSPEchoStruct != NULL)
1081       {
1082         audioctrl->ahiac_EffDSPEchoStruct->ahiecho_Code(
1083             audioctrl->ahiac_EffDSPEchoStruct, dst, audioctrl);
1084       }
1085
1086       cd = audioctrl->ahiac_DryList;
1087
1088       if(audioctrl->ac.ahiac_Flags & AHIACF_POSTPROC)
1089       {
1090         /*** AHIET_MASTERVOLUME ***/
1091
1092         DoMasterVolume(dst, audioctrl);
1093
1094         /*
1095         ** When AHIACB_POSTPROC is set, the dry data shall be placed
1096         ** immediate after the wet data. This is done by modifying the
1097         ** dst pointer
1098         */
1099
1100         dst = (char *) dst + audioctrl->ac.ahiac_BuffSamples *
1101           _AHI_SampleFrameSize( audioctrl->ac.ahiac_BuffType, AHIBase );
1102       }
1103
1104       continue; /* while(TRUE) */
1105     }
1106     else
1107     {
1108       break; /* while(TRUE) */
1109     }
1110   } // while(TRUE)
1111
1112   return;
1113 }
1114
1115
1116 /******************************************************************************
1117 ** DoMasterVolume *************************************************************
1118 ******************************************************************************/
1119
1120 /*
1121 ** This function would be better if it was written in assembler,
1122 ** since overflow could then be detected. Instead we reduce the
1123 ** number of bits to 20 and then scale and compare.
1124 */
1125
1126 void
1127 DoMasterVolume( void *buffer,
1128                 struct AHIPrivAudioCtrl *audioctrl )
1129 {
1130   int   cnt;
1131   LONG  vol;
1132   LONG  sample;
1133
1134   cnt = audioctrl->ac.ahiac_BuffSamples;
1135
1136   switch(audioctrl->ac.ahiac_BuffType)
1137   {
1138
1139     case AHIST_M16S:
1140     case AHIST_M32S:
1141       break;
1142
1143     case AHIST_S16S:
1144     case AHIST_S32S:
1145       cnt *= 2;
1146       break;
1147
1148     case AHIST_L7_1:
1149       cnt *= 8;
1150       break;
1151
1152     default:
1153       return; // Panic
1154   }
1155
1156   if( audioctrl->ac.ahiac_BuffType == AHIST_M32S
1157       || audioctrl->ac.ahiac_BuffType == AHIST_S32S
1158       || audioctrl->ac.ahiac_BuffType == AHIST_L7_1 )
1159   {
1160     LONG *dst = buffer;
1161
1162     vol = audioctrl->ahiac_SetMasterVolume >> 8;
1163
1164     while(cnt > 0)
1165     {
1166       cnt--;
1167
1168       sample = (*dst >> 12) * vol;
1169
1170       if(sample > (LONG) 0x07ffffff)
1171         sample = 0x07ffffff;
1172       else if(sample < (LONG) 0xf8000000)
1173         sample = 0xf8000000;
1174
1175       *dst++ = sample << 4;
1176     }
1177   }
1178   else
1179   {
1180     WORD *dst = buffer;
1181
1182     vol = audioctrl->ahiac_SetMasterVolume >> 4;
1183
1184     while(cnt > 0)
1185     {
1186       cnt--;
1187
1188       sample = *dst * vol;
1189
1190       if(sample > (LONG) 0x07ffffff)
1191         sample = 0x07ffffff;
1192       else if(sample < (LONG) 0xf8000000)
1193         sample = 0xf8000000;
1194
1195       *dst++ = sample >> 12;
1196     }
1197
1198   }
1199 }
1200
1201
1202 /******************************************************************************
1203 ** DoOutputBuffer *************************************************************
1204 ******************************************************************************/
1205
1206 void
1207 DoOutputBuffer( void *buffer,
1208                 struct AHIPrivAudioCtrl *audioctrl )
1209 {
1210   struct AHIEffOutputBuffer *ob;
1211
1212   ob = audioctrl->ahiac_EffOutputBufferStruct;
1213
1214   if(ob != NULL)
1215   {
1216     ob->ahieob_Buffer = buffer;
1217     ob->ahieob_Length = audioctrl->ac.ahiac_BuffSamples;
1218     ob->ahieob_Type   = audioctrl->ac.ahiac_BuffType;
1219
1220     CallHookPkt( ob->ahieob_Func,
1221                  audioctrl,
1222                  ob);
1223   }
1224 }
1225
1226
1227 /******************************************************************************
1228 ** DoChannelInfo **************************************************************
1229 ******************************************************************************/
1230
1231 void
1232 DoChannelInfo( struct AHIPrivAudioCtrl *audioctrl )
1233 {
1234   struct AHIEffChannelInfo *ci;
1235   struct AHIChannelData    *cd;
1236   ULONG                    *offsets;
1237
1238   ci = audioctrl->ahiac_EffChannelInfoStruct;
1239
1240   if(ci != NULL)
1241   {
1242     int i;
1243
1244     cd      = audioctrl->ahiac_ChannelDatas;
1245     offsets = ci->ahieci_Offset;
1246
1247     for(i = ci->ahieci_Channels; i > 0; i--)
1248     {
1249       *offsets++ = cd->cd_Offset >> 32;
1250       cd++;
1251     }
1252
1253     CallHookPkt( ci->ahieci_Func,
1254                  audioctrl,
1255                  ci );
1256   }
1257 }
1258
1259
1260 /******************************************************************************
1261 ** CalcSamples ****************************************************************
1262 ******************************************************************************/
1263
1264 LONG
1265 CalcSamples ( Fixed64 Add,
1266               ULONG   Type,
1267               Fixed64 LastOffset,
1268               Fixed64 Offset )
1269
1270 {
1271   Fixed64 len;
1272
1273   if( Type & AHIST_BW )
1274   {
1275     len = Offset - LastOffset;
1276   }
1277   else
1278   {
1279     len = LastOffset - Offset;
1280   }
1281
1282   if(len < 0 || Add == 0) return 0; // Error!
1283
1284   return (LONG) ( len / Add ) + 1;
1285 }