From 2dd46e7cbb6c00606d1aa0a34e4b0e012f860f49 Mon Sep 17 00:00:00 2001 From: Dimitris Panokostas Date: Sun, 23 Dec 2018 16:04:05 +0100 Subject: [PATCH] Fixed audio.cpp missing math include, modernized code --- src/audio.cpp | 1637 ++++++++++++++++++++++++------------------------- 1 file changed, 814 insertions(+), 823 deletions(-) diff --git a/src/audio.cpp b/src/audio.cpp index 0d3313af..78abb7a3 100644 --- a/src/audio.cpp +++ b/src/audio.cpp @@ -12,9 +12,8 @@ * */ -#include -#include - +#include +#include #include "sysdeps.h" #include "options.h" @@ -33,10 +32,10 @@ volatile bool cd_audio_mode_changed; STATIC_INLINE bool isaudio(void) { - return currprefs.produce_sound != 0; + return currprefs.produce_sound != 0; } -STATIC_INLINE bool usehacks (void) +STATIC_INLINE bool usehacks(void) { return currprefs.cpu_model >= 68020 || currprefs.m68k_speed != 0; } @@ -61,23 +60,23 @@ struct audio_channel_data2 int sinc_queue_time; int sinc_queue_head; int vol; - unsigned int adk_mask; + unsigned int adk_mask; }; struct audio_channel_data { - unsigned int evtime; + unsigned int evtime; bool dmaenstore; bool intreq2; bool dr; bool dsr; bool pbufldl; bool dat_written; - uaecptr lc, pt; - int state; - int per; - int len, wlen; - uae_u16 dat, dat2; + uaecptr lc, pt; + int state; + int per; + int len, wlen; + uae_u16 dat, dat2; struct audio_channel_data2 data; /* too fast cpu fixes */ uaecptr ptx; @@ -103,13 +102,15 @@ static float next_sample_evtime; typedef uae_s8 sample8_t; #define DO_CHANNEL_1(v, c) do { (v) *= audio_channel[c].data.vol; } while (0) -STATIC_INLINE int FINISH_DATA (int data, int bits, int ch) +STATIC_INLINE int FINISH_DATA(int data, int bits, int ch) { if (bits == 16) { return data; - } else if (bits - 16 > 0) { - data >>= bits - 16; - } else { + } + else if (bits - 16 > 0) { + data >>= bits - 16; + } + else { int shift = 16 - bits; data <<= shift; } @@ -138,9 +139,9 @@ 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_NONE = 0, + FILTER_MODEL_A500, + FILTER_MODEL_A1200 }; /* Amiga has two separate filtering circuits per channel, a static RC filter @@ -161,51 +162,51 @@ enum { static int filter(int input, struct filter_state *fs) { - int o; - float normal_output, led_output; + int o; + float normal_output, led_output; - input = (uae_s16)input; - switch (sound_use_filter) { - - case FILTER_MODEL_A500: - fs->rc1 = a500e_filter1_a0 * input + (1 - a500e_filter1_a0) * fs->rc1 + DENORMAL_OFFSET; - fs->rc2 = a500e_filter2_a0 * fs->rc1 + (1-a500e_filter2_a0) * fs->rc2; - normal_output = fs->rc2; + input = uae_s16(input); + switch (sound_use_filter) { - 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; + case FILTER_MODEL_A500: + fs->rc1 = a500e_filter1_a0 * input + (1 - a500e_filter1_a0) * fs->rc1 + DENORMAL_OFFSET; + fs->rc2 = a500e_filter2_a0 * fs->rc1 + (1 - a500e_filter2_a0) * fs->rc2; + normal_output = fs->rc2; - led_output = fs->rc5; - break; - - case FILTER_MODEL_A1200: - normal_output = input; + 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; - fs->rc2 = 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->rc5; + break; - led_output = fs->rc4; - break; + case FILTER_MODEL_A1200: + normal_output = input; - case FILTER_NONE: - default: - return input; + fs->rc2 = 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; - if (led_filter_on) - o = led_output; - else - o = normal_output; + case FILTER_NONE: + default: + return input; - if (o > 32767) - o = 32767; - else if (o < -32768) - o = -32768; + } - return o; + 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. */ @@ -217,219 +218,212 @@ static void put_sound_word_stereo_func_filter_mixed(uae_u32 lnew, uae_u32 rnew) { uae_u32 rold, lold, tmp; - lnew = filter (lnew, &sound_filter_state[0]); - rnew = filter (rnew, &sound_filter_state[1]); + lnew = filter(lnew, &sound_filter_state[0]); + rnew = filter(rnew, &sound_filter_state[1]); - left_word_saved[saved_ptr] = lnew; - right_word_saved[saved_ptr] = rnew; + left_word_saved[saved_ptr] = lnew; + right_word_saved[saved_ptr] = rnew; - saved_ptr = (saved_ptr + 1) & mixed_stereo_size; + saved_ptr = (saved_ptr + 1) & mixed_stereo_size; - lold = left_word_saved[saved_ptr]; - tmp = (rnew * mixed_mul2 + lold * mixed_mul1) / MIXED_STEREO_SCALE; + lold = left_word_saved[saved_ptr]; + tmp = (rnew * mixed_mul2 + lold * mixed_mul1) / MIXED_STEREO_SCALE; - rold = right_word_saved[saved_ptr]; - lnew = (lnew * mixed_mul2 + rold * mixed_mul1) / MIXED_STEREO_SCALE; + rold = right_word_saved[saved_ptr]; + lnew = (lnew * mixed_mul2 + rold * mixed_mul1) / MIXED_STEREO_SCALE; - PUT_SOUND_WORD_STEREO(lnew, tmp); + PUT_SOUND_WORD_STEREO(lnew, tmp); } static void put_sound_word_stereo_func_filter_notmixed(uae_u32 left, uae_u32 right) { - left = filter (left, &sound_filter_state[0]); - right = filter (right, &sound_filter_state[1]); - PUT_SOUND_WORD_STEREO(left, right); + left = filter(left, &sound_filter_state[0]); + right = filter(right, &sound_filter_state[1]); + PUT_SOUND_WORD_STEREO(left, right); } static void put_sound_word_stereo_func_nofilter_mixed(uae_u32 lnew, uae_u32 rnew) { uae_u32 rold, lold, tmp; - left_word_saved[saved_ptr] = lnew; - right_word_saved[saved_ptr] = rnew; + left_word_saved[saved_ptr] = lnew; + right_word_saved[saved_ptr] = rnew; - saved_ptr = (saved_ptr + 1) & mixed_stereo_size; + saved_ptr = (saved_ptr + 1) & mixed_stereo_size; - lold = left_word_saved[saved_ptr]; - tmp = (rnew * mixed_mul2 + lold * mixed_mul1) / MIXED_STEREO_SCALE; + lold = left_word_saved[saved_ptr]; + tmp = (rnew * mixed_mul2 + lold * mixed_mul1) / MIXED_STEREO_SCALE; - rold = right_word_saved[saved_ptr]; - lnew = (lnew * mixed_mul2 + rold * mixed_mul1) / MIXED_STEREO_SCALE; + rold = right_word_saved[saved_ptr]; + lnew = (lnew * mixed_mul2 + rold * mixed_mul1) / MIXED_STEREO_SCALE; - PUT_SOUND_WORD_STEREO(lnew, tmp); + PUT_SOUND_WORD_STEREO(lnew, tmp); } static void put_sound_word_stereo_func_nofilter_notmixed(uae_u32 left, uae_u32 right) { - PUT_SOUND_WORD_STEREO(left, right); + PUT_SOUND_WORD_STEREO(left, right); } static void put_sound_word_mono_func_filter(uae_u32 data) { - data = filter (data, &sound_filter_state[0]); - PUT_SOUND_WORD(data); + data = filter(data, &sound_filter_state[0]); + PUT_SOUND_WORD(data); } static void put_sound_word_mono_func_nofilter(uae_u32 data) { - PUT_SOUND_WORD(data); + PUT_SOUND_WORD(data); } static void anti_prehandler(unsigned long best_evtime) { - int i, output; - struct audio_channel_data2 *acd; + int i, output; + struct audio_channel_data2 *acd; - /* Handle accumulator antialiasiation */ - for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) { + /* Handle accumulator antialiasiation */ + for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) { acd = audio_data[i]; - output = (acd->current_sample * acd->vol) & acd->adk_mask; - acd->sample_accum += output * best_evtime; - acd->sample_accum_time += best_evtime; - } + output = (acd->current_sample * acd->vol) & acd->adk_mask; + acd->sample_accum += output * best_evtime; + acd->sample_accum_time += best_evtime; + } } -STATIC_INLINE void samplexx_anti_handler (int *datasp) +STATIC_INLINE void samplexx_anti_handler(int *datasp) { - int i; - for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) { - struct audio_channel_data2 *acd = audio_data[i]; + for (auto i = 0; i < AUDIO_CHANNELS_PAULA; i++) { + auto acd = audio_data[i]; datasp[i] = acd->sample_accum_time ? (acd->sample_accum / acd->sample_accum_time) : 0; acd->sample_accum = 0; acd->sample_accum_time = 0; - } + } } -static void sinc_prehandler_paula (unsigned long best_evtime) +static void sinc_prehandler_paula(unsigned long best_evtime) { - int i, output; - struct audio_channel_data2 *acd; + for (auto& i : audio_data) + { + auto acd = i; + auto vol = acd->vol; + int output = (acd->current_sample * vol) & acd->adk_mask; - for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) { - acd = audio_data[i]; - int vol = acd->vol; - 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) { + /* 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_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_INLINE void samplexx_sinc_handler (int *datasp) +STATIC_INLINE void samplexx_sinc_handler(int *datasp) { - int n, i; - int const *winsinc; + int n; - if (sound_use_filter_sinc) { - n = (sound_use_filter_sinc == FILTER_MODEL_A500) ? 0 : 2; - if (led_filter_on) - n += 1; - } else { - n = 4; - } - winsinc = winsinc_integral[n]; + if (sound_use_filter_sinc) { + n = (sound_use_filter_sinc == FILTER_MODEL_A500) ? 0 : 2; + if (led_filter_on) + n += 1; + } + else { + n = 4; + } + auto winsinc = winsinc_integral[n]; - for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) { - 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; + for (auto i = 0; i < AUDIO_CHANNELS_PAULA; i++) { + auto acd = audio_data[i]; + /* The sum rings with harmonic components up to infinity... */ + auto sum = acd->sinc_output_state << 17; + /* ...but we cancel them through mixing in BLEPs instead */ + auto offsetpos = acd->sinc_queue_head & (SINC_QUEUE_LENGTH - 1); + for (int j = 0; j < SINC_QUEUE_LENGTH; j += 1) { + auto 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[i] = v; - } + auto v = sum >> 15; + if (v > 32767) + v = 32767; + else if (v < -32768) + v = -32768; + datasp[i] = v; + } } -static void sample16i_sinc_handler (void) +static void sample16i_sinc_handler(void) { - int datas[AUDIO_CHANNELS_PAULA], data1; - - samplexx_sinc_handler (datas); - data1 = datas[0] + datas[3] + datas[1] + datas[2]; - data1 = FINISH_DATA (data1, 18, 0); + int datas[AUDIO_CHANNELS_PAULA], data1; - put_sound_word_mono_func (data1); - check_sound_buffers (); + samplexx_sinc_handler(datas); + data1 = datas[0] + datas[3] + datas[1] + datas[2]; + data1 = FINISH_DATA(data1, 18, 0); + + put_sound_word_mono_func(data1); + check_sound_buffers(); } -void sample16_handler (void) +void sample16_handler(void) { int data; - if(audio_channel[0].data.adk_mask) - data = audio_channel[0].data.current_sample * audio_channel[0].data.vol; - else - data = 0; - if(audio_channel[1].data.adk_mask) - data += audio_channel[1].data.current_sample * audio_channel[1].data.vol; - if(audio_channel[2].data.adk_mask) - data += audio_channel[2].data.current_sample * audio_channel[2].data.vol; - if(audio_channel[3].data.adk_mask) - data += audio_channel[3].data.current_sample * audio_channel[3].data.vol; - - data = FINISH_DATA (data, 16, 0); + if (audio_channel[0].data.adk_mask) + data = audio_channel[0].data.current_sample * audio_channel[0].data.vol; + else + data = 0; + if (audio_channel[1].data.adk_mask) + data += audio_channel[1].data.current_sample * audio_channel[1].data.vol; + if (audio_channel[2].data.adk_mask) + data += audio_channel[2].data.current_sample * audio_channel[2].data.vol; + if (audio_channel[3].data.adk_mask) + data += audio_channel[3].data.current_sample * audio_channel[3].data.vol; - put_sound_word_mono_func (data); - check_sound_buffers (); + data = FINISH_DATA(data, 16, 0); + + put_sound_word_mono_func(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) +static void sample16i_anti_handler(void) { - int datas[AUDIO_CHANNELS_PAULA], data1; + int datas[AUDIO_CHANNELS_PAULA]; - samplexx_anti_handler (datas); - data1 = datas[0] + datas[3] + datas[1] + datas[2]; - data1 = FINISH_DATA (data1, 16, 0); + samplexx_anti_handler(datas); + auto data1 = datas[0] + datas[3] + datas[1] + datas[2]; + data1 = FINISH_DATA(data1, 16, 0); - put_sound_word_mono_func (data1); - check_sound_buffers (); + put_sound_word_mono_func(data1); + check_sound_buffers(); } -static void sample16i_rh_handler (void) +static void sample16i_rh_handler(void) { - unsigned long delta, ratio; + auto data0 = audio_channel[0].data.current_sample; + auto data1 = audio_channel[1].data.current_sample; + auto data2 = audio_channel[2].data.current_sample; + auto data3 = audio_channel[3].data.current_sample; + auto data0p = audio_channel[0].data.last_sample; + auto data1p = audio_channel[1].data.last_sample; + auto data2p = audio_channel[2].data.last_sample; + auto data3p = audio_channel[3].data.last_sample; - 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); + 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; @@ -440,46 +434,45 @@ static void sample16i_rh_handler (void) 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 = data0; - data = FINISH_DATA (data, 16, 0); + /* linear interpolation and summing up... */ + unsigned long delta = audio_channel[0].per; + auto 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; + auto data = data0; + data = FINISH_DATA(data, 16, 0); - put_sound_word_mono_func (data); - check_sound_buffers(); + put_sound_word_mono_func(data); + check_sound_buffers(); } -static void sample16i_crux_handler (void) +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; + auto data0 = audio_channel[0].data.current_sample; + auto data1 = audio_channel[1].data.current_sample; + auto data2 = audio_channel[2].data.current_sample; + auto data3 = audio_channel[3].data.current_sample; + auto data0p = audio_channel[0].data.last_sample; + auto data1p = audio_channel[1].data.last_sample; + auto data2p = audio_channel[2].data.last_sample; + auto data3p = audio_channel[3].data.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); + 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; @@ -490,46 +483,44 @@ static void sample16i_crux_handler (void) data3 &= audio_channel[3].data.adk_mask; data3p &= audio_channel[3].data.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; + auto cdp = audio_channel + 0; + unsigned long ratio1 = cdp->per - cdp->evtime; + auto ratio = ulong((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 + 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 + 2; + ratio1 = cdp->per - cdp->evtime; + ratio = ulong((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; - data = data0; - data = FINISH_DATA (data, 16, 0); + cdp = audio_channel + 3; + ratio1 = cdp->per - cdp->evtime; + ratio = ulong((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; + auto data = data0; + data = FINISH_DATA(data, 16, 0); - put_sound_word_mono_func (data); - check_sound_buffers (); + put_sound_word_mono_func(data); + check_sound_buffers(); } #ifdef HAVE_STEREO_SUPPORT @@ -537,68 +528,68 @@ static void sample16i_crux_handler (void) /* This interpolator examines sample points when Paula switches the output * voltage and computes the average of Paula's output */ -static void sample16si_anti_handler (void) +static void sample16si_anti_handler(void) { - int datas[AUDIO_CHANNELS_PAULA], data1, data2; + int datas[AUDIO_CHANNELS_PAULA]; - samplexx_anti_handler (datas); - data1 = datas[0] + datas[3]; - data2 = datas[1] + datas[2]; - data1 = FINISH_DATA (data1, 15, 0); - data2 = FINISH_DATA (data2, 15, 1); + samplexx_anti_handler(datas); + auto data1 = datas[0] + datas[3]; + auto data2 = datas[1] + datas[2]; + data1 = FINISH_DATA(data1, 15, 0); + data2 = FINISH_DATA(data2, 15, 1); - put_sound_word_stereo_func(data1, data2); - check_sound_buffers (); + put_sound_word_stereo_func(data1, data2); + check_sound_buffers(); } -static void sample16si_sinc_handler (void) +static void sample16si_sinc_handler(void) { - int datas[AUDIO_CHANNELS_PAULA], data1, data2; + int datas[AUDIO_CHANNELS_PAULA]; - samplexx_sinc_handler (datas); - data1 = datas[0] + datas[3]; - data2 = datas[1] + datas[2]; - data1 = FINISH_DATA (data1, 17, 0); - data2 = FINISH_DATA (data2, 17, 1); + samplexx_sinc_handler(datas); + auto data1 = datas[0] + datas[3]; + auto data2 = datas[1] + datas[2]; + data1 = FINISH_DATA(data1, 17, 0); + data2 = FINISH_DATA(data2, 17, 1); - put_sound_word_stereo_func(data1, data2); - check_sound_buffers (); + put_sound_word_stereo_func(data1, data2); + check_sound_buffers(); } -void sample16s_handler (void) +void sample16s_handler(void) { - int data_l = audio_channel[0].data.adk_mask ? audio_channel[0].data.current_sample * audio_channel[0].data.vol : 0; - int data_r = audio_channel[1].data.adk_mask ? audio_channel[1].data.current_sample * audio_channel[1].data.vol : 0; - if(audio_channel[2].data.adk_mask) - data_r += audio_channel[2].data.current_sample * audio_channel[2].data.vol; - if(audio_channel[3].data.adk_mask) - data_l += audio_channel[3].data.current_sample * audio_channel[3].data.vol; - data_l = FINISH_DATA(data_l, 15, 0); - data_r = FINISH_DATA(data_r, 15, 1); + auto data_l = audio_channel[0].data.adk_mask ? audio_channel[0].data.current_sample * audio_channel[0].data.vol : 0; + auto data_r = audio_channel[1].data.adk_mask ? audio_channel[1].data.current_sample * audio_channel[1].data.vol : 0; + if (audio_channel[2].data.adk_mask) + data_r += audio_channel[2].data.current_sample * audio_channel[2].data.vol; + if (audio_channel[3].data.adk_mask) + data_l += audio_channel[3].data.current_sample * audio_channel[3].data.vol; + data_l = FINISH_DATA(data_l, 15, 0); + data_r = FINISH_DATA(data_r, 15, 1); - put_sound_word_stereo_func(data_l, data_r); - check_sound_buffers(); + put_sound_word_stereo_func(data_l, data_r); + check_sound_buffers(); } -static void sample16si_crux_handler (void) +static void sample16si_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; + auto data0 = audio_channel[0].data.current_sample; + auto data1 = audio_channel[1].data.current_sample; + auto data2 = audio_channel[2].data.current_sample; + auto data3 = audio_channel[3].data.current_sample; + auto data0p = audio_channel[0].data.last_sample; + auto data1p = audio_channel[1].data.last_sample; + auto data2p = audio_channel[2].data.last_sample; + auto data3p = audio_channel[3].data.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); + 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; @@ -609,68 +600,64 @@ static void sample16si_crux_handler (void) data3 &= audio_channel[3].data.adk_mask; data3p &= audio_channel[3].data.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; + auto cdp = audio_channel + 0; + unsigned long ratio1 = cdp->per - cdp->evtime; + auto ratio = ulong((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 + 1; + ratio1 = cdp->per - cdp->evtime; + ratio = ulong((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 + 2; + ratio1 = cdp->per - cdp->evtime; + ratio = ulong((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 = FINISH_DATA (data0, 15, 0); - data1 = FINISH_DATA (data1, 15, 1); + cdp = audio_channel + 3; + ratio1 = cdp->per - cdp->evtime; + ratio = ulong((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 = FINISH_DATA(data0, 15, 0); + data1 = FINISH_DATA(data1, 15, 1); - put_sound_word_stereo_func(data0, data1); - check_sound_buffers (); + put_sound_word_stereo_func(data0, data1); + check_sound_buffers(); } -static void sample16si_rh_handler (void) +static void sample16si_rh_handler(void) { - unsigned long delta, ratio; + auto data0 = audio_channel[0].data.current_sample; + auto data1 = audio_channel[1].data.current_sample; + auto data2 = audio_channel[2].data.current_sample; + auto data3 = audio_channel[3].data.current_sample; + auto data0p = audio_channel[0].data.last_sample; + auto data1p = audio_channel[1].data.last_sample; + auto data2p = audio_channel[2].data.last_sample; + auto data3p = audio_channel[3].data.last_sample; - 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; - - 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); + 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; @@ -681,116 +668,113 @@ static void sample16si_rh_handler (void) 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; - 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; - data0 = FINISH_DATA (data0, 15, 0); - data1 = FINISH_DATA (data1, 15, 1); + /* linear interpolation and summing up... */ + unsigned long delta = audio_channel[0].per; + unsigned long 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; + data0 = FINISH_DATA(data0, 15, 0); + data1 = FINISH_DATA(data1, 15, 1); - put_sound_word_stereo_func(data0, data1); - check_sound_buffers (); + put_sound_word_stereo_func(data0, data1); + check_sound_buffers(); } #else -void sample16s_handler (void) +void sample16s_handler(void) { - sample16_handler (); + sample16_handler(); } -static void sample16si_crux_handler (void) +static void sample16si_crux_handler(void) { - sample16i_crux_handler (); + sample16i_crux_handler(); } -static void sample16si_rh_handler (void) +static void sample16si_rh_handler(void) { - sample16i_rh_handler (); + sample16i_rh_handler(); } #endif static int audio_work_to_do; -static void zerostate (int nr) +static void zerostate(int nr) { - struct audio_channel_data *cdp = audio_channel + nr; - cdp->state = 0; - cdp->evtime = MAX_EV; - cdp->intreq2 = 0; + auto cdp = audio_channel + nr; + cdp->state = 0; + cdp->evtime = MAX_EV; + cdp->intreq2 = false; cdp->dmaenstore = false; cdp->dmaofftime_active = 0; } -static void schedule_audio (void) +static void schedule_audio(void) { unsigned long best = MAX_EV; - int i; eventtab[ev_audio].active = 0; - for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) { - struct audio_channel_data *cdp = audio_channel + i; + for (auto i = 0; i < AUDIO_CHANNELS_PAULA; i++) { + auto cdp = audio_channel + i; if (cdp->evtime != MAX_EV) { if (best > cdp->evtime) { best = cdp->evtime; - eventtab[ev_audio].active = 1; - } - } - } - eventtab[ev_audio].evtime = get_cycles () + best; + eventtab[ev_audio].active = 1; + } + } + } + eventtab[ev_audio].evtime = get_cycles() + best; } -static void audio_event_reset (void) +static void audio_event_reset(void) { - int i; - - last_cycles = get_cycles (); + last_cycles = get_cycles(); next_sample_evtime = scaled_sample_evtime; - if (!isrestore ()) { - for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) - zerostate (i); + if (!isrestore()) { + for (auto i = 0; i < AUDIO_CHANNELS_PAULA; i++) + zerostate(i); } - schedule_audio (); - events_schedule (); + schedule_audio(); + events_schedule(); } void audio_deactivate(void) { - gui_data.sndbuf_status = 3; - gui_data.sndbuf = 0; + gui_data.sndbuf_status = 3; + gui_data.sndbuf = 0; audio_work_to_do = 0; - pause_sound_buffer (); - clear_sound_buffers(); - audio_event_reset(); + pause_sound_buffer(); + clear_sound_buffers(); + audio_event_reset(); } int audio_activate(void) { - int ret = 0; + auto ret = 0; - if (!audio_work_to_do) { - restart_sound_buffer(); - ret = 1; - audio_event_reset(); - } - audio_work_to_do = 4 * maxvpos_nom * 50; - return ret; + if (!audio_work_to_do) { + restart_sound_buffer(); + ret = 1; + audio_event_reset(); + } + audio_work_to_do = 4 * maxvpos_nom * 50; + return ret; } STATIC_INLINE int is_audio_active(void) { - return audio_work_to_do; + return audio_work_to_do; } STATIC_INLINE void update_volume(int nr, uae_u16 v) { - struct audio_channel_data *cdp = audio_channel + nr; + auto cdp = audio_channel + nr; // 7 bit register in Paula. v &= 127; if (v > 64) @@ -798,11 +782,11 @@ STATIC_INLINE void update_volume(int nr, uae_u16 v) cdp->data.vol = v; } -uae_u16 audio_dmal (void) +uae_u16 audio_dmal(void) { uae_u16 dmal = 0; - for (int nr = 0; nr < AUDIO_CHANNELS_PAULA; nr++) { - struct audio_channel_data *cdp = audio_channel + nr; + for (auto nr = 0; nr < AUDIO_CHANNELS_PAULA; nr++) { + auto cdp = audio_channel + nr; if (cdp->dr) dmal |= 1 << (nr * 2); if (cdp->dsr) @@ -812,37 +796,37 @@ uae_u16 audio_dmal (void) return dmal; } -static int isirq (int nr) +static int isirq(int nr) { - return INTREQR() & (0x80 << nr); + return INTREQR() & (0x80 << nr); } -STATIC_INLINE void setirq (int nr, int which) +STATIC_INLINE void setirq(int nr, int which) { - INTREQ_0 (0x8000 | (0x80 << nr)); + INTREQ_0(0x8000 | (0x80 << nr)); } -static void newsample (int nr, sample8_t sample) +static void newsample(int nr, sample8_t sample) { - struct audio_channel_data *cdp = audio_channel + nr; + auto cdp = audio_channel + nr; cdp->data.last_sample = cdp->data.current_sample; cdp->data.current_sample = sample; -} +} -STATIC_INLINE void setdr (int nr) +STATIC_INLINE void setdr(int nr) { - struct audio_channel_data *cdp = audio_channel + nr; + auto cdp = audio_channel + nr; cdp->dr = true; if (cdp->wlen == 1) { cdp->dsr = true; } } -static void loaddat (int nr, bool modper) +static void loaddat(int nr, bool modper) { - struct audio_channel_data *cdp = audio_channel + nr; - int audav = adkcon & (0x01 << nr); - int audap = adkcon & (0x10 << nr); + auto cdp = audio_channel + nr; + auto audav = adkcon & (0x01 << nr); + auto audap = adkcon & (0x10 << nr); if (audav || (modper && audap)) { if (nr >= 3) return; @@ -853,57 +837,59 @@ static void loaddat (int nr, bool modper) cdp[1].per = cdp->dat * CYCLE_UNIT; else cdp[1].per = PERIOD_MIN * CYCLE_UNIT; - } else if (audav) { + } + else if (audav) { update_volume(nr + 1, cdp->dat); } - } else { + } + else { cdp->dat2 = cdp->dat; } } -static void loaddat (int nr) +static void loaddat(int nr) { - loaddat (nr, false); + loaddat(nr, false); } -STATIC_INLINE void loadper (int nr) +STATIC_INLINE void loadper(int nr) { - struct audio_channel_data *cdp = audio_channel + nr; + auto cdp = audio_channel + nr; cdp->evtime = cdp->per; if (cdp->evtime < CYCLE_UNIT) - write_log (_T("LOADPER%d bug %d\n"), nr, cdp->evtime); + write_log(_T("LOADPER%d bug %d\n"), nr, cdp->evtime); } -static void audio_state_channel2 (int nr, bool perfin) +static void audio_state_channel2(int nr, bool perfin) { - struct audio_channel_data *cdp = audio_channel + nr; - bool chan_ena = (dmacon & DMA_MASTER) && (dmacon & (1 << nr)); - bool old_dma = cdp->dmaenstore; - int audav = adkcon & (0x01 << nr); - int audap = adkcon & (0x10 << nr); + auto cdp = audio_channel + nr; + auto chan_ena = (dmacon & DMA_MASTER) && (dmacon & (1 << nr)); + auto old_dma = cdp->dmaenstore; + auto audav = adkcon & (0x01 << nr); + auto audap = adkcon & (0x10 << nr); int napnav = (!audav && !audap) || audav; - int hpos = current_hpos (); + auto hpos = current_hpos(); cdp->dmaenstore = chan_ena; if (currprefs.produce_sound == 0) { - zerostate (nr); + zerostate(nr); return; } - audio_activate (); + audio_activate(); if ((cdp->state == 2 || cdp->state == 3) && usehacks()) { - if (!chan_ena && old_dma) { - // DMA switched off, state=2/3 and "too fast CPU": set flag + if (!chan_ena && old_dma) { + // DMA switched off, state=2/3 and "too fast CPU": set flag cdp->dmaofftime_active = true; } if (cdp->dmaofftime_active && !old_dma && chan_ena) { // We are still in state=2/3 and program is going to re-enable // DMA. Force state to zero to prevent CPU timed DMA wait // routines in common tracker players to lose notes. - newsample (nr, (cdp->dat2 >> 0) & 0xff); - zerostate (nr); + newsample(nr, (cdp->dat2 >> 0) & 0xff); + zerostate(nr); } } @@ -922,32 +908,35 @@ static void audio_state_channel2 (int nr, bool perfin) if (cdp->wlen > 2) cdp->ptx_tofetch = true; cdp->dsr = true; - } else if (cdp->dat_written && !isirq (nr)) { + } + else if (cdp->dat_written && !isirq(nr)) { cdp->state = 2; - setirq (nr, 0); - loaddat (nr); + setirq(nr, 0); + loaddat(nr); if (usehacks() && cdp->per < 10 * CYCLE_UNIT) { // make sure audio.device AUDxDAT startup returns to idle state before DMA is enabled - newsample (nr, (cdp->dat2 >> 0) & 0xff); - zerostate (nr); - } else { - cdp->pbufldl = true; - audio_state_channel2 (nr, false); + newsample(nr, (cdp->dat2 >> 0) & 0xff); + zerostate(nr); } - } else { - zerostate (nr); + else { + cdp->pbufldl = true; + audio_state_channel2(nr, false); + } + } + else { + zerostate(nr); } break; case 1: cdp->evtime = MAX_EV; if (!chan_ena) { - zerostate (nr); + zerostate(nr); return; } if (!cdp->dat_written) return; - setirq (nr, 10); - setdr (nr); + setirq(nr, 10); + setdr(nr); if (cdp->wlen != 1) cdp->wlen = (cdp->wlen - 1) & 0xffff; cdp->state = 5; @@ -955,7 +944,7 @@ static void audio_state_channel2 (int nr, bool perfin) case 5: cdp->evtime = MAX_EV; if (!chan_ena) { - zerostate (nr); + zerostate(nr); return; } if (!cdp->dat_written) @@ -964,129 +953,129 @@ static void audio_state_channel2 (int nr, bool perfin) cdp->ptx_written = 0; cdp->lc = cdp->ptx; } - loaddat (nr); + loaddat(nr); if (napnav) - setdr (nr); + setdr(nr); cdp->state = 2; - loadper (nr); + loadper(nr); cdp->pbufldl = true; cdp->intreq2 = 0; - audio_state_channel2 (nr, false); + audio_state_channel2(nr, false); break; case 2: if (cdp->pbufldl) { - newsample (nr, (cdp->dat2 >> 8) & 0xff); - loadper (nr); + newsample(nr, (cdp->dat2 >> 8) & 0xff); + loadper(nr); cdp->pbufldl = false; } if (!perfin) return; if (audap) - loaddat (nr, true); + loaddat(nr, true); if (chan_ena) { if (audap) - setdr (nr); + setdr(nr); if (cdp->intreq2 && audap) - setirq (nr, 21); - } else { + setirq(nr, 21); + } + else { if (audap) - setirq (nr, 22); + setirq(nr, 22); } cdp->pbufldl = true; cdp->state = 3; - audio_state_channel2 (nr, false); + audio_state_channel2(nr, false); break; case 3: if (cdp->pbufldl) { - newsample (nr, (cdp->dat2 >> 0) & 0xff); - loadper (nr); + newsample(nr, (cdp->dat2 >> 0) & 0xff); + loadper(nr); cdp->pbufldl = false; } if (!perfin) return; if (chan_ena) { - loaddat (nr); + loaddat(nr); if (cdp->intreq2 && napnav) - setirq (nr, 31); + setirq(nr, 31); if (napnav) - setdr (nr); - } else { - if (isirq (nr)) { - zerostate (nr); + setdr(nr); + } + else { + if (isirq(nr)) { + zerostate(nr); return; } - loaddat (nr); + loaddat(nr); if (napnav) - setirq (nr, 32); + setirq(nr, 32); } cdp->intreq2 = 0; cdp->pbufldl = true; cdp->state = 2; - audio_state_channel2 (nr, false); + audio_state_channel2(nr, false); break; } } -static void audio_state_channel (int nr, bool perfin) +static void audio_state_channel(int nr, bool perfin) { - struct audio_channel_data *cdp = audio_channel + nr; - audio_state_channel2 (nr, perfin); - cdp->dat_written = false; + auto cdp = audio_channel + nr; + audio_state_channel2(nr, perfin); + cdp->dat_written = false; } -void audio_state_machine (void) +void audio_state_machine(void) { - update_audio (); - for (int nr = 0; nr < AUDIO_CHANNELS_PAULA; nr++) { - struct audio_channel_data *cdp = audio_channel + nr; - audio_state_channel2 (nr, false); + update_audio(); + for (auto nr = 0; nr < AUDIO_CHANNELS_PAULA; nr++) { + auto cdp = audio_channel + nr; + audio_state_channel2(nr, false); cdp->dat_written = false; } - schedule_audio (); - events_schedule (); + schedule_audio(); + events_schedule(); } -void audio_reset (void) +void audio_reset(void) { - int i; - struct audio_channel_data *cdp; - - reset_sound (); - memset(sound_filter_state, 0, sizeof sound_filter_state); - if (!isrestore ()) { - for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) { - cdp = &audio_channel[i]; - memset (cdp, 0, sizeof *audio_channel); - cdp->per = PERIOD_MAX - 1; + reset_sound(); + memset(sound_filter_state, 0, sizeof sound_filter_state); + if (!isrestore()) { + for (auto& i : audio_channel) + { + auto cdp = &i; + memset(cdp, 0, sizeof *audio_channel); + cdp->per = PERIOD_MAX - 1; cdp->data.vol = 0; - cdp->evtime = MAX_EV; - } - } + cdp->evtime = MAX_EV; + } + } - last_cycles = get_cycles (); - next_sample_evtime = scaled_sample_evtime; - schedule_audio (); - events_schedule (); + last_cycles = get_cycles(); + next_sample_evtime = scaled_sample_evtime; + schedule_audio(); + events_schedule(); } -static int sound_prefs_changed (void) +static int sound_prefs_changed(void) { if (!config_changed) return 0; - if (changed_prefs.produce_sound != currprefs.produce_sound - || changed_prefs.sound_stereo != currprefs.sound_stereo - || changed_prefs.sound_freq != currprefs.sound_freq) - return 1; + if (changed_prefs.produce_sound != currprefs.produce_sound + || changed_prefs.sound_stereo != currprefs.sound_stereo + || changed_prefs.sound_freq != currprefs.sound_freq) + return 1; - if (changed_prefs.sound_stereo_separation != currprefs.sound_stereo_separation - || changed_prefs.sound_mixed_stereo_delay != currprefs.sound_mixed_stereo_delay - || changed_prefs.sound_interpol != currprefs.sound_interpol + if (changed_prefs.sound_stereo_separation != currprefs.sound_stereo_separation + || changed_prefs.sound_mixed_stereo_delay != currprefs.sound_mixed_stereo_delay + || changed_prefs.sound_interpol != currprefs.sound_interpol || changed_prefs.sound_volume_paula != currprefs.sound_volume_paula || changed_prefs.sound_volume_cd != currprefs.sound_volume_cd - || changed_prefs.sound_filter != currprefs.sound_filter - || changed_prefs.sound_filter_type != currprefs.sound_filter_type) - return -1; - return 0; + || changed_prefs.sound_filter != currprefs.sound_filter + || changed_prefs.sound_filter_type != currprefs.sound_filter_type) + return -1; + return 0; } double softfloat_tan(double v); @@ -1098,271 +1087,270 @@ double softfloat_tan(double v); #endif static float rc_calculate_a0(int sample_rate, int cutoff_freq) { - float omega; - /* The BLT correction formula below blows up if the cutoff is above nyquist. */ - if (cutoff_freq >= sample_rate / 2) - return 1.0; + /* The BLT correction formula below blows up if the cutoff is above nyquist. */ + if (cutoff_freq >= sample_rate / 2) + return 1.0; - omega = 2 * M_PI * cutoff_freq / sample_rate; - /* Compensate for the bilinear transformation. This allows us to specify the - * stop frequency more exactly, but the filter becomes less steep further - * from stopband. */ - omega = softfloat_tan (omega / 2.0) * 2.0; - float out = 1.0 / (1.0 + 1.0 / omega); + float omega = 2 * M_PI * cutoff_freq / sample_rate; + /* Compensate for the bilinear transformation. This allows us to specify the + * stop frequency more exactly, but the filter becomes less steep further + * from stopband. */ + omega = softfloat_tan(omega / 2.0) * 2.0; + const float out = 1.0 / (1.0 + 1.0 / omega); return out; } -void check_prefs_changed_audio (void) +void check_prefs_changed_audio(void) { - int ch; - - if (sound_available) { - ch = sound_prefs_changed (); + if (sound_available) { + auto ch = sound_prefs_changed(); if (ch > 0) { - clear_sound_buffers (); + clear_sound_buffers(); } if (ch) { - set_audio (); - audio_activate (); + set_audio(); + audio_activate(); } } } void set_audio(void) { - int old_mixed_size = mixed_stereo_size; - int sep, delay; - int ch; + const auto old_mixed_size = mixed_stereo_size; - ch = sound_prefs_changed (); - if (ch >= 0) - close_sound (); + const auto ch = sound_prefs_changed(); + if (ch >= 0) + close_sound(); currprefs.produce_sound = changed_prefs.produce_sound; currprefs.sound_stereo = changed_prefs.sound_stereo; currprefs.sound_freq = changed_prefs.sound_freq; - currprefs.sound_stereo_separation = changed_prefs.sound_stereo_separation; - currprefs.sound_mixed_stereo_delay = changed_prefs.sound_mixed_stereo_delay; + currprefs.sound_stereo_separation = changed_prefs.sound_stereo_separation; + currprefs.sound_mixed_stereo_delay = changed_prefs.sound_mixed_stereo_delay; currprefs.sound_interpol = changed_prefs.sound_interpol; - currprefs.sound_filter = changed_prefs.sound_filter; - currprefs.sound_filter_type = changed_prefs.sound_filter_type; + currprefs.sound_filter = changed_prefs.sound_filter; + currprefs.sound_filter_type = changed_prefs.sound_filter_type; currprefs.sound_volume_paula = changed_prefs.sound_volume_paula; currprefs.sound_volume_cd = changed_prefs.sound_volume_cd; sound_cd_volume[0] = sound_cd_volume[1] = (100 - (currprefs.sound_volume_cd < 0 ? 0 : currprefs.sound_volume_cd)) * 32768 / 100; sound_paula_volume[0] = sound_paula_volume[1] = (100 - currprefs.sound_volume_paula) * 32768 / 100; - if (ch >= 0) { - if (currprefs.produce_sound >= 2) { - if (!init_audio ()) { - if (! sound_available) { - write_log (_T("Sound is not supported.\n")); - } else { - write_log (_T("Sorry, can't initialize sound.\n")); - currprefs.produce_sound = 1; - /* So we don't do this every frame */ - changed_prefs.produce_sound = 1; - } - } - } - next_sample_evtime = scaled_sample_evtime; - last_cycles = get_cycles (); - compute_vsynctime (); - } else { - sound_volume (0); - } + if (ch >= 0) { + if (currprefs.produce_sound >= 2) { + if (!init_audio()) { + if (!sound_available) { + write_log(_T("Sound is not supported.\n")); + } + else { + write_log(_T("Sorry, can't initialize sound.\n")); + currprefs.produce_sound = 1; + /* So we don't do this every frame */ + changed_prefs.produce_sound = 1; + } + } + } + next_sample_evtime = scaled_sample_evtime; + last_cycles = get_cycles(); + compute_vsynctime(); + } + else { + sound_volume(0); + } - sep = (currprefs.sound_stereo_separation = changed_prefs.sound_stereo_separation) * 3 / 2; - if (sep >= 15) - sep = 16; - delay = currprefs.sound_mixed_stereo_delay = changed_prefs.sound_mixed_stereo_delay; - mixed_mul1 = MIXED_STEREO_SCALE / 2 - sep; - mixed_mul2 = MIXED_STEREO_SCALE / 2 + sep; + auto sep = (currprefs.sound_stereo_separation = changed_prefs.sound_stereo_separation) * 3 / 2; + if (sep >= 15) + sep = 16; + const auto delay = currprefs.sound_mixed_stereo_delay = changed_prefs.sound_mixed_stereo_delay; + mixed_mul1 = MIXED_STEREO_SCALE / 2 - sep; + mixed_mul2 = MIXED_STEREO_SCALE / 2 + sep; mixed_stereo_size = delay > 0 ? (1 << delay) - 1 : 0; mixed_on = sep < MIXED_STEREO_MAX || mixed_stereo_size > 0; - if (mixed_on && old_mixed_size != mixed_stereo_size) { - saved_ptr = 0; - memset (right_word_saved, 0, sizeof right_word_saved); - } + if (mixed_on && old_mixed_size != mixed_stereo_size) { + saved_ptr = 0; + memset(right_word_saved, 0, sizeof right_word_saved); + } - led_filter_forced = -1; // always off - sound_use_filter = sound_use_filter_sinc = 0; - if (currprefs.sound_filter) { - if (currprefs.sound_filter == FILTER_SOUND_ON) - led_filter_forced = 1; - if (currprefs.sound_filter == FILTER_SOUND_EMUL) - led_filter_forced = 0; - if (currprefs.sound_filter_type == FILTER_SOUND_TYPE_A500) - sound_use_filter = FILTER_MODEL_A500; - else if (currprefs.sound_filter_type == FILTER_SOUND_TYPE_A1200) - sound_use_filter = FILTER_MODEL_A1200; - } - a500e_filter1_a0 = rc_calculate_a0(currprefs.sound_freq, 6200); - a500e_filter2_a0 = rc_calculate_a0(currprefs.sound_freq, 20000); - filter_a0 = rc_calculate_a0(currprefs.sound_freq, 7000); - memset (sound_filter_state, 0, sizeof sound_filter_state); - led_filter_audio(); + led_filter_forced = -1; // always off + sound_use_filter = sound_use_filter_sinc = 0; + if (currprefs.sound_filter) { + if (currprefs.sound_filter == FILTER_SOUND_ON) + led_filter_forced = 1; + if (currprefs.sound_filter == FILTER_SOUND_EMUL) + led_filter_forced = 0; + if (currprefs.sound_filter_type == FILTER_SOUND_TYPE_A500) + sound_use_filter = FILTER_MODEL_A500; + else if (currprefs.sound_filter_type == FILTER_SOUND_TYPE_A1200) + sound_use_filter = FILTER_MODEL_A1200; + } + a500e_filter1_a0 = rc_calculate_a0(currprefs.sound_freq, 6200); + a500e_filter2_a0 = rc_calculate_a0(currprefs.sound_freq, 20000); + filter_a0 = rc_calculate_a0(currprefs.sound_freq, 7000); + memset(sound_filter_state, 0, sizeof sound_filter_state); + led_filter_audio(); - /* Select the right interpolation method. */ - if (sample_handler == sample16_handler - || sample_handler == sample16i_crux_handler - || sample_handler == sample16i_rh_handler - || sample_handler == sample16i_sinc_handler - || sample_handler == sample16i_anti_handler) + /* Select the right interpolation method. */ + if (sample_handler == sample16_handler + || sample_handler == sample16i_crux_handler + || sample_handler == sample16i_rh_handler + || sample_handler == sample16i_sinc_handler + || sample_handler == sample16i_anti_handler) { - sample_handler = (currprefs.sound_interpol == 0 ? sample16_handler - : currprefs.sound_interpol == 3 ? sample16i_rh_handler - : currprefs.sound_interpol == 4 ? sample16i_crux_handler - : currprefs.sound_interpol == 2 ? sample16i_sinc_handler - : sample16i_anti_handler); - } else if (sample_handler == sample16s_handler - || sample_handler == sample16si_crux_handler - || sample_handler == sample16si_rh_handler - || sample_handler == sample16si_sinc_handler - || sample_handler == sample16si_anti_handler) - { - sample_handler = (currprefs.sound_interpol == 0 ? sample16s_handler - : currprefs.sound_interpol == 3 ? sample16si_rh_handler - : currprefs.sound_interpol == 4 ? sample16si_crux_handler - : currprefs.sound_interpol == 2 ? sample16si_sinc_handler - : sample16si_anti_handler); - } - sample_prehandler = NULL; - if (sample_handler == sample16si_sinc_handler || sample_handler == sample16i_sinc_handler) { - sample_prehandler = sinc_prehandler_paula; - sound_use_filter_sinc = sound_use_filter; - sound_use_filter = 0; - } else if (sample_handler == sample16si_anti_handler || sample_handler == sample16i_anti_handler) { - sample_prehandler = anti_prehandler; - } - for (int i = 0; i < AUDIO_CHANNELS_PAULA; i++) { + sample_handler = (currprefs.sound_interpol == 0 ? sample16_handler + : currprefs.sound_interpol == 3 ? sample16i_rh_handler + : currprefs.sound_interpol == 4 ? sample16i_crux_handler + : currprefs.sound_interpol == 2 ? sample16i_sinc_handler + : sample16i_anti_handler); + } + else if (sample_handler == sample16s_handler + || sample_handler == sample16si_crux_handler + || sample_handler == sample16si_rh_handler + || sample_handler == sample16si_sinc_handler + || sample_handler == sample16si_anti_handler) + { + sample_handler = (currprefs.sound_interpol == 0 ? sample16s_handler + : currprefs.sound_interpol == 3 ? sample16si_rh_handler + : currprefs.sound_interpol == 4 ? sample16si_crux_handler + : currprefs.sound_interpol == 2 ? sample16si_sinc_handler + : sample16si_anti_handler); + } + sample_prehandler = NULL; + if (sample_handler == sample16si_sinc_handler || sample_handler == sample16i_sinc_handler) { + sample_prehandler = sinc_prehandler_paula; + sound_use_filter_sinc = sound_use_filter; + sound_use_filter = 0; + } + else if (sample_handler == sample16si_anti_handler || sample_handler == sample16i_anti_handler) { + sample_prehandler = anti_prehandler; + } + for (auto i = 0; i < AUDIO_CHANNELS_PAULA; i++) { audio_data[i] = &audio_channel[i].data; } - if(currprefs.sound_stereo) { - if(currprefs.sound_filter) { - if(mixed_on) - put_sound_word_stereo_func = put_sound_word_stereo_func_filter_mixed; - else - put_sound_word_stereo_func = put_sound_word_stereo_func_filter_notmixed; - } - else { - if(mixed_on) - put_sound_word_stereo_func = put_sound_word_stereo_func_nofilter_mixed; - else - put_sound_word_stereo_func = put_sound_word_stereo_func_nofilter_notmixed; - } - } - else { - if(currprefs.sound_filter) { - put_sound_word_mono_func = put_sound_word_mono_func_filter; - } - else { - put_sound_word_mono_func = put_sound_word_mono_func_nofilter; - } - } + if (currprefs.sound_stereo) { + if (currprefs.sound_filter) { + if (mixed_on) + put_sound_word_stereo_func = put_sound_word_stereo_func_filter_mixed; + else + put_sound_word_stereo_func = put_sound_word_stereo_func_filter_notmixed; + } + else { + if (mixed_on) + put_sound_word_stereo_func = put_sound_word_stereo_func_nofilter_mixed; + else + put_sound_word_stereo_func = put_sound_word_stereo_func_nofilter_notmixed; + } + } + else { + if (currprefs.sound_filter) { + put_sound_word_mono_func = put_sound_word_mono_func_filter; + } + else { + put_sound_word_mono_func = put_sound_word_mono_func_nofilter; + } + } - if (currprefs.produce_sound == 0) { - eventtab[ev_audio].active = 0; - events_schedule (); - } else { - audio_activate (); - schedule_audio (); - events_schedule (); - } - set_config_changed (); + if (currprefs.produce_sound == 0) { + eventtab[ev_audio].active = false; + events_schedule(); + } + else { + audio_activate(); + schedule_audio(); + events_schedule(); + } + set_config_changed(); cd_audio_mode_changed = true; } -void update_audio (void) +void update_audio(void) { - unsigned long int n_cycles = 0; + unsigned long int n_cycles = 0; - if (!isaudio()) - goto end; - if (isrestore ()) - goto end; - if (!is_audio_active()) - goto end; + if (!isaudio()) + goto end; + if (isrestore()) + goto end; + if (!is_audio_active()) + goto end; - n_cycles = get_cycles () - last_cycles; - while (n_cycles > 0) { - unsigned long int best_evtime = n_cycles + 1; - unsigned long rounded; - int i; + n_cycles = get_cycles() - last_cycles; + while (n_cycles > 0) { + auto best_evtime = n_cycles + 1; + int i; - for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) { - if (audio_channel[i].evtime != MAX_EV && best_evtime > audio_channel[i].evtime) - best_evtime = audio_channel[i].evtime; - } + for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) { + if (audio_channel[i].evtime != MAX_EV && best_evtime > audio_channel[i].evtime) + best_evtime = audio_channel[i].evtime; + } /* next_sample_evtime >= 0 so floor() behaves as expected */ - rounded = floorf (next_sample_evtime); - if ((next_sample_evtime - rounded) >= 0.5) + auto rounded = ulong(floorf(next_sample_evtime)); + if (next_sample_evtime - rounded >= 0.5) rounded++; - if (currprefs.produce_sound > 1 && best_evtime > rounded) - best_evtime = rounded; + if (currprefs.produce_sound > 1 && best_evtime > rounded) + best_evtime = rounded; if (best_evtime > n_cycles) best_evtime = n_cycles; - - /* Decrease time-to-wait counters */ - next_sample_evtime -= best_evtime; - if (sample_prehandler && (currprefs.produce_sound > 1)) { - sample_prehandler(best_evtime / CYCLE_UNIT); - } + /* Decrease time-to-wait counters */ + next_sample_evtime -= best_evtime; - for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) { - if (audio_channel[i].evtime != MAX_EV) - audio_channel[i].evtime -= best_evtime; - } + if (sample_prehandler && (currprefs.produce_sound > 1)) { + sample_prehandler(best_evtime / CYCLE_UNIT); + } - n_cycles -= best_evtime; + for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) { + if (audio_channel[i].evtime != MAX_EV) + audio_channel[i].evtime -= best_evtime; + } - /* Test if new sample needs to be outputted */ - if ((rounded == best_evtime) && (currprefs.produce_sound > 1)) { + n_cycles -= best_evtime; + + /* Test if new sample needs to be outputted */ + if ((rounded == best_evtime) && (currprefs.produce_sound > 1)) { /* Before the following addition, next_sample_evtime is in range [-0.5, 0.5) */ - next_sample_evtime += scaled_sample_evtime; - (*sample_handler) (); - } + next_sample_evtime += scaled_sample_evtime; + (*sample_handler) (); + } - for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) { + for (i = 0; i < AUDIO_CHANNELS_PAULA; i++) { if (audio_channel[i].evtime == 0) { - audio_state_channel (i, true); + audio_state_channel(i, true); } - } + } } end: - last_cycles = get_cycles () - n_cycles; + last_cycles = get_cycles() - n_cycles; } -void audio_evhandler (void) +void audio_evhandler(void) { - update_audio (); - schedule_audio (); + update_audio(); + schedule_audio(); } -void audio_hsync (void) +void audio_hsync(void) { if (!currprefs.produce_sound) return; - if (!isaudio()) - return; + if (!isaudio()) + return; if (audio_work_to_do > 0) { - audio_work_to_do--; - if (audio_work_to_do == 0) - audio_deactivate(); - } - update_audio(); + audio_work_to_do--; + if (audio_work_to_do == 0) + audio_deactivate(); + } + update_audio(); } -void AUDxDAT (int nr, uae_u16 v) +void AUDxDAT(int nr, uae_u16 v) { - struct audio_channel_data *cdp = audio_channel + nr; - int chan_ena = (dmacon & DMA_MASTER) && (dmacon & (1 << nr)); + const auto cdp = audio_channel + nr; + const int chan_ena = (dmacon & DMA_MASTER) && (dmacon & (1 << nr)); cdp->dat = v; cdp->dat_written = true; @@ -1371,74 +1359,77 @@ void AUDxDAT (int nr, uae_u16 v) if (cdp->wlen == 1) { cdp->wlen = cdp->len; cdp->intreq2 = true; - } else { + } + else { cdp->wlen = (cdp->wlen - 1) & 0xffff; } } - } else { - audio_activate (); - update_audio (); - audio_state_channel (nr, false); - schedule_audio (); - events_schedule (); + } + else { + audio_activate(); + update_audio(); + audio_state_channel(nr, false); + schedule_audio(); + events_schedule(); } cdp->dat_written = false; } -uaecptr audio_getpt (int nr, bool reset) +uaecptr audio_getpt(int nr, bool reset) { - struct audio_channel_data *cdp = audio_channel + nr; - uaecptr p = cdp->pt; - cdp->pt += 2; + auto cdp = audio_channel + nr; + const auto p = cdp->pt; + cdp->pt += 2; if (reset) cdp->pt = cdp->lc; cdp->ptx_tofetch = false; return p; } -void AUDxLCH (int nr, uae_u16 v) +void AUDxLCH(int nr, uae_u16 v) { - struct audio_channel_data *cdp = audio_channel + nr; - audio_activate(); - update_audio (); + const auto cdp = audio_channel + nr; + audio_activate(); + update_audio(); // someone wants to update PT but DSR has not yet been processed. // too fast CPU and some tracker players: enable DMA, CPU delay, update AUDxPT with loop position if (usehacks() && ((cdp->ptx_tofetch && cdp->state == 1) || cdp->ptx_written)) { cdp->ptx = cdp->lc; cdp->ptx_written = true; - } else { - cdp->lc = (cdp->lc & 0xffff) | ((uae_u32)v << 16); - } + } + else { + cdp->lc = (cdp->lc & 0xffff) | ((uae_u32)v << 16); + } } -void AUDxLCL (int nr, uae_u16 v) +void AUDxLCL(int nr, uae_u16 v) { - struct audio_channel_data *cdp = audio_channel + nr; - audio_activate(); - update_audio (); + const auto cdp = audio_channel + nr; + audio_activate(); + update_audio(); if (usehacks() && ((cdp->ptx_tofetch && cdp->state == 1) || cdp->ptx_written)) { cdp->ptx = cdp->lc; cdp->ptx_written = true; - } else { - cdp->lc = (cdp->lc & ~0xffff) | (v & 0xFFFE); - } + } + else { + cdp->lc = (cdp->lc & ~0xffff) | (v & 0xFFFE); + } } -void AUDxPER (int nr, uae_u16 v) +void AUDxPER(int nr, uae_u16 v) { - struct audio_channel_data *cdp = audio_channel + nr; - unsigned long per; + const auto cdp = audio_channel + nr; - audio_activate(); - update_audio (); + audio_activate(); + update_audio(); - per = v * CYCLE_UNIT; - if (per == 0) - per = PERIOD_MAX - 1; + unsigned long per = v * CYCLE_UNIT; + if (per == 0) + per = PERIOD_MAX - 1; if (per < PERIOD_MIN * CYCLE_UNIT) { - /* smaller values would cause extremely high cpu usage */ + /* smaller values would cause extremely high cpu usage */ per = PERIOD_MIN * CYCLE_UNIT; } if (per < PERIOD_MIN_NONCE * CYCLE_UNIT && cdp->dmaenstore) { @@ -1448,113 +1439,113 @@ void AUDxPER (int nr, uae_u16 v) per = PERIOD_MIN_NONCE * CYCLE_UNIT; } - if (cdp->per == PERIOD_MAX - 1 && per != PERIOD_MAX - 1) { - cdp->evtime = CYCLE_UNIT; - if (isaudio()) { - schedule_audio (); - events_schedule (); - } - } - cdp->per = per; + if (cdp->per == PERIOD_MAX - 1 && per != PERIOD_MAX - 1) { + cdp->evtime = CYCLE_UNIT; + if (isaudio()) { + schedule_audio(); + events_schedule(); + } + } + cdp->per = per; } -void AUDxLEN (int nr, uae_u16 v) +void AUDxLEN(int nr, uae_u16 v) { - struct audio_channel_data *cdp = audio_channel + nr; - audio_activate(); - update_audio (); - cdp->len = v; + auto cdp = audio_channel + nr; + audio_activate(); + update_audio(); + cdp->len = v; } -void AUDxVOL (int nr, uae_u16 v) +void AUDxVOL(int nr, uae_u16 v) { - struct audio_channel_data *cdp = audio_channel + nr; + auto cdp = audio_channel + nr; - audio_activate(); - update_audio (); + audio_activate(); + update_audio(); update_volume(nr, v); } -void audio_update_adkmasks (void) +void audio_update_adkmasks(void) { - static int prevcon = -1; - unsigned long t = adkcon | (adkcon >> 4); + static auto prevcon = -1; + const unsigned long t = adkcon | (adkcon >> 4); audio_channel[0].data.adk_mask = (((t >> 0) & 1) - 1); audio_channel[1].data.adk_mask = (((t >> 1) & 1) - 1); audio_channel[2].data.adk_mask = (((t >> 2) & 1) - 1); audio_channel[3].data.adk_mask = (((t >> 3) & 1) - 1); - if ((prevcon & 0xff) != (adkcon & 0xff)) { - audio_activate(); - prevcon = adkcon; - } + if ((prevcon & 0xff) != (adkcon & 0xff)) { + audio_activate(); + prevcon = adkcon; + } } -int init_audio (void) +int init_audio(void) { - return init_sound (); + return init_sound(); } -void led_filter_audio (void) +void led_filter_audio(void) { - led_filter_on = 0; - if (led_filter_forced > 0 || (gui_data.powerled && led_filter_forced >= 0)) - led_filter_on = 1; + led_filter_on = 0; + if (led_filter_forced > 0 || (gui_data.powerled && led_filter_forced >= 0)) + led_filter_on = 1; } -void restore_audio_finish (void) +void restore_audio_finish(void) { - last_cycles = get_cycles (); - schedule_audio (); - events_schedule (); + last_cycles = get_cycles(); + schedule_audio(); + events_schedule(); } -uae_u8 *restore_audio (int nr, uae_u8 *src) +uae_u8 *restore_audio(int nr, uae_u8 *src) { - struct audio_channel_data *acd = audio_channel + nr; + const auto acd = audio_channel + nr; - zerostate (nr); - acd->state = restore_u8 (); - acd->data.vol = restore_u8 (); - acd->intreq2 = restore_u8 () ? true : false; - uae_u8 flags = restore_u8 (); + zerostate(nr); + acd->state = restore_u8(); + acd->data.vol = restore_u8(); + acd->intreq2 = restore_u8() != 0; + const auto flags = restore_u8(); acd->dr = acd->dsr = false; if (flags & 1) acd->dr = true; if (flags & 2) acd->dsr = true; - acd->len = restore_u16 (); - acd->wlen = restore_u16 (); - uae_u16 p = restore_u16 (); - acd->per = p ? p * CYCLE_UNIT : PERIOD_MAX; - acd->dat = acd->dat2 = restore_u16 (); - acd->lc = restore_u32 (); - acd->pt = restore_u32 (); - acd->evtime = restore_u32 (); + acd->len = restore_u16(); + acd->wlen = restore_u16(); + const auto p = restore_u16(); + acd->per = p ? p * CYCLE_UNIT : PERIOD_MAX; + acd->dat = acd->dat2 = restore_u16(); + acd->lc = restore_u32(); + acd->pt = restore_u32(); + acd->evtime = restore_u32(); acd->dmaenstore = (dmacon & DMA_MASTER) && (dmacon & (1 << nr)); - return src; + return src; } -uae_u8 *save_audio (int nr, int *len, uae_u8 *dstptr) +uae_u8 *save_audio(int nr, int *len, uae_u8 *dstptr) { - struct audio_channel_data *acd = audio_channel + nr; - uae_u8 *dst, *dstbak; + const auto acd = audio_channel + nr; + uae_u8 *dst, *dstbak; - if (dstptr) - dstbak = dst = dstptr; - else - dstbak = dst = xmalloc (uae_u8, 100); - save_u8 (acd->state); - save_u8 (acd->data.vol); - save_u8 (acd->intreq2); - save_u8 ((acd->dr ? 1 : 0) | (acd->dsr ? 2 : 0) | 0x80); - save_u16 (acd->len); - save_u16 (acd->wlen); - save_u16 (acd->per == PERIOD_MAX ? 0 : acd->per / CYCLE_UNIT); - save_u16 (acd->dat); - save_u32 (acd->lc); - save_u32 (acd->pt); - save_u32 (acd->evtime); - *len = dst - dstbak; - return dstbak; + if (dstptr) + dstbak = dst = dstptr; + else + dstbak = dst = xmalloc(uae_u8, 100); + save_u8(acd->state); + save_u8(acd->data.vol); + save_u8(acd->intreq2); + save_u8((acd->dr ? 1 : 0) | (acd->dsr ? 2 : 0) | 0x80); + save_u16(acd->len); + save_u16(acd->wlen); + save_u16(acd->per == PERIOD_MAX ? 0 : acd->per / CYCLE_UNIT); + save_u16(acd->dat); + save_u32(acd->lc); + save_u32(acd->pt); + save_u32(acd->evtime); + *len = dst - dstbak; + return dstbak; }