/*

* UAE - The Un*x Amiga Emulator

*

* Paula audio emulation

*

* Copyright 1995, 1996, 1997 Bernd Schmidt

* Copyright 1996 Marcus Sundberg

* Copyright 1996 Manfred Thole

* Copyright 2006 Toni Wilen

*

* new filter algorithm and anti&sinc interpolators by Antti S. Lankila

*

*/

#include "sysconfig.h"

#include "sysdeps.h"

#include "options.h"

#include "memory.h"

#include "custom.h"

#include "newcpu.h"

#include "gensound.h"

#include "audio.h"

#include "sounddep/sound.h"

#include "events.h"

#include "savestate.h"

#ifdef DRIVESOUND

#include "driveclick.h"

#endif

#include "zfile.h"

#include "uae.h"

#include "gui.h"

#include "debug.h"

#ifdef WITH_SNDBOARD

#include "sndboard.h"

#endif

#ifdef AVIOUTPUT

#include "avioutput.h"

#endif

#ifdef AHI

#include "ahidsound.h"

#ifdef AHI_v2

#include "ahidsound_new.h"

#endif

#endif

#include <math.h>

#define DEBUG_AUDIO 0

#define DEBUG_AUDIO2 0

#define DEBUG_AUDIO_HACK 0

#define DEBUG_CHANNEL_MASK 15

#define TEST_AUDIO 0

#define TEST_MISSED_DMA 0

#define TEST_MANUAL_AUDIO 0

#define PERIOD_MIN 1

#define PERIOD_MIN_NONCE 60

#define PERIOD_MIN_LOOP 24

#define PERIOD_MIN_LOOP_COUNT 64

#define PERIOD_LOW 124

int audio_channel_mask = 15;

volatile bool cd_audio_mode_changed;

STATIC_INLINE bool isaudio (void)

{

return currprefs.produce_sound != 0;

}

#if DEBUG_AUDIO > 0 || DEBUG_AUDIO_HACK > 0 || DEBUG_AUDIO2 > 0

static bool debugchannel (int ch)

{

return ((1 << ch) & DEBUG_CHANNEL_MASK) != 0;

}

#endif

STATIC_INLINE bool usehacks(void)

{

return !(currprefs.cs_hacks & 8) && (currprefs.cpu_model >= 68020 || currprefs.m68k_speed != 0 || (currprefs.cs_hacks & 4));

}

#define SINC_QUEUE_MAX_AGE 2048

/* Queue length 256 implies minimum emulated period of 8. This should be

* sufficient for all imaginable purposes. This must be power of two. */

#define SINC_QUEUE_LENGTH 256

#include "sinctable.cpp"

typedef struct {

int time, output;

} sinc_queue_t;

struct audio_channel_data2

{

int current_sample, last_sample;

uae_u8 new_sample;

int sample_accum, sample_accum_time;

int sinc_output_state;

sinc_queue_t sinc_queue[SINC_QUEUE_LENGTH];

int sinc_queue_time;

int sinc_queue_head;

int audvol;

int mixvol;

unsigned int adk_mask;

};

struct audio_stream_data

{

bool active;

unsigned int evtime;

struct audio_channel_data2 data[AUDIO_CHANNEL_MAX_STREAM_CH];

SOUND_STREAM_CALLBACK cb;

void *cb_data;

};

#define FIR_WIDTH 512

#define VOLCNT_BUFFER_SIZE 4096

union sIntFlt { uae_u32 U32; float F32; };

static float firmem[2 * FIR_WIDTH + 1];

struct audio_channel_data

{

uae_u32 evtime;

bool dmaenstore;

bool intreq2;

int irqcheck;

bool dr;

bool dsr;

bool pbufldl;

int drhpos;

bool dat_written;

#if TEST_MISSED_DMA

bool dat_loaded;

#endif

#if TEST_MANUAL_AUDIO

bool mdat_loaded;

#endif

uaecptr lc, pt;

int state;

int per;

int len, wlen;

int volcnt;

uae_u16 dat, dat2;

struct audio_channel_data2 data;

#if TEST_AUDIO > 0

bool hisample, losample;

bool have_dat;

int per_original;

#endif

/* too fast cpu fixes */

uaecptr ptx;

bool ptx_written;

bool ptx_tofetch;

int dmaofftime_active;

int dmaofftime_cpu_cnt;

uaecptr dmaofftime_pc;

int minperloop;

int volcntbufcnt;

float volcntbuf[VOLCNT_BUFFER_SIZE];

};

static int audio_extra_streams[AUDIO_CHANNEL_STREAMS];

static int audio_total_extra_streams;

static int samplecnt;

#if SOUNDSTUFF > 0

static int extrasamples, outputsample, doublesample;

#endif

int sampleripper_enabled;

struct ripped_sample

{

struct ripped_sample *next;

uae_u8 *sample;

uaecptr pt;

int len, per, changed;

};

static struct ripped_sample *ripped_samples;

void write_wavheader (struct zfile *wavfile, size_t size, uae_u32 freq)

{

uae_u16 tw;

size_t tl;

int bits = 8, channels = 1;

zfile_fseek (wavfile, 0, SEEK_SET);

zfile_fwrite ("RIFF", 1, 4, wavfile);

tl = 0;

if (size)

tl = size - 8;

zfile_fwrite (&tl, 1, 4, wavfile);

zfile_fwrite ("WAVEfmt ", 1, 8, wavfile);

tl = 16;

zfile_fwrite (&tl, 1, 4, wavfile);

tw = 1;

zfile_fwrite (&tw, 1, 2, wavfile);

tw = channels;

zfile_fwrite (&tw, 1, 2, wavfile);

tl = freq;

zfile_fwrite (&tl, 1, 4, wavfile);

tl = freq * channels * bits / 8;

zfile_fwrite (&tl, 1, 4, wavfile);

tw = channels * bits / 8;

zfile_fwrite (&tw, 1, 2, wavfile);

tw = bits;

zfile_fwrite (&tw, 1, 2, wavfile);

zfile_fwrite ("data", 1, 4, wavfile);

tl = 0;

if (size)

tl = size - 44;

zfile_fwrite (&tl, 1, 4, wavfile);

}

static void convertsample (uae_u8 *sample, int len)

{

int i;

for (i = 0; i < len; i++)

sample[i] += 0x80;

}

static void namesplit (TCHAR *s)

{

int l;

l = uaetcslen(s) - 1;

while (l >= 0) {

if (s[l] == '.')

s[l] = 0;

if (s[l] == '\\' || s[l] == '/' || s[l] == ':' || s[l] == '?') {

l++;

break;

}

l--;

}

if (l > 0)

memmove (s, s + l, (_tcslen (s + l) + 1) * sizeof (TCHAR));

}

void audio_sampleripper (int mode)

{

struct ripped_sample *rs = ripped_samples;

int cnt = 1;

TCHAR path[MAX_DPATH], name[MAX_DPATH], filename[MAX_DPATH];

TCHAR underline[] = _T("_");

TCHAR extension[4];

struct zfile *wavfile;

if (mode < 0) {

while (rs) {

struct ripped_sample *next = rs->next;

xfree(rs);

rs = next;

}

ripped_samples = NULL;

return;

}

while (rs) {

if (rs->changed) {

int type = -1;

rs->changed = 0;

fetch_ripperpath (path, sizeof (path) / sizeof (TCHAR));

name[0] = 0;

if (currprefs.floppyslots[0].dfxtype >= 0) {

_tcscpy(name, currprefs.floppyslots[0].df);

type = PATH_FLOPPY;

} else if (currprefs.cdslots[0].inuse) {

_tcscpy(name, currprefs.cdslots[0].name);

type = PATH_CD;

}

if (!name[0])

underline[0] = 0;

if (type >= 0)

cfgfile_resolve_path_load(name, sizeof(name) / sizeof(TCHAR), type);

namesplit (name);

_tcscpy (extension, _T("wav"));

_stprintf (filename, _T("%s%s%s_%08x_%06x_%03d.%s"), path, name, underline, rs->pt, rs->len, cnt, extension);

wavfile = zfile_fopen (filename, _T("wb"), 0);

if (wavfile) {

int freq = rs->per > 0 ? (currprefs.ntscmode ? 3579545 : 3546895 / rs->per) : 8000;

write_wavheader (wavfile, 0, 0);

convertsample (rs->sample, rs->len);

zfile_fwrite (rs->sample, rs->len, 1, wavfile);

convertsample (rs->sample, rs->len);

write_wavheader (wavfile, zfile_ftell32(wavfile), freq);

zfile_fclose (wavfile);

write_log (_T("SAMPLERIPPER: %d: %dHz %d bytes\n"), cnt, freq, rs->len);

} else {

write_log (_T("SAMPLERIPPER: failed to open '%s'\n"), filename);

}

}

cnt++;

rs = rs->next;

}

}

static void do_samplerip (struct audio_channel_data *adp)

{

struct ripped_sample *rs = ripped_samples, *prev;

int len = adp->wlen * 2;

uae_u8 *smp = chipmem_xlate_indirect (adp->pt);

int cnt = 0, i;

if (!smp || !chipmem_check_indirect (adp->pt, len))

return;

for (i = 0; i < len; i++) {

if (smp[i] != 0)

break;

}

if (i == len || len <= 2)

return;

prev = NULL;

while(rs) {

if (rs->sample) {

if (len == rs->len && !memcmp (rs->sample, smp, len))

break;

/* replace old identical but shorter sample */

if (len > rs->len && !memcmp (rs->sample, smp, rs->len)) {

xfree (rs->sample);

rs->sample = xmalloc (uae_u8, len);

memcpy (rs->sample, smp, len);

write_log (_T("SAMPLERIPPER: replaced sample %d (%d -> %d)\n"), cnt, rs->len, len);

rs->pt = adp->pt;

rs->len = len;

rs->per = adp->per / CYCLE_UNIT;

rs->changed = 1;

audio_sampleripper (0);

return;

}

}

prev = rs;

rs = rs->next;

cnt++;

}

if (rs || cnt > 100)

return;

rs = xmalloc (struct ripped_sample ,1);

if (prev)

prev->next = rs;

else

ripped_samples = rs;

rs->pt = adp->pt;

rs->len = len;

rs->per = adp->per / CYCLE_UNIT;

rs->sample = xmalloc (uae_u8, len);

memcpy (rs->sample, smp, len);

rs->next = NULL;

rs->changed = 1;

write_log (_T("SAMPLERIPPER: sample added (%06X, %d bytes), total %d samples\n"), adp->pt, len, ++cnt);

audio_sampleripper (0);

}

static struct audio_channel_data audio_channel[AUDIO_CHANNELS_PAULA];

static struct audio_stream_data audio_stream[AUDIO_CHANNEL_STREAMS];

static struct audio_channel_data2 *audio_data[AUDIO_CHANNELS_PAULA + AUDIO_CHANNEL_STREAMS * AUDIO_CHANNEL_MAX_STREAM_CH];

int sound_available = 0;

void (*sample_handler) (void);

static void(*sample_prehandler) (unsigned long best_evtime);

static void(*extra_sample_prehandler) (unsigned long best_evtime);

float sample_evtime;

float scaled_sample_evtime;

int sound_cd_volume[2];

int sound_paula_volume[2];

static evt_t last_cycles;

static float next_sample_evtime;

static int previous_volcnt_update;

typedef uae_s8 sample8_t;

#define DO_CHANNEL_1(v, c) do { (v) *= audio_channel[c].data.mixvol; } while (0)

#define SBASEVAL16(logn) ((logn) == 1 ? SOUND16_BASE_VAL >> 1 : SOUND16_BASE_VAL)

STATIC_INLINE int FINISH_DATA (int data, int bits, int ch)

{

if (bits < 16) {

int shift = 16 - bits;

data <<= shift;

} else {

int shift = bits - 16;

data >>= shift;

}

data = data * sound_paula_volume[ch] / 32768;

return data;

}

static uae_u32 right_word_saved[SOUND_MAX_DELAY_BUFFER];

static uae_u32 left_word_saved[SOUND_MAX_DELAY_BUFFER];

static uae_u32 right2_word_saved[SOUND_MAX_DELAY_BUFFER];

static uae_u32 left2_word_saved[SOUND_MAX_DELAY_BUFFER];

static int saved_ptr, saved_ptr2;

static int mixed_on, mixed_stereo_size, mixed_mul1, mixed_mul2;

static int led_filter_forced, sound_use_filter, sound_use_filter_sinc, led_filter_on;

#define PAULARATE 3740000

static float Sinc(float x)

{

return x ? sinf(x) / x : 1;

}

static float Hamming(float x)

{

float pi = 4 * atanf(1);

float v;

if (x > -1 && x < 1)

v = cosf(x * pi / 2);

else

v = 0;

return v * v;

}

static void makefir(void)

{

float pi = 4 * atanf(1);

float *FIRTable = firmem + FIR_WIDTH;

float yscale = float(currprefs.sound_freq) / float(PAULARATE);

float xscale = pi * yscale;

for (int i = -FIR_WIDTH; i <= FIR_WIDTH; i++)

FIRTable[i] = yscale * Sinc(float(i) * xscale) * Hamming(float(i) / float(FIR_WIDTH - 1));

}

/* denormals are very small floating point numbers that force FPUs into slow

mode. All lowpass filters using floats are suspectible to denormals unless

a small offset is added to avoid very small floating point numbers. */

#define DENORMAL_OFFSET (1E-10)

static struct filter_state {

float rc1, rc2, rc3, rc4, rc5;

} sound_filter_state[AUDIO_CHANNELS_PAULA];

static float a500e_filter1_a0;

static float a500e_filter2_a0;

static float filter_a0; /* a500 and a1200 use the same */

enum {

FILTER_NONE = 0,

FILTER_MODEL_A500,

FILTER_MODEL_A1200,

FILTER_MODEL_A500_FIXEDONLY

};

/* Amiga has two separate filtering circuits per channel, a static RC filter

* on A500 and the LED filter. This code emulates both.

*

* The Amiga filtering circuitry depends on Amiga model. Older Amigas seem

* to have a 6 dB/oct RC filter with cutoff frequency such that the -6 dB

* point for filter is reached at 6 kHz, while newer Amigas have no filtering.

*

* The LED filter is complicated, and we are modelling it with a pair of

* RC filters, the other providing a highboost. The LED starts to cut

* into signal somewhere around 5-6 kHz, and there's some kind of highboost

* in effect above 12 kHz. Better measurements are required.

*

* The current filtering should be accurate to 2 dB with the filter on,

* and to 1 dB with the filter off.

*/

static int filter (int input, struct filter_state *fs)

{

int o;

float normal_output, led_output;

input = (uae_s16)input;

switch (sound_use_filter) {

case FILTER_MODEL_A500:

fs->rc1 = (float)(a500e_filter1_a0 * input + (1.0f - a500e_filter1_a0) * fs->rc1 + DENORMAL_OFFSET);

fs->rc2 = a500e_filter2_a0 * fs->rc1 + (1.0f - a500e_filter2_a0) * fs->rc2;

normal_output = fs->rc2;

fs->rc3 = filter_a0 * normal_output + (1 - filter_a0) * fs->rc3;

fs->rc4 = filter_a0 * fs->rc3 + (1 - filter_a0) * fs->rc4;

fs->rc5 = filter_a0 * fs->rc4 + (1 - filter_a0) * fs->rc5;

led_output = fs->rc5;

break;

case FILTER_MODEL_A500_FIXEDONLY:

fs->rc1 = (float)(a500e_filter1_a0 * input + (1.0f - a500e_filter1_a0) * fs->rc1 + DENORMAL_OFFSET);

fs->rc2 = a500e_filter2_a0 * fs->rc1 + (1.0f - a500e_filter2_a0) * fs->rc2;

normal_output = fs->rc2;

led_output = fs->rc2;

break;

case FILTER_MODEL_A1200:

normal_output = (float)input;

fs->rc2 = (float)(filter_a0 * normal_output + (1 - filter_a0) * fs->rc2 + DENORMAL_OFFSET);

fs->rc3 = filter_a0 * fs->rc2 + (1 - filter_a0) * fs->rc3;

fs->rc4 = filter_a0 * fs->rc3 + (1 - filter_a0) * fs->rc4;

led_output = fs->rc4;

break;

case FILTER_NONE:

default:

return input;

}

if (led_filter_on)

o = (int)led_output;

else

o = (int)normal_output;

if (o > 32767)

o = 32767;

else if (o < -32768)

o = -32768;

return o;

}

/* Always put the right word before the left word. */

static void put_sound_word_right (uae_u32 w)

{

if (mixed_on) {

right_word_saved[saved_ptr] = w;

return;

}

PUT_SOUND_WORD(w);

}

static void put_sound_word_left (uae_u32 w)

{

if (mixed_on) {

uae_u32 rold, lold, rnew, lnew, tmp;

left_word_saved[saved_ptr] = w;

lnew = w - SOUND16_BASE_VAL;

rnew = right_word_saved[saved_ptr] - SOUND16_BASE_VAL;

saved_ptr = (saved_ptr + 1) & mixed_stereo_size;

lold = left_word_saved[saved_ptr] - SOUND16_BASE_VAL;

tmp = (rnew * mixed_mul2 + lold * mixed_mul1) / MIXED_STEREO_SCALE;

tmp += SOUND16_BASE_VAL;

rold = right_word_saved[saved_ptr] - SOUND16_BASE_VAL;

w = (lnew * mixed_mul2 + rold * mixed_mul1) / MIXED_STEREO_SCALE;

PUT_SOUND_WORD(tmp);

PUT_SOUND_WORD(w);

} else {

PUT_SOUND_WORD(w);

}

}

static void put_sound_word_right2 (uae_u32 w)

{

if (mixed_on) {

right2_word_saved[saved_ptr2] = w;

return;

}

PUT_SOUND_WORD(w);

}

static void put_sound_word_left2 (uae_u32 w)

{

if (mixed_on) {

uae_u32 rold, lold, rnew, lnew, tmp;

left2_word_saved[saved_ptr2] = w;

lnew = w - SOUND16_BASE_VAL;

rnew = right2_word_saved[saved_ptr2] - SOUND16_BASE_VAL;

saved_ptr2 = (saved_ptr2 + 1) & mixed_stereo_size;

lold = left2_word_saved[saved_ptr2] - SOUND16_BASE_VAL;

tmp = (rnew * mixed_mul2 + lold * mixed_mul1) / MIXED_STEREO_SCALE;

tmp += SOUND16_BASE_VAL;

rold = right2_word_saved[saved_ptr2] - SOUND16_BASE_VAL;

w = (lnew * mixed_mul2 + rold * mixed_mul1) / MIXED_STEREO_SCALE;

PUT_SOUND_WORD(tmp);

PUT_SOUND_WORD(w);

} else {

PUT_SOUND_WORD(w);

}

}

static void anti_prehandler (unsigned long best_evtime)

{

/* Handle accumulator antialiasing */

for (int i = 0; audio_data[i]; i++) {

struct audio_channel_data2 *acd = audio_data[i];

int vol = acd->mixvol;

int output = (acd->current_sample *vol) & acd->adk_mask;

acd->sample_accum += output * best_evtime;

acd->sample_accum_time += best_evtime;

}

}

static void samplexx_anti_handler (int *datasp, int ch_start, int ch_num)

{

for (int i = ch_start, j = 0; j < ch_num; i++, j++) {

struct audio_channel_data2 *acd = audio_data[i];

int v = acd->sample_accum_time ? (acd->sample_accum / acd->sample_accum_time) : 0;

acd->sample_accum = 0;

acd->sample_accum_time = 0;

if (v > 32767)

v = 32767;

else if (v < -32768)

v = -32768;

datasp[j] = v;

}

}

static void sinc_prehandler_paula (unsigned long best_evtime)

{

for (int i = 0; i < AUDIO_CHANNELS_PAULA; i++) {

struct audio_channel_data2 *acd = audio_data[i];

int vol = acd->mixvol;

int output = (acd->current_sample * vol) & acd->adk_mask;

/* if output state changes, record the state change and also

* write data into sinc queue for mixing in the BLEP */

if (acd->sinc_output_state != output) {

acd->sinc_queue_head = (acd->sinc_queue_head - 1) & (SINC_QUEUE_LENGTH - 1);

acd->sinc_queue[acd->sinc_queue_head].time = acd->sinc_queue_time;

acd->sinc_queue[acd->sinc_queue_head].output = output - acd->sinc_output_state;

acd->sinc_output_state = output;

}

acd->sinc_queue_time += best_evtime;

}

}

/* this interpolator performs BLEP mixing (bleps are shaped like integrated sinc

* functions) with a type of BLEP that matches the filtering configuration. */

static void samplexx_sinc_handler (int *datasp, int ch_start, int ch_num)

{

int n, i, k;

int const *winsinc;

if (sound_use_filter_sinc && ch_start == 0) {

n = (sound_use_filter_sinc == FILTER_MODEL_A500 || sound_use_filter_sinc == FILTER_MODEL_A500_FIXEDONLY) ? 0 : 2;

if (led_filter_on)

n += 1;

} else {

n = 4;

}

winsinc = winsinc_integral[n];

for (i = ch_start, k = 0; k < ch_num; i++, k++) {

int j, v;

struct audio_channel_data2 *acd = audio_data[i];

/* The sum rings with harmonic components up to infinity... */

int sum = acd->sinc_output_state << 17;

/* ...but we cancel them through mixing in BLEPs instead */

int offsetpos = acd->sinc_queue_head & (SINC_QUEUE_LENGTH - 1);

for (j = 0; j < SINC_QUEUE_LENGTH; j += 1) {

int age = acd->sinc_queue_time - acd->sinc_queue[offsetpos].time;

if (age >= SINC_QUEUE_MAX_AGE || age < 0)

break;

sum -= winsinc[age] * acd->sinc_queue[offsetpos].output;

offsetpos = (offsetpos + 1) & (SINC_QUEUE_LENGTH - 1);

}

v = sum >> 15;

if (v > 32767)

v = 32767;

else if (v < -32768)

v = -32768;

datasp[k] = v;

}

}

static void do_filter(int *data, int num)

{

if (currprefs.sound_filter)

*data = filter(*data, &sound_filter_state[num]);

}

static void get_extra_channels(int *data1, int *data2, int sample1, int sample2)

{

int d1 = *data1 + sample1;

int d2 = (data2 ? *data2 : 0) + sample2;

if (d1 < -32768)

d1 = -32768;

if (d1 > 32767)

d1 = 32767;

if (d2 < -32768)

d2 = -32768;

if (d2 > 32767)

d2 = 32767;

int needswap = currprefs.sound_stereo_swap_paula ^ currprefs.sound_stereo_swap_ahi;

if (needswap) {

*data1 = d2;

if (data2)

*data2 = d1;

} else {

*data1 = d1;

if (data2)

*data2 = d2;

}

}

static void do_extra_channels(int idx, int ch, int *data1, int *data2, int *data3, int *data4, int *data5, int *data6)

{

idx += AUDIO_CHANNELS_PAULA;

if (ch == 2) {

int datas[2];

samplexx_anti_handler(datas, idx, 2);

get_extra_channels(data1, data2, datas[0], datas[1]);

} else if (ch == 1) {

int datas[1];

samplexx_anti_handler(datas, idx, 1);

int d1 = *data1 + datas[0];

if (d1 < -32768)

d1 = -32768;

if (d1 > 32767)

d1 = 32767;

*data1 = d1;

if (data2)

*data2 = d1;

} else if (ch > 2) {

int datas[AUDIO_CHANNEL_MAX_STREAM_CH];

samplexx_anti_handler(datas, idx, 6);

get_extra_channels(data1, data2, datas[0], datas[1]);

if (data3 && data4)

get_extra_channels(data3, data4, datas[2], datas[3]);

if (data5 && data6)

get_extra_channels(data5, data6, datas[4], datas[5]);

}

}

static void get_extra_channels_sample2(int *data1, int *data2, int mode)

{

if (!audio_total_extra_streams)

return;

int idx = 0;

for (int i = 0; i < AUDIO_CHANNEL_STREAMS; i++) {

int ch = audio_extra_streams[i];

if (ch) {

do_extra_channels(idx, ch, data1, data2, NULL, NULL, NULL, NULL);

idx += ch;

}

}

}

static void get_extra_channels_sample6(int *data1, int *data2, int *data3, int *data4, int *data5, int *data6, int mode)

{

if (!audio_total_extra_streams)

return;

int idx = 0;

for (int i = 0; i < AUDIO_CHANNEL_STREAMS; i++) {

int ch = audio_extra_streams[i];

if (ch) {

do_extra_channels(idx, ch, data1, data2, data3, data4, data5, data6);

idx += ch;

}

}

}

static void set_sound_buffers(void)

{

#if SOUNDSTUFF > 1

paula_sndbufpt_prev = paula_sndbufpt_start;

paula_sndbufpt_start = paula_sndbufpt;

#endif

}

static void clear_sound_buffers(void)

{

memset(paula_sndbuffer, 0, paula_sndbufsize);

paula_sndbufpt = paula_sndbuffer;

}

static void check_sound_buffers(void)

{

#if SOUNDSTUFF > 1

int len;

#endif

#ifdef DRIVESOUND

uae_s16 *bufp = (uae_s16*)paula_sndbufpt - 2;

#endif

if (active_sound_stereo == SND_4CH_CLONEDSTEREO) {

((uae_u16*)paula_sndbufpt)[0] = ((uae_u16*)paula_sndbufpt)[-2];

((uae_u16*)paula_sndbufpt)[1] = ((uae_u16*)paula_sndbufpt)[-1];

paula_sndbufpt = (uae_u16*)(((uae_u8*)paula_sndbufpt) + 2 * 2);

} else if (active_sound_stereo == SND_6CH_CLONEDSTEREO) {

uae_s16 *p = ((uae_s16*)paula_sndbufpt);

uae_s32 sum;

p[2] = p[-2];

p[3] = p[-1];

sum = (uae_s32)(p[-2]) + (uae_s32)(p[-1]) + (uae_s32)(p[2]) + (uae_s32)(p[3]);

p[0] = sum / 8;

p[1] = sum / 8;

paula_sndbufpt = (uae_u16*)(((uae_u8*)paula_sndbufpt) + 4 * 2);

} else if (active_sound_stereo == SND_8CH_CLONEDSTEREO) {

uae_s16 *p = ((uae_s16*)paula_sndbufpt);

uae_s32 sum;

p[2] = p[-2];

p[3] = p[-1];

p[4] = p[-2];

p[5] = p[-1];

sum = (uae_s32)(p[-2]) + (uae_s32)(p[-1]) + (uae_s32)(p[2]) + (uae_s32)(p[3]);

p[0] = sum / 8;

p[1] = sum / 8;

paula_sndbufpt = (uae_u16*)(((uae_u8*)paula_sndbufpt) + 6 * 2);

}

#ifdef DRIVESOUND

if (driveclick_wave_initialized) {

driveclick_mix(bufp, active_sound_stereo, currprefs.dfxclickchannelmask);

}

#endif

#if SOUNDSTUFF > 1

if (outputsample == 0)

return;

len = paula_sndbufpt - paula_sndbufpt_start;

if (outputsample < 0) {

int i;

uae_s16 *p1 = (uae_s16 *)paula_sndbufpt_prev;

uae_s16 *p2 = (uae_s16 *)paula_sndbufpt_start;

for (i = 0; i < len; i++) {

*p1 = (*p1 + *p2) / 2;

}

paula_sndbufpt = paula_sndbufpt_start;

}

#endif

#if SOUND_MODE_NG

if ((uae_u8*)paula_sndbufpt - (uae_u8*)paula_sndbuffer >= paula_sndbufsize * 2) {

paula_sndbufpt = paula_sndbuffer;

}

#else

if ((uae_u8*)paula_sndbufpt - (uae_u8*)paula_sndbuffer >= paula_sndbufsize) {

finish_sound_buffer();

}

#endif

#if SOUNDSTUFF > 1

while (doublesample-- > 0) {

memcpy(paula_sndbufpt, paula_sndbufpt_start, len * 2);

paula_sndbufpt += len;

if ((uae_u8 *)paula_sndbufpt - (uae_u8 *)paula_sndbuffer >= paula_sndbufsize) {

finish_sound_buffer();

paula_sndbufpt = paula_sndbuffer;

}

}

#endif

}

static void sample16i_sinc_handler (void)

{

int datas[AUDIO_CHANNELS_PAULA], data1;

samplexx_sinc_handler (datas, 0, AUDIO_CHANNELS_PAULA);

data1 = datas[0] + datas[3] + datas[1] + datas[2];

data1 = FINISH_DATA (data1, 18, 0);

do_filter(&data1, 0);

get_extra_channels_sample2(&data1, NULL, 2);

set_sound_buffers ();

PUT_SOUND_WORD_MONO (data1);

check_sound_buffers ();

}

void sample16_handler (void)

{

int data0 = audio_channel[0].data.current_sample;

int data1 = audio_channel[1].data.current_sample;

int data2 = audio_channel[2].data.current_sample;

int data3 = audio_channel[3].data.current_sample;

int data;

DO_CHANNEL_1 (data0, 0);

DO_CHANNEL_1 (data1, 1);

DO_CHANNEL_1 (data2, 2);

DO_CHANNEL_1 (data3, 3);

data0 &= audio_channel[0].data.adk_mask;

data1 &= audio_channel[1].data.adk_mask;

data2 &= audio_channel[2].data.adk_mask;

data3 &= audio_channel[3].data.adk_mask;

data0 += data1;

data0 += data2;

data0 += data3;

data = SBASEVAL16(2) + data0;

data = FINISH_DATA (data, 16, 0);

do_filter(&data, 0);

get_extra_channels_sample2(&data, NULL, 0);

set_sound_buffers ();

PUT_SOUND_WORD_MONO (data);

check_sound_buffers ();

}

/* This interpolator examines sample points when Paula switches the output

* voltage and computes the average of Paula's output */

static void sample16i_anti_handler (void)

{

int datas[AUDIO_CHANNELS_PAULA], data1;

samplexx_anti_handler (datas, 0, AUDIO_CHANNELS_PAULA);

data1 = datas[0] + datas[3] + datas[1] + datas[2];

data1 = FINISH_DATA (data1, 16, 0);

do_filter(&data1, 0);

get_extra_channels_sample2(&data1, NULL, 1);

set_sound_buffers ();

PUT_SOUND_WORD_MONO (data1);

check_sound_buffers ();

}

static void sample16i_rh_handler (void)

{

unsigned long delta, ratio;

int data0 = audio_channel[0].data.current_sample;

int data1 = audio_channel[1].data.current_sample;

int data2 = audio_channel[2].data.current_sample;

int data3 = audio_channel[3].data.current_sample;

int data0p = audio_channel[0].data.last_sample;

int data1p = audio_channel[1].data.last_sample;

int data2p = audio_channel[2].data.last_sample;

int data3p = audio_channel[3].data.last_sample;

int data;

DO_CHANNEL_1 (data0, 0);

DO_CHANNEL_1 (data1, 1);

DO_CHANNEL_1 (data2, 2);

DO_CHANNEL_1 (data3, 3);

DO_CHANNEL_1 (data0p, 0);

DO_CHANNEL_1 (data1p, 1);

DO_CHANNEL_1 (data2p, 2);

DO_CHANNEL_1 (data3p, 3);

data0 &= audio_channel[0].data.adk_mask;

data0p &= audio_channel[0].data.adk_mask;

data1 &= audio_channel[1].data.adk_mask;

data1p &= audio_channel[1].data.adk_mask;

data2 &= audio_channel[2].data.adk_mask;

data2p &= audio_channel[2].data.adk_mask;

data3 &= audio_channel[3].data.adk_mask;

data3p &= audio_channel[3].data.adk_mask;

/* linear interpolation and summing up... */

delta = audio_channel[0].per;

ratio = ((audio_channel[0].evtime % delta) << 8) / delta;

data0 = (data0 * (256 - ratio) + data0p * ratio) >> 8;

delta = audio_channel[1].per;

ratio = ((audio_channel[1].evtime % delta) << 8) / delta;

data0 += (data1 * (256 - ratio) + data1p * ratio) >> 8;

delta = audio_channel[2].per;

ratio = ((audio_channel[2].evtime % delta) << 8) / delta;

data0 += (data2 * (256 - ratio) + data2p * ratio) >> 8;

delta = audio_channel[3].per;

ratio = ((audio_channel[3].evtime % delta) << 8) / delta;

data0 += (data3 * (256 - ratio) + data3p * ratio) >> 8;

data = SBASEVAL16(2) + data0;

data = FINISH_DATA (data, 16, 0);

do_filter(&data, 0);

get_extra_channels_sample2(&data, NULL, 0);

set_sound_buffers ();

PUT_SOUND_WORD_MONO (data);

check_sound_buffers ();

}

static void sample16i_crux_handler (void)

{

int data0 = audio_channel[0].data.current_sample;

int data1 = audio_channel[1].data.current_sample;

int data2 = audio_channel[2].data.current_sample;

int data3 = audio_channel[3].data.current_sample;

int data0p = audio_channel[0].data.last_sample;

int data1p = audio_channel[1].data.last_sample;

int data2p = audio_channel[2].data.last_sample;

int data3p = audio_channel[3].data.last_sample;

int data;

DO_CHANNEL_1 (data0, 0);

DO_CHANNEL_1 (data1, 1);

DO_CHANNEL_1 (data2, 2);

DO_CHANNEL_1 (data3, 3);

DO_CHANNEL_1 (data0p, 0);

DO_CHANNEL_1 (data1p, 1);

DO_CHANNEL_1 (data2p, 2);

DO_CHANNEL_1 (data3p, 3);

data0 &= audio_channel[0].data.adk_mask;

data0p &= audio_channel[0].data.adk_mask;

data1 &= audio_channel[1].data.adk_mask;

data1p &= audio_channel[1].data.adk_mask;

data2 &= audio_channel[2].data.adk_mask;

data2p &= audio_channel[2].data.adk_mask;

data3 &= audio_channel[3].data.adk_mask;