/*
 * Snes9x - Portable Super Nintendo Entertainment System (TM) emulator.
 *
 * (c) Copyright 1996 - 2001 Gary Henderson (gary.henderson@ntlworld.com) and
 *                           Jerremy Koot (jkoot@snes9x.com)
 *
 * Super FX C emulator code
 * (c) Copyright 1997 - 1999 Ivar (ivar@snes9x.com) and
 *                           Gary Henderson.
 * Super FX assembler emulator code (c) Copyright 1998 zsKnight and _Demo_.
 *
 * DSP1 emulator code (c) Copyright 1998 Ivar, _Demo_ and Gary Henderson.
 * C4 asm and some C emulation code (c) Copyright 2000 zsKnight and _Demo_.
 * C4 C code (c) Copyright 2001 Gary Henderson (gary.henderson@ntlworld.com).
 *
 * (c) Copyright 2014 - 2016 Daniel De Matteis. (UNDER NO CIRCUMSTANCE 
 * WILL COMMERCIAL RIGHTS EVER BE APPROPRIATED TO ANY PARTY)
 *
 * DOS port code contains the works of other authors. See headers in
 * individual files.
 *
 * Snes9x homepage: http://www.snes9x.com
 *
 * Permission to use, copy, modify and distribute Snes9x in both binary and
 * source form, for non-commercial purposes, is hereby granted without fee,
 * providing that this license information and copyright notice appear with
 * all copies and any derived work.
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event shall the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Snes9x is freeware for PERSONAL USE only. Commercial users should
 * seek permission of the copyright holders first. Commercial use includes
 * charging money for Snes9x or software derived from Snes9x.
 *
 * The copyright holders request that bug fixes and improvements to the code
 * should be forwarded to them so everyone can benefit from the modifications
 * in future versions.
 *
 * Super NES and Super Nintendo Entertainment System are trademarks of
 * Nintendo Co., Limited and its subsidiary companies.
 */

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
//#include <fcntl.h>

#define CLIP16(v) \
if ((v) < -32768) \
    (v) = -32768; \
else \
if ((v) > 32767) \
    (v) = 32767

#define CLIP16_latch(v,l) \
if ((v) < -32768) \
{ (v) = -32768; (l)++; }\
else \
if ((v) > 32767) \
{ (v) = 32767; (l)++; }

#define CLIP24(v) \
if ((v) < -8388608) \
    (v) = -8388608; \
else \
if ((v) > 8388607) \
    (v) = 8388607

/*
#define CLIP8(v) \
if ((v) < -128) \
    (v) = -128; \
else \
if ((v) > 127) \
    (v) = 127
*/


#include "snes9x.h"
#include "soundux.h"
#include "apu.h"
#include "memmap.h"
#include "cpuexec.h"
#include "asmmemfuncs.h"


static int wave[SOUND_BUFFER_SIZE];

//extern int Echo [24000];
extern int MixBuffer [SOUND_BUFFER_SIZE];
//extern int EchoBuffer [SOUND_BUFFER_SIZE];
//extern int FilterTaps [8];
extern unsigned long Z;
//extern int Loop [16];

extern long FilterValues[4][2];
//extern int NoiseFreq [32];

//#define FIXED_POINT 0x10000UL
#define FIXED_POINT_REMAINDER 0xffffUL
#define FIXED_POINT_SHIFT 16

#define VOL_DIV8  0x8000
#define VOL_DIV16 0x0080
#define ENVX_SHIFT 24

void DecodeBlockAsm(int8*, int16*, int32*, int32*);

// F is channel's current frequency and M is the 16-bit modulation waveform
// from the previous channel multiplied by the current envelope volume level.
#define PITCH_MOD(F,M) ((F) * ((((unsigned long) (M)) + 0x800000) >> 16) >> 7)
//#define PITCH_MOD(F,M) ((F) * ((((M) & 0x7fffff) >> 14) + 1) >> 8)

#define LAST_SAMPLE 0xffffff
#define JUST_PLAYED_LAST_SAMPLE(c) ((c)->sample_pointer >= LAST_SAMPLE)


static INLINE void S9xAPUSetEndOfSample(int i, Channel* ch)
{
   ch->state = SOUND_SILENT;
   ch->mode = MODE_NONE;
   APU.DSP [APU_ENDX] |= 1 << i;
   APU.DSP [APU_KON] &= ~(1 << i);
   APU.DSP [APU_KOFF] &= ~(1 << i);
   APU.KeyedChannels &= ~(1 << i);
}
#ifdef __DJGPP
END_OF_FUNCTION(S9xAPUSetEndOfSample)
#endif

static INLINE void S9xAPUSetEndX(int ch)
{
   APU.DSP [APU_ENDX] |= 1 << ch;
}
#ifdef __DJGPP
END_OF_FUNCTION(S9xAPUSetEndX)
#endif

void S9xSetEchoDelay(int delay)
{
   SoundData.echo_buffer_size = (512 * delay * so.playback_rate) >> 15; // notaz / 32000;
   if (so.stereo)
      SoundData.echo_buffer_size <<= 1;
   if (SoundData.echo_buffer_size)
   {
      while (SoundData.echo_ptr >= SoundData.echo_buffer_size)
         SoundData.echo_ptr -= SoundData.echo_buffer_size;
   }
   else
      SoundData.echo_ptr = 0;
   S9xSetEchoEnable(APU.DSP [APU_EON]);
}

