--- uae/src/audio.c 2018/04/24 16:39:49 1.1.1.1 +++ uae/src/audio.c 2018/04/24 17:12:19 1.1.1.14 @@ -15,41 +15,31 @@ #include "options.h" #include "memory.h" #include "custom.h" +#include "newcpu.h" +#include "autoconf.h" #include "gensound.h" #include "sounddep/sound.h" #include "events.h" #include "audio.h" +#include "savestate.h" -#undef BENCHMARK_AUDIO - -#ifdef BENCHMARK_AUDIO - -#define BEGIN_BENCH frame_time_t audbench = read_processor_time (); -#define END_BENCH sh_time += read_processor_time () - audbench; sh_count++; -static frame_time_t sh_time = 0; -unsigned long sh_count = 0; - -#else - -#define BEGIN_BENCH -#define END_BENCH - -#endif - +struct audio_channel_data audio_channel[4]; int sound_available = 0; +int sound_table[64][256]; +void (*sample_handler) (void); -struct audio_channel_data audio_channel[4]; +unsigned long sample_evtime, scaled_sample_evtime; +int scaled_sample_evtime_ok; -int sound_table[64][256]; -unsigned long int sample_evtime; +static unsigned long last_cycles, next_sample_evtime; -void init_sound_table16(void) +void init_sound_table16 (void) { int i,j; for (i = 0; i < 256; i++) for (j = 0; j < 64; j++) - sound_table[j][i] = j * (uae_s8)i * (currprefs.stereo ? 2 : 1); + sound_table[j][i] = j * (uae_s8)i * (currprefs.sound_stereo ? 2 : 1); } void init_sound_table8 (void) @@ -58,44 +48,9 @@ void init_sound_table8 (void) for (i = 0; i < 256; i++) for (j = 0; j < 64; j++) - sound_table[j][i] = (j * (uae_s8)i * (currprefs.stereo ? 2 : 1)) / 256; -} - -void AUDxDAT(int nr, uae_u16 v) -{ - struct audio_channel_data *cdp = audio_channel + nr; - cdp->dat = v; - if (cdp->state == 0 && !(INTREQR() & (0x80 << nr))) { - cdp->state = 2; - INTREQ(0x8000 | (0x80 << nr)); - /* data_written = 2 ???? */ - eventtab[ev_aud0 + nr].evtime = cycles + cdp->per; - eventtab[ev_aud0 + nr].oldcycles = cycles; - eventtab[ev_aud0 + nr].active = 1; - events_schedule(); - } + sound_table[j][i] = (j * (uae_s8)i * (currprefs.sound_stereo ? 2 : 1)) / 256; } -void AUDxLCH(int nr, uae_u16 v) { audio_channel[nr].lc = (audio_channel[nr].lc & 0xffff) | ((uae_u32)v << 16); } -void AUDxLCL(int nr, uae_u16 v) { audio_channel[nr].lc = (audio_channel[nr].lc & ~0xffff) | (v & 0xFFFE); } -void AUDxPER(int nr, uae_u16 v) -{ - if (v <= 0) { -#if 0 /* v == 0 is rather common, and harmless, and the value isn't signed anyway */ - static int warned = 0; - if (!warned) - write_log ("Broken program accessing the sound hardware\n"), warned++; -#endif - v = 65535; - } - if (v < maxhpos/2 && currprefs.produce_sound < 3) - v = maxhpos/2; - - audio_channel[nr].per = v; -} - -void AUDxLEN(int nr, uae_u16 v) { audio_channel[nr].len = v; } - #define MULTIPLICATION_PROFITABLE #ifdef MULTIPLICATION_PROFITABLE @@ -103,7 +58,7 @@ typedef uae_s8 sample8_t; #define DO_CHANNEL_1(v, c) do { (v) *= audio_channel[c].vol; } while (0) #define SBASEVAL8(logn) ((logn) == 1 ? SOUND8_BASE_VAL << 7 : SOUND8_BASE_VAL << 8) #define SBASEVAL16(logn) ((logn) == 1 ? SOUND16_BASE_VAL >> 1 : SOUND16_BASE_VAL) -#define FINISH_DATA(b,logn) do { if (14 - (b) + (logn) > 0) data >>= 14 - (b) + (logn); else data <<= (b) - 14 - (logn); } while (0); +#define FINISH_DATA(data,b,logn) do { if (14 - (b) + (logn) > 0) (data) >>= 14 - (b) + (logn); else (data) <<= (b) - 14 - (logn); } while (0); #else typedef uae_u8 sample8_t; #define DO_CHANNEL_1(v, c) do { (v) = audio_channel[c].voltbl[(v)]; } while (0) @@ -112,22 +67,47 @@ typedef uae_u8 sample8_t; #define FINISH_DATA(b,logn) #endif -void AUDxVOL(int nr, uae_u16 v) +/* Always put the right word before the left word. */ +#define DELAY_BUFFER 32 +static uae_u32 right_word_saved[DELAY_BUFFER]; +static uae_u32 left_word_saved[DELAY_BUFFER]; +static int saved_ptr; + +STATIC_INLINE void put_sound_word_right (uae_u32 w) { - int v2 = v & 64 ? 63 : v & 63; - audio_channel[nr].vol = v2; -#ifndef MULTIPLICATION_PROFITABLE - audio_channel[nr].voltbl = sound_table[v2]; -#endif + if (currprefs.mixed_stereo) { + right_word_saved[saved_ptr] = w; + return; + } + + PUT_SOUND_WORD_RIGHT (w); +} + +STATIC_INLINE void put_sound_word_left (uae_u32 w) +{ + if (currprefs.mixed_stereo) { + 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) & (DELAY_BUFFER - 1); + lold = left_word_saved[saved_ptr] - SOUND16_BASE_VAL; + tmp = (rnew * 5 + lold * 3) >> 3; + tmp += SOUND16_BASE_VAL; + PUT_SOUND_WORD_RIGHT (tmp); + + rold = right_word_saved[saved_ptr] - SOUND16_BASE_VAL; + w = (lnew * 5 + rold * 3) >> 3; + } + PUT_SOUND_WORD_LEFT (w); } #define DO_CHANNEL(v, c) do { (v) &= audio_channel[c].adk_mask; data += v; } while (0); -/* Templates! I want templates! */ -void sample16_handler(void) +void sample16_handler (void) { - BEGIN_BENCH - uae_u32 data0 = audio_channel[0].current_sample; uae_u32 data1 = audio_channel[1].current_sample; uae_u32 data2 = audio_channel[2].current_sample; @@ -145,21 +125,138 @@ void sample16_handler(void) data0 += data3; { uae_u32 data = SBASEVAL16(2) + data0; - FINISH_DATA(16, 2); + FINISH_DATA (data, 16, 2); + PUT_SOUND_WORD (data); + } + check_sound_buffers (); +} + +void sample16i_rh_handler (void) +{ + unsigned long delta, ratio; + + uae_u32 data0 = audio_channel[0].current_sample; + uae_u32 data1 = audio_channel[1].current_sample; + uae_u32 data2 = audio_channel[2].current_sample; + uae_u32 data3 = audio_channel[3].current_sample; + uae_u32 data0p = audio_channel[0].last_sample; + uae_u32 data1p = audio_channel[1].last_sample; + uae_u32 data2p = audio_channel[2].last_sample; + uae_u32 data3p = audio_channel[3].last_sample; + 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].adk_mask; + data0p &= audio_channel[0].adk_mask; + data1 &= audio_channel[1].adk_mask; + data1p &= audio_channel[1].adk_mask; + data2 &= audio_channel[2].adk_mask; + data2p &= audio_channel[2].adk_mask; + data3 &= audio_channel[3].adk_mask; + data3p &= audio_channel[3].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; + + { + uae_u32 data = SBASEVAL16(2) + data0; + FINISH_DATA (data, 16, 2); PUT_SOUND_WORD (data); } - END_BENCH check_sound_buffers (); +} + +void sample16i_crux_handler (void) +{ + uae_u32 data0 = audio_channel[0].current_sample; + uae_u32 data1 = audio_channel[1].current_sample; + uae_u32 data2 = audio_channel[2].current_sample; + uae_u32 data3 = audio_channel[3].current_sample; + uae_u32 data0p = audio_channel[0].last_sample; + uae_u32 data1p = audio_channel[1].last_sample; + uae_u32 data2p = audio_channel[2].last_sample; + uae_u32 data3p = audio_channel[3].last_sample; + 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); - eventtab[ev_sample].evtime = cycles + sample_evtime; - eventtab[ev_sample].oldcycles = cycles; + data0 &= audio_channel[0].adk_mask; + data0p &= audio_channel[0].adk_mask; + data1 &= audio_channel[1].adk_mask; + data1p &= audio_channel[1].adk_mask; + data2 &= audio_channel[2].adk_mask; + data2p &= audio_channel[2].adk_mask; + data3 &= audio_channel[3].adk_mask; + data3p &= audio_channel[3].adk_mask; + + { + struct audio_channel_data *cdp; + unsigned long ratio, ratio1; +#define INTERVAL (scaled_sample_evtime * 3) + cdp = audio_channel + 0; + ratio1 = cdp->per - cdp->evtime; + ratio = (ratio1 << 12) / INTERVAL; + if (cdp->evtime < scaled_sample_evtime || ratio1 >= INTERVAL) + ratio = 4096; + data0 = (data0 * ratio + data0p * (4096 - ratio)) >> 12; + + cdp = audio_channel + 1; + ratio1 = cdp->per - cdp->evtime; + ratio = (ratio1 << 12) / INTERVAL; + if (cdp->evtime < scaled_sample_evtime || ratio1 >= INTERVAL) + ratio = 4096; + data1 = (data1 * ratio + data1p * (4096 - ratio)) >> 12; + + cdp = audio_channel + 2; + ratio1 = cdp->per - cdp->evtime; + ratio = (ratio1 << 12) / INTERVAL; + if (cdp->evtime < scaled_sample_evtime || ratio1 >= INTERVAL) + ratio = 4096; + data2 = (data2 * ratio + data2p * (4096 - ratio)) >> 12; + + cdp = audio_channel + 3; + ratio1 = cdp->per - cdp->evtime; + ratio = (ratio1 << 12) / INTERVAL; + if (cdp->evtime < scaled_sample_evtime || ratio1 >= INTERVAL) + ratio = 4096; + data3 = (data3 * ratio + data3p * (4096 - ratio)) >> 12; + } + data1 += data2; + data0 += data3; + data0 += data1; + { + uae_u32 data = SBASEVAL16(2) + data0; + FINISH_DATA (data, 16, 2); + PUT_SOUND_WORD (data); + } + check_sound_buffers (); } -void sample8_handler(void) +void sample8_handler (void) { - BEGIN_BENCH - uae_u32 data0 = audio_channel[0].current_sample; uae_u32 data1 = audio_channel[1].current_sample; uae_u32 data2 = audio_channel[2].current_sample; @@ -177,22 +274,16 @@ void sample8_handler(void) data0 += data3; { uae_u32 data = SBASEVAL8(2) + data0; - FINISH_DATA(8, 2); + FINISH_DATA (data, 8, 2); PUT_SOUND_BYTE (data); } - END_BENCH check_sound_buffers (); - - eventtab[ev_sample].evtime = cycles + sample_evtime; - eventtab[ev_sample].oldcycles = cycles; } #ifdef HAVE_STEREO_SUPPORT -void sample16s_handler(void) +void sample16s_handler (void) { - BEGIN_BENCH - uae_u32 data0 = audio_channel[0].current_sample; uae_u32 data1 = audio_channel[1].current_sample; uae_u32 data2 = audio_channel[2].current_sample; @@ -210,29 +301,157 @@ void sample16s_handler(void) data0 += data3; { uae_u32 data = SBASEVAL16(1) + data0; - FINISH_DATA (16, 1); - PUT_SOUND_WORD_RIGHT (data); + FINISH_DATA (data, 16, 1); + put_sound_word_right (data); } data1 += data2; { - uae_u32 data = SBASEVAL16(1) + data1; - FINISH_DATA (16, 1); - PUT_SOUND_WORD_LEFT (data); + uae_u32 data = SBASEVAL16(1) + data1; + FINISH_DATA (data, 16, 1); + put_sound_word_left (data); } - - END_BENCH - + check_sound_buffers (); +} + +void sample16si_crux_handler (void) +{ + uae_u32 data0 = audio_channel[0].current_sample; + uae_u32 data1 = audio_channel[1].current_sample; + uae_u32 data2 = audio_channel[2].current_sample; + uae_u32 data3 = audio_channel[3].current_sample; + uae_u32 data0p = audio_channel[0].last_sample; + uae_u32 data1p = audio_channel[1].last_sample; + uae_u32 data2p = audio_channel[2].last_sample; + uae_u32 data3p = audio_channel[3].last_sample; + + 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].adk_mask; + data0p &= audio_channel[0].adk_mask; + data1 &= audio_channel[1].adk_mask; + data1p &= audio_channel[1].adk_mask; + data2 &= audio_channel[2].adk_mask; + data2p &= audio_channel[2].adk_mask; + data3 &= audio_channel[3].adk_mask; + data3p &= audio_channel[3].adk_mask; + + { + struct audio_channel_data *cdp; + unsigned long ratio, ratio1; +#define INTERVAL (scaled_sample_evtime * 3) + cdp = audio_channel + 0; + ratio1 = cdp->per - cdp->evtime; + ratio = (ratio1 << 12) / INTERVAL; + if (cdp->evtime < scaled_sample_evtime || ratio1 >= INTERVAL) + ratio = 4096; + data0 = (data0 * ratio + data0p * (4096 - ratio)) >> 12; + + cdp = audio_channel + 1; + ratio1 = cdp->per - cdp->evtime; + ratio = (ratio1 << 12) / INTERVAL; + if (cdp->evtime < scaled_sample_evtime || ratio1 >= INTERVAL) + ratio = 4096; + data1 = (data1 * ratio + data1p * (4096 - ratio)) >> 12; + + cdp = audio_channel + 2; + ratio1 = cdp->per - cdp->evtime; + ratio = (ratio1 << 12) / INTERVAL; + if (cdp->evtime < scaled_sample_evtime || ratio1 >= INTERVAL) + ratio = 4096; + data2 = (data2 * ratio + data2p * (4096 - ratio)) >> 12; + + cdp = audio_channel + 3; + ratio1 = cdp->per - cdp->evtime; + ratio = (ratio1 << 12) / INTERVAL; + if (cdp->evtime < scaled_sample_evtime || ratio1 >= INTERVAL) + ratio = 4096; + data3 = (data3 * ratio + data3p * (4096 - ratio)) >> 12; + } + data1 += data2; + data0 += data3; + { + uae_u32 data = SBASEVAL16 (1) + data0; + FINISH_DATA (data, 16, 1); + put_sound_word_right (data); + } - eventtab[ev_sample].evtime = cycles + sample_evtime; - eventtab[ev_sample].oldcycles = cycles; + { + uae_u32 data = SBASEVAL16 (1) + data1; + FINISH_DATA (data, 16, 1); + put_sound_word_left (data); + } + check_sound_buffers (); } -void sample8s_handler(void) +void sample16si_rh_handler (void) { - BEGIN_BENCH + unsigned long delta, ratio; + + uae_u32 data0 = audio_channel[0].current_sample; + uae_u32 data1 = audio_channel[1].current_sample; + uae_u32 data2 = audio_channel[2].current_sample; + uae_u32 data3 = audio_channel[3].current_sample; + uae_u32 data0p = audio_channel[0].last_sample; + uae_u32 data1p = audio_channel[1].last_sample; + uae_u32 data2p = audio_channel[2].last_sample; + uae_u32 data3p = audio_channel[3].last_sample; + + 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].adk_mask; + data0p &= audio_channel[0].adk_mask; + data1 &= audio_channel[1].adk_mask; + data1p &= audio_channel[1].adk_mask; + data2 &= audio_channel[2].adk_mask; + data2p &= audio_channel[2].adk_mask; + data3 &= audio_channel[3].adk_mask; + data3p &= audio_channel[3].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; + data1 = (data1 * (256 - ratio) + data1p * ratio) >> 8; + delta = audio_channel[2].per; + ratio = ((audio_channel[2].evtime % delta) << 8) / delta; + data1 += (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; + { + uae_u32 data = SBASEVAL16 (1) + data0; + FINISH_DATA (data, 16, 1); + put_sound_word_right (data); + } + + { + uae_u32 data = SBASEVAL16 (1) + data1; + FINISH_DATA (data, 16, 1); + put_sound_word_left (data); + } + check_sound_buffers (); +} + +void sample8s_handler (void) +{ uae_u32 data0 = audio_channel[0].current_sample; uae_u32 data1 = audio_channel[1].current_sample; uae_u32 data2 = audio_channel[2].current_sample; @@ -250,35 +469,38 @@ void sample8s_handler(void) data0 += data3; { uae_u32 data = SBASEVAL8(1) + data0; - FINISH_DATA (8, 1); + FINISH_DATA (data, 8, 1); PUT_SOUND_BYTE_RIGHT (data); } data1 += data2; { uae_u32 data = SBASEVAL8(1) + data1; - FINISH_DATA (8, 1); + FINISH_DATA (data, 8, 1); PUT_SOUND_BYTE_LEFT (data); } - END_BENCH - check_sound_buffers (); - - eventtab[ev_sample].evtime = cycles + sample_evtime; - eventtab[ev_sample].oldcycles = cycles; } #else -void sample8s_handler(void) +void sample8s_handler (void) { sample8_handler(); } -void sample16s_handler(void) +void sample16s_handler (void) { sample16_handler(); } +void sample16si_crux_handler (void) +{ + sample16i_crux_handler(); +} +void sample16si_rh_handler (void) +{ + sample16i_rh_handler(); +} #endif -static uae_u8 int2ulaw(int ch) +static uae_u8 int2ulaw (int ch) { int mask; @@ -317,9 +539,6 @@ void sample_ulaw_handler (void) int nr; uae_u32 data = 0; - eventtab[ev_sample].evtime += cycles - eventtab[ev_sample].oldcycles; - eventtab[ev_sample].oldcycles = cycles; - for (nr = 0; nr < 4; nr++) { if (!(adkcon & (0x11 << nr))) { uae_u32 d = audio_channel[nr].current_sample; @@ -331,25 +550,44 @@ void sample_ulaw_handler (void) check_sound_buffers (); } +void schedule_audio (void) +{ + unsigned long best = ~0ul; + int i; + + eventtab[ev_audio].active = 0; + eventtab[ev_audio].oldcycles = get_cycles (); + for (i = 0; i < 6; i++) { + struct audio_channel_data *cdp = audio_channel + i; + + if (cdp->state != 0) { + if (best > cdp->evtime) { + best = cdp->evtime; + eventtab[ev_audio].active = 1; + } + } + } + eventtab[ev_audio].evtime = get_cycles () + best; +} + static void audio_handler (int nr) { struct audio_channel_data *cdp = audio_channel + nr; switch (cdp->state) { case 0: - fprintf(stderr, "Bug in sound code\n"); + write_log ("Bug in sound code\n"); break; case 1: /* We come here at the first hsync after DMA was turned on. */ - eventtab[ev_aud0 + nr].evtime += maxhpos; - eventtab[ev_aud0 + nr].oldcycles += maxhpos; + cdp->evtime = maxhpos * CYCLE_UNIT; cdp->state = 5; INTREQ(0x8000 | (0x80 << nr)); if (cdp->wlen != 1) - cdp->wlen--; - cdp->nextdat = chipmem_bank.wget(cdp->pt); + cdp->wlen = (cdp->wlen - 1) & 0xFFFF; + cdp->nextdat = chipmem_wget (cdp->pt); cdp->pt += 2; break; @@ -357,11 +595,11 @@ static void audio_handler (int nr) case 5: /* We come here at the second hsync after DMA was turned on. */ if (currprefs.produce_sound == 0) - cdp->per = 65535; + cdp->per = PERIOD_MAX; - eventtab[ev_aud0 + nr].evtime = cycles + cdp->per; - eventtab[ev_aud0 + nr].oldcycles = cycles; + cdp->evtime = cdp->per; cdp->dat = cdp->nextdat; + cdp->last_sample = cdp->current_sample; cdp->current_sample = (sample8_t)(cdp->dat >> 8); cdp->state = 2; @@ -377,18 +615,18 @@ static void audio_handler (int nr) case 2: /* We come here when a 2->3 transition occurs */ if (currprefs.produce_sound == 0) - cdp->per = 65535; + cdp->per = PERIOD_MAX; + cdp->last_sample = cdp->current_sample; cdp->current_sample = (sample8_t)(cdp->dat & 0xFF); - eventtab[ev_aud0 + nr].evtime = cycles + cdp->per; - eventtab[ev_aud0 + nr].oldcycles = cycles; + cdp->evtime = cdp->per; cdp->state = 3; /* Period attachment? */ if (adkcon & (0x10 << nr)) { if (cdp->intreq2 && cdp->dmaen) - INTREQ(0x8000 | (0x80 << nr)); + INTREQ (0x8000 | (0x80 << nr)); cdp->intreq2 = 0; cdp->dat = cdp->nextdat; @@ -396,12 +634,11 @@ static void audio_handler (int nr) cdp->data_written = 2; if (nr < 3) { if (cdp->dat == 0) - (cdp+1)->per = 65535; - - else if (cdp->dat < maxhpos/2 && currprefs.produce_sound < 3) - (cdp+1)->per = maxhpos/2; + (cdp+1)->per = PERIOD_MAX; + else if (cdp->dat < maxhpos * CYCLE_UNIT / 2 && currprefs.produce_sound < 3) + (cdp+1)->per = maxhpos * CYCLE_UNIT / 2; else - (cdp+1)->per = cdp->dat; + (cdp+1)->per = cdp->dat * CYCLE_UNIT; } } break; @@ -409,15 +646,14 @@ static void audio_handler (int nr) case 3: /* We come here when a 3->2 transition occurs */ if (currprefs.produce_sound == 0) - cdp->per = 65535; + cdp->per = PERIOD_MAX; - eventtab[ev_aud0 + nr].evtime = cycles + cdp->per; - eventtab[ev_aud0 + nr].oldcycles = cycles; + cdp->evtime = cdp->per; if ((INTREQR() & (0x80 << nr)) && !cdp->dmaen) { cdp->state = 0; + cdp->last_sample = 0; cdp->current_sample = 0; - eventtab[ev_aud0 + nr].active = 0; break; } else { int audav = adkcon & (1 << nr); @@ -431,6 +667,7 @@ static void audio_handler (int nr) cdp->intreq2 = 0; cdp->dat = cdp->nextdat; + cdp->last_sample = cdp->current_sample; cdp->current_sample = (sample8_t)(cdp->dat >> 8); if (cdp->dmaen && napnav) @@ -450,7 +687,6 @@ static void audio_handler (int nr) default: cdp->state = 0; - eventtab[ev_aud0 + nr].active = 0; break; } } @@ -472,22 +708,307 @@ void aud3_handler (void) audio_handler (3); } +void audio_channel_enable_dma (struct audio_channel_data *cdp) +{ + if (cdp->state == 0) { + cdp->state = 1; + cdp->pt = cdp->lc; + cdp->wper = cdp->per; + cdp->wlen = cdp->len; + cdp->data_written = 2; + cdp->evtime = eventtab[ev_hsync].evtime - get_cycles (); + } +} + +void audio_channel_disable_dma (struct audio_channel_data *cdp) +{ + if (cdp->state == 1 || cdp->state == 5) { + cdp->state = 0; + cdp->last_sample = 0; + cdp->current_sample = 0; + } +} + void audio_reset (void) { - memset (audio_channel, 0, sizeof audio_channel); - audio_channel[0].per = 65535; - audio_channel[1].per = 65535; - audio_channel[2].per = 65535; - audio_channel[3].per = 65535; - audio_channel[0].voltbl = sound_table[0]; - audio_channel[1].voltbl = sound_table[0]; - audio_channel[2].voltbl = sound_table[0]; - audio_channel[3].voltbl = sound_table[0]; + int i; + if (savestate_state != STATE_RESTORE) { + memset (audio_channel, 0, 4 * sizeof *audio_channel); + audio_channel[0].per = PERIOD_MAX; + audio_channel[1].per = PERIOD_MAX; + audio_channel[2].per = PERIOD_MAX; + audio_channel[3].per = PERIOD_MAX; + audio_channel[0].voltbl = sound_table[0]; + audio_channel[1].voltbl = sound_table[0]; + audio_channel[2].voltbl = sound_table[0]; + audio_channel[3].voltbl = sound_table[0]; + } else + for (i = 0; i < 4; i++) + audio_channel[i].dmaen = (dmacon & 0x200) && (dmacon & (1 << i)); + +#ifndef MULTIPLICATION_PROFITABLE + for (i = 0; i < 4; i++) + audio_channel[nr].voltbl = sound_table[audio_channel[nr].vol]; +#endif + + last_cycles = 0; + next_sample_evtime = scaled_sample_evtime; + + schedule_audio (); +} + +STATIC_INLINE int sound_prefs_changed (void) +{ + return (changed_prefs.produce_sound != currprefs.produce_sound + || changed_prefs.sound_stereo != currprefs.sound_stereo + || changed_prefs.mixed_stereo != currprefs.mixed_stereo + || changed_prefs.sound_maxbsiz != currprefs.sound_maxbsiz + || changed_prefs.sound_freq != currprefs.sound_freq + || changed_prefs.sound_bits != currprefs.sound_bits); +} + +void check_prefs_changed_audio (void) +{ + if (sound_available && sound_prefs_changed ()) { + close_sound (); + + currprefs.produce_sound = changed_prefs.produce_sound; + currprefs.sound_stereo = changed_prefs.sound_stereo; + currprefs.mixed_stereo = changed_prefs.mixed_stereo; + currprefs.sound_bits = changed_prefs.sound_bits; + currprefs.sound_freq = changed_prefs.sound_freq; + currprefs.sound_maxbsiz = changed_prefs.sound_maxbsiz; + if (currprefs.produce_sound >= 2) { + if (init_audio ()) { + last_cycles = get_cycles () - 1; + next_sample_evtime = scaled_sample_evtime; + } else + if (! sound_available) { + write_log ("Sound is not supported.\n"); + } else { + write_log ("Sorry, can't initialize sound.\n"); + currprefs.produce_sound = 0; + /* So we don't do this every frame */ + changed_prefs.produce_sound = 0; + } + } + compute_vsynctime (); + } + /* Select the right interpolation method. */ + if (sample_handler == sample16_handler + || sample_handler == sample16i_crux_handler + || sample_handler == sample16i_rh_handler) + sample_handler = (currprefs.sound_interpol == 0 ? sample16_handler + : currprefs.sound_interpol == 1 ? sample16i_rh_handler + : sample16i_crux_handler); + else if (sample_handler == sample16s_handler + || sample_handler == sample16si_crux_handler + || sample_handler == sample16si_rh_handler) + sample_handler = (currprefs.sound_interpol == 0 ? sample16s_handler + : currprefs.sound_interpol == 1 ? sample16si_rh_handler + : sample16si_crux_handler); + if (currprefs.produce_sound == 0) { + eventtab[ev_audio].active = 0; + events_schedule (); + } +} + +void update_audio (void) +{ + unsigned long int n_cycles; + + if (currprefs.produce_sound == 0 || savestate_state == STATE_RESTORE) + return; + + n_cycles = get_cycles () - last_cycles; + for (;;) { + unsigned long int best_evtime = n_cycles + 1; + if (audio_channel[0].state != 0 && best_evtime > audio_channel[0].evtime) + best_evtime = audio_channel[0].evtime; + if (audio_channel[1].state != 0 && best_evtime > audio_channel[1].evtime) + best_evtime = audio_channel[1].evtime; + if (audio_channel[2].state != 0 && best_evtime > audio_channel[2].evtime) + best_evtime = audio_channel[2].evtime; + if (audio_channel[3].state != 0 && best_evtime > audio_channel[3].evtime) + best_evtime = audio_channel[3].evtime; + if (audio_channel[4].state != 0 && best_evtime > audio_channel[4].evtime) + best_evtime = audio_channel[4].evtime; + if (audio_channel[5].state != 0 && best_evtime > audio_channel[5].evtime) + best_evtime = audio_channel[5].evtime; + if (currprefs.produce_sound > 1 && best_evtime > next_sample_evtime) + best_evtime = next_sample_evtime; + + if (best_evtime > n_cycles) + break; + + next_sample_evtime -= best_evtime; + audio_channel[0].evtime -= best_evtime; + audio_channel[1].evtime -= best_evtime; + audio_channel[2].evtime -= best_evtime; + audio_channel[3].evtime -= best_evtime; + audio_channel[4].evtime -= best_evtime; + audio_channel[5].evtime -= best_evtime; + n_cycles -= best_evtime; + if (next_sample_evtime == 0 && currprefs.produce_sound > 1) { + next_sample_evtime = scaled_sample_evtime; + (*sample_handler) (); + } + if (audio_channel[0].evtime == 0 && audio_channel[0].state != 0) + audio_handler (0); + if (audio_channel[1].evtime == 0 && audio_channel[1].state != 0) + audio_handler (1); + if (audio_channel[2].evtime == 0 && audio_channel[2].state != 0) + audio_handler (2); + if (audio_channel[3].evtime == 0 && audio_channel[3].state != 0) + audio_handler (3); + } + last_cycles = get_cycles () - n_cycles; +} + +void audio_evhandler (void) +{ + if (currprefs.produce_sound == 0) + abort (); + + update_audio (); + schedule_audio (); +} + +void AUDxDAT (int nr, uae_u16 v) +{ + struct audio_channel_data *cdp = audio_channel + nr; + + if (currprefs.produce_sound == 0) + return; + + update_audio (); + + cdp->dat = v; + if (cdp->state == 0 && !(INTREQR() & (0x80 << nr))) { + cdp->state = 2; + INTREQ(0x8000 | (0x80 << nr)); + /* data_written = 2 ???? */ + cdp->evtime = cdp->per; + schedule_audio (); + events_schedule (); + } +} + +void AUDxLCH (int nr, uae_u16 v) +{ + update_audio (); + + audio_channel[nr].lc = (audio_channel[nr].lc & 0xffff) | ((uae_u32)v << 16); +} + +void AUDxLCL (int nr, uae_u16 v) +{ + update_audio (); + + audio_channel[nr].lc = (audio_channel[nr].lc & ~0xffff) | (v & 0xFFFE); +} + +void AUDxPER (int nr, uae_u16 v) +{ + unsigned long per = v * CYCLE_UNIT; + update_audio (); + + if (per == 0) + per = PERIOD_MAX; + + if (per < maxhpos * CYCLE_UNIT / 2 && currprefs.produce_sound < 3) + per = maxhpos * CYCLE_UNIT / 2; + + if (audio_channel[nr].per == PERIOD_MAX + && per != PERIOD_MAX) + { + audio_channel[nr].evtime = CYCLE_UNIT; + if (currprefs.produce_sound > 0) { + schedule_audio (); + events_schedule (); + } + } + audio_channel[nr].per = per; } -void dump_audio_bench (void) +void AUDxLEN (int nr, uae_u16 v) { -#ifdef BENCHMARK_AUDIO - printf ("Average cycles per sample handler: %f\n", ((double)sh_time / sh_count)); + update_audio (); + audio_channel[nr].len = v; +} + +void AUDxVOL (int nr, uae_u16 v) +{ + int v2 = v & 64 ? 63 : v & 63; + + update_audio (); + + audio_channel[nr].vol = v2; +#ifndef MULTIPLICATION_PROFITABLE + audio_channel[nr].voltbl = sound_table[v2]; #endif } + +int init_audio (void) +{ + int retval; + /* Some backward compatibility hacks until every port initializes + scaled_sample_evtime... */ + scaled_sample_evtime_ok = 0; + retval = init_sound (); + if (! scaled_sample_evtime_ok) + scaled_sample_evtime = sample_evtime * CYCLE_UNIT; + return retval; +} + +/* audio save/restore code FIXME: not working correctly */ +/* help needed */ + +uae_u8 *restore_audio (uae_u8 *src, int i) +{ + struct audio_channel_data *acd; + uae_u16 p; + + acd = audio_channel + i; + acd->state = restore_u8 (); + acd->vol = restore_u8 (); + acd->intreq2 = restore_u8 (); + acd->data_written = restore_u8 (); + acd->len = restore_u16 (); + acd->wlen = restore_u16 (); + p = restore_u16 (); + acd->per = p ? p * CYCLE_UNIT : PERIOD_MAX; + p = restore_u16 (); + acd->wper = p ? p * CYCLE_UNIT : PERIOD_MAX; + acd->lc = restore_u32 (); + acd->pt = restore_u32 (); + acd->evtime = restore_u32 (); + + return src; +} + + +uae_u8 *save_audio (int *len, int i) +{ + struct audio_channel_data *acd; + uae_u8 *dst = malloc (100); + uae_u8 *dstbak = dst; + uae_u16 p; + + acd = audio_channel + i; + save_u8 ((uae_u8)acd->state); + save_u8 (acd->vol); + save_u8 (acd->intreq2); + save_u8 (acd->data_written); + save_u16 (acd->len); + save_u16 (acd->wlen); + p = acd->per == PERIOD_MAX ? 0 : acd->per / CYCLE_UNIT; + save_u16 (p); + p = acd->per == PERIOD_MAX ? 0 : acd->wper / CYCLE_UNIT; + save_u16 (p); + save_u32 (acd->lc); + save_u32 (acd->pt); + save_u32 (acd->evtime); + *len = dst - dstbak; + return dstbak; +}