src/AmigaOS/audio_amiga.cpp

/*
 *  audio_amiga.cpp - Audio support, AmigaOS implementation using AHI
 *
 *  Basilisk II (C) 1997-2008 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sysdeps.h"

#include <exec/types.h>
#include <exec/memory.h>
#include <devices/ahi.h>
#define __USE_SYSBASE
#include <proto/exec.h>
#include <proto/ahi.h>
#include <inline/exec.h>
#include <inline/ahi.h>

#include "cpu_emulation.h"
#include "main.h"
#include "prefs.h"
#include "user_strings.h"
#include "audio.h"
#include "audio_defs.h"

#define DEBUG 0
#include "debug.h"

#define D1(x) ;


// Global variables
static ULONG ahi_id = AHI_DEFAULT_ID;                   // AHI audio ID
static struct AHIAudioCtrl *ahi_ctrl = NULL;
static struct AHISampleInfo sample[2];                  // Two sample infos for double-buffering
static struct Hook sf_hook;
static int play_buf = 0;                                                // Number of currently played buffer
static long sound_buffer_size;                                  // Size of one audio buffer in bytes
static int audio_block_fetched = 0;                             // Number of audio blocks fetched by interrupt routine

static bool main_mute = false;
static bool speaker_mute = false;
static ULONG supports_volume_changes = false;
static ULONG supports_stereo_panning = false;
static ULONG current_main_volume;
static ULONG current_speaker_volume;


// Prototypes
static __saveds __attribute__((regparm(3))) ULONG audio_callback(struct Hook *hook /*a0*/, struct AHISoundMessage *msg /*a1*/, struct AHIAudioCtrl *ahi_ctrl /*a2*/);
void audio_set_sample_rate_byval(uint32 value);
void audio_set_sample_size_byval(uint32 value);
void audio_set_channels_byval(uint32 value);


/*
 *  Initialization
 */

// Set AudioStatus to reflect current audio stream format
static void set_audio_status_format(int sample_rate_index)
{
        AudioStatus.sample_rate = audio_sample_rates[sample_rate_index];
        AudioStatus.sample_size = audio_sample_sizes[0];
        AudioStatus.channels = audio_channel_counts[0];
}

void AudioInit(void)
{
        sample[0].ahisi_Address = sample[1].ahisi_Address = NULL;

        // Init audio status and feature flags
        audio_channel_counts.push_back(2);
//      set_audio_status_format();
        AudioStatus.mixer = 0;
        AudioStatus.num_sources = 0;
        audio_component_flags = cmpWantsRegisterMessage | kStereoOut | k16BitOut;

        // Sound disabled in prefs? Then do nothing
        if (PrefsFindBool("nosound"))
                return;

        // AHI available?
        if (AHIBase == NULL) {
                WarningAlert(GetString(STR_NO_AHI_WARN));
                return;
        }

        // Initialize callback hook
        sf_hook.h_Entry = (HOOKFUNC)audio_callback;

        // Read "sound" preferences
        const char *str = PrefsFindString("sound");
        if (str)
                sscanf(str, "ahi/%08lx", &ahi_id);

        // Open audio control structure
        if ((ahi_ctrl = AHI_AllocAudio(
                AHIA_AudioID, ahi_id,
                AHIA_MixFreq, AudioStatus.sample_rate >> 16,
                AHIA_Channels, 1,
                AHIA_Sounds, 2,
                AHIA_SoundFunc, (ULONG)&sf_hook,
                TAG_END)) == NULL) {
                WarningAlert(GetString(STR_NO_AHI_CTRL_WARN));
                return;
        }

        ULONG max_channels, sample_rate, frequencies, sample_rate_index;

        AHI_GetAudioAttrs(ahi_id, ahi_ctrl,
                AHIDB_MaxChannels, (ULONG) &max_channels,
                AHIDB_Frequencies, (ULONG) &frequencies,
                TAG_END);

        D(bug("AudioInit: max_channels=%ld frequencies=%ld\n", max_channels, frequencies));

        for (int n=0; n<frequencies; n++)
                {
                AHI_GetAudioAttrs(ahi_id, ahi_ctrl,
                        AHIDB_FrequencyArg, n,
                        AHIDB_Frequency, (ULONG) &sample_rate,
                        TAG_END);

                D(bug("AudioInit: f=%ld Hz\n", sample_rate));
                audio_sample_rates.push_back(sample_rate << 16);
                }

        ULONG sample_size_bits = 16;

        D(bug("AudioInit: sampe_rates=%ld\n", audio_sample_rates.size() ));

        // get index of sample rate closest to 22050 Hz
        AHI_GetAudioAttrs(ahi_id, ahi_ctrl,
                AHIDB_IndexArg, 22050,
                AHIDB_Bits, (ULONG) &sample_size_bits,
                AHIDB_Index, (ULONG) &sample_rate_index,
                AHIDB_Volume, (ULONG) &supports_volume_changes,
                AHIDB_Panning, (ULONG) &supports_stereo_panning,
                TAG_END);

        audio_sample_sizes.push_back(16);

        set_audio_status_format(sample_rate_index);

        // 2048 frames per block
        audio_frames_per_block = 2048;
        sound_buffer_size = (AudioStatus.sample_size >> 3) * AudioStatus.channels * audio_frames_per_block;

        // Prepare SampleInfos and load sounds (two sounds for double buffering)
        sample[0].ahisi_Type = AudioStatus.sample_size == 16 ? AHIST_S16S : AHIST_S8S;
        sample[0].ahisi_Length = audio_frames_per_block;
        sample[0].ahisi_Address = AllocVec(sound_buffer_size, MEMF_PUBLIC | MEMF_CLEAR);
        sample[1].ahisi_Type = AudioStatus.sample_size == 16 ? AHIST_S16S : AHIST_S8S;
        sample[1].ahisi_Length = audio_frames_per_block;
        sample[1].ahisi_Address = AllocVec(sound_buffer_size, MEMF_PUBLIC | MEMF_CLEAR);
        if (sample[0].ahisi_Address == NULL || sample[1].ahisi_Address == NULL)
                return;

        AHI_LoadSound(0, AHIST_DYNAMICSAMPLE, &sample[0], ahi_ctrl);
        AHI_LoadSound(1, AHIST_DYNAMICSAMPLE, &sample[1], ahi_ctrl);

        // Set parameters
        play_buf = 0;
        current_main_volume = current_speaker_volume = 0x10000;
        AHI_SetVol(0, current_speaker_volume, 0x8000, ahi_ctrl, AHISF_IMM);

        AHI_SetFreq(0, AudioStatus.sample_rate >> 16, ahi_ctrl, AHISF_IMM);
        AHI_SetSound(0, play_buf, 0, 0, ahi_ctrl, AHISF_IMM);

        // Everything OK
        audio_open = true;
}


