static void *ym3812_start(int sndindex, int clock, const void *config)
{
static const struct YM3812interface dummy = { 0 };
int rate = Machine->sample_rate;
struct ym3812_info *info;
info = auto_malloc(sizeof(*info));
memset(info, 0, sizeof(*info));
info->intf = config ? config : &dummy;
rate = clock/72;
/* stream system initialize */
info->chip = YM3812Init(sndindex,clock,rate);
if (!info->chip)
return NULL;
info->stream = stream_create(0,1,rate,info,ym3812_stream_update);
/* YM3812 setup */
YM3812SetTimerHandler (info->chip, TimerHandler_3812, info);
YM3812SetIRQHandler (info->chip, IRQHandler_3812, info);
YM3812SetUpdateHandler(info->chip, _stream_update_3812, info);
info->timer[0] = timer_alloc_ptr(timer_callback_3812_0, info);
info->timer[1] = timer_alloc_ptr(timer_callback_3812_1, info);
return info;
}
///////////////////////////////////////////////////////////////////////////
//
// SD_Startup() - starts up the Sound Mgr
// Detects all additional sound hardware and installs my ISR
//
///////////////////////////////////////////////////////////////////////////
void
SD_Startup(void)
{
int i;
if (SD_Started)
return;
if((audioMutex = SDL_CreateMutex()) == NULL)
{
printf("Unable to create audio mutex\n");
return;
}
if(Mix_OpenAudio(param_samplerate, AUDIO_S16, 2, param_audiobuffer))
{
printf("Unable to open audio: %s\n", Mix_GetError());
return;
}
Mix_ReserveChannels(2); // reserve player and boss weapon channels
Mix_GroupChannels(2, MIX_CHANNELS-1, 1); // group remaining channels
// Init music
if(YM3812Init(1,3579545,param_samplerate))
{
printf("Unable to create virtual OPL!!\n");
}
for(i=1; i<0xf6; i++)
YM3812Write(oplChip,i,0,MAX_VOLUME);
YM3812Write(oplChip,1,0x20,MAX_VOLUME); // Set WSE=1
// YM3812Write(0,8,0); // Set CSM=0 & SEL=0 // already set in for statement
samplesPerMusicTick = param_samplerate / MUSIC_RATE; // SDL_t0FastAsmService played at 700Hz
Mix_HookMusic(SDL_IMFMusicPlayer, 0);
Mix_ChannelFinished(SD_ChannelFinished);
AdLibPresent = true;
SoundBlasterPresent = true;
alTimeCount = 0;
SD_SetSoundMode(sdm_Off);
SD_SetMusicMode(smm_Off);
SD_Started = true;
SoundInfo.Init();
SoundSeq.Init();
}
int YM3812_sh_start(const struct MachineSound *msound)
{
int i;
int rate = Machine->sample_rate;
intf_3812 = msound->sound_interface;
if( intf_3812->num > MAX_3812 ) return 1;
if (options.use_filter)
rate = intf_3812->baseclock/72;
/* Timer state clear */
memset(Timer_3812,0,sizeof(Timer_3812));
/* stream system initialize */
if ( YM3812Init(intf_3812->num,intf_3812->baseclock,rate) != 0)
return 1;
for (i = 0;i < intf_3812->num;i++)
{
/* stream setup */
char name[40];
int vol = intf_3812->mixing_level[i];
/* emulator create */
/* stream setup */
sprintf(name,"%s #%d",sound_name(msound),i);
stream_3812[i] = stream_init(name,vol,rate,i,YM3812UpdateOne);
/* YM3812 setup */
YM3812SetTimerHandler (i, TimerHandler_3812, i*2);
YM3812SetIRQHandler (i, IRQHandler_3812, i);
YM3812SetUpdateHandler(i, stream_update, stream_3812[i]);
Timer_3812[i*2+0] = timer_alloc(timer_callback_3812);
Timer_3812[i*2+1] = timer_alloc(timer_callback_3812);
}
return 0;
}
///////////////////////////////////////////////////////////////////////////
//
// SD_Startup() - starts up the Sound Mgr
// Detects all additional sound hardware and installs my ISR
//
///////////////////////////////////////////////////////////////////////////
void SD_Startup(void)
{
int i;
if (SD_Started)
return;
if(Mix_OpenAudio(44100, AUDIO_S16, 2, 2048))
return; /* Unable to open audio */
Mix_ReserveChannels(2); /* reserve player and boss weapon channels */
Mix_GroupChannels(2, MIX_CHANNELS-1, 1); /* group remaining channels */
/* Initialize music */
samplesPerMusicTick = 44100 / 700; /*played at 700Hzs */
if(YM3812Init(1, 3579545, 44100))
printf("Unable to create virtual OPL!!\n");
for(i=1;i<0xf6;i++)
YM3812Write(0,i,0);
YM3812Write(0,1,0x20); /* Set WSE=1 */
Mix_HookMusic(SD_IMFMusicPlayer, 0);
Mix_ChannelFinished(SD_ChannelFinished);
AdLibPresent = true;
SoundBlasterPresent = true;
alTimeCount = 0;
SD_SetSoundMode(SDM_OFF);
SD_SetMusicMode(SMM_OFF);
SD_SetupDigi();
SD_Started = true;
}
WLAudio::WLAudio():
m_adLib(false), m_soundBlaster(false), m_soundPositioned(0),
m_numReadySamples(0), m_curAlSound(0), m_curAlSoundPtr(0), m_curAlLengthLeft(0),
m_soundTimeCounter(5), m_originalSampleRate(7042), m_sqMaxTracks(10),
m_alChar(0x20), m_alScale(0x40), m_alAttack(0x60), m_alSus(0x80), m_alWave(0xe0),
m_alFreqL(0xa0), m_alFreqH(0xb0), m_alFeedCon(0xc0), m_alEffects(0xbd),
m_nextSoundPos(false)
{
QAudioFormat format;
#if QT_VERSION >= 0x050000
format.setSampleRate(param_samplerate);
format.setChannelCount(2);
#else
format.setFrequency(param_samplerate);
format.setChannels(2);
#endif
format.setByteOrder(QAudioFormat::LittleEndian);
format.setCodec("audio/pcm");
format.setSampleSize(16);
format.setSampleType(QAudioFormat::SignedInt);
m_soundServer = new GameSoundServer(format);
m_samplesPerMusicTick = param_samplerate / 700;
if(YM3812Init(1,3579545,param_samplerate)) {
printf("Unable to create virtual OPL!!\n");
}
for(int i = 1;i < 0xf6;i++)
YM3812Write(0,i,0);
YM3812Write(0, 1, 0x20); // Set WSE=1
m_adLib = true;
m_soundBlaster = true;
m_alTimeCount = 0;
setSoundMode(sdm_Off);
setMusicMode(smm_Off);
setupDigi();
}
CEmuopl::CEmuopl(int rate, bool bit16, bool usestereo)
: use16bit(bit16), stereo(usestereo), oplRate(rate)
{
YM3812Init(1, 3579545, rate);
}
void opl_init( void )
{
YM3812Init(1, 3579545, 11025 * OUTPUT_QUALITY);
}
void BE_ST_InitAudio(void)
{
g_sdlAudioSubsystemUp = false;
g_sdlEmulatedOPLChipReady = false;
int inSampleRate = BE_Cross_GetSelectedGameVerSampleRate();
bool doDigitized = (inSampleRate != 0);
if (!doDigitized)
inSampleRate = OPL_SAMPLE_RATE;
if (g_refKeenCfg.sndSubSystem)
{
if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0)
{
BE_Cross_LogMessage(BE_LOG_MSG_WARNING, "SDL audio system initialization failed,\n%s\n", SDL_GetError());
}
else
{
g_sdlAudioSpec.freq = g_refKeenCfg.sndSampleRate;
#ifdef MIXER_SAMPLE_FORMAT_FLOAT
g_sdlAudioSpec.format = AUDIO_F32SYS;
#elif (defined MIXER_SAMPLE_FORMAT_SINT16)
g_sdlAudioSpec.format = AUDIO_S16SYS;
#endif
g_sdlAudioSpec.channels = 1;
// Should be some power-of-two roughly proportional to the sample rate; Using 1024 for 48000Hz.
for (g_sdlAudioSpec.samples = 1; g_sdlAudioSpec.samples < g_refKeenCfg.sndSampleRate/64; g_sdlAudioSpec.samples *= 2)
{
}
if (doDigitized)
g_sdlAudioSpec.callback = (g_refKeenCfg.sndSampleRate == inSampleRate) ? BEL_ST_Simple_DigiCallBack : BEL_ST_Resampling_DigiCallBack;
else
g_sdlAudioSpec.callback = ((g_refKeenCfg.sndSampleRate == inSampleRate) || !g_refKeenCfg.oplEmulation) ? BEL_ST_Simple_EmuCallBack : BEL_ST_Resampling_EmuCallBack;
g_sdlAudioSpec.userdata = NULL;
if (SDL_OpenAudio(&g_sdlAudioSpec, NULL))
{
BE_Cross_LogMessage(BE_LOG_MSG_WARNING, "Cannot open SDL audio device,\n%s\n", SDL_GetError());
SDL_QuitSubSystem(SDL_INIT_AUDIO);
}
else
{
#ifdef REFKEEN_CONFIG_THREADS
g_sdlCallbackMutex = SDL_CreateMutex();
if (!g_sdlCallbackMutex)
{
BE_Cross_LogMessage(BE_LOG_MSG_ERROR, "Cannot create recursive mutex for SDL audio callback,\n%s\nClosing SDL audio subsystem\n", SDL_GetError());
SDL_CloseAudio();
SDL_QuitSubSystem(SDL_INIT_AUDIO);
}
else
#endif
{
BE_Cross_LogMessage(BE_LOG_MSG_NORMAL, "Audio subsystem initialized, requested spec: freq %d, format %u, channels %d, samples %u\n", (int)g_sdlAudioSpec.freq, (unsigned int)g_sdlAudioSpec.format, (int)g_sdlAudioSpec.channels, (unsigned int)g_sdlAudioSpec.samples);
g_sdlAudioSubsystemUp = true;
}
}
}
}
// If the audio subsystem is off, let us simulate a byte rate
// of 1000Hz (same as SDL_GetTicks() time units)
if (!g_sdlAudioSubsystemUp)
{
g_sdlAudioSpec.freq = doDigitized ? inSampleRate : (NUM_OF_BYTES_FOR_SOUND_CALLBACK_WITH_DISABLED_SUBSYSTEM / sizeof(BE_ST_SndSample_T));
g_sdlAudioSpec.callback = doDigitized ? BEL_ST_Resampling_DigiCallBack : BEL_ST_Resampling_EmuCallBack;
return;
}
if (g_refKeenCfg.oplEmulation)
{
YM3812Init(1, 3579545, OPL_SAMPLE_RATE);
g_sdlEmulatedOPLChipReady = true;
}
if ((doDigitized || g_sdlEmulatedOPLChipReady) && (g_sdlAudioSpec.freq != inSampleRate))
{
// Should allocate this first, for g_sdlSrcData.data_in
g_sdlMiscOutNumOfSamples = 2*g_sdlAudioSpec.samples;
g_sdlMiscOutSamples = (BE_ST_SndSample_T *)malloc(sizeof(BE_ST_SndSample_T) * g_sdlMiscOutNumOfSamples);
if (g_sdlMiscOutSamples == NULL)
BE_ST_ExitWithErrorMsg("BE_ST_InitAudio: Out of memory! (Failed to allocate g_sdlMiscOutSamples.)");
#ifndef REFKEEN_RESAMPLER_NONE
if (g_refKeenCfg.useResampler)
{
#if (!defined REFKEEN_RESAMPLER_LIBRESAMPLE) && (!defined REFKEEN_RESAMPLER_LIBAVCODEC)
char errMsg[160];
#endif
#if (defined REFKEEN_RESAMPLER_LIBSWRESAMPLE)
g_sdlSwrContext = swr_alloc_set_opts(
NULL, // allocating a new context
AV_CH_LAYOUT_MONO, // out channels layout
AV_SAMPLE_FMT_S16, // out format
g_sdlAudioSpec.freq, // out rate
AV_CH_LAYOUT_MONO, // in channels layout
AV_SAMPLE_FMT_S16, // in format
inSampleRate, // in rate
0,
NULL
);
if (g_sdlSwrContext == NULL)
BE_ST_ExitWithErrorMsg("BE_ST_InitAudio: swr_alloc_set_opts failed!");
int error = swr_init(g_sdlSwrContext);
if (error != 0)
{
// av_err2str requires libavutil/libavutil-ffmpeg, so don't convert code to string
snprintf(errMsg, sizeof(errMsg), "BE_ST_InitAudio: swr_init failed! Error code: %d", error);
BE_ST_ExitWithErrorMsg(errMsg);
}
#elif (defined REFKEEN_RESAMPLER_LIBAVRESAMPLE)
g_sdlAvAudioResampleContext = avresample_alloc_context();
if (g_sdlAvAudioResampleContext == NULL)
BE_ST_ExitWithErrorMsg("BE_ST_InitAudio: avresample_alloc_context failed!");
av_opt_set_int(g_sdlAvAudioResampleContext, "in_channel_layout", AV_CH_LAYOUT_MONO, 0);
av_opt_set_int(g_sdlAvAudioResampleContext, "out_channel_layout", AV_CH_LAYOUT_MONO, 0);
av_opt_set_int(g_sdlAvAudioResampleContext, "in_sample_rate", inSampleRate, 0);
av_opt_set_int(g_sdlAvAudioResampleContext, "out_sample_rate", g_sdlAudioSpec.freq, 0);
av_opt_set_int(g_sdlAvAudioResampleContext, "in_sample_fmt", AV_SAMPLE_FMT_S16, 0);
av_opt_set_int(g_sdlAvAudioResampleContext, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0);
int error = avresample_open(g_sdlAvAudioResampleContext);
if (error != 0)
{
// av_err2str requires libavutil/libavutil-ffmpeg, so don't convert code to string
snprintf(errMsg, sizeof(errMsg), "BE_ST_InitAudio: swr_init failed! Error code: %d", error);
BE_ST_ExitWithErrorMsg(errMsg);
}
#elif (defined REFKEEN_RESAMPLER_LIBAVCODEC)
avcodec_register_all();
g_sdlAvResampleContext = av_resample_init(
g_sdlAudioSpec.freq, // out rate
inSampleRate, // in rate
16, // filter length
10, // phase count
0, // linear FIR filter
1.0 // cutoff frequency
);
if (g_sdlAvResampleContext == NULL)
BE_ST_ExitWithErrorMsg("BE_ST_InitAudio: av_resample_init failed!");
#elif (defined REFKEEN_RESAMPLER_LIBRESAMPLE)
g_sdlResampleFactor = (double)g_sdlAudioSpec.freq/inSampleRate;
g_sdlResampleHandle = resample_open(0, g_sdlResampleFactor, g_sdlResampleFactor);
if (g_sdlResampleHandle == NULL)
BE_ST_ExitWithErrorMsg("BE_ST_InitAudio: resample_open failed!");
#elif (defined REFKEEN_RESAMPLER_LIBSOXR)
soxr_io_spec_t io_spec = soxr_io_spec(SOXR_INT16, SOXR_INT16);
soxr_quality_spec_t q_spec = soxr_quality_spec(SOXR_LQ, 0); // Default quality spec adds an audible latency for resampling to 8000Hz
soxr_error_t error;
g_sdlSoxr = soxr_create(
inSampleRate, // in rate
g_sdlAudioSpec.freq, // out rate
1, // channels
&error,
&io_spec,
&q_spec,
NULL // runtime spec
);
if (g_sdlSoxr == NULL)
{
snprintf(errMsg, sizeof(errMsg), "BE_ST_InitAudio: soxr_create failed!\nError: %s", soxr_strerror(error));
BE_ST_ExitWithErrorMsg(errMsg);
}
#elif (defined REFKEEN_RESAMPLER_LIBSPEEXDSP)
int error;
g_sdlSpeexResamplerState = speex_resampler_init(
1, // channels
inSampleRate, // in rate
g_sdlAudioSpec.freq, // out rate
0, // quality in the range 0-10 (10 is higher)
&error
);
if (g_sdlSpeexResamplerState == NULL)
{
snprintf(errMsg, sizeof(errMsg), "BE_ST_InitAudio: speex_resampler_init failed! Error code: %d\nError: %s", error, speex_resampler_strerror(error));
BE_ST_ExitWithErrorMsg(errMsg);
}
#elif (defined REFKEEN_RESAMPLER_LIBSAMPLERATE)
int error;
g_sdlSrcResampler = src_new(SRC_SINC_FASTEST, 1, &error);
if (g_sdlSrcResampler == NULL)
{
snprintf(errMsg, sizeof(errMsg), "BE_ST_InitAudio: src_new failed!\nError code: %d", error);
BE_ST_ExitWithErrorMsg(errMsg);
}
g_sdlSrcData.data_in = doDigitized ? g_sdlMiscOutSamples : g_sdlALOutSamples;
g_sdlSrcData.src_ratio = (double)g_sdlAudioSpec.freq / inSampleRate;
#endif
}
else
#endif // REFKEEN_RESAMPLER_NONE
{
// The sum of all entries should be g_sdlAudioSpec.freq,
// "uniformly" distributed over g_sdlALSampleRateConvTable
g_sdlSampleRateConvTable = (int *)malloc(sizeof(int) * inSampleRate);
if (g_sdlSampleRateConvTable == NULL)
BE_ST_ExitWithErrorMsg("BE_ST_InitAudio: Failed to allocate memory for sample rate conversion!");
g_sdlSampleRateConvTableSize = inSampleRate;
for (int i = 0; i < inSampleRate; ++i)
{
// Using uint64_t cause an overflow is possible
g_sdlSampleRateConvTable[i] = ((uint64_t)(i+1)*(uint64_t)g_sdlAudioSpec.freq/inSampleRate)-(uint64_t)i*(uint64_t)g_sdlAudioSpec.freq/inSampleRate;
}
g_sdlSampleRateConvCurrIndex = 0;
g_sdlSampleRateConvCounter = 0;
}
}
}