void S9xSetSoundKeyOff(int channel)
{
   Channel* ch = &SoundData.channels[channel];

   if (ch->state != SOUND_SILENT)
   {
      ch->state = SOUND_RELEASE;
      ch->mode = MODE_RELEASE;
      S9xSetEnvRate(ch, 8, -1, 0, 5 << 28);
   }
}

void S9xFixSoundAfterSnapshotLoad(void)
{
   int i;

   SoundData.echo_write_enabled = !(APU.DSP [APU_FLG] & 0x20);
   SoundData.echo_channel_enable = APU.DSP [APU_EON];
   S9xSetEchoDelay(APU.DSP [APU_EDL] & 0xf);
   S9xSetEchoFeedback((signed char) APU.DSP [APU_EFB]);

   S9xSetFilterCoefficient(0, (signed char) APU.DSP [APU_C0]);
   S9xSetFilterCoefficient(1, (signed char) APU.DSP [APU_C1]);
   S9xSetFilterCoefficient(2, (signed char) APU.DSP [APU_C2]);
   S9xSetFilterCoefficient(3, (signed char) APU.DSP [APU_C3]);
   S9xSetFilterCoefficient(4, (signed char) APU.DSP [APU_C4]);
   S9xSetFilterCoefficient(5, (signed char) APU.DSP [APU_C5]);
   S9xSetFilterCoefficient(6, (signed char) APU.DSP [APU_C6]);
   S9xSetFilterCoefficient(7, (signed char) APU.DSP [APU_C7]);

   for (i = 0; i < 8; i++)
   {
      SoundData.channels[i].needs_decode = TRUE;
      S9xSetSoundFrequency(i, SoundData.channels[i].hertz);
      SoundData.channels [i].envxx = SoundData.channels [i].envx << ENVX_SHIFT;
      SoundData.channels [i].next_sample = 0;
      SoundData.channels [i].interpolate = 0;
      SoundData.channels [i].previous [0] = (int32) SoundData.channels [i].previous16 [0];
      SoundData.channels [i].previous [1] = (int32) SoundData.channels [i].previous16 [1];
   }
   SoundData.master_volume [0] = SoundData.master_volume_left;
   SoundData.master_volume [1] = SoundData.master_volume_right;
   SoundData.echo_volume [0] = SoundData.echo_volume_left;
   SoundData.echo_volume [1] = SoundData.echo_volume_right;
   IAPU.Scanline = 0;
}

void S9xSetEnvelopeHeight(int channel, int level)
{
   Channel* ch = &SoundData.channels[channel];

   ch->envx = level;
   ch->envxx = level << ENVX_SHIFT;

   ch->left_vol_level = (level * ch->volume_left) / 128;
   ch->right_vol_level = (level * ch->volume_right) / 128;

   if (ch->envx == 0 && ch->state != SOUND_SILENT && ch->state != SOUND_GAIN)
      S9xAPUSetEndOfSample(channel, ch);
}

#if 1
void S9xSetSoundSample(int channel, uint16 sample_number)
{
}
#else
void S9xSetSoundSample(int channel, uint16 sample_number)
{
   Channel* ch = &SoundData.channels[channel];

   if (ch->state != SOUND_SILENT &&
         sample_number != ch->sample_number)
   {
      int keep = ch->state;
      ch->state = SOUND_SILENT;
      ch->sample_number = sample_number;
      ch->loop = FALSE;
      ch->needs_decode = TRUE;
      ch->last_block = FALSE;
      ch->previous [0] = ch->previous[1] = 0;
      ch->block_pointer = *S9xGetSampleAddress(sample_number);
      ch->sample_pointer = 0;
      ch->state = keep;
   }
}
#endif

static void DecodeBlock(Channel* ch)
{
   int16* raw;
   int8_t * compressed;
   uint8_t filter;
#ifndef ASM_SPC700
   int32 out;
   uint8_t shift;
   int8_t sample1, sample2;
   unsigned int i;
   int32 prev0, prev1;
#endif

   if (ch->block_pointer >= 0x10000 - 9)
   {
      ch->last_block = TRUE;
      ch->loop = FALSE;
      ch->block = ch->decoded;
      memset32((uint32_t*) ch->decoded, 0, 8);
      return;
   }
   compressed = (int8_t*) &IAPU.RAM [ch->block_pointer];
   filter     = *compressed;

   if ((ch->last_block = filter & 1))
      ch->loop = (filter & 2) != 0;

   raw = ch->block = ch->decoded;

#ifdef ASM_SPC700
   DecodeBlockAsm(compressed, raw, &ch->previous [0], &ch->previous [1]);
#else
   compressed++;


   prev0 = ch->previous [0];
   prev1 = ch->previous [1];
   shift = filter >> 4;

   switch ((filter >> 2) & 3)
   {
      case 0:
         for (i = 8; i != 0; i--)
         {
            sample1 = *compressed++;
            sample2 = sample1 << 4;
            sample2 >>= 4;
            sample1 >>= 4;
            *raw++ = ((int32) sample1 << shift);
            *raw++ = ((int32) sample2 << shift);
         }
         prev1 = *(raw - 2);
         prev0 = *(raw - 1);
         break;
      case 1:
         for (i = 8; i != 0; i--)
         {
            sample1 = *compressed++;
            sample2 = sample1 << 4;
            sample2 >>= 4;
            sample1 >>= 4;
            prev0 = (int16) prev0;
            *raw++ = prev1 = ((int32) sample1 << shift) + prev0 - (prev0 >> 4);
            prev1 = (int16) prev1;
            *raw++ = prev0 = ((int32) sample2 << shift) + prev1 - (prev1 >> 4);
         }
         break;
      case 2:
         for (i = 8; i != 0; i--)
         {
            sample1 = *compressed++;
            sample2 = sample1 << 4;
            sample2 >>= 4;
            sample1 >>= 4;

            out = (sample1 << shift) - prev1 + (prev1 >> 4);
            prev1 = (int16) prev0;
            prev0 &= ~3;
            *raw++ = prev0 = out + (prev0 << 1) - (prev0 >> 5) -
               (prev0 >> 4);

            out = (sample2 << shift) - prev1 + (prev1 >> 4);
            prev1 = (int16) prev0;
            prev0 &= ~3;
            *raw++ = prev0 = out + (prev0 << 1) - (prev0 >> 5) -
               (prev0 >> 4);
         }
         break;
      case 3:
         for (i = 8; i != 0; i--)
         {
            sample1 = *compressed++;
            sample2 = sample1 << 4;
            sample2 >>= 4;
            sample1 >>= 4;
            out = (sample1 << shift);

            out = out - prev1 + (prev1 >> 3) + (prev1 >> 4);
            prev1 = (int16) prev0;
            prev0 &= ~3;
            *raw++ = prev0 = out + (prev0 << 1) - (prev0 >> 3) -
               (prev0 >> 4) - (prev1 >> 6);

            out = (sample2 << shift);
            out = out - prev1 + (prev1 >> 3) + (prev1 >> 4);
            prev1 = (int16) prev0;
            prev0 &= ~3;
            *raw++ = prev0 = out + (prev0 << 1) - (prev0 >> 3) -
               (prev0 >> 4) - (prev1 >> 6);
         }
         break;
   }
   ch->previous [0] = prev0;
   ch->previous [1] = prev1;

#endif
   ch->block_pointer += 9;
}