/*
 *  Deinitialization
 */

void AudioExit(void)
{
        // Free everything
        if (ahi_ctrl != NULL) {
                AHI_ControlAudio(ahi_ctrl, AHIC_Play, FALSE, TAG_END);
                AHI_FreeAudio(ahi_ctrl);
        }

        FreeVec(sample[0].ahisi_Address);
        FreeVec(sample[1].ahisi_Address);
}


/*
 *  First source added, start audio stream
 */

void audio_enter_stream()
{
        AHI_ControlAudio(ahi_ctrl, AHIC_Play, TRUE, TAG_END);
}


/*
 *  Last source removed, stop audio stream
 */

void audio_exit_stream()
{
        AHI_ControlAudio(ahi_ctrl, AHIC_Play, FALSE, TAG_END);
}


/*
 *  AHI sound callback, request next buffer
 */

static __saveds __attribute__((regparm(3))) ULONG audio_callback(struct Hook *hook /*a0*/, struct AHISoundMessage *msg /*a1*/, struct AHIAudioCtrl *ahi_ctrl /*a2*/)
{
        play_buf ^= 1;

        // New buffer available?
        if (audio_block_fetched)
                {
                audio_block_fetched--;

                if (main_mute || speaker_mute)
                        {
                        memset(sample[play_buf].ahisi_Address, 0, sound_buffer_size);
                        }
                else
                        {
                        // Get size of audio data
                        uint32 apple_stream_info = ReadMacInt32(audio_data + adatStreamInfo);
                        if (apple_stream_info) {
                                int32 sample_count = ReadMacInt32(apple_stream_info + scd_sampleCount);

                                uint32 num_channels = ReadMacInt16(apple_stream_info + scd_numChannels);
                                uint32 sample_size = ReadMacInt16(apple_stream_info + scd_sampleSize);
                                uint32 sample_rate = ReadMacInt32(apple_stream_info + scd_sampleRate);

                                D(bug("stream: sample_count=%ld  num_channels=%ld  sample_size=%ld  sample_rate=%ld\n", sample_count, num_channels, sample_size, sample_rate >> 16));

                                // Yes, this can happen.
                                if(sample_count != 0) {
                                        if(sample_rate != AudioStatus.sample_rate) {
                                                audio_set_sample_rate_byval(sample_rate);
                                        }
                                        if(num_channels != AudioStatus.channels) {
                                                audio_set_channels_byval(num_channels);
                                        }
                                        if(sample_size != AudioStatus.sample_size) {
                                                audio_set_sample_size_byval(sample_size);
                                        }
                                }

                                if (sample_count < 0)
                                        sample_count = 0;

                                int work_size = sample_count * num_channels * (sample_size>>3);
                                D(bug("stream: work_size=%ld  sound_buffer_size=%ld\n", work_size, sound_buffer_size));

                                if (work_size > sound_buffer_size)
                                        work_size = sound_buffer_size;

                                // Put data into AHI buffer (convert 8-bit data unsigned->signed)
                                if (AudioStatus.sample_size == 16)
                                        Mac2Host_memcpy(sample[play_buf].ahisi_Address, ReadMacInt32(apple_stream_info + scd_buffer), work_size);
                                else {
                                        uint32 *p = (uint32 *)Mac2HostAddr(ReadMacInt32(apple_stream_info + scd_buffer));
                                        uint32 *q = (uint32 *)sample[play_buf].ahisi_Address;
                                        int r = work_size >> 2;
                                        while (r--)
                                                *q++ = *p++ ^ 0x80808080;
                                }
                                if (work_size != sound_buffer_size)
                                        memset((uint8 *)sample[play_buf].ahisi_Address + work_size, 0, sound_buffer_size - work_size);
                        }
                }

                }
        else
                memset(sample[play_buf].ahisi_Address, 0, sound_buffer_size);

        // Play next buffer
        AHI_SetSound(0, play_buf, 0, 0, ahi_ctrl, 0);

        // Trigger audio interrupt to get new buffer
        if (AudioStatus.num_sources) {
                D1(bug("stream: triggering irq\n"));
                SetInterruptFlag(INTFLAG_AUDIO);
                TriggerInterrupt();
        }
        return 0;
}


