int SOUND_OpenAudio(int freq, int format, int channels, int samples)
{
if (g_fAudioOpened) {
return 0;
}
// Set the audio format
audio_spec.freq = freq;
audio_spec.format = format;
audio_spec.channels = channels; // 1 = mono, 2 = stereo
audio_spec.samples = samples;
audio_spec.callback = SOUND_FillAudio;
audio_spec.userdata = nullptr;
// Open the audio device, forcing the desired format
if (SDL_OpenAudio(&audio_spec, nullptr) < 0) {
fprintf(stderr, "WARNING: Couldn't open audio: %s\n", SDL_GetError());
return -1;
} else {
g_fAudioOpened = true;
return 0;
}
}
const char* Sync_Audio::start( long sample_rate, int chan_count, int latency )
{
stop();
write_buf = 0;
write_pos = 0;
read_buf = 0;
long sample_latency = latency * sample_rate * chan_count / 1000;
buf_count = sample_latency / buf_size;
if ( buf_count < 2 )
buf_count = 2;
bufs = (sample_t*) malloc( (long) buf_size * buf_count * sizeof *bufs );
if ( !bufs )
return "Out of memory";
free_sem = SDL_CreateSemaphore( buf_count - 1 );
if ( !free_sem )
return sdl_error( "Couldn't create semaphore" );
SDL_AudioSpec as;
as.freq = sample_rate;
as.format = AUDIO_S16SYS;
as.channels = chan_count;
as.silence = 0;
as.samples = buf_size / chan_count;
as.size = 0;
as.callback = fill_buffer_;
as.userdata = this;
if ( SDL_OpenAudio( &as, 0 ) < 0 )
return sdl_error( "Couldn't open SDL audio" );
SDL_PauseAudio( 0 );
sound_open = 1;
return 0; // success
}
int shr::SDLAudio::Open(unsigned freq, unsigned samples, void *buf) {
int res;
udata = buf;
fmt.freq = freq;
fmt.format = AUDIO_S16LSB;
fmt.channels = 2;
fmt.samples = samples;
fmt.callback = cb;
fmt.userdata = this;
res = SDL_OpenAudio(&fmt, NULL);
if(res < 0) {
std::cerr << "SDLAudio::Open failed, "
<< SDL_GetError() << std::endl;
return -1;
}
SDL_LockMutex(mut);
return 0;
}
const char* Sound_Queue::start( long sample_rate, int chan_count )
{
assert( !bufs ); // can only be initialized once
write_buf = 0;
write_pos = 0;
read_buf = 0;
#ifndef DREAMCAST
bufs = new sample_t [(long) buf_size * buf_count];
#else
bufs = (sample_t *)std::malloc((long) buf_size * buf_count);
#endif
if ( !bufs )
return "Out of memory";
currently_playing_ = bufs;
free_sem = SDL_CreateSemaphore( buf_count - 1 );
if ( !free_sem )
return sdl_error( "Couldn't create semaphore" );
SDL_AudioSpec as;
as.freq = sample_rate;
as.format = AUDIO_S16SYS;
as.channels = chan_count;
as.silence = 0;
as.samples = buf_size / chan_count;
as.size = 0;
as.callback = fill_buffer_;
as.userdata = this;
if ( SDL_OpenAudio( &as, NULL ) < 0 )
return sdl_error( "Couldn't open SDL audio" );
SDL_PauseAudio( false );
sound_open = true;
return NULL;
}
static void init_sdl() {
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER) < 0) {
exit(11);
}
//SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
//SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
//SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
//SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
//SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 2);
/* Set the video mode */
int videoFlags = SDL_OPENGL;
if (fullscreen)
videoFlags |= SDL_FULLSCREEN;
SDL_Surface *surface = SDL_SetVideoMode(scrWidth, scrHeight, scrBPP,
videoFlags);
if (!surface) {
SDL_Quit();
exit(12);
}
SDL_WM_SetCaption("Latheific!", "Latheific!");
SDL_AudioSpec aspec;
aspec.freq = 44100;
aspec.format = AUDIO_S16;
aspec.channels = 1;
aspec.samples = 2048;
aspec.callback = audio_callback;
aspec.userdata = 0;
if (SDL_OpenAudio(&aspec, NULL) != 0) {
SDL_Quit();
exit(13);
}
}
int main(int argc, char **argv) {
SDL_AudioSpec spec_voulue;
spec_voulue.freq = 44100;
spec_voulue.format = AUDIO_S16; /* Tableau d'entiers 16-bit */
spec_voulue.channels = 2; /* 1 = mono, 2 = stereo */
spec_voulue.samples = 1024; /* Une puissance de 2 sympa (pas plus de 4096) */
spec_voulue.callback = remplir_audio;
spec_voulue.userdata = NULL;
if(SDL_OpenAudio(&spec_voulue, NULL) < 0) {
fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
return EXIT_FAILURE;
}
if(argc <= 1) {
fprintf(stderr, "Usage: %s <music.wav>\n", argv[0]);
return EXIT_FAILURE;
}
SDL_AudioSpec wav_spec = spec_voulue;
if(!SDL_LoadWAV(argv[1], &wav_spec, &son_samples, &son_taille)) {
fprintf(stderr, "Could not open `%s': %s\n", argv[1], SDL_GetError());
return EXIT_FAILURE;
}
son_curseur = son_samples;
SDL_PauseAudio(0);
/* On attend 1/10 de seconde de manière répétée
* tant que le son n'a pas fini de jouer. */
while(son_curseur < son_samples+son_taille)
SDL_Delay(100);
SDL_FreeWAV(son_samples);
SDL_CloseAudio();
return EXIT_SUCCESS;
}
void AudioEngine::init(const AudioParams& ap, float volume)
{
m_Volume = volume;
if (!m_bInitialized) {
m_bInitialized = true;
m_AP = ap;
Dynamics<float, 2>* pLimiter = new Dynamics<float, 2>(float(m_AP.m_SampleRate));
pLimiter->setThreshold(0.f); // in dB
pLimiter->setAttackTime(0.f); // in seconds
pLimiter->setReleaseTime(0.05f); // in seconds
pLimiter->setRmsTime(0.f); // in seconds
pLimiter->setRatio(std::numeric_limits<float>::infinity());
pLimiter->setMakeupGain(0.f); // in dB
m_pLimiter = pLimiter;
SDL_AudioSpec desired;
desired.freq = m_AP.m_SampleRate;
desired.format = AUDIO_S16SYS;
desired.channels = m_AP.m_Channels;
desired.silence = 0;
desired.samples = m_AP.m_OutputBufferSamples;
desired.callback = audioCallback;
desired.userdata = this;
int err = SDL_OpenAudio(&desired, 0);
if (err < 0) {
static bool bWarned = false;
if (!bWarned) {
AVG_TRACE(Logger::category::CONFIG, Logger::severity::WARNING,
"Can't open audio: " << SDL_GetError());
bWarned = true;
}
}
} else {
SDL_PauseAudio(0);
}
}
/**
* audio_sdl_init(): Initialize the SDL audio subsystem.
* @return 0 on success; non-zero on error.
*/
static int audio_sdl_init(void)
{
if (audio_initialized)
return -1;
// Make sure sound is shut down first.
audio_sdl_end();
// Attempt to initialize SDL audio.
if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0)
return -1;
// Set up the SDL audio specification.
SDL_AudioSpec spec;
spec.freq = audio_get_sound_rate();
spec.format = AUDIO_S16SYS;
spec.channels = !(audio_get_stereo()) ? 1 : 2; // TODO: Initializing 1 channel seems to double-free if it's later changed...
spec.samples = 1024;
spec.callback = audio_sdl_callback;
spec.userdata = NULL;
// Initialize the audio buffer.
audio_sdl_audiobuf = (unsigned char*)(calloc(1, (spec.samples * spec.channels * 2 * 4) * sizeof(short)));
if (SDL_OpenAudio(&spec, 0) != 0)
{
// Could not open audio.
free(audio_sdl_audiobuf);
audio_sdl_audiobuf = NULL;
return -2;
}
SDL_PauseAudio(0);
// Sound is initialized.
audio_initialized = TRUE;
return 0;
}
int osd_start_audio_stream(int stereo)
{
stream_cache_channels = (stereo?2:1);
if (options.force_stereo) stream_cache_channels=2;
/* determine the number of samples per frame */
//Fix for games like galaxian that have fractional fps
if(Machine->drv->frames_per_second > 60)
{
samples_per_frame = Machine->sample_rate / (int)Machine->drv->frames_per_second;
}
else
{
samples_per_frame = Machine->sample_rate / Machine->drv->frames_per_second;
}
bytes_per_frame = (samples_per_frame * stream_cache_channels * sizeof(int16_t));
//Sound switched off?
if (Machine->sample_rate == 0) return samples_per_frame;
// attempt to initialize SDL
SDL_AudioSpec spec;
SDL_zero(spec);
spec.freq = Machine->sample_rate;
spec.format = AUDIO_S16SYS;
spec.channels = stream_cache_channels;
spec.samples = 1024;
if (SDL_OpenAudio(&spec, NULL) < 0) {
logerror("Couldn't open audio: %s\n", SDL_GetError());
Machine->sample_rate = 0;
return samples_per_frame;
}
SDL_PauseAudioDevice(audio_device, 0);
return samples_per_frame;
}
/**
* Initialise audio.
*/
void openAudio () {
SDL_AudioSpec asDesired;
#if defined(USE_MODPLUG)
musicFile = NULL;
#elif defined(USE_XMP)
xmpC = xmp_create_context();
#endif
// Set up SDL audio
asDesired.freq = SOUND_FREQ;
asDesired.format = AUDIO_S16;
asDesired.channels = 2;
#if defined(GP2X) || defined(PSP) || defined(_3DS)
asDesired.samples = 512;
#else
asDesired.samples = 2048;
#endif
asDesired.callback = audioCallback;
asDesired.userdata = NULL;
if (SDL_OpenAudio(&asDesired, &audioSpec) < 0)
logError("Unable to open audio", SDL_GetError());
// Load sounds
if (loadSounds("SOUNDS.000") != E_NONE) sounds = NULL;
// Start audio for sfx to work
SDL_PauseAudio(0);
return;
}
int CSound::Init()
{
m_pGraphics = Kernel()->RequestInterface<IEngineGraphics>();
m_pStorage = Kernel()->RequestInterface<IStorage>();
SDL_AudioSpec Format;
m_SoundLock = lock_create();
if(!g_Config.m_SndEnable)
return 0;
m_MixingRate = g_Config.m_SndRate;
// Set 16-bit stereo audio at 22Khz
Format.freq = g_Config.m_SndRate; // ignore_convention
Format.format = AUDIO_S16; // ignore_convention
Format.channels = 2; // ignore_convention
Format.samples = g_Config.m_SndBufferSize; // ignore_convention
Format.callback = SdlCallback; // ignore_convention
Format.userdata = NULL; // ignore_convention
// Open the audio device and start playing sound!
if(SDL_OpenAudio(&Format, NULL) < 0)
{
dbg_msg("client/sound", "unable to open audio: %s", SDL_GetError());
return -1;
}
else
dbg_msg("client/sound", "sound init successful");
SDL_PauseAudio(0);
m_SoundEnabled = 1;
Update(); // update the volume
return 0;
}
/* InitSound:
* Initialise le module de streaming audio.
*/
void
InitSound(void)
{
SDL_AudioSpec desired;
SDL_AudioSpec obtained;
memset(&obtained,0,sizeof(SDL_AudioSpec));
memset(&desired,0,sizeof(SDL_AudioSpec));
# if 0
desired.freq = SDL_SOUND_FREQ;
desired.format = AUDIO_U8;
desired.samples = SDL_SOUND_BUFFER_SIZE;
desired.channels = 1;
desired.callback = loc_SoundCallback;
# else
desired.freq = SDL_SOUND_FREQ; // 44100
desired.format = AUDIO_S16;
desired.samples = SDL_SOUND_BUFFER_SIZE;
desired.channels = 2;
desired.callback = loc_SoundCallback;
# endif
if (SDL_OpenAudio(&desired, &obtained) < 0) {
fprintf(stderr, "Could not open audio: %s\n", SDL_GetError());
exit(1);
}
# if 0 //LUDO: FOR_DEBUG
fprintf(stdout, "freq=%d\n", obtained.freq);
fprintf(stdout, "format=%d\n", obtained.format);
fprintf(stdout, "samples=%d\n", obtained.samples);
fprintf(stdout, "channels=%d\n", obtained.channels);
# endif
memset(sdl_sound_buffer, 0x0, SDL_SOUND_BUFFER_BYTES);
SDL_PauseAudio(0);
THOM.thom_sound_mute = 0;
}
int sound_init_sdl() {
SDL_AudioSpec fmt;
ordenador.sign=0;
ordenador.format=1; //16 bit LE
ordenador.channels=2; //stereo
ordenador.freq=48000;
ordenador.buffer_len=4096;
/* Set 16-bit stereo audio at 48Khz */
fmt.freq = ordenador.freq;
fmt.format = AUDIO_S16SYS; //signed Little endian/Big endian
fmt.channels = ordenador.channels;
fmt.samples = ordenador.buffer_len; //number of samples
fmt.callback = sdlcallback;
fmt.userdata = NULL;
started_sound_sdl=0;
/* Open the audio device and start playing sound! */
if (SDL_OpenAudio(&fmt, NULL) < 0 ) return -1;
printf("SDL audio initiated\n");
ordenador.freq = fmt.freq;
ordenador.channels = fmt.channels;
ordenador.buffer_len = fmt.samples; //number of samples
printf("freq = %d\n",fmt.freq);
printf("channels = %d\n",fmt.channels);
printf("buffer_len = %d\n",fmt.samples);
printf("format = %x\n",fmt.format);
return 0;
}
void HWInitialise(void)
{
unsigned int i,xs,ys;
char Msg[128];
Screen = ScreenBuffer = NULL;
for (i = 0;i < 16;i++) FromHW[i]=-1; /* Create HW->Logical table */
for (i = 0;i < 16;i++) FromHW[ToHW[i]] = i;
if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO) /* Try to start up SDL */
== -1) MERROR();
atexit(SDL_Quit); /* What happens on exit */
Screen = SDL_SetVideoMode(Glo.xSize,Glo.ySize,Glo.Depth,SDL_SWSURFACE);
if (Screen == NULL) MERROR();
ScreenBuffer = SDL_CreateRGBSurface(SDL_SWSURFACE,
Screen->w,Screen->h,
Screen->format->BytesPerPixel*8,0,0,0,0);
if (ScreenBuffer == NULL) MERROR();
SDL_EnableUNICODE(1);
sprintf(Msg,"Football Manager %s",VERSION);
SDL_WM_SetCaption(Msg,NULL);
xs = Glo.xSize/256;ys = Glo.ySize/192; /* Calculate working scale */
Scale = (xs > ys) ? ys : xs;
xOffset = (Glo.xSize-256*Scale)/2; /* And frame */
yOffset = (Glo.ySize-192*Scale)/2;
AudioSpec.freq = 11025; /* Audio frequency */
AudioSpec.format = AUDIO_U8;
AudioSpec.channels = 1;
AudioSpec.samples = 1024;
AudioSpec.callback = HWFillAudio;
AudioSpec.userdata = NULL;
AudioFound = (SDL_OpenAudio(&AudioSpec,NULL) >= 0);
}
bool SoundSDL::init()
{
SDL_AudioSpec audio;
audio.freq = SDL_SAMPLE_RATE;
audio.format = AUDIO_S16SYS;
audio.channels = 2;
audio.samples = 1024;
audio.callback = soundCallback;
audio.userdata = this;
if(SDL_OpenAudio(&audio, NULL))
{
fprintf(stderr,"Failed to open audio: %s\n", SDL_GetError());
return false;
}
_rbuf.reset(_delay * SDL_SAMPLE_RATE * 2);
_cond = SDL_CreateCond();
_mutex = SDL_CreateMutex();
_initialized = true;
return true;
}
void init_audio_platform(struct config_info *conf)
{
SDL_AudioSpec desired_spec =
{
0,
AUDIO_S16SYS,
2,
0,
conf->buffer_size,
0,
0,
sdl_audio_callback,
NULL
};
desired_spec.freq = audio.output_frequency;
SDL_OpenAudio(&desired_spec, &audio_settings);
audio.mix_buffer = cmalloc(audio_settings.size * 2);
audio.buffer_samples = audio_settings.samples;
// now set the audio going
SDL_PauseAudio(0);
}
void Audio_Init(void) {
Sound_Init(); // Init SDL_Sound
// output_decoders();
SDL_AudioSpec* spec = new SDL_AudioSpec;
// spec->freq = 22050;
spec->freq = 48000;
// spec->format = AUDIO_S16SYS;
spec->format = AUDIO_S16LSB;
spec->channels = 2;
spec->samples = 1024;
sound = new Sound::System(spec);
spec->userdata = sound;
spec->callback = sound->GetCallback();
SDL_AudioSpec obtained;
if(SDL_OpenAudio( spec, &obtained ) != 0) {
fprintf(stderr, "[error] %s\n", SDL_GetError());
sound->SetStatus(Sound::eUninitialized);
} else {
sound->SetStatus(Sound::eInitialized);
/*
fprintf(stderr, "[sound] frequency: %d\n", obtained.freq);
fprintf(stderr, "[sound] format: %d\n", obtained.format);
fprintf(stderr, "[sound] channels: %d\n", obtained.channels);
fprintf(stderr, "[sound] silence: %d\n", obtained.silence);
fprintf(stderr, "[sound] buffer in samples: %d\n", obtained.samples);
fprintf(stderr, "[sound] buffer in bytes: %d\n", obtained.size);
*/
}
sound->SetMixMusic(gSettingsCache.playMusic);
sound->SetMixFX(gSettingsCache.playEffects);
}
void
e8910_init_sound()
{
// SDL audio stuff
SDL_AudioSpec reqSpec;
SDL_AudioSpec givenSpec;
PSG.Regs = snd_regs;
PSG.RNG = 1;
PSG.OutputA = 0;
PSG.OutputB = 0;
PSG.OutputC = 0;
PSG.OutputN = 0xff;
e8910_build_mixer_table();
PSG.ready = 1;
// set up audio buffering
reqSpec.freq = SOUND_FREQ; // Audio frequency in samples per second
reqSpec.format = AUDIO_U8; // Audio data format
reqSpec.channels = 1; // Number of channels: 1 mono, 2 stereo
reqSpec.samples = SOUND_SAMPLE; // Audio buffer size in samples
reqSpec.callback = e8910_callback; // Callback function for filling the audio buffer
reqSpec.userdata = NULL;
/* Open the audio device */
if ( SDL_OpenAudio(&reqSpec, &givenSpec) < 0 ){
fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
exit(-1);
}
# if 0
fprintf(stdout, "samples:%d format=%x freq=%d\n", givenSpec.samples, givenSpec.format, givenSpec.freq);
# endif
// Start playing audio
SDL_PauseAudio(0);
}
void srv_sound_on()
{
SDL_AudioSpec desired, obtained;
if (quiet==0)
{
if (sound_is_on) return;
desired.freq = 44100; /* CD-quality */
desired.callback = fillerup;
desired.format = AUDIO_S16; /* 16-bit */
desired.channels = 1; /* mono */
desired.samples = 1024; /* SQ_Max/3 */
if ( SDL_OpenAudio(&desired, &obtained) < 0 )
{
printf("Couldn't open audio: %s\n",SDL_GetError());
quiet = 1;
}
SDL_PauseAudio(0); /* turn on the callback */
sound_is_on = 1;
}
}
/* Open the audio device to what we want */
void
wxGamePanel::StartBuzzer()
{
if (! m_buzzing) {
SDL_AudioSpec as;
/* Fill out what we want */
as.freq = 44100;
as.format = AUDIO_S16SYS;
as.channels = 2;
as.samples = 1024;
as.callback = CreateTone;
/* Get it */
SDL_OpenAudio(&as, NULL);
/* Go! */
SDL_PauseAudio(0);
m_buzzerTimer.Start(1000, true); // 1 sec
m_buzzing = true;
}
}
SDLAudioDevice*
SDLAudioDevice::create(const ParameterList& parameters) {
std::string device = parameters.getValue("device", "DEFAULT");
if (device != "DEFAULT") {
device = "SDL_AUDIO_DRIVER=" + device;
putenv(const_cast<char *>(device.c_str()));
}
SDL_AudioSpec pars;
if (SDL_Init(SDL_INIT_AUDIO) < 0) {
fprintf(stderr, "Unable to init SDL audio: %s.\n", SDL_GetError());
return 0;
}
// fprintf(stderr, "SDL audio intialized\n");
pars.freq = 44100;
pars.callback = sdl_callback;
pars.format = AUDIO_S16SYS;
pars.channels = 2;
pars.samples = 2048;
SDLAudioDevice *dev = new SDLAudioDevice(pars.samples * 16, pars.silence);
pars.userdata = dev;
if (SDL_OpenAudio(&pars, NULL) < 0) {
delete dev;
fprintf(stderr, "Unable to open SDL audio unit: %s.\n", SDL_GetError());
return 0;
}
// fprintf(stderr, "SDL unit opened: %lx\n", dev);
return dev;
}
static qboolean SDL_InitCard(soundcardinfo_t *sc, const char *devicename)
{
SDL_AudioSpec desired, obtained;
if(!SSDL_InitAudio())
{
Con_Printf("Couldn't initialize SDL audio subsystem\n");
return false;
}
memset(&desired, 0, sizeof(desired));
desired.freq = sc->sn.speed;
desired.channels = sc->sn.numchannels; //fixme!
desired.samples = 0x0200; //'Good values seem to range between 512 and 8192 inclusive, depending on the application and CPU speed.'
desired.format = AUDIO_S16SYS;
desired.callback = (void*)SSDL_Paint;
desired.userdata = sc;
memcpy(&obtained, &desired, sizeof(obtained));
#if SDL_MAJOR_VERSION >= 2
sc->audio_fd = SDL_OpenAudioDevice(devicename, false, &desired, &obtained, (sndcardinfo?0:SDL_AUDIO_ALLOW_FREQUENCY_CHANGE) | SDL_AUDIO_ALLOW_CHANNELS_CHANGE);
if (!sc->audio_fd)
{
Con_Printf("SDL_OpenAudioDevice(%s) failed: couldn't open sound device (%s).\n", devicename?devicename:"default", SDL_GetError());
return false;
}
if (devicename)
Con_Printf("Initing SDL audio device '%s'.\n", devicename);
else
Con_Printf("Initing default SDL audio device.\n");
#else
if (sndcardinfo)
return false; //SDL1 only supports opening one audio device at a time. the existing one might not be sdl, but I don't care.
if ( SDL_OpenAudio(&desired, &obtained) < 0 )
{
Con_Printf("SDL_OpenAudio failed: couldn't open sound device (%s).\n", SDL_GetError());
return false;
}
Con_Printf("Initing default SDL audio device.\n");
#endif
sc->sn.numchannels = obtained.channels;
sc->sn.speed = obtained.freq;
sc->sn.samplebits = obtained.format&0xff;
sc->sn.samples = 32768;//*sc->sn.numchannels; //doesn't really matter, so long as it's higher than obtained.samples
#ifdef SELFPAINT
sc->selfpainting = true;
#endif
Con_DPrintf("channels: %i\n", sc->sn.numchannels);
Con_DPrintf("Speed: %i\n", sc->sn.speed);
Con_DPrintf("Samplebits: %i\n", sc->sn.samplebits);
Con_DPrintf("SDLSamples: %i (low for latency)\n", obtained.samples);
Con_DPrintf("FakeSamples: %i\n", sc->sn.samples);
#ifndef SELFPAINT
sc->sn.buffer = malloc(sc->sn.samples*sc->sn.samplebits/8);
#endif
Con_DPrintf("Got sound %i-%i\n", obtained.freq, obtained.format);
sc->Lock = SSDL_LockBuffer;
sc->Unlock = SSDL_UnlockBuffer;
sc->Submit = SSDL_Submit;
sc->Shutdown = SSDL_Shutdown;
sc->GetDMAPos = SSDL_GetDMAPos;
#if SDL_MAJOR_VERSION >= 2
SDL_PauseAudioDevice(sc->audio_fd, 0);
#else
SDL_PauseAudio(0);
#endif
return true;
}
/* Open the mixer with a certain desired audio format */
int Mix_OpenAudio(int frequency, Uint16 format, int nchannels, int chunksize)
{
int i;
SDL_AudioSpec desired;
/* If the mixer is already opened, increment open count */
if ( audio_opened ) {
if ( format == mixer.format && nchannels == mixer.channels ) {
++audio_opened;
return(0);
}
while ( audio_opened ) {
Mix_CloseAudio();
}
}
/* Set the desired format and frequency */
desired.freq = frequency;
desired.format = format;
desired.channels = nchannels;
desired.samples = chunksize;
desired.callback = mix_channels;
desired.userdata = NULL;
/* Accept nearly any audio format */
if ( SDL_OpenAudio(&desired, &mixer) < 0 ) {
return(-1);
}
#if 0
PrintFormat("Audio device", &mixer);
#endif
/* Initialize the music players */
if ( open_music(&mixer) < 0 ) {
SDL_CloseAudio();
return(-1);
}
num_channels = MIX_CHANNELS;
mix_channel = (struct _Mix_Channel *) SDL_malloc(num_channels * sizeof(struct _Mix_Channel));
/* Clear out the audio channels */
for ( i=0; i<num_channels; ++i ) {
mix_channel[i].chunk = NULL;
mix_channel[i].playing = 0;
mix_channel[i].looping = 0;
mix_channel[i].volume = SDL_MIX_MAXVOLUME;
mix_channel[i].fade_volume = SDL_MIX_MAXVOLUME;
mix_channel[i].fade_volume_reset = SDL_MIX_MAXVOLUME;
mix_channel[i].fading = MIX_NO_FADING;
mix_channel[i].tag = -1;
mix_channel[i].expire = 0;
mix_channel[i].effects = NULL;
mix_channel[i].paused = 0;
}
Mix_VolumeMusic(SDL_MIX_MAXVOLUME);
_Mix_InitEffects();
/* This list is (currently) decided at build time. */
add_chunk_decoder("WAVE");
add_chunk_decoder("AIFF");
add_chunk_decoder("VOC");
#ifdef OGG_MUSIC
add_chunk_decoder("OGG");
#endif
#ifdef FLAC_MUSIC
add_chunk_decoder("FLAC");
#endif
audio_opened = 1;
SDL_PauseAudio(0);
return(0);
}
int main(int argc, char *argv[]) {
AVFormatContext *pFormatCtx;
int i, videoStream, audioStream;
AVCodecContext *pCodecCtx;
AVCodec *pCodec;
AVFrame *pFrame;
AVPacket packet;
int frameFinished;
float aspect_ratio;
struct SwsContext *img_convert_ctx;
AVCodecContext *aCodecCtx;
AVCodec *aCodec;
SDL_Overlay *bmp;
SDL_Surface *screen;
SDL_Rect rect;
SDL_Event event;
SDL_AudioSpec wanted_spec, spec;
if(argc < 2) {
fprintf(stderr, "Usage: test <file>\n");
exit(1);
}
// Register all formats and codecs
av_register_all();
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
exit(1);
}
// Open video file
if(av_open_input_file(&pFormatCtx, argv[1], NULL, 0, NULL)!=0)
return -1; // Couldn't open file
// Retrieve stream information
if(av_find_stream_info(pFormatCtx)<0)
return -1; // Couldn't find stream information
// Dump information about file onto standard error
dump_format(pFormatCtx, 0, argv[1], 0);
// Find the first video stream
videoStream=-1;
audioStream=-1;
for(i=0; i<pFormatCtx->nb_streams; i++) {
if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_VIDEO &&
videoStream < 0) {
videoStream=i;
}
if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_AUDIO &&
audioStream < 0) {
audioStream=i;
}
}
if(videoStream==-1)
return -1; // Didn't find a video stream
if(audioStream==-1)
return -1;
aCodecCtx=pFormatCtx->streams[audioStream]->codec;
// Set audio settings from codec info
wanted_spec.freq = aCodecCtx->sample_rate;
wanted_spec.format = AUDIO_S16SYS;
wanted_spec.channels = aCodecCtx->channels;
wanted_spec.silence = 0;
wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
wanted_spec.callback = audio_callback;
wanted_spec.userdata = aCodecCtx;
if(SDL_OpenAudio(&wanted_spec, &spec) < 0) {
fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
return -1;
}
aCodec = avcodec_find_decoder(aCodecCtx->codec_id);
if(!aCodec) {
fprintf(stderr, "Unsupported codec!\n");
return -1;
}
if (avcodec_open(aCodecCtx, aCodec) < 0) {
fprintf(stderr, "Cannot open audio codec!\n");
return -1;
}
// audio_st = pFormatCtx->streams[index]
packet_queue_init(&audioq);
SDL_PauseAudio(0);
// Get a pointer to the codec context for the video stream
pCodecCtx=pFormatCtx->streams[videoStream]->codec;
// Find the decoder for the video stream
pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
if(pCodec==NULL) {
fprintf(stderr, "Unsupported codec!\n");
return -1; // Codec not found
}
// Open codec
if(avcodec_open(pCodecCtx, pCodec)<0) {
fprintf(stderr, "Cannot open video codec!\n");
return -1; // Could not open codec
}
// construct the scale context, conversing to PIX_FMT_YUV420P
img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height,pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);// other codes
if (img_convert_ctx == NULL) {
fprintf(stderr, "Cannot initialize the conversion context!\n");
return -1;
}
// Allocate video frame
pFrame=avcodec_alloc_frame();
// Make a screen to put our video
#ifndef __DARWIN__
screen = SDL_SetVideoMode(pCodecCtx->width, pCodecCtx->height, 0, 0);
#else
screen = SDL_SetVideoMode(pCodecCtx->width, pCodecCtx->height, 24, 0);
#endif
if(!screen) {
fprintf(stderr, "SDL: could not set video mode - exiting\n");
exit(1);
}
// Allocate a place to put our YUV image on that screen
bmp = SDL_CreateYUVOverlay(pCodecCtx->width,
pCodecCtx->height,
SDL_YV12_OVERLAY,
screen);
// Read frames and save first five frames to disk
i=0;
while(av_read_frame(pFormatCtx, &packet)>=0) {
// Is this a packet from the video stream?
if(packet.stream_index==videoStream) {
// Decode video frame
avcodec_decode_video(pCodecCtx, pFrame, &frameFinished,
packet.data, packet.size);
// Did we get a video frame?
if(frameFinished) {
SDL_LockYUVOverlay(bmp);
AVPicture pict;
pict.data[0] = bmp->pixels[0];
pict.data[1] = bmp->pixels[2];
pict.data[2] = bmp->pixels[1];
pict.linesize[0] = bmp->pitches[0];
pict.linesize[1] = bmp->pitches[2];
pict.linesize[2] = bmp->pitches[1];
// Convert the image into YUV format that SDL uses
/*
img_convert(&pict, PIX_FMT_YUV420P,
(AVPicture *)pFrame, pCodecCtx->pix_fmt,
pCodecCtx->width, pCodecCtx->height);
*/
sws_scale(img_convert_ctx, (const uint8_t * const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pict.data, pict.linesize);
SDL_UnlockYUVOverlay(bmp);
rect.x = 0;
rect.y = 0;
rect.w = pCodecCtx->width;
rect.h = pCodecCtx->height;
SDL_DisplayYUVOverlay(bmp, &rect);
av_free_packet(&packet);
}
} else if(packet.stream_index==audioStream) {
packet_queue_put(&audioq, &packet);
} else {
av_free_packet(&packet);
}
// Free the packet that was allocated by av_read_frame
SDL_PollEvent(&event);
switch(event.type) {
case SDL_QUIT:
quit = 1;
SDL_Quit();
exit(0);
break;
default:
break;
}
}
sws_freeContext(img_convert_ctx);
// Free the YUV frame
av_free(pFrame);
// Close the codec
avcodec_close(pCodecCtx);
// Close the video file
av_close_input_file(pFormatCtx);
return 0;
}
static int consumer_play_audio( consumer_sdl self, mlt_frame frame, int init_audio, int *duration )
{
// Get the properties of self consumer
mlt_properties properties = self->properties;
mlt_audio_format afmt = mlt_audio_s16;
// Set the preferred params of the test card signal
int channels = mlt_properties_get_int( properties, "channels" );
int dest_channels = channels;
int frequency = mlt_properties_get_int( properties, "frequency" );
static int counter = 0;
int samples = mlt_sample_calculator( mlt_properties_get_double( self->properties, "fps" ), frequency, counter++ );
int16_t *pcm;
int bytes;
mlt_frame_get_audio( frame, (void**) &pcm, &afmt, &frequency, &channels, &samples );
*duration = ( ( samples * 1000 ) / frequency );
pcm += mlt_properties_get_int( properties, "audio_offset" );
if ( mlt_properties_get_int( properties, "audio_off" ) )
{
self->playing = 1;
init_audio = 1;
return init_audio;
}
if ( init_audio == 1 )
{
SDL_AudioSpec request;
SDL_AudioSpec got;
int audio_buffer = mlt_properties_get_int( properties, "audio_buffer" );
// specify audio format
memset( &request, 0, sizeof( SDL_AudioSpec ) );
self->playing = 0;
request.freq = frequency;
request.format = AUDIO_S16SYS;
request.channels = dest_channels;
request.samples = audio_buffer;
request.callback = sdl_fill_audio;
request.userdata = (void *)self;
if ( SDL_OpenAudio( &request, &got ) != 0 )
{
mlt_log_error( MLT_CONSUMER_SERVICE( self ), "SDL failed to open audio: %s\n", SDL_GetError() );
init_audio = 2;
}
else if ( got.size != 0 )
{
SDL_PauseAudio( 0 );
init_audio = 0;
}
}
if ( init_audio == 0 )
{
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
bytes = samples * dest_channels * sizeof(*pcm);
pthread_mutex_lock( &self->audio_mutex );
while ( self->running && bytes > ( sizeof( self->audio_buffer) - self->audio_avail ) )
pthread_cond_wait( &self->audio_cond, &self->audio_mutex );
if ( self->running )
{
if ( mlt_properties_get_double( properties, "_speed" ) == 1 )
{
if ( channels == dest_channels )
{
memcpy( &self->audio_buffer[ self->audio_avail ], pcm, bytes );
}
else
{
int16_t *dest = (int16_t*) &self->audio_buffer[ self->audio_avail ];
int i = samples + 1;
while ( --i )
{
memcpy( dest, pcm, dest_channels * sizeof(*pcm) );
pcm += channels;
dest += dest_channels;
}
}
}
else
{
memset( &self->audio_buffer[ self->audio_avail ], 0, bytes );
}
self->audio_avail += bytes;
}
pthread_cond_broadcast( &self->audio_cond );
pthread_mutex_unlock( &self->audio_mutex );
}
else
{
self->playing = 1;
}
return init_audio;
}
bool visualiserWin::play(std::string &file)
{
//Initalise ffmpeg.
av_register_all();
//Attempt to open the file.
AVFormatContext* fmtCtx;
if(av_open_input_file(&fmtCtx, file.c_str(), NULL, 0, NULL) != 0)
{
std::cerr << "Could not open file." << std::endl;
return false;
}
if(av_find_stream_info(fmtCtx) < 0)
{
std::cerr << "Could not find stream information." << std::cerr;
return false;
}
AVCodecContext* codecCtx;
int audioStream = -1;
for(int i = 0; i < fmtCtx->nb_streams; i++)
{
if(fmtCtx->streams[i]->codec->codec_type ==
CODEC_TYPE_AUDIO)
{
audioStream = i;
break;
}
}
if(audioStream == -1)
{
std::cerr << "Couldn't find audio stream." << std::endl;
return false;
}
codecCtx = fmtCtx->streams[audioStream]->codec;
AVCodec *codec;
codec = avcodec_find_decoder(codecCtx->codec_id);
if(!codec)
{
std::cerr << "Could not find codec!" << std::endl;
return false;
}
avcodec_open(codecCtx, codec);
SDL_AudioSpec wantedSpec;
SDL_AudioSpec gotSpec;
packetQueue* queue = new packetQueue;
sdlargst* SDLArgs = new sdlargst;
SDLArgs->avcodeccontext = codecCtx;
SDLArgs->queue = queue;
SDLArgs->dspman = dspman;
wantedSpec.freq = codecCtx->sample_rate;
wantedSpec.format = AUDIO_S16SYS;
wantedSpec.channels = codecCtx->channels;
wantedSpec.silence = 0;
wantedSpec.samples = 1024;
wantedSpec.callback = audioThreadEntryPoint;
wantedSpec.userdata = (void*)SDLArgs;
if(SDL_OpenAudio(&wantedSpec, &gotSpec) < 0)
{
throw(SDLException());
return false;
}
SDL_PauseAudio(0);
//Construct worker thread arguments.
ffmpegargst* args = new ffmpegargst;
args->audiostream = audioStream;
args->avformatcontext = fmtCtx;
args->queue = queue;
//Begin ffmpeg worker thread.
ffmpegworkerthread = new pthread_t;
//Run the thread.
pthread_create(ffmpegworkerthread, NULL, ffmpegWorkerEntry, args);
// Also run the sound.
return false;
}
qboolean
SNDDMA_Init (void)
{
SDL_AudioSpec desired, obtained;
int desired_bits, freq;
if (SDL_WasInit(SDL_INIT_EVERYTHING) == 0) {
if (SDL_Init(SDL_INIT_AUDIO) < 0) {
Com_Printf ("Couldn't init SDL audio: %s\n", SDL_GetError ());
return 0;
}
} else if (SDL_WasInit(SDL_INIT_AUDIO) == 0) {
if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
Com_Printf ("Couldn't init SDL audio: %s\n", SDL_GetError ());
return 0;
}
}
snd_inited = 0;
desired_bits = (Cvar_Get("sndbits", "16", CVAR_ARCHIVE))->value;
/* Set up the desired format */
freq = (Cvar_Get("s_khz", "0", CVAR_ARCHIVE))->value;
if (freq == 44)
desired.freq = 44100;
else if (freq == 22)
desired.freq = 22050;
else
desired.freq = 11025;
switch (desired_bits) {
case 8:
desired.format = AUDIO_U8;
break;
case 16:
if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
desired.format = AUDIO_S16MSB;
else
desired.format = AUDIO_S16LSB;
break;
default:
Com_Printf ("Unknown number of audio bits: %d\n", desired_bits);
return 0;
}
desired.channels = (Cvar_Get("sndchannels", "2", CVAR_ARCHIVE))->value;
if (desired.freq == 44100)
desired.samples = 2048;
else if (desired.freq == 22050)
desired.samples = 1024;
else
desired.samples = 512;
desired.callback = paint_audio;
/* Open the audio device */
if (SDL_OpenAudio (&desired, &obtained) < 0) {
Com_Printf ("Couldn't open SDL audio: %s\n", SDL_GetError ());
return 0;
}
/* Make sure we can support the audio format */
switch (obtained.format) {
case AUDIO_U8:
/* Supported */
break;
case AUDIO_S16LSB:
case AUDIO_S16MSB:
if (((obtained.format == AUDIO_S16LSB) &&
(SDL_BYTEORDER == SDL_LIL_ENDIAN)) ||
((obtained.format == AUDIO_S16MSB) &&
(SDL_BYTEORDER == SDL_BIG_ENDIAN))) {
/* Supported */
break;
}
/* Unsupported, fall through */ ;
default:
/* Not supported -- force SDL to do our bidding */
SDL_CloseAudio ();
if (SDL_OpenAudio (&desired, NULL) < 0) {
Com_Printf ("Couldn't open SDL audio: %s\n", SDL_GetError ());
return 0;
}
memcpy (&obtained, &desired, sizeof (desired));
break;
}
SDL_PauseAudio (0);
/* Fill the audio DMA information block */
shm = &dma;
shm->samplebits = (obtained.format & 0xFF);
shm->speed = obtained.freq;
shm->channels = obtained.channels;
shm->samples = obtained.samples * shm->channels;
shm->samplepos = 0;
shm->submission_chunk = 1;
shm->buffer = NULL;
snd_inited = 1;
return 1;
}
void InitializeAudio(int freq)
{
if(SDL_WasInit(SDL_INIT_AUDIO|SDL_INIT_TIMER) == (SDL_INIT_AUDIO|SDL_INIT_TIMER) )
{
#ifdef DEBUG
printf("[JttL's SDL Audio plugin] Debug: Audio and timer allready initialized.\n");
#endif
}
else
{
#ifdef DEBUG
printf("[JttL's SDL Audio plugin] Debug: Audio and timer not yet initialized. Initializing...\n");
#endif
InitializeSDL();
}
if (critical_failure == 1)
return;
GameFreq = freq; // This is important for the sync
if(hardware_spec != NULL) free(hardware_spec);
SDL_PauseAudio(1);
SDL_CloseAudio();
// Prototype of our callback function
void my_audio_callback(void *userdata, Uint8 *stream, int len);
// Open the audio device
SDL_AudioSpec *desired, *obtained;
// Allocate a desired SDL_AudioSpec
desired = malloc(sizeof(SDL_AudioSpec));
// Allocate space for the obtained SDL_AudioSpec
obtained = malloc(sizeof(SDL_AudioSpec));
// 22050Hz - FM Radio quality
//desired->freq=freq;
if(freq < 11025) OutputFreq = 11025;
else if(freq < 22050) OutputFreq = 22050;
else OutputFreq = 44100;
desired->freq = OutputFreq;
#ifdef DEBUG
printf("[JttL's SDL Audio plugin] Debug: Requesting frequency: %iHz.\n", desired->freq);
#endif
/* 16-bit signed audio */
desired->format=AUDIO_S16SYS;
#ifdef DEBUG
printf("[JttL's SDL Audio plugin] Debug: Requesting format: %i.\n", desired->format);
#endif
/* Stereo */
desired->channels=2;
/* Large audio buffer reduces risk of dropouts but increases response time */
desired->samples=SecondaryBufferSize;
/* Our callback function */
desired->callback=my_audio_callback;
desired->userdata=NULL;
if(buffer == NULL)
{
printf("[JttL's SDL Audio plugin] Allocating memory for audio buffer: %i bytes.\n", (int) (PrimaryBufferSize*sizeof(Uint8)));
buffer = (Uint8*) malloc(PrimaryBufferSize);
}
if (mixBuffer == NULL)
{
//this should be the size of the SDL audio buffer
mixBuffer = (Uint8*) malloc(SecondaryBufferSize * 4);
}
memset(buffer, 0, PrimaryBufferSize * sizeof(Uint8));
/* Open the audio device */
if ( SDL_OpenAudio(desired, obtained) < 0 )
{
fprintf(stderr, "[JttL's SDL Audio plugin] Error: Couldn't open audio: %s\n", SDL_GetError());
critical_failure = 1;
return;
}
/* desired spec is no longer needed */
if(desired->format != obtained->format)
{
fprintf(stderr, "[JttL's SDL Audio plugin] Error: Obtained audio format differs from requested.\n");
}
if(desired->freq != obtained->freq)
{
fprintf(stderr, "[JttL's SDL Audio plugin] Error: Obtained frequency differs from requested.\n");
}
free(desired);
hardware_spec=obtained;
#ifdef DEBUG
printf("[JttL's SDL Audio plugin] Debug: Frequency: %i\n", hardware_spec->freq);
printf("[JttL's SDL Audio plugin] Debug: Format: %i\n", hardware_spec->format);
printf("[JttL's SDL Audio plugin] Debug: Channels: %i\n", hardware_spec->channels);
printf("[JttL's SDL Audio plugin] Debug: Silence: %i\n", hardware_spec->silence);
printf("[JttL's SDL Audio plugin] Debug: Samples: %i\n", hardware_spec->samples);
printf("[JttL's SDL Audio plugin] Debug: Size: %i\n", hardware_spec->size);
#endif
SDL_PauseAudio(0);
/* set playback volume */
if (VolumeControlType == VOLUME_TYPE_SDL)
{
VolSDL = SDL_MIX_MAXVOLUME * VolPercent / 100;
}
else
{
VolPercent = volGet();
}
}
EXPORT void CALL DllTest ( HWND hParent )
{
// Defining flags for tests
BOOL init_audio = FALSE;
BOOL init_timer = FALSE;
BOOL open_audio_device = FALSE;
BOOL format_match = FALSE;
BOOL freq_match = FALSE;
// Storage for SDL_Errors.
char *sdl_error[3];
// Clear the pointers (Should not be truly necessary unless something horrible goes wrong)
memset(sdl_error, 0, sizeof(char*[3]));
// Print out inital message
printf("[JttL's SDL Audio plugin] Starting Audio Test.\n");
// Make Sure SDL Audio is disabled so we can restart fresh
SDL_PauseAudio(1);
SDL_CloseAudio();
// Quit the subsystems before attempting to reinitalize them, if either are initalized already
if(SDL_WasInit(SDL_INIT_AUDIO) != 0) SDL_QuitSubSystem(SDL_INIT_AUDIO);
if(SDL_WasInit(SDL_INIT_TIMER) != 0) SDL_QuitSubSystem(SDL_INIT_TIMER);
// Attempt to initialize SDL Audio
if(SDL_Init(SDL_INIT_AUDIO) < 0 )
{
sdl_error[0] = SDL_GetError();
printf("[JttL's SDL Audio plugin] Error: Couldn't initialize audio subsystem: %s\n", sdl_error[0]);
init_audio = FALSE;
}
else
{
printf("[JttL's SDL Audio plugin] Audio subsystem initialized.\n");
init_audio = TRUE;
}
// Attempt to initialize SDL Timer
if(SDL_InitSubSystem(SDL_INIT_TIMER) < 0 )
{
sdl_error[1] = SDL_GetError();
printf("[JttL's SDL Audio plugin] Error: Couldn't initialize timer subsystem: %s\n", sdl_error[1]);
init_timer = FALSE;
}
else
{
printf("[JttL's SDL Audio plugin] Timer subsystem initialized.\n");
init_timer = TRUE;
}
// Close the audio device
SDL_PauseAudio(1);
SDL_CloseAudio();
// Prototype of our callback function
void my_audio_callback(void *userdata, Uint8 *stream, int len);
// Open the audio device
SDL_AudioSpec *desired, *obtained;
// Allocate a desired SDL_AudioSpec
desired = malloc(sizeof(SDL_AudioSpec));
// Allocate space for the obtained SDL_AudioSpec
obtained = malloc(sizeof(SDL_AudioSpec));
// 22050Hz - FM Radio quality
desired->freq=GameFreq;
// Print out message for frequency
printf("[JttL's SDL Audio plugin] Requesting frequency: %iHz.\n", desired->freq);
// 16-bit signed audio
desired->format=AUDIO_S16SYS;
// Print out message for format
printf("[JttL's SDL Audio plugin] Requesting format: %i.\n", desired->format);
// Enable two hardware channels (for Stereo output)
desired->channels=2;
// Large audio buffer reduces risk of dropouts but increases response time
desired->samples=SecondaryBufferSize;
// Our callback function
desired->callback=my_audio_callback;
desired->userdata=NULL;
// Open the audio device
if ( SDL_OpenAudio(desired, obtained) < 0 )
{
sdl_error[2] = SDL_GetError();
fprintf(stderr, "[JttL's SDL Audio plugin] Error: Couldn't open audio device: %s\n", sdl_error[2]);
open_audio_device = FALSE;
}
else
{
open_audio_device = TRUE;
}
// Check to see if we have the audio format we requested.
if(desired->format != obtained->format)
{
fprintf(stderr, "[JttL's SDL Audio plugin] Error: Obtained audio format differs from requested.\n");
format_match = FALSE;
}
else
{
format_match = TRUE;
}
// Check to see if we have the frequency we requested.
if(desired->freq != obtained->freq)
{
fprintf(stderr, "[JttL's SDL Audio plugin] Error: Obtained frequency differs from requested.\n");
freq_match = FALSE;
}
else
{
freq_match = TRUE;
}
// Free no longer needed objects used for testing the specifications.
free(desired);
free(obtained);
// Uninitialize SDL audio, as it is no longer needed.
SDL_PauseAudio(1);
SDL_CloseAudio();
// Quit the Audio and Timer subsystems if they are enabled. (They should be, unless something went horribly wrong.)
if(SDL_WasInit(SDL_INIT_AUDIO) != 0) SDL_QuitSubSystem(SDL_INIT_AUDIO);
if(SDL_WasInit(SDL_INIT_TIMER) != 0) SDL_QuitSubSystem(SDL_INIT_TIMER);
char tMsg[1024];
if((init_audio == TRUE) && ( init_timer == TRUE ) && ( open_audio_device == TRUE ) && (format_match == TRUE) && (freq_match == TRUE))
{
sprintf(tMsg,"[JttL's SDL Audio plugin] Audio test successful.");
critical_failure = 0;
}
else
{
sprintf(tMsg,"[JttL's SDL Audio plugin] Test Results\n--\n");
if(init_audio != TRUE)
{
sprintf(tMsg, "%sError initalizing SDL Audio:\n - %s\n", tMsg,sdl_error[0]);
}
if(init_timer != TRUE)
{
sprintf(tMsg, "%sError initalizing SDL Timer:\n - %s\n", tMsg,sdl_error[1]);
}
if(open_audio_device != TRUE)
{
sprintf(tMsg, "%sError opening audio device:\n - %s\n", tMsg,sdl_error[2]);
}
if(format_match != TRUE)
{
sprintf(tMsg, "%sUnable to get the requested output audio format.\n", tMsg);
}
if(freq_match != TRUE)
{
sprintf(tMsg, "%sUnable to get the requested output frequency.\n", tMsg);
}
critical_failure = 1;
}
display_test(tMsg);
}
SDL_bool
SDLTest_CommonInit(SDLTest_CommonState * state)
{
int i, j, m, n, w, h;
SDL_DisplayMode fullscreen_mode;
if (state->flags & SDL_INIT_VIDEO) {
if (state->verbose & VERBOSE_VIDEO) {
n = SDL_GetNumVideoDrivers();
if (n == 0) {
fprintf(stderr, "No built-in video drivers\n");
} else {
fprintf(stderr, "Built-in video drivers:");
for (i = 0; i < n; ++i) {
if (i > 0) {
fprintf(stderr, ",");
}
fprintf(stderr, " %s", SDL_GetVideoDriver(i));
}
fprintf(stderr, "\n");
}
}
if (SDL_VideoInit(state->videodriver) < 0) {
fprintf(stderr, "Couldn't initialize video driver: %s\n",
SDL_GetError());
return SDL_FALSE;
}
if (state->verbose & VERBOSE_VIDEO) {
fprintf(stderr, "Video driver: %s\n",
SDL_GetCurrentVideoDriver());
}
/* Upload GL settings */
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, state->gl_red_size);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, state->gl_green_size);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, state->gl_blue_size);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, state->gl_alpha_size);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, state->gl_double_buffer);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, state->gl_buffer_size);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, state->gl_depth_size);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, state->gl_stencil_size);
SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, state->gl_accum_red_size);
SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, state->gl_accum_green_size);
SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, state->gl_accum_blue_size);
SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, state->gl_accum_alpha_size);
SDL_GL_SetAttribute(SDL_GL_STEREO, state->gl_stereo);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, state->gl_multisamplebuffers);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, state->gl_multisamplesamples);
if (state->gl_accelerated >= 0) {
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL,
state->gl_accelerated);
}
SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, state->gl_retained_backing);
if (state->gl_major_version) {
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, state->gl_major_version);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, state->gl_minor_version);
}
if (state->gl_debug) {
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
}
if (state->verbose & VERBOSE_MODES) {
SDL_Rect bounds;
SDL_DisplayMode mode;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
n = SDL_GetNumVideoDisplays();
fprintf(stderr, "Number of displays: %d\n", n);
for (i = 0; i < n; ++i) {
fprintf(stderr, "Display %d: %s\n", i, SDL_GetDisplayName(i));
SDL_zero(bounds);
SDL_GetDisplayBounds(i, &bounds);
fprintf(stderr, "Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y);
SDL_GetDesktopDisplayMode(i, &mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
&Bmask, &Amask);
fprintf(stderr,
" Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
mode.w, mode.h, mode.refresh_rate, bpp,
SDL_GetPixelFormatName(mode.format));
if (Rmask || Gmask || Bmask) {
fprintf(stderr, " Red Mask = 0x%.8x\n", Rmask);
fprintf(stderr, " Green Mask = 0x%.8x\n", Gmask);
fprintf(stderr, " Blue Mask = 0x%.8x\n", Bmask);
if (Amask)
fprintf(stderr, " Alpha Mask = 0x%.8x\n", Amask);
}
/* Print available fullscreen video modes */
m = SDL_GetNumDisplayModes(i);
if (m == 0) {
fprintf(stderr, "No available fullscreen video modes\n");
} else {
fprintf(stderr, " Fullscreen video modes:\n");
for (j = 0; j < m; ++j) {
SDL_GetDisplayMode(i, j, &mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
&Gmask, &Bmask, &Amask);
fprintf(stderr,
" Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
j, mode.w, mode.h, mode.refresh_rate, bpp,
SDL_GetPixelFormatName(mode.format));
if (Rmask || Gmask || Bmask) {
fprintf(stderr, " Red Mask = 0x%.8x\n",
Rmask);
fprintf(stderr, " Green Mask = 0x%.8x\n",
Gmask);
fprintf(stderr, " Blue Mask = 0x%.8x\n",
Bmask);
if (Amask)
fprintf(stderr,
" Alpha Mask = 0x%.8x\n",
Amask);
}
}
}
}
}
if (state->verbose & VERBOSE_RENDER) {
SDL_RendererInfo info;
n = SDL_GetNumRenderDrivers();
if (n == 0) {
fprintf(stderr, "No built-in render drivers\n");
} else {
fprintf(stderr, "Built-in render drivers:\n");
for (i = 0; i < n; ++i) {
SDL_GetRenderDriverInfo(i, &info);
SDLTest_PrintRenderer(&info);
}
}
}
SDL_zero(fullscreen_mode);
switch (state->depth) {
case 8:
fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8;
break;
case 15:
fullscreen_mode.format = SDL_PIXELFORMAT_RGB555;
break;
case 16:
fullscreen_mode.format = SDL_PIXELFORMAT_RGB565;
break;
case 24:
fullscreen_mode.format = SDL_PIXELFORMAT_RGB24;
break;
default:
fullscreen_mode.format = SDL_PIXELFORMAT_RGB888;
break;
}
fullscreen_mode.refresh_rate = state->refresh_rate;
state->windows =
(SDL_Window **) SDL_malloc(state->num_windows *
sizeof(*state->windows));
state->renderers =
(SDL_Renderer **) SDL_malloc(state->num_windows *
sizeof(*state->renderers));
if (!state->windows || !state->renderers) {
fprintf(stderr, "Out of memory!\n");
return SDL_FALSE;
}
for (i = 0; i < state->num_windows; ++i) {
char title[1024];
if (state->num_windows > 1) {
SDL_snprintf(title, SDL_arraysize(title), "%s %d",
state->window_title, i + 1);
} else {
SDL_strlcpy(title, state->window_title, SDL_arraysize(title));
}
state->windows[i] =
SDL_CreateWindow(title, state->window_x, state->window_y,
state->window_w, state->window_h,
state->window_flags);
if (!state->windows[i]) {
fprintf(stderr, "Couldn't create window: %s\n",
SDL_GetError());
return SDL_FALSE;
}
if (state->window_minW || state->window_minH) {
SDL_SetWindowMinimumSize(state->windows[i], state->window_minW, state->window_minH);
}
if (state->window_maxW || state->window_maxH) {
SDL_SetWindowMaximumSize(state->windows[i], state->window_maxW, state->window_maxH);
}
SDL_GetWindowSize(state->windows[i], &w, &h);
if (!(state->window_flags & SDL_WINDOW_RESIZABLE) &&
(w != state->window_w || h != state->window_h)) {
printf("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h);
state->window_w = w;
state->window_h = h;
}
if (SDL_SetWindowDisplayMode(state->windows[i], &fullscreen_mode) < 0) {
fprintf(stderr, "Can't set up fullscreen display mode: %s\n",
SDL_GetError());
return SDL_FALSE;
}
if (state->window_icon) {
SDL_Surface *icon = SDLTest_LoadIcon(state->window_icon);
if (icon) {
SDL_SetWindowIcon(state->windows[i], icon);
SDL_FreeSurface(icon);
}
}
SDL_ShowWindow(state->windows[i]);
state->renderers[i] = NULL;
if (!state->skip_renderer
&& (state->renderdriver
|| !(state->window_flags & SDL_WINDOW_OPENGL))) {
m = -1;
if (state->renderdriver) {
SDL_RendererInfo info;
n = SDL_GetNumRenderDrivers();
for (j = 0; j < n; ++j) {
SDL_GetRenderDriverInfo(j, &info);
if (SDL_strcasecmp(info.name, state->renderdriver) ==
0) {
m = j;
break;
}
}
if (m == n) {
fprintf(stderr,
"Couldn't find render driver named %s",
state->renderdriver);
return SDL_FALSE;
}
}
state->renderers[i] = SDL_CreateRenderer(state->windows[i],
m, state->render_flags);
if (!state->renderers[i]) {
fprintf(stderr, "Couldn't create renderer: %s\n",
SDL_GetError());
return SDL_FALSE;
}
if (state->logical_w && state->logical_h) {
SDL_RenderSetLogicalSize(state->renderers[i], state->logical_w, state->logical_h);
} else if (state->scale) {
SDL_RenderSetScale(state->renderers[i], state->scale, state->scale);
}
if (state->verbose & VERBOSE_RENDER) {
SDL_RendererInfo info;
fprintf(stderr, "Current renderer:\n");
SDL_GetRendererInfo(state->renderers[i], &info);
SDLTest_PrintRenderer(&info);
}
}
}
}
if (state->flags & SDL_INIT_AUDIO) {
if (state->verbose & VERBOSE_AUDIO) {
n = SDL_GetNumAudioDrivers();
if (n == 0) {
fprintf(stderr, "No built-in audio drivers\n");
} else {
fprintf(stderr, "Built-in audio drivers:");
for (i = 0; i < n; ++i) {
if (i > 0) {
fprintf(stderr, ",");
}
fprintf(stderr, " %s", SDL_GetAudioDriver(i));
}
fprintf(stderr, "\n");
}
}
if (SDL_AudioInit(state->audiodriver) < 0) {
fprintf(stderr, "Couldn't initialize audio driver: %s\n",
SDL_GetError());
return SDL_FALSE;
}
if (state->verbose & VERBOSE_VIDEO) {
fprintf(stderr, "Audio driver: %s\n",
SDL_GetCurrentAudioDriver());
}
if (SDL_OpenAudio(&state->audiospec, NULL) < 0) {
fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
return SDL_FALSE;
}
}
return SDL_TRUE;
}