static void MixStereo(int sample_count)
{
   int pitch_mod = SoundData.pitch_mod & (0xFFFFFFFF ^ APU.DSP[APU_NON]); //~APU.DSP[APU_NON];

   uint32 J;
   for (J = 0; J < NUM_CHANNELS; J++)
   {
      uint32 I;
      bool8 mod;
      int32 VL, VR;
      Channel* ch = &SoundData.channels[J];
      unsigned long freq0 = ch->frequency;

      if (ch->state == SOUND_SILENT)
         continue;

      //    freq0 = (unsigned long) ((double) freq0 * 0.985);//uncommented by jonathan gevaryahu, as it is necessary for most cards in linux

      mod = pitch_mod & (1 << J);

      if (ch->needs_decode)
      {
         DecodeBlock(ch);
         ch->needs_decode = FALSE;
         ch->sample = ch->block[0];
         ch->sample_pointer = freq0 >> FIXED_POINT_SHIFT;
         if (ch->sample_pointer == 0)
            ch->sample_pointer = 1;
         if (ch->sample_pointer > SOUND_DECODE_LENGTH)
            ch->sample_pointer = SOUND_DECODE_LENGTH - 1;

         ch->next_sample = ch->block[ch->sample_pointer];
         ch->interpolate = 0;

         if (Settings.InterpolatedSound && freq0 < FIXED_POINT && !mod)
            ch->interpolate = ((ch->next_sample - ch->sample) *
                               (long) freq0) / (long) FIXED_POINT;
      }
      VL = (ch->sample * ch-> left_vol_level) / 128;
      VR = (ch->sample * ch->right_vol_level) / 128;

      for (I = 0; I < (uint32) sample_count; I += 2)
      {
         unsigned long freq = freq0;

         if (mod)
            freq = PITCH_MOD(freq, wave [I / 2]);

         ch->env_error += ch->erate;
         if (ch->env_error >= FIXED_POINT)
         {
            uint32 step = ch->env_error >> FIXED_POINT_SHIFT;

            switch (ch->state)
            {
            case SOUND_ATTACK:
               ch->env_error &= FIXED_POINT_REMAINDER;
               ch->envx += step << 1;
               ch->envxx = ch->envx << ENVX_SHIFT;

               if (ch->envx >= 126)
               {
                  ch->envx = 127;
                  ch->envxx = 127 << ENVX_SHIFT;
                  ch->state = SOUND_DECAY;
                  if (ch->sustain_level != 8)
                  {
                     S9xSetEnvRate(ch, ch->decay_rate, -1,
                                   (MAX_ENVELOPE_HEIGHT * ch->sustain_level) >> 3, 1 << 28);
                     break;
                  }
                  ch->state = SOUND_SUSTAIN;
                  S9xSetEnvRate(ch, ch->sustain_rate, -1, 0, 2 << 28);
               }
               break;

            case SOUND_DECAY:
               while (ch->env_error >= FIXED_POINT)
               {
                  ch->envxx = (ch->envxx >> 8) * 255;
                  ch->env_error -= FIXED_POINT;
               }
               ch->envx = ch->envxx >> ENVX_SHIFT;
               if (ch->envx <= ch->envx_target)
               {
                  if (ch->envx <= 0)
                  {
                     S9xAPUSetEndOfSample(J, ch);
                     goto stereo_exit;
                  }
                  ch->state = SOUND_SUSTAIN;
                  S9xSetEnvRate(ch, ch->sustain_rate, -1, 0, 2 << 28);
               }
               break;

            case SOUND_SUSTAIN:
               while (ch->env_error >= FIXED_POINT)
               {
                  ch->envxx = (ch->envxx >> 8) * 255;
                  ch->env_error -= FIXED_POINT;
               }
               ch->envx = ch->envxx >> ENVX_SHIFT;
               if (ch->envx <= 0)
               {
                  S9xAPUSetEndOfSample(J, ch);
                  goto stereo_exit;
               }
               break;

            case SOUND_RELEASE:
               while (ch->env_error >= FIXED_POINT)
               {
                  ch->envxx -= (MAX_ENVELOPE_HEIGHT << ENVX_SHIFT) / 256;
                  ch->env_error -= FIXED_POINT;
               }
               ch->envx = ch->envxx >> ENVX_SHIFT;
               if (ch->envx <= 0)
               {
                  S9xAPUSetEndOfSample(J, ch);
                  goto stereo_exit;
               }
               break;

            case SOUND_INCREASE_LINEAR:
               ch->env_error &= FIXED_POINT_REMAINDER;
               ch->envx += step << 1;
               ch->envxx = ch->envx << ENVX_SHIFT;

               if (ch->envx >= 126)
               {
                  ch->envx = 127;
                  ch->envxx = 127 << ENVX_SHIFT;
                  ch->state = SOUND_GAIN;
                  ch->mode = MODE_GAIN;
                  S9xSetEnvRate(ch, 0, -1, 0, 0);
               }
               break;

            case SOUND_INCREASE_BENT_LINE:
               if (ch->envx >= (MAX_ENVELOPE_HEIGHT * 3) / 4)
               {
                  while (ch->env_error >= FIXED_POINT)
                  {
                     ch->envxx += (MAX_ENVELOPE_HEIGHT << ENVX_SHIFT) / 256;
                     ch->env_error -= FIXED_POINT;
                  }
                  ch->envx = ch->envxx >> ENVX_SHIFT;
               }
               else
               {
                  ch->env_error &= FIXED_POINT_REMAINDER;
                  ch->envx += step << 1;
                  ch->envxx = ch->envx << ENVX_SHIFT;
               }

               if (ch->envx >= 126)
               {
                  ch->envx = 127;
                  ch->envxx = 127 << ENVX_SHIFT;
                  ch->state = SOUND_GAIN;
                  ch->mode = MODE_GAIN;
                  S9xSetEnvRate(ch, 0, -1, 0, 0);
               }
               break;

            case SOUND_DECREASE_LINEAR:
               ch->env_error &= FIXED_POINT_REMAINDER;
               ch->envx -= step << 1;
               ch->envxx = ch->envx << ENVX_SHIFT;
               if (ch->envx <= 0)
               {
                  S9xAPUSetEndOfSample(J, ch);
                  goto stereo_exit;
               }
               break;

            case SOUND_DECREASE_EXPONENTIAL:
               while (ch->env_error >= FIXED_POINT)
               {
                  ch->envxx = (ch->envxx >> 8) * 255;
                  ch->env_error -= FIXED_POINT;
               }
               ch->envx = ch->envxx >> ENVX_SHIFT;
               if (ch->envx <= 0)
               {
                  S9xAPUSetEndOfSample(J, ch);
                  goto stereo_exit;
               }
               break;

            case SOUND_GAIN:
               S9xSetEnvRate(ch, 0, -1, 0, 0);
               break;
            }
            ch-> left_vol_level = (ch->envx * ch->volume_left) / 128;
            ch->right_vol_level = (ch->envx * ch->volume_right) / 128;
            VL = (ch->sample * ch-> left_vol_level) / 128;
            VR = (ch->sample * ch->right_vol_level) / 128;
         }

         ch->count += freq;
         if (ch->count >= FIXED_POINT)
         {
            VL = ch->count >> FIXED_POINT_SHIFT;
            ch->sample_pointer += VL;
            ch->count &= FIXED_POINT_REMAINDER;

            ch->sample = ch->next_sample;
            if (ch->sample_pointer >= SOUND_DECODE_LENGTH)
            {
               if (JUST_PLAYED_LAST_SAMPLE(ch))
               {
                  S9xAPUSetEndOfSample(J, ch);
                  goto stereo_exit;
               }
               do
               {
                  ch->sample_pointer -= SOUND_DECODE_LENGTH;
                  if (ch->last_block)
                  {
                     if (!ch->loop)
                     {
                        ch->sample_pointer = LAST_SAMPLE;
                        ch->next_sample = ch->sample;
                        break;
                     }
                     else
                     {
                        uint16 *dir;

                        S9xAPUSetEndX(J);
                        ch->last_block    = FALSE;
                        dir               = S9xGetSampleAddress(ch->sample_number);
                        ch->block_pointer = *(dir + 1);
                     }
                  }
                  DecodeBlock(ch);
               }
               while (ch->sample_pointer >= SOUND_DECODE_LENGTH);
               if (!JUST_PLAYED_LAST_SAMPLE(ch))
                  ch->next_sample = ch->block [ch->sample_pointer];
            }
            else
               ch->next_sample = ch->block [ch->sample_pointer];

            if (ch->type == SOUND_SAMPLE)
            {
               if (Settings.InterpolatedSound && freq < FIXED_POINT && !mod)
               {
                  ch->interpolate = ((ch->next_sample - ch->sample) *
                                     (long) freq) / (long) FIXED_POINT;
                  ch->sample = (int16_t)(ch->sample + (((ch->next_sample - ch->sample) *
                                                      (long)(ch->count)) / (long) FIXED_POINT));
               }
               else
                  ch->interpolate = 0;
            }
            else
            {
#if 1
               // Snes9x 1.53's SPC_DSP.cpp, by blargg
               int feedback = (so.noise_gen << 13) ^ (so.noise_gen << 14);
               so.noise_gen = (feedback & 0x4000) ^ (so.noise_gen >> 1);
               ch->sample = (so.noise_gen << 17) >> 17;
               ch->interpolate = 0;
#else
               for (; VL > 0; VL--)
                  if ((so.noise_gen <<= 1) & 0x80000000L)
                     so.noise_gen ^= 0x0040001L;
               ch->sample = (so.noise_gen << 17) >> 17;
#endif
            }

            VL = (ch->sample * ch-> left_vol_level) / 128;
            VR = (ch->sample * ch->right_vol_level) / 128;
         }
         else
         {
            if (ch->interpolate)
            {
               int32_t s = (int32_t) ch->sample + ch->interpolate;

               CLIP16(s);
               ch->sample = (int16_t) s;
               VL = (ch->sample * ch-> left_vol_level) / 128;
               VR = (ch->sample * ch->right_vol_level) / 128;
            }
         }

         if (pitch_mod & (1 << (J + 1)))
            wave [I / 2] = ch->sample * ch->envx;

         MixBuffer [I]   += VL;
         MixBuffer [I + 1] += VR;
         if (ch->echo_buf_ptr)
         {
            ch->echo_buf_ptr [I]   += VL;
            ch->echo_buf_ptr [I + 1] += VR;
         }
      }
stereo_exit:
      ;
   }
}

static void MixMono(int sample_count)
{
   int pitch_mod = SoundData.pitch_mod & (0xFFFFFFFF ^ APU.DSP[APU_NON]);

   uint32 J;
   for (J = 0; J < NUM_CHANNELS; J++)
   {
      int32 V;
      bool8 mod;
      uint32 I;
      Channel* ch = &SoundData.channels[J];
      unsigned long freq0 = ch->frequency;

      if (ch->state == SOUND_SILENT)
         continue;

      // freq0 = (unsigned long) ((double) freq0 * 0.985);

      mod = pitch_mod & (1 << J);

      if (ch->needs_decode)
      {
         DecodeBlock(ch);
         ch->needs_decode = FALSE;
         ch->sample = ch->block[0];
         ch->sample_pointer = freq0 >> FIXED_POINT_SHIFT;
         if (ch->sample_pointer == 0)
            ch->sample_pointer = 1;
         if (ch->sample_pointer > SOUND_DECODE_LENGTH)
            ch->sample_pointer = SOUND_DECODE_LENGTH - 1;
         ch->next_sample = ch->block[ch->sample_pointer];

      }
      V = (ch->sample * ch->left_vol_level) / 128;

      for (I = 0; I < (uint32) sample_count; I++)
      {
         unsigned long freq = freq0;

         if (mod)
            freq = PITCH_MOD(freq, wave [I]);

         ch->env_error += ch->erate;
         if (ch->env_error >= FIXED_POINT)
         {
            uint32 step = ch->env_error >> FIXED_POINT_SHIFT;

            switch (ch->state)
            {
               case SOUND_ATTACK:
                  ch->env_error &= FIXED_POINT_REMAINDER;
                  ch->envx += step << 1;
                  ch->envxx = ch->envx << ENVX_SHIFT;

                  if (ch->envx >= 126)
                  {
                     ch->envx = 127;
                     ch->envxx = 127 << ENVX_SHIFT;
                     ch->state = SOUND_DECAY;
                     if (ch->sustain_level != 8)
                     {
                        S9xSetEnvRate(ch, ch->decay_rate, -1,
                              (MAX_ENVELOPE_HEIGHT * ch->sustain_level) >> 3, 1 << 28);
                        break;
                     }
                     ch->state = SOUND_SUSTAIN;
                     S9xSetEnvRate(ch, ch->sustain_rate, -1, 0, 2 << 28);
                  }
                  break;

               case SOUND_DECAY:
                  while (ch->env_error >= FIXED_POINT)
                  {
                     ch->envxx = (ch->envxx >> 8) * 255;
                     ch->env_error -= FIXED_POINT;
                  }
                  ch->envx = ch->envxx >> ENVX_SHIFT;
                  if (ch->envx <= ch->envx_target)
                  {
                     if (ch->envx <= 0)
                     {
                        S9xAPUSetEndOfSample(J, ch);
                        goto mono_exit;
                     }
                     ch->state = SOUND_SUSTAIN;
                     S9xSetEnvRate(ch, ch->sustain_rate, -1, 0, 2 << 28);
                  }
                  break;

               case SOUND_SUSTAIN:
                  while (ch->env_error >= FIXED_POINT)
                  {
                     ch->envxx = (ch->envxx >> 8) * 255;
                     ch->env_error -= FIXED_POINT;
                  }
                  ch->envx = ch->envxx >> ENVX_SHIFT;
                  if (ch->envx <= 0)
                  {
                     S9xAPUSetEndOfSample(J, ch);
                     goto mono_exit;
                  }
                  break;

               case SOUND_RELEASE:
                  while (ch->env_error >= FIXED_POINT)
                  {
                     ch->envxx -= (MAX_ENVELOPE_HEIGHT << ENVX_SHIFT) / 256;
                     ch->env_error -= FIXED_POINT;
                  }
                  ch->envx = ch->envxx >> ENVX_SHIFT;
                  if (ch->envx <= 0)
                  {
                     S9xAPUSetEndOfSample(J, ch);
                     goto mono_exit;
                  }
                  break;

               case SOUND_INCREASE_LINEAR:
                  ch->env_error &= FIXED_POINT_REMAINDER;
                  ch->envx += step << 1;
                  ch->envxx = ch->envx << ENVX_SHIFT;

                  if (ch->envx >= 126)
                  {
                     ch->envx = 127;
                     ch->envxx = 127 << ENVX_SHIFT;
                     ch->state = SOUND_GAIN;
                     ch->mode = MODE_GAIN;
                     S9xSetEnvRate(ch, 0, -1, 0, 0);
                  }
                  break;

               case SOUND_INCREASE_BENT_LINE:
                  if (ch->envx >= (MAX_ENVELOPE_HEIGHT * 3) / 4)
                  {
                     while (ch->env_error >= FIXED_POINT)
                     {
                        ch->envxx += (MAX_ENVELOPE_HEIGHT << ENVX_SHIFT) / 256;
                        ch->env_error -= FIXED_POINT;
                     }
                     ch->envx = ch->envxx >> ENVX_SHIFT;
                  }
                  else
                  {
                     ch->env_error &= FIXED_POINT_REMAINDER;
                     ch->envx += step << 1;
                     ch->envxx = ch->envx << ENVX_SHIFT;
                  }

                  if (ch->envx >= 126)
                  {
                     ch->envx = 127;
                     ch->envxx = 127 << ENVX_SHIFT;
                     ch->state = SOUND_GAIN;
                     ch->mode = MODE_GAIN;
                     S9xSetEnvRate(ch, 0, -1, 0, 0);
                  }
                  break;

               case SOUND_DECREASE_LINEAR:
                  ch->env_error &= FIXED_POINT_REMAINDER;
                  ch->envx -= step << 1;
                  ch->envxx = ch->envx << ENVX_SHIFT;
                  if (ch->envx <= 0)
                  {
                     S9xAPUSetEndOfSample(J, ch);
                     goto mono_exit;
                  }
                  break;

               case SOUND_DECREASE_EXPONENTIAL:
                  while (ch->env_error >= FIXED_POINT)
                  {
                     ch->envxx = (ch->envxx >> 8) * 255;
                     ch->env_error -= FIXED_POINT;
                  }
                  ch->envx = ch->envxx >> ENVX_SHIFT;
                  if (ch->envx <= 0)
                  {
                     S9xAPUSetEndOfSample(J, ch);
                     goto mono_exit;
                  }
                  break;

               case SOUND_GAIN:
                  S9xSetEnvRate(ch, 0, -1, 0, 0);
                  break;
            }
            ch->left_vol_level = (ch->envx * ch->volume_left) / 128;
            V = (ch->sample * ch->left_vol_level) / 128;
         }

         ch->count += freq;
         if (ch->count >= FIXED_POINT)
         {
            V = ch->count >> FIXED_POINT_SHIFT;
            ch->sample_pointer += V;
            ch->count &= FIXED_POINT_REMAINDER;

            ch->sample = ch->next_sample;
            if (ch->sample_pointer >= SOUND_DECODE_LENGTH)
            {
               if (JUST_PLAYED_LAST_SAMPLE(ch))
               {
                  S9xAPUSetEndOfSample(J, ch);
                  goto mono_exit;
               }
               do
               {
                  ch->sample_pointer -= SOUND_DECODE_LENGTH;
                  if (ch->last_block)
                  {
                     if (!ch->loop)
                     {
                        ch->sample_pointer = LAST_SAMPLE;
                        ch->next_sample = ch->sample;
                        break;
                     }
                     else
                     {
                        uint16 *dir;

                        ch->last_block    = FALSE;
                        dir               = S9xGetSampleAddress(ch->sample_number);
                        ch->block_pointer = *(dir + 1);
                        S9xAPUSetEndX(J);
                     }
                  }
                  DecodeBlock(ch);
               }
               while (ch->sample_pointer >= SOUND_DECODE_LENGTH);
               if (!JUST_PLAYED_LAST_SAMPLE(ch))
                  ch->next_sample = ch->block [ch->sample_pointer];
            }
            else
               ch->next_sample = ch->block [ch->sample_pointer];

            if (ch->type != SOUND_SAMPLE)
            {
               for (; V > 0; V--)
                  if ((so.noise_gen <<= 1) & 0x80000000L)
                     so.noise_gen ^= 0x0040001L;
               ch->sample = (so.noise_gen << 17) >> 17;
            }
            V = (ch->sample * ch-> left_vol_level) / 128;
         }

         MixBuffer [I] += V;
         if (ch->echo_buf_ptr)
            ch->echo_buf_ptr [I] += V;

         if (pitch_mod & (1 << (J + 1)))
            wave [I] = ch->sample * ch->envx;
      }
mono_exit:
      ;
   }
}


// For backwards compatibility with older port specific code
void S9xMixSamples(signed short* buffer, int sample_count)
{
   S9xMixSamplesO(buffer, sample_count, 0);
}


void S9xMixSamplesO(signed short* buffer, int sample_count, int sample_offset)
{
   // 16-bit sound only
   int J;

   buffer += sample_offset;

   if (so.mute_sound)
   {
      memset16((uint16_t*)buffer, 0, sample_count);
      return;
   }

   memset32((uint32_t*)MixBuffer, 0, sample_count);
   if (SoundData.echo_enable)
      memset32((uint32_t*)EchoBuffer, 0, sample_count);

   if (so.stereo)
      MixStereo(sample_count);
   else
      MixMono(sample_count);

   /* Mix and convert waveforms */
   if (SoundData.echo_enable && SoundData.echo_buffer_size)
   {
      if (so.stereo)
      {
         int l, r;
         int master_vol_l = SoundData.master_volume[0];
         int master_vol_r = SoundData.master_volume[1];
         int echo_vol_l = SoundData.echo_volume[0];
         int echo_vol_r = SoundData.echo_volume[1];

         // 16-bit stereo sound with echo enabled ...
         if (SoundData.no_filter)
         {
            // ... but no filter defined.
            for (J = 0; J < sample_count; J += 2)
            {
               int E = Echo [SoundData.echo_ptr];

               Echo[SoundData.echo_ptr++] = (E * SoundData.echo_feedback) / 128 + EchoBuffer[J];
               Echo[SoundData.echo_ptr++] = (E * SoundData.echo_feedback) / 128 + EchoBuffer[J + 1];

               if (SoundData.echo_ptr >= SoundData.echo_buffer_size)
                  SoundData.echo_ptr = 0;

               l = (MixBuffer[J]   * master_vol_l + E * echo_vol_l) / VOL_DIV16;
               r = (MixBuffer[J + 1] * master_vol_r + E * echo_vol_r) / VOL_DIV16;

               CLIP16(l);
               CLIP16(r);
               buffer[J]   = l;
               buffer[J + 1] = r;
            }
         }
         else
         {
            // ... with filter defined.
            for (J = 0; J < sample_count; J += 2)
            {
               int E = Echo [SoundData.echo_ptr];

               Loop [(Z - 0) & 15] = E;



               E =  E                    * FilterTaps [0];
               E += Loop [(Z -  2) & 15] * FilterTaps [1];
               E += Loop [(Z -  4) & 15] * FilterTaps [2];
               E += Loop [(Z -  6) & 15] * FilterTaps [3];
               E += Loop [(Z -  8) & 15] * FilterTaps [4];
               E += Loop [(Z - 10) & 15] * FilterTaps [5];
               E += Loop [(Z - 12) & 15] * FilterTaps [6];
               E += Loop [(Z - 14) & 15] * FilterTaps [7];
               E /= 128;
               Z++;

               Echo[SoundData.echo_ptr++] = (E * SoundData.echo_feedback) / 128 + EchoBuffer[J];
               Echo[SoundData.echo_ptr++] = (E * SoundData.echo_feedback) / 128 + EchoBuffer[J + 1];

               if (SoundData.echo_ptr >= SoundData.echo_buffer_size)
                  SoundData.echo_ptr = 0;

               l = (MixBuffer[J]   * master_vol_l + E * echo_vol_l) / VOL_DIV16;
               r = (MixBuffer[J + 1] * master_vol_r + E * echo_vol_r) / VOL_DIV16;

               CLIP16(l);
               CLIP16(r);
               buffer[J]   = l;
               buffer[J + 1] = r;
            }
         }
      }
      else
      {
         int I;
         int master_vol_l = SoundData.master_volume[0];
         int echo_vol_l = SoundData.echo_volume[0];

         // 16-bit mono sound with echo enabled...
         if (SoundData.no_filter)
         {
            // ... no filter defined
            for (J = 0; J < sample_count; J++)
            {
               int E = Echo [SoundData.echo_ptr];

               Echo[SoundData.echo_ptr++] = (E * SoundData.echo_feedback) / 128 + EchoBuffer[J];

               if (SoundData.echo_ptr >= SoundData.echo_buffer_size)
                  SoundData.echo_ptr = 0;

               I = (MixBuffer[J] * master_vol_l + E * echo_vol_l) / VOL_DIV16;
               CLIP16(I);
               buffer[J] = I;
            }
         }
         else
         {
            // ... with filter defined
            for (J = 0; J < sample_count; J++)
            {
               int E = Echo [SoundData.echo_ptr];

               Loop [(Z - 0) & 7] = E;
               E =  E                  * FilterTaps [0];
               E += Loop [(Z - 1) & 7] * FilterTaps [1];
               E += Loop [(Z - 2) & 7] * FilterTaps [2];
               E += Loop [(Z - 3) & 7] * FilterTaps [3];
               E += Loop [(Z - 4) & 7] * FilterTaps [4];
               E += Loop [(Z - 5) & 7] * FilterTaps [5];
               E += Loop [(Z - 6) & 7] * FilterTaps [6];
               E += Loop [(Z - 7) & 7] * FilterTaps [7];
               E /= 128;
               Z++;

               Echo[SoundData.echo_ptr++] = (E * SoundData.echo_feedback) / 128 + EchoBuffer[J];

               if (SoundData.echo_ptr >= SoundData.echo_buffer_size)
                  SoundData.echo_ptr = 0;

               I = (MixBuffer[J] * master_vol_l + E * echo_vol_l) / VOL_DIV16;
               CLIP16(I);
               buffer[J] = I;
            }
         }
      }
   }
   else
   {
      int l, master_vol_l = SoundData.master_volume[0];

      if (so.stereo)
      {
         int r, master_vol_r = SoundData.master_volume[1];

         // 16-bit stereo sound, no echo
         for (J = 0; J < sample_count; J += 2)
         {
            l = (MixBuffer[J]   * master_vol_l) / VOL_DIV16;
            r = (MixBuffer[J + 1] * master_vol_r) / VOL_DIV16;

            CLIP16(l);
            CLIP16(r);
            buffer[J]   = l;
            buffer[J + 1] = r;
         }
      }
      else
      {
         // 16-bit mono sound, no echo
         for (J = 0; J < sample_count; J++)
         {
            l = (MixBuffer[J] * master_vol_l) / VOL_DIV16;

            CLIP16(l);
            buffer[J] = l;
         }
      }
   }
}

#ifdef __DJGPP
END_OF_FUNCTION(S9xMixSamplesO);
#endif

void S9xResetSound(bool8 full)
{
   int i;
   for (i = 0; i < 8; i++)
   {
      SoundData.channels[i].state = SOUND_SILENT;
      SoundData.channels[i].mode = MODE_NONE;
      SoundData.channels[i].type = SOUND_SAMPLE;
      SoundData.channels[i].volume_left = 0;
      SoundData.channels[i].volume_right = 0;
      SoundData.channels[i].hertz = 0;
      SoundData.channels[i].count = 0;
      SoundData.channels[i].loop = FALSE;
      SoundData.channels[i].envx_target = 0;
      SoundData.channels[i].env_error = 0;
      SoundData.channels[i].erate = 0;
      SoundData.channels[i].envx = 0;
      SoundData.channels[i].envxx = 0;
      SoundData.channels[i].left_vol_level = 0;
      SoundData.channels[i].right_vol_level = 0;
      SoundData.channels[i].direction = 0;
      SoundData.channels[i].attack_rate = 0;
      SoundData.channels[i].decay_rate = 0;
      SoundData.channels[i].sustain_rate = 0;
      SoundData.channels[i].release_rate = 0;
      SoundData.channels[i].sustain_level = 0;
      // notaz
      SoundData.channels[i].env_ind_attack = 0;
      SoundData.channels[i].env_ind_decay = 0;
      SoundData.channels[i].env_ind_sustain = 0;
      SoundData.echo_ptr = 0;
      SoundData.echo_feedback = 0;
      SoundData.echo_buffer_size = 1;
   }
   FilterTaps [0] = 127;
   FilterTaps [1] = 0;
   FilterTaps [2] = 0;
   FilterTaps [3] = 0;
   FilterTaps [4] = 0;
   FilterTaps [5] = 0;
   FilterTaps [6] = 0;
   FilterTaps [7] = 0;
   so.mute_sound = TRUE;
   so.noise_gen = 1;

   if (full)
   {
      SoundData.master_volume_left = 0;
      SoundData.master_volume_right = 0;
      SoundData.echo_volume_left = 0;
      SoundData.echo_volume_right = 0;
      SoundData.echo_enable = 0;
      SoundData.echo_write_enabled = 0;
      SoundData.echo_channel_enable = 0;
      SoundData.pitch_mod = 0;
      SoundData.dummy[0] = 0;
      SoundData.dummy[1] = 0;
      SoundData.dummy[2] = 0;
      SoundData.master_volume[0] = 0;
      SoundData.master_volume[1] = 0;
      SoundData.echo_volume[0] = 0;
      SoundData.echo_volume[1] = 0;
      SoundData.noise_hertz = 0;
   }

   SoundData.master_volume_left = 127;
   SoundData.master_volume_right = 127;
   SoundData.master_volume [0] = SoundData.master_volume [1] = 127;
   SoundData.no_filter = TRUE;
}



extern unsigned long AttackRate [16];
extern unsigned long DecayRate [8];
extern unsigned long SustainRate [32];
extern unsigned long IncreaseRate [32];
extern unsigned long DecreaseRateExp [32];


void S9xSetPlaybackRate(uint32 playback_rate)
{
   int i;

   so.playback_rate = playback_rate;

   if (playback_rate)
   {
      static int steps [] =
      {
         //0, 64, 1238, 1238, 256, 1, 64, 109, 64, 1238
         0, 64, 619, 619, 128, 1, 64, 55, 64, 619
      };
      int u;

      // notaz: calculate a value (let's call it freqbase) to simplify 
      // channel freq calculations later.
      so.freqbase = (FIXED_POINT << 11) / (playback_rate * 33 / 32);
      // now precalculate env rates for S9xSetEnvRate
      for (i = 0; i < 16; i++)
         for (u = 0; u < 10; u++)
            AttackERate[i][u] = (unsigned long)(((int64) FIXED_POINT * 1000 * steps[u]) /
                                                (AttackRate[i] * playback_rate));
      for (i = 0; i < 8; i++)
         for (u = 0; u < 10; u++)
            DecayERate[i][u]  = (unsigned long)(((int64) FIXED_POINT * 1000 * steps[u]) /
                                                (DecayRate[i]  * playback_rate));

      for (i = 0; i < 32; i++)
         for (u = 0; u < 10; u++)
            SustainERate[i][u] = (unsigned long)(((int64) FIXED_POINT * 1000 * steps[u]) /
                                                 (SustainRate[i]  * playback_rate));

      for (i = 0; i < 32; i++)
         for (u = 0; u < 10; u++)
            IncreaseERate[i][u] = (unsigned long)(((int64) FIXED_POINT * 1000 * steps[u]) /
                                                  (IncreaseRate[i] * playback_rate));

      for (i = 0; i < 32; i++)
         for (u = 0; u < 10; u++)
            DecreaseERateExp[i][u] = (unsigned long)(((int64) FIXED_POINT * 1000 * steps[u]) /
                                     (DecreaseRateExp[i] / 2 * playback_rate));

      for (u = 0; u < 10; u++)
         KeyOffERate[u] = (unsigned long)(((int64) FIXED_POINT * 1000 * steps[u]) /
                                          (8 * playback_rate));
   }

   S9xSetEchoDelay(APU.DSP [APU_EDL] & 0xf);
   for (i = 0; i < 8; i++)
      S9xSetSoundFrequency(i, SoundData.channels [i].hertz);
}

bool8 S9xInitSound(void)
{
   so.playback_rate = 0;
   so.stereo = 0;

   S9xResetSound(TRUE);
   S9xSetSoundMute(TRUE);

   return (1);
}