/*
 *  MacOS audio interrupt, read next data block
 */

void AudioInterrupt(void)
{
        D1(bug("AudioInterrupt\n"));

        // Get data from apple mixer
        if (AudioStatus.mixer) {
                M68kRegisters r;
                r.a[0] = audio_data + adatStreamInfo;
                r.a[1] = AudioStatus.mixer;
                Execute68k(audio_data + adatGetSourceData, &r);
                D1(bug(" GetSourceData() returns %08lx\n", r.d[0]));
        } else
                WriteMacInt32(audio_data + adatStreamInfo, 0);

        // Signal stream function
        audio_block_fetched++;
        D1(bug("AudioInterrupt done\n"));
}


/*
 *  Set sampling parameters
 *  "index" is an index into the audio_sample_rates[] etc. arrays
 *  It is guaranteed that AudioStatus.num_sources == 0
 */

void audio_set_sample_rate_byval(uint32 value)
{
        bool changed = (AudioStatus.sample_rate != value);
        if(changed)
                {
                ULONG sample_rate_index;

                // get index of sample rate closest to <value> Hz
                AHI_GetAudioAttrs(ahi_id, ahi_ctrl,
                        AHIDB_IndexArg, value >> 16,
                        AHIDB_Index, (ULONG) &sample_rate_index,
                        TAG_END);

                D(bug(" audio_set_sample_rate_byval requested rate=%ld Hz\n", value >> 16));

                AudioStatus.sample_rate = audio_sample_rates[sample_rate_index];

                AHI_SetFreq(0, AudioStatus.sample_rate >> 16, ahi_ctrl, 0);
                }

        D(bug(" audio_set_sample_rate_byval rate=%ld Hz\n", AudioStatus.sample_rate >> 16));
}

void audio_set_sample_size_byval(uint32 value)
{
        bool changed = (AudioStatus.sample_size != value);
        if(changed) {
//              AudioStatus.sample_size = value;
//              update_sound_parameters();
//              WritePrivateProfileInt( "Audio", "SampleSize", AudioStatus.sample_size, ini_file_name );
        }
        D(bug(" audio_set_sample_size_byval %d\n", AudioStatus.sample_size));
}

void audio_set_channels_byval(uint32 value)
{
        bool changed = (AudioStatus.channels != value);
        if(changed) {
//              AudioStatus.channels = value;
//              update_sound_parameters();
//              WritePrivateProfileInt( "Audio", "Channels", AudioStatus.channels, ini_file_name );
        }
        D(bug(" audio_set_channels_byval %d\n", AudioStatus.channels));
}

bool audio_set_sample_rate(int index)
{
        if(index >= 0 && index < audio_sample_rates.size() ) {
                audio_set_sample_rate_byval( audio_sample_rates[index] );
                D(bug(" audio_set_sample_rate index=%ld rate=%ld\n", index, AudioStatus.sample_rate >> 16));
        }

        return true;
}

bool audio_set_sample_size(int index)
{
        if(index >= 0 && index < audio_sample_sizes.size()  ) {
                audio_set_sample_size_byval( audio_sample_sizes[index] );
                D(bug(" audio_set_sample_size %d,%d\n", index,AudioStatus.sample_size));
        }

        return true;
}

bool audio_set_channels(int index)
{
        if(index >= 0 && index < audio_channel_counts.size()   ) {
                audio_set_channels_byval( audio_channel_counts[index] );
                D(bug(" audio_set_channels %d,%d\n", index,AudioStatus.channels));
        }

        return true;
}


/*
 *  Get/set volume controls (volume values received/returned have the left channel
 *  volume in the upper 16 bits and the right channel volume in the lower 16 bits;
 *  both volumes are 8.8 fixed point values with 0x0100 meaning "maximum volume"))
 */

bool audio_get_main_mute(void)
{
        D(bug("audio_get_main_mute:  mute=%ld\n", main_mute));

        return main_mute;
}

uint32 audio_get_main_volume(void)
{
        D(bug("audio_get_main_volume\n"));

                ULONG volume = current_main_volume >> 8;        // 0x10000 => 0x100

                D(bug("audio_get_main_volume: volume=%08lx\n", volume));

                return (volume << 16) + volume;

        return 0x01000100;
}

bool audio_get_speaker_mute(void)
{
        D(bug("audio_get_speaker_mute:  mute=%ld\n", speaker_mute));

        return speaker_mute;
}

uint32 audio_get_speaker_volume(void)
{
        D(bug("audio_get_speaker_volume: \n"));

        if (audio_open)
                {
                ULONG volume = current_speaker_volume >> 8;     // 0x10000 => 0x100

                D(bug("audio_get_speaker_volume: volume=%08lx\n", volume));

                return (volume << 16) + volume;
                }

        return 0x01000100;
}

void audio_set_main_mute(bool mute)
{
        D(bug("audio_set_main_mute: mute=%ld\n", mute));

        if (mute != main_mute)
                {
                main_mute = mute;
                }
}

void audio_set_main_volume(uint32 vol)
{
        D(bug("audio_set_main_volume: vol=%08lx\n", vol));

        if (audio_open && supports_volume_changes)
                {
                ULONG volume = 0x80 * ((vol >> 16) + (vol & 0xffff));

                D(bug("audio_set_main_volume: volume=%08lx\n", volume));

                current_main_volume = volume;

                AHI_SetVol(0, volume, 0x8000, ahi_ctrl, AHISF_IMM);
                }
}

void audio_set_speaker_mute(bool mute)
{
        D(bug("audio_set_speaker_mute: mute=%ld\n", mute));

        if (mute != speaker_mute)
                {
                speaker_mute = mute;
                }
}

void audio_set_speaker_volume(uint32 vol)
{
        D(bug("audio_set_speaker_volume: vol=%08lx\n", vol));

        if (audio_open && supports_volume_changes)
                {
                ULONG volume = 0x80 * ((vol >> 16) + (vol & 0xffff));

                D(bug("audio_set_speaker_volume: volume=%08lx\n", volume));

                current_speaker_volume = volume;

                AHI_SetVol(0, volume, 0x8000, ahi_ctrl, AHISF_IMM);
                }
}
Revision:	1.12
Committed:	2008-01-01T09:40:31Z (16 years, 10 months ago) by gbeauche
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.11:	+1 -1 lines
Log Message:	Happy New Year!
#	Content
1	/*
2	* audio_amiga.cpp - Audio support, AmigaOS implementation using AHI
3	*
4	* Basilisk II (C) 1997-2008 Christian Bauer
5	*
6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/
20
21	#include "sysdeps.h"
22
23	#include <exec/types.h>
24	#include <exec/memory.h>
25	#include <devices/ahi.h>
26	#define __USE_SYSBASE
27	#include <proto/exec.h>
28	#include <proto/ahi.h>
29	#include <inline/exec.h>
30	#include <inline/ahi.h>
31
32	#include "cpu_emulation.h"
33	#include "main.h"
34	#include "prefs.h"
35	#include "user_strings.h"
36	#include "audio.h"
37	#include "audio_defs.h"
38
39	#define DEBUG 0
40	#include "debug.h"
41
42	#define D1(x) ;
43
44
45	// Global variables
46	static ULONG ahi_id = AHI_DEFAULT_ID; // AHI audio ID
47	static struct AHIAudioCtrl *ahi_ctrl = NULL;
48	static struct AHISampleInfo sample[2]; // Two sample infos for double-buffering
49	static struct Hook sf_hook;
50	static int play_buf = 0; // Number of currently played buffer
51	static long sound_buffer_size; // Size of one audio buffer in bytes
52	static int audio_block_fetched = 0; // Number of audio blocks fetched by interrupt routine
53
54	static bool main_mute = false;
55	static bool speaker_mute = false;
56	static ULONG supports_volume_changes = false;
57	static ULONG supports_stereo_panning = false;
58	static ULONG current_main_volume;
59	static ULONG current_speaker_volume;
60
61
62	// Prototypes
63	static __saveds __attribute__((regparm(3))) ULONG audio_callback(struct Hook hook /a0/, struct AHISoundMessage msg /a1/, struct AHIAudioCtrl ahi_ctrl /a2*/);
64	void audio_set_sample_rate_byval(uint32 value);
65	void audio_set_sample_size_byval(uint32 value);
66	void audio_set_channels_byval(uint32 value);
67
68
69	/*
70	* Initialization
71	*/
72
73	// Set AudioStatus to reflect current audio stream format
74	static void set_audio_status_format(int sample_rate_index)
75	{
76	AudioStatus.sample_rate = audio_sample_rates[sample_rate_index];
77	AudioStatus.sample_size = audio_sample_sizes[0];
78	AudioStatus.channels = audio_channel_counts[0];
79	}
80
81	void AudioInit(void)
82	{
83	sample[0].ahisi_Address = sample[1].ahisi_Address = NULL;
84
85	// Init audio status and feature flags
86	audio_channel_counts.push_back(2);
87	// set_audio_status_format();
88	AudioStatus.mixer = 0;
89	AudioStatus.num_sources = 0;
90	audio_component_flags = cmpWantsRegisterMessage \| kStereoOut \| k16BitOut;
91
92	// Sound disabled in prefs? Then do nothing
93	if (PrefsFindBool("nosound"))
94	return;
95
96	// AHI available?
97	if (AHIBase == NULL) {
98	WarningAlert(GetString(STR_NO_AHI_WARN));
99	return;
100	}
101
102	// Initialize callback hook
103	sf_hook.h_Entry = (HOOKFUNC)audio_callback;
104
105	// Read "sound" preferences
106	const char *str = PrefsFindString("sound");
107	if (str)
108	sscanf(str, "ahi/%08lx", &ahi_id);
109
110	// Open audio control structure
111	if ((ahi_ctrl = AHI_AllocAudio(
112	AHIA_AudioID, ahi_id,
113	AHIA_MixFreq, AudioStatus.sample_rate >> 16,
114	AHIA_Channels, 1,
115	AHIA_Sounds, 2,
116	AHIA_SoundFunc, (ULONG)&sf_hook,
117	TAG_END)) == NULL) {
118	WarningAlert(GetString(STR_NO_AHI_CTRL_WARN));
119	return;
120	}
121
122	ULONG max_channels, sample_rate, frequencies, sample_rate_index;
123
124	AHI_GetAudioAttrs(ahi_id, ahi_ctrl,
125	AHIDB_MaxChannels, (ULONG) &max_channels,
126	AHIDB_Frequencies, (ULONG) &frequencies,
127	TAG_END);
128
129	D(bug("AudioInit: max_channels=%ld frequencies=%ld\n", max_channels, frequencies));
130
131	for (int n=0; n<frequencies; n++)
132	{
133	AHI_GetAudioAttrs(ahi_id, ahi_ctrl,
134	AHIDB_FrequencyArg, n,
135	AHIDB_Frequency, (ULONG) &sample_rate,
136	TAG_END);
137
138	D(bug("AudioInit: f=%ld Hz\n", sample_rate));
139	audio_sample_rates.push_back(sample_rate << 16);
140	}
141
142	ULONG sample_size_bits = 16;
143
144	D(bug("AudioInit: sampe_rates=%ld\n", audio_sample_rates.size() ));
145
146	// get index of sample rate closest to 22050 Hz
147	AHI_GetAudioAttrs(ahi_id, ahi_ctrl,
148	AHIDB_IndexArg, 22050,
149	AHIDB_Bits, (ULONG) &sample_size_bits,
150	AHIDB_Index, (ULONG) &sample_rate_index,
151	AHIDB_Volume, (ULONG) &supports_volume_changes,
152	AHIDB_Panning, (ULONG) &supports_stereo_panning,
153	TAG_END);
154
155	audio_sample_sizes.push_back(16);
156
157	set_audio_status_format(sample_rate_index);
158
159	// 2048 frames per block
160	audio_frames_per_block = 2048;
161	sound_buffer_size = (AudioStatus.sample_size >> 3) * AudioStatus.channels * audio_frames_per_block;
162
163	// Prepare SampleInfos and load sounds (two sounds for double buffering)
164	sample[0].ahisi_Type = AudioStatus.sample_size == 16 ? AHIST_S16S : AHIST_S8S;
165	sample[0].ahisi_Length = audio_frames_per_block;
166	sample[0].ahisi_Address = AllocVec(sound_buffer_size, MEMF_PUBLIC \| MEMF_CLEAR);
167	sample[1].ahisi_Type = AudioStatus.sample_size == 16 ? AHIST_S16S : AHIST_S8S;
168	sample[1].ahisi_Length = audio_frames_per_block;
169	sample[1].ahisi_Address = AllocVec(sound_buffer_size, MEMF_PUBLIC \| MEMF_CLEAR);
170	if (sample[0].ahisi_Address == NULL \|\| sample[1].ahisi_Address == NULL)
171	return;
172
173	AHI_LoadSound(0, AHIST_DYNAMICSAMPLE, &sample[0], ahi_ctrl);
174	AHI_LoadSound(1, AHIST_DYNAMICSAMPLE, &sample[1], ahi_ctrl);
175
176	// Set parameters
177	play_buf = 0;
178	current_main_volume = current_speaker_volume = 0x10000;
179	AHI_SetVol(0, current_speaker_volume, 0x8000, ahi_ctrl, AHISF_IMM);
180
181	AHI_SetFreq(0, AudioStatus.sample_rate >> 16, ahi_ctrl, AHISF_IMM);
182	AHI_SetSound(0, play_buf, 0, 0, ahi_ctrl, AHISF_IMM);
183
184	// Everything OK
185	audio_open = true;
186	}
187
188
189	/*
190	* Deinitialization
191	*/
192
193	void AudioExit(void)
194	{
195	// Free everything
196	if (ahi_ctrl != NULL) {
197	AHI_ControlAudio(ahi_ctrl, AHIC_Play, FALSE, TAG_END);
198	AHI_FreeAudio(ahi_ctrl);
199	}
200
201	FreeVec(sample[0].ahisi_Address);
202	FreeVec(sample[1].ahisi_Address);
203	}
204
205
206	/*
207	* First source added, start audio stream
208	*/
209
210	void audio_enter_stream()
211	{
212	AHI_ControlAudio(ahi_ctrl, AHIC_Play, TRUE, TAG_END);
213	}
214
215
216	/*
217	* Last source removed, stop audio stream
218	*/
219
220	void audio_exit_stream()
221	{
222	AHI_ControlAudio(ahi_ctrl, AHIC_Play, FALSE, TAG_END);
223	}
224
225
226	/*
227	* AHI sound callback, request next buffer
228	*/
229
230	static __saveds __attribute__((regparm(3))) ULONG audio_callback(struct Hook hook /a0/, struct AHISoundMessage msg /a1/, struct AHIAudioCtrl ahi_ctrl /a2*/)
231	{
232	play_buf ^= 1;
233
234	// New buffer available?
235	if (audio_block_fetched)
236	{
237	audio_block_fetched--;
238
239	if (main_mute \|\| speaker_mute)
240	{
241	memset(sample[play_buf].ahisi_Address, 0, sound_buffer_size);
242	}
243	else
244	{
245	// Get size of audio data
246	uint32 apple_stream_info = ReadMacInt32(audio_data + adatStreamInfo);
247	if (apple_stream_info) {
248	int32 sample_count = ReadMacInt32(apple_stream_info + scd_sampleCount);
249
250	uint32 num_channels = ReadMacInt16(apple_stream_info + scd_numChannels);
251	uint32 sample_size = ReadMacInt16(apple_stream_info + scd_sampleSize);
252	uint32 sample_rate = ReadMacInt32(apple_stream_info + scd_sampleRate);
253
254	D(bug("stream: sample_count=%ld num_channels=%ld sample_size=%ld sample_rate=%ld\n", sample_count, num_channels, sample_size, sample_rate >> 16));
255
256	// Yes, this can happen.
257	if(sample_count != 0) {
258	if(sample_rate != AudioStatus.sample_rate) {
259	audio_set_sample_rate_byval(sample_rate);
260	}
261	if(num_channels != AudioStatus.channels) {
262	audio_set_channels_byval(num_channels);
263	}
264	if(sample_size != AudioStatus.sample_size) {
265	audio_set_sample_size_byval(sample_size);
266	}
267	}
268
269	if (sample_count < 0)
270	sample_count = 0;
271
272	int work_size = sample_count * num_channels * (sample_size>>3);
273	D(bug("stream: work_size=%ld sound_buffer_size=%ld\n", work_size, sound_buffer_size));
274
275	if (work_size > sound_buffer_size)
276	work_size = sound_buffer_size;
277
278	// Put data into AHI buffer (convert 8-bit data unsigned->signed)
279	if (AudioStatus.sample_size == 16)
280	Mac2Host_memcpy(sample[play_buf].ahisi_Address, ReadMacInt32(apple_stream_info + scd_buffer), work_size);
281	else {
282	uint32 p = (uint32 )Mac2HostAddr(ReadMacInt32(apple_stream_info + scd_buffer));
283	uint32 q = (uint32 )sample[play_buf].ahisi_Address;
284	int r = work_size >> 2;
285	while (r--)
286	q++ = p++ ^ 0x80808080;
287	}
288	if (work_size != sound_buffer_size)
289	memset((uint8 *)sample[play_buf].ahisi_Address + work_size, 0, sound_buffer_size - work_size);
290	}
291	}
292
293	}
294	else
295	memset(sample[play_buf].ahisi_Address, 0, sound_buffer_size);
296
297	// Play next buffer
298	AHI_SetSound(0, play_buf, 0, 0, ahi_ctrl, 0);
299
300	// Trigger audio interrupt to get new buffer
301	if (AudioStatus.num_sources) {
302	D1(bug("stream: triggering irq\n"));
303	SetInterruptFlag(INTFLAG_AUDIO);
304	TriggerInterrupt();
305	}
306	return 0;
307	}
308
309
310	/*
311	* MacOS audio interrupt, read next data block
312	*/
313
314	void AudioInterrupt(void)
315	{
316	D1(bug("AudioInterrupt\n"));
317
318	// Get data from apple mixer
319	if (AudioStatus.mixer) {
320	M68kRegisters r;
321	r.a[0] = audio_data + adatStreamInfo;
322	r.a[1] = AudioStatus.mixer;
323	Execute68k(audio_data + adatGetSourceData, &r);
324	D1(bug(" GetSourceData() returns %08lx\n", r.d[0]));
325	} else
326	WriteMacInt32(audio_data + adatStreamInfo, 0);
327
328	// Signal stream function
329	audio_block_fetched++;
330	D1(bug("AudioInterrupt done\n"));
331	}
332
333
334	/*
335	* Set sampling parameters
336	* "index" is an index into the audio_sample_rates[] etc. arrays
337	* It is guaranteed that AudioStatus.num_sources == 0
338	*/
339
340	void audio_set_sample_rate_byval(uint32 value)
341	{
342	bool changed = (AudioStatus.sample_rate != value);
343	if(changed)
344	{
345	ULONG sample_rate_index;
346
347	// get index of sample rate closest to <value> Hz
348	AHI_GetAudioAttrs(ahi_id, ahi_ctrl,
349	AHIDB_IndexArg, value >> 16,
350	AHIDB_Index, (ULONG) &sample_rate_index,
351	TAG_END);
352
353	D(bug(" audio_set_sample_rate_byval requested rate=%ld Hz\n", value >> 16));
354
355	AudioStatus.sample_rate = audio_sample_rates[sample_rate_index];
356
357	AHI_SetFreq(0, AudioStatus.sample_rate >> 16, ahi_ctrl, 0);
358	}
359
360	D(bug(" audio_set_sample_rate_byval rate=%ld Hz\n", AudioStatus.sample_rate >> 16));
361	}
362
363	void audio_set_sample_size_byval(uint32 value)
364	{
365	bool changed = (AudioStatus.sample_size != value);
366	if(changed) {
367	// AudioStatus.sample_size = value;
368	// update_sound_parameters();
369	// WritePrivateProfileInt( "Audio", "SampleSize", AudioStatus.sample_size, ini_file_name );
370	}
371	D(bug(" audio_set_sample_size_byval %d\n", AudioStatus.sample_size));
372	}
373
374	void audio_set_channels_byval(uint32 value)
375	{
376	bool changed = (AudioStatus.channels != value);
377	if(changed) {
378	// AudioStatus.channels = value;
379	// update_sound_parameters();
380	// WritePrivateProfileInt( "Audio", "Channels", AudioStatus.channels, ini_file_name );
381	}
382	D(bug(" audio_set_channels_byval %d\n", AudioStatus.channels));
383	}
384
385	bool audio_set_sample_rate(int index)
386	{
387	if(index >= 0 && index < audio_sample_rates.size() ) {
388	audio_set_sample_rate_byval( audio_sample_rates[index] );
389	D(bug(" audio_set_sample_rate index=%ld rate=%ld\n", index, AudioStatus.sample_rate >> 16));
390	}
391
392	return true;
393	}
394
395	bool audio_set_sample_size(int index)
396	{
397	if(index >= 0 && index < audio_sample_sizes.size() ) {
398	audio_set_sample_size_byval( audio_sample_sizes[index] );
399	D(bug(" audio_set_sample_size %d,%d\n", index,AudioStatus.sample_size));
400	}
401
402	return true;
403	}
404
405	bool audio_set_channels(int index)
406	{
407	if(index >= 0 && index < audio_channel_counts.size() ) {
408	audio_set_channels_byval( audio_channel_counts[index] );
409	D(bug(" audio_set_channels %d,%d\n", index,AudioStatus.channels));
410	}
411
412	return true;
413	}
414
415
416	/*
417	* Get/set volume controls (volume values received/returned have the left channel
418	* volume in the upper 16 bits and the right channel volume in the lower 16 bits;
419	* both volumes are 8.8 fixed point values with 0x0100 meaning "maximum volume"))
420	*/
421
422	bool audio_get_main_mute(void)
423	{
424	D(bug("audio_get_main_mute: mute=%ld\n", main_mute));
425
426	return main_mute;
427	}
428
429	uint32 audio_get_main_volume(void)
430	{
431	D(bug("audio_get_main_volume\n"));
432
433	ULONG volume = current_main_volume >> 8; // 0x10000 => 0x100
434
435	D(bug("audio_get_main_volume: volume=%08lx\n", volume));
436
437	return (volume << 16) + volume;
438
439	return 0x01000100;
440	}
441
442	bool audio_get_speaker_mute(void)
443	{
444	D(bug("audio_get_speaker_mute: mute=%ld\n", speaker_mute));
445
446	return speaker_mute;
447	}
448
449	uint32 audio_get_speaker_volume(void)
450	{
451	D(bug("audio_get_speaker_volume: \n"));
452
453	if (audio_open)
454	{
455	ULONG volume = current_speaker_volume >> 8; // 0x10000 => 0x100
456
457	D(bug("audio_get_speaker_volume: volume=%08lx\n", volume));
458
459	return (volume << 16) + volume;
460	}
461
462	return 0x01000100;
463	}
464
465	void audio_set_main_mute(bool mute)
466	{
467	D(bug("audio_set_main_mute: mute=%ld\n", mute));
468
469	if (mute != main_mute)
470	{
471	main_mute = mute;
472	}
473	}
474
475	void audio_set_main_volume(uint32 vol)
476	{
477	D(bug("audio_set_main_volume: vol=%08lx\n", vol));
478
479	if (audio_open && supports_volume_changes)
480	{
481	ULONG volume = 0x80 * ((vol >> 16) + (vol & 0xffff));
482
483	D(bug("audio_set_main_volume: volume=%08lx\n", volume));
484
485	current_main_volume = volume;
486
487	AHI_SetVol(0, volume, 0x8000, ahi_ctrl, AHISF_IMM);
488	}
489	}
490
491	void audio_set_speaker_mute(bool mute)
492	{
493	D(bug("audio_set_speaker_mute: mute=%ld\n", mute));
494
495	if (mute != speaker_mute)
496	{
497	speaker_mute = mute;
498	}
499	}
500
501	void audio_set_speaker_volume(uint32 vol)
502	{
503	D(bug("audio_set_speaker_volume: vol=%08lx\n", vol));
504
505	if (audio_open && supports_volume_changes)
506	{
507	ULONG volume = 0x80 * ((vol >> 16) + (vol & 0xffff));
508
509	D(bug("audio_set_speaker_volume: volume=%08lx\n", volume));
510
511	current_speaker_volume = volume;
512
513	AHI_SetVol(0, volume, 0x8000, ahi_ctrl, AHISF_IMM);
514	}
515	}