Example #1
0
/**\brief Audio system shutdown.
 */
bool Audio::Shutdown( void ){
	/* This is the cleaning up part */
	this->HaltAll();


#if defined(SDL_MIXER_MAJOR_VERSION) && (SDL_MIXER_MAJOR_VERSION>1) \
	&& (SDL_MIXER_MINOR_VERSON>2) && (SDL_MIXER_PATCHLEVEL>=10)
	// Free every library loaded
	const SDL_version *mix_version=Mix_Linked_Version();
	if( (mix_version->major>=1) && (mix_version->minor>=2) && (mix_version->patch>=10) ){
		while(Mix_Init(0))
			Mix_Quit();
	}
#endif // SDL_Mixer version requirements

	// Query number of times audio device was opened (should be 1)
	int freq, chan, ntimes;
	Uint16 format;
	if ( (ntimes = Mix_QuerySpec( &freq, &format, &chan )) != 1 )
		LogMsg(WARN,"Audio was initialized multiple times.");

	// Close as many times as opened.
	for ( int i = 0; i < ntimes; i++ )
		Mix_CloseAudio();
	return true;
}
AudioSDLMixer::AudioSDLMixer(AudioConfig &sc)
  : Audio(sc), audio_open(0), music(NULL), oldPlaying(false)
{
  if ( SDL_InitSubSystem(SDL_INIT_AUDIO) < 0 ) 
    throw std::runtime_error(std::string("Couldn't initialize SDL: ")+SDL_GetError());
    
  /* Open the audio device */
  int audio_rate = m_sc.srate;
  Uint16 audio_format=AUDIO_S8;
  if (m_sc.sbits==16)
    audio_format=AUDIO_S16;
  int audio_channels=1;
  if (m_sc.stereo) audio_channels=2;
  int audio_buffers = m_sc.sbuffers;

  if (Mix_OpenAudio(audio_rate, audio_format, audio_channels, audio_buffers) < 0) {
    throw std::runtime_error(std::string("Couldn't open audio: ")+SDL_GetError());
  } else {
    Mix_QuerySpec(&audio_rate, &audio_format, &audio_channels);
    /*    printf("Opened audio at %d Hz %d bit %s, %d bytes audio buffer\n", audio_rate,
	   (audio_format&0xFF),
	   (audio_channels > 1) ? "stereo" : "mono", 
	   audio_buffers ); */
  }
  audio_open = 1;
  
  /* Set the external music player, if any */
  // TODO: perhaps we should not use this for security reasons
  Mix_SetMusicCMD(getenv("MUSIC_CMD"));
}
Example #3
0
/**
 * @brief Loads a sound into the sound_list.
 *
 *    @param filename Name fo the file to load.
 *    @return The SDL_Mixer of the loaded chunk.
 *
 * @sa sound_makeList
 */
int sound_mix_load( alSound *s, const char *filename )
{
   SDL_RWops *rw;
   int freq, bytes, channels;
   Uint16 format;

   /* get the file data buffer from packfile */
   rw = ndata_rwops( filename );

   /* bind to buffer */
   s->u.mix.buf = Mix_LoadWAV_RW(rw,1);
   if (s->u.mix.buf == NULL) {
      DEBUG("Unable to load sound '%s': %s", filename, Mix_GetError());
      return -1;
   }

   /* Get spec. */
   Mix_QuerySpec( &freq, &format, &channels );
   switch (format) {
      case AUDIO_U8:
      case AUDIO_S8:
         bytes = 1;
         break;
      default:
         bytes = 2;
         break;
   }

   /* Set length. */
   s->length = (double)s->u.mix.buf->alen / (double)(freq*bytes*channels);

   return 0;
}
Example #4
0
/**
 * @brief Prints the current and compiled SDL_Mixer versions.
 */
static void print_MixerVersion (void)
{
   int frequency;
   Uint16 format;
   int channels;
   SDL_version compiled;
   const SDL_version *linked;
   char device[PATH_MAX];

   /* Query stuff. */
   Mix_QuerySpec(&frequency, &format, &channels);
   MIX_VERSION(&compiled);
   linked = Mix_Linked_Version();
   SDL_AudioDriverName(device, PATH_MAX);

   /* Version itself. */
   DEBUG("SDL_Mixer Started: %d Hz %s", frequency,
         (channels == 2) ? "Stereo" : "Mono" );
   /* Check if major/minor version differ. */
   if ((linked->major*100 + linked->minor) > compiled.major*100 + compiled.minor)
      WARN("SDL_Mixer is newer than compiled version");
   if ((linked->major*100 + linked->minor) < compiled.major*100 + compiled.minor)
      WARN("SDL_Mixer is older than compiled version.");
   /* Print other debug info. */
   DEBUG("Renderer: %s",device);
   DEBUG("Version: %d.%d.%d [compiled: %d.%d.%d]", 
         compiled.major, compiled.minor, compiled.patch,
         linked->major, linked->minor, linked->patch);
   DEBUG();
}
Example #5
0
void initSound() {
  int audio_rate;
  Uint16 audio_format;
  int audio_channels;
  int audio_buffers;

  if ( SDL_InitSubSystem(SDL_INIT_AUDIO) < 0 ) {
    fprintf(stderr, "Unable to initialize SDL_AUDIO: %s\n", SDL_GetError());
    return;
  }

  audio_rate = 44100;
  audio_format = AUDIO_S16;
  audio_channels = 1;
  audio_buffers = 4096;
  
  if (Mix_OpenAudio(audio_rate, audio_format, audio_channels, audio_buffers) < 0) {
    fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
    return;
  } else {
    Mix_QuerySpec(&audio_rate, &audio_format, &audio_channels);
  }

  useAudio = 1;
  loadSounds();
}
Example #6
0
static dboolean SDLIsInitialized(void)
{
    int         freq, channels;
    Uint16      format;

    return (!!Mix_QuerySpec(&freq, &format, &channels));
}
Example #7
0
/**\brief Audio system initialization.
 */
bool Audio::Initialize( void ) {
	if( initialized ) {
		return false;
	}

	if(OPTION(bool, "options/sound/disable-audio")) {
		LogMsg(INFO, "Not initializing audio as it is disabled.");
		return true; // audio is disabled
	}

	if(SDL_Init(SDL_INIT_AUDIO) < 0) {
		LogMsg(ERR, "SDL could not initialize audio: %s", SDL_GetError());
		return false;
	}

	if(Mix_OpenAudio(this->audio_rate, this->audio_format, this->audio_channels, this->audio_buffers)) {
		LogMsg(ERR, "Audio initialization failed!: %s", Mix_GetError());
		return false;
	}

	Mix_QuerySpec(&this->audio_rate, &this->audio_format, &this->audio_channels);

	LogMsg(DEBUG, "SDL_mixer gave us rate %d, format %d, channels %d", this->audio_rate, this->audio_format, this->audio_channels);

	// Load MOD and OGG libraries
	Mix_Init( MIX_INIT_MOD | MIX_INIT_OGG );

	// Allocate channels
	Mix_AllocateChannels( this->max_chan);

	assert( this->max_chan == static_cast<unsigned int>(this->GetTotalChannels()) );

	return true;
}
Example #8
0
/**\brief Audio system shutdown.
 */
bool Audio::Shutdown( void ) {
	if(OPTION(bool, "options/sound/disable-audio")) {
		return true; // audio is disabled
	}

	/* Halt all currently playing sounds */
	Mix_HaltChannel( -1 );

	// Free every library loaded
	while(Mix_Init(0)) {
		Mix_Quit();
	}

	// Query number of times audio device was opened (should be 1)
	int freq, chan, ntimes;
	Uint16 format;
	ntimes = Mix_QuerySpec( &freq, &format, &chan );

	LogMsg(DEBUG, "Audio Query: %d Frequencies, Format: %d, Channels: %s.", freq, format, (chan==2?"Stereo":"Mono"));

	if(ntimes != 1 ) {
		LogMsg(WARN, "Audio was initialized %d times.", ntimes);
	}

	// Close only if open
	if( ntimes ) {
		Mix_CloseAudio();
	}

	return true;
}
Example #9
0
static bool start_sound_engine()
{
  /* This is where we open up our audio device.  Mix_OpenAudio takes
     as its parameters the audio format we'd /like/ to have. */
  if(Mix_OpenAudio(info.rate, info.format, info.channels, info.buffers))
  {
    GB.Error("Unable to open audio");
    return TRUE;
  }

	if (pipe(_ch_pipe))
	{
		GB.Error("Unable to initialize channel pipe");
		return TRUE;
	}
	
  Mix_QuerySpec(&info.rate, &info.format, &info.channels);
	//fprintf(stderr, "Mix_QuerySpec: %d %d %d\n", info.rate, info.format, info.channels);

  channel_count = Mix_AllocateChannels(-1);

  Mix_ChannelFinished(channel_finished);

	return FALSE;
}
Example #10
0
void SoundManager::ShutdownMix()
{
  // for each Mix_OpenAudio call, there must be corresponding Mix_CloseAudio call
  int numOpen = Mix_QuerySpec(nullptr, nullptr, nullptr);
  for (int i = 0; i < numOpen; ++i)
    Mix_CloseAudio();
}
Example #11
0
/**\brief Audio system shutdown.
 */
bool Audio::Shutdown( void ){
	/* This is the cleaning up part */
	this->HaltAll();


#if defined(SDL_MIXER_MAJOR_VERSION) && (SDL_MIXER_MAJOR_VERSION>1) \
	&& (SDL_MIXER_MINOR_VERSON>2) && (SDL_MIXER_PATCHLEVEL>=10)
	// Free every library loaded
	const SDL_version *mix_version=Mix_Linked_Version();
	if( (mix_version->major>=1) && (mix_version->minor>=2) && (mix_version->patch>=10) ){
		while(Mix_Init(0))
			Mix_Quit();
	}
#endif // SDL_Mixer version requirements

	// Query number of times audio device was opened (should be 1)
	int freq, chan, ntimes;
	Uint16 format;
	ntimes = Mix_QuerySpec( &freq, &format, &chan );

	LogMsg(INFO,"Audio Query: %d Frequencies, Format: %d, Channels: %s.", freq, format, (chan==2?"Stereo":"Mono"));

	if(ntimes != 1 ) {
		LogMsg(WARN,"Audio was initialized %d times.", ntimes);
	}

	// Close only if open
	if( ntimes ) {
		Mix_CloseAudio();
	}

	return true;
}
Example #12
0
SoundEffect::SoundEffect(const string& filename, Uint8 volume)
   : sound(NULL), channel(-1)
{
   if (++loadCount == 1) {
      
      if (Mix_OpenAudio(audioRate, audioFormat, audioChannels, audioBuffers)) {
         cerr << "Failed to open audio: " << Mix_GetError() << endl;
         cerr << "(Disabling sound effects)" << endl;
         
         SetEnabled(false);
         return;
      }

      // Get the actual settings used
      Mix_QuerySpec(&audioRate, &audioFormat, &audioChannels);
   }

   if (!enabled) return;

   if (!(sound = Mix_LoadWAV(filename.c_str()))) {
      ostringstream ss;
      ss << "Error loading " << filename << ": ";
      ss << Mix_GetError();
      throw runtime_error(ss.str());
   }

   sound->volume = volume;
}
Example #13
0
/*
 * S_Init
 */
void S_Init(void) {
	int freq, channels;
	unsigned short format;

	memset(&s_env, 0, sizeof(s_env));

	if (Cvar_GetValue("s_disable")) {
		Com_Warn("Sound disabled.\n");
		return;
	}

	Com_Print("Sound initialization...\n");

	s_rate = Cvar_Get("s_rate", "44100", CVAR_ARCHIVE | CVAR_S_DEVICE,
			"Sound sampling rate in Hz.");
	s_reverse = Cvar_Get("s_reverse", "0", CVAR_ARCHIVE,
			"Reverse left and right channels.");
	s_volume = Cvar_Get("s_volume", "1.0", CVAR_ARCHIVE,
			"Global sound volume level.");

	Cmd_AddCommand("s_restart", S_Restart_f, "Restart the sound subsystem");
	Cmd_AddCommand("s_play", S_Play_f, NULL);
	Cmd_AddCommand("s_stop", S_Stop_f, NULL);
	Cmd_AddCommand("s_list", S_List_f, NULL);

	if (SDL_WasInit(SDL_INIT_EVERYTHING) == 0) {
		if (SDL_Init(SDL_INIT_AUDIO) < 0) {
			Com_Warn("S_Init: %s.\n", SDL_GetError());
			return;
		}
	} else if (SDL_WasInit(SDL_INIT_AUDIO) == 0) {
		if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
			Com_Warn("S_Init: %s.\n", SDL_GetError());
			return;
		}
	}

	if (Mix_OpenAudio(s_rate->integer, MIX_DEFAULT_FORMAT, 2, 1024) == -1) {
		Com_Warn("S_Init: %s\n", Mix_GetError());
		return;
	}

	if (Mix_QuerySpec(&freq, &format, &channels) == 0) {
		Com_Warn("S_Init: %s\n", Mix_GetError());
		return;
	}

	if (Mix_AllocateChannels(MAX_CHANNELS) != MAX_CHANNELS) {
		Com_Warn("S_Init: %s\n", Mix_GetError());
		return;
	}

	Mix_ChannelFinished(S_FreeChannel);

	Com_Print("Sound initialized %dKHz %d channels.\n", freq, channels);

	s_env.initialized = true;

	S_InitMusic();
}
Example #14
0
bool AudioDevice::init(Log* _debugLog) {

    debugLog = _debugLog;

    if (debugLog != NULL) {
        debugLog->printf("Initializing audio system with default settings\n");
    }

    int audioRate           = MIX_DEFAULT_FREQUENCY;
    uint16 audioFormat      = MIX_DEFAULT_FORMAT;
    int audioChannels       = 2; // stereo

    bool ret = Mix_OpenAudio(audioRate, audioFormat, audioChannels, 4096) >= 0;

    if (debugLog != NULL) {
        if (ret) {
            debugLog->println("Audio initalization      Ok");
        } else {
            debugLog->println("Audio initalization      FAIL");
            debugLog->printf("Couldn't open audio: %s\n", SDL_GetError());
        }
    }

    if (ret) {
        Mix_QuerySpec(&audioRate, &audioFormat, &audioChannels);
    }

    return ret;
}
Example #15
0
void close_sound() 
{
	int numtimesopened, frequency, channels;
	Uint16 format;

	if (mix_ok) {
		stop_bell();
		stop_UI_sound();
		stop_sound();
		sound_cache.clear();
		stop_music();
		mix_ok = false;

		numtimesopened = Mix_QuerySpec(&frequency, &format, &channels);
		if(numtimesopened == 0) {
			ERR_AUDIO << "Error closing audio device: " << Mix_GetError() << "\n";
		}
		while (numtimesopened) {
			Mix_CloseAudio();
			--numtimesopened;
		}
	}
	if (SDL_WasInit(SDL_INIT_AUDIO) != 0) {
		SDL_QuitSubSystem(SDL_INIT_AUDIO);
	}

	LOG_AUDIO << "Audio device released.\n";
}
Example #16
0
static int SDLIsInitialized(void)
{
    int freq, channels;
    Uint16 format;

    return Mix_QuerySpec(&freq, &format, &channels);
}
Example #17
0
void CleanupT4KCommon(void)
{
    int frequency, channels, n_timesopened;
    Uint16 format;

    // Close the audio mixer. We have to do this at least as many times
    // as it was opened.
    n_timesopened = Mix_QuerySpec(&frequency, &format, &channels);
    while (n_timesopened)
    {
	Mix_CloseAudio();
	n_timesopened--;
    }
    
    T4K_UnloadMenus();
    // Unload SDL_Pango or SDL_ttf:
    T4K_Cleanup_SDL_Text();
    
#ifdef HAVE_LIBSDL_NET
    /* Quit networking if appropriate: */
    SDLNet_Quit();
#endif

    // Finally, quit SDL
    SDL_Quit();
}
Example #18
0
File: sound.c Project: wimh/instead
int snd_hz(void)
{
	int freq = 0;
	if (sound_on)
		Mix_QuerySpec(&freq, NULL, NULL);
	return freq;
}
Example #19
0
void Snd_Init()
{
	printf( "Initializing Sound\n" );

	//return;

	/* Initialize variables */
	audio_rate = MIX_DEFAULT_FREQUENCY;
	audio_format = MIX_DEFAULT_FORMAT;
	audio_channels = 2;

	/* Open Device */
	if( Mix_OpenAudio( audio_rate, audio_format, audio_channels, 4096 ) < 0 )
	{
		printf( "ERROR: Couldn't open audio device\n" );
	}
	else
	{
		printf( "Trying to query audio device\n" );
		Mix_QuerySpec( &audio_rate, &audio_format, &audio_channels );
		printf( "Successfully opened audio device\n" );
		printf("Opened audio at %d Hz %d bit %s\n", audio_rate, (audio_format&0xFF), (audio_channels > 1) ? "stereo" : "mono");
	}

	audioOpen = True;
	soundcount = 0;

	bPlaySounds = True;

	nullsound.soundid = -1;
}
Example #20
0
/**\brief Audio system initialization.
 */
bool Audio::Initialize( void ){
	if ( this -> initstatus )
		return false;				// Already initialized

	if(SDL_Init(SDL_INIT_AUDIO) < 0) {
		LogMsg(CRITICAL,"SDL could not initialize audio: %s", SDL_GetError());
	}

	if(Mix_OpenAudio(this->audio_rate,
				this->audio_format,
				this->audio_channels,
				this->audio_buffers)){
		LogMsg(CRITICAL,"Audio initialization failed!: %s", Mix_GetError());
		return false;
	}

	Mix_QuerySpec(&this->audio_rate, &this->audio_format, &this->audio_channels);
	LogMsg(INFO,"SDL_mixer gave us rate %d, format %d, channels %d", this->audio_rate, this->audio_format, this->audio_channels);

#if defined(SDL_MIXER_MAJOR_VERSION) && (SDL_MIXER_MAJOR_VERSION>1) \
	&& (SDL_MIXER_MINOR_VERSON>2) && (SDL_MIXER_PATCHLEVEL>=10)
	// Load MOD and OGG libraries (If SDL_mixer version supports it)
	const SDL_version *mix_version=Mix_Linked_Version();
	if( (mix_version->major >= 1) && (mix_version->minor >= 2) && (mix_version->patch >= 10) ){
		LogMsg(INFO,"This SDL_mixer version supports dynamic library loading.");
		Mix_Init( MIX_INIT_MOD | MIX_INIT_OGG );
	}
#endif // SDL_MIXER version requirements

	// Allocate channels
	Mix_AllocateChannels( this->max_chan);
	assert( this->max_chan == static_cast<unsigned int>(this->GetTotalChannels()) );

	return true;
}
Example #21
0
   SDLSoundChannel(const ByteArray &inBytes, const SoundTransform &inTransform)
   {
      Mix_QuerySpec(&mFrequency, &mFormat, &mChannels);
      if (mFrequency!=44100)
         ELOG("Warning - Frequency mismatch %d",mFrequency);
      if (mFormat!=32784)
         ELOG("Warning - Format mismatch    %d",mFormat);
      if (mChannels!=2)
         ELOG("Warning - channe mismatch    %d",mChannels);


      mChunk = 0;
      mDynamicBuffer = new short[BUF_SIZE * STEREO_SAMPLES];
      memset(mDynamicBuffer,0,BUF_SIZE*sizeof(short));
      mSound = 0;
      mChannel = -1;
      mDynamicChunk.allocated = 0;
      mDynamicChunk.abuf = (Uint8 *)mDynamicBuffer;
      mDynamicChunk.alen = BUF_SIZE * sizeof(short) * STEREO_SAMPLES; // bytes
      mDynamicChunk.volume = MIX_MAX_VOLUME;
	  #ifndef WEBOS
	   mDynamicChunk.length_ticks = 0;
	  #endif
      mDynamicFillPos = 0;
      mDynamicStartPos = 0;
      mDynamicDataDue = 0;

      // Allocate myself a channel
      for(int i=0;i<sMaxChannels;i++)
         if (!sUsedChannel[i])
         {
            IncRef();
            sDoneChannel[i] = false;
            sUsedChannel[i] = true;
            mChannel = i;
            break;
         }

      if (mChannel>=0)
      {
         FillBuffer(inBytes);
         // Just once ...
         if (mDynamicFillPos<1024)
         {
            mDynamicDone = true;
            mDynamicChunk.alen = mDynamicFillPos * sizeof(short) * STEREO_SAMPLES;
            Mix_PlayChannel( mChannel , &mDynamicChunk,  0 );
         }
         else
         {
            mDynamicDone = false;
            // TODO: Lock?
            Mix_PlayChannel( mChannel , &mDynamicChunk,  -1 );
            mDynamicStartPos = sSoundPos;
         }

         Mix_Volume( mChannel, inTransform.volume*MIX_MAX_VOLUME );
      }
   }
Example #22
0
int32_t MUSIC_StopSong(void)
{
#if defined FORK_EXEC_MIDI
    if (external_midi)
    {
        if (external_midi_pid > 0)
        {
            int32_t ret;
            struct timespec ts;

            external_midi_restart = 0;  // make SIGCHLD handler a no-op

            ts.tv_sec = 0;
            ts.tv_nsec = 5000000;  // sleep 5ms at most

            kill(external_midi_pid, SIGTERM);
            nanosleep(&ts, NULL);
            ret = waitpid(external_midi_pid, NULL, WNOHANG|WUNTRACED);
//            printf("(%d)", ret);

            if (ret != external_midi_pid)
            {
                if (ret==-1)
                    perror("waitpid");
                else
                {
                    // we tried to be nice, but no...
                    kill(external_midi_pid, SIGKILL);
                    initprintf("%s: wait for SIGTERM timed out.\n", __func__);
                    if (waitpid(external_midi_pid, NULL, WUNTRACED)==-1)
                        perror("waitpid (2)");
                }
            }

            external_midi_pid = -1;
        }

        return(MUSIC_Ok);
    }
#endif

    //if (!fx_initialized)
    if (!Mix_QuerySpec(NULL, NULL, NULL))
    {
        setErrorMessage("Need FX system initialized, too. Sorry.");
        return(MUSIC_Error);
    } // if

    if ((Mix_PlayingMusic()) || (Mix_PausedMusic()))
        Mix_HaltMusic();

    if (music_musicchunk)
        Mix_FreeMusic(music_musicchunk);

    music_musicchunk = NULL;

    return(MUSIC_Ok);
} // MUSIC_StopSong
Example #23
0
int _main(int arvc , char * argv[]) {

	SDL_Surface *screen;
	SDL_Event event;
	int done = 0;

	/* We're going to be requesting certain things from our audio
		device, so we set them up beforehand */
	int audio_rate = 22050;
	Uint16 audio_format = AUDIO_S16; /* 16-bit stereo */
	int audio_channels = 2;
	int audio_buffers = 4096;

	SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);

	/* This is where we open up our audio device.  Mix_OpenAudio takes
		as its parameters the audio format we'd /like/ to have. */
	if(Mix_OpenAudio(audio_rate, audio_format, audio_channels, audio_buffers)) {
		printf("Unable to open audio!\n");
		exit(1);
	}

	/* If we actually care about what we got, we can ask here.  In this
		program we don't, but I'm showing the function call here anyway
		in case we'd want to know later. */
	Mix_QuerySpec(&audio_rate, &audio_format, &audio_channels);

	/* We're going to be using a window onscreen to register keypresses
		in.  We don't really care what it has in it, since we're not
		doing graphics, so we'll just throw something up there. */
	screen = SDL_SetVideoMode(320, 240, 0, 0);

	while(!done) 
	{
		while(SDL_PollEvent(&event))
		{
		switch(event.type)
			{
				case SDL_QUIT:
					done = 1;
					break;
				case SDL_KEYDOWN:
				case SDL_KEYUP:
					handleKey(event.key);
					break;
			}
		}

		/* So we don't hog the CPU */
		SDL_Delay(50);
	}

	/* This is the cleaning up part */
	Mix_CloseAudio();
	SDL_Quit();

	return 0;
}
Example #24
0
void SoundProcessor::printSoundInformation() const
{
#ifdef _FMOD_SOUND
	FMOD_RESULT result;
	int driver_num;
	result = soundEngine->getNumDrivers(&driver_num);
	ERRCHECK(result);

	std::ostringstream os; os << "* Available sound drivers: ";
	for(unsigned int i = driver_num; i--;)
	{
		char driver_name[256];
		result = soundEngine->getDriverInfo(i, driver_name, 256, 0);
		ERRCHECK(result);
		os << driver_name << " ";
	}
	toInfoLog(os.str());
	os.str("");
	int current_driver;
	result = soundEngine->getDriver(&current_driver);
	ERRCHECK(result);

	os << "* Driver used: ";
	if(current_driver == -1)
	{
		os << "Primary or main sound device as selected by the operating system settings";
		if(driver_num == 1)
		{
			char driver_name[256];
			result = soundEngine->getDriverInfo(current_driver, driver_name, 256, 0);
			ERRCHECK(result);
			os << "(probably '" << driver_name << "')";
		}
	}
	else
	{
		char driver_name[256];
		result = soundEngine->getDriverInfo(current_driver, driver_name, 256, 0);
		ERRCHECK(result);
		os << driver_name;
	}
	toInfoLog(os.str());
#elif _SDL_MIXER_SOUND
	int audio_rate, audio_channels;
	Uint16 audio_format;
	int success = Mix_QuerySpec(&audio_rate, &audio_format, &audio_channels);
	
	if(!success) {
		std::ostringstream os;
		os << "ERROR (SoundProcessor::printSoundInformation()): " << Mix_GetError();
		throw SDLException(os.str());
	}
	int bits = audio_format & 0xFF;
	std::ostringstream os; 
	os << "* Opened audio at " << audio_rate << "Hz " << bits << "bit " << ((audio_channels>1)?"stereo":"mono");// << ", " << audio_buffers << " bytes audio buffer";
	toInfoLog(os.str());
#endif
}
Example #25
0
/*! 
  Returns the status of the audio device
  \return  True if audio has been opened, False otherwise
  \author  jfpatry
  \date    Created:  2000-09-02
  \date    Modified: 2000-09-02
*/
bool_t is_audio_open()
{
    int tmp_freq;
    Uint16 tmp_format;
    int tmp_channels;

    return (bool_t) Mix_QuerySpec( &tmp_freq, &tmp_format, &tmp_channels );

}
Example #26
0
int32_t SDLDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, void * initdata)
{
    int32_t err = 0;
    int32_t chunksize;
    uint16_t fmt;

    UNREFERENCED_PARAMETER(numchannels);
    UNREFERENCED_PARAMETER(initdata);

    if (Initialised) {
        SDLDrv_PCM_Shutdown();
    }

    chunksize = 512;
#ifdef __ANDROID__
    chunksize = droidinfo.audio_buffer_size;
#endif

    if (*mixrate >= 16000) chunksize *= 2;
    if (*mixrate >= 32000) chunksize *= 2;

    err = Mix_OpenAudio(*mixrate, AUDIO_S16SYS, *numchannels, chunksize);

    if (err < 0) {
        ErrorCode = SDLErr_OpenAudio;
        return SDLErr_Error;
    }


    if (Mix_QuerySpec(mixrate, &fmt, numchannels))
    {
        if (fmt == AUDIO_U8 || fmt == AUDIO_S8)
        {
            ErrorCode = SDLErr_OpenAudio;
            return SDLErr_Error;
        }
    }

    //Mix_SetPostMix(fillData, NULL);

    EffectFence = SDL_CreateMutex();

    // channel 0 and 1 are actual sounds
    // dummy channel 2 runs our fillData() callback as an effect
    Mix_RegisterEffect(2, fillData, NULL, NULL);

    DummyBuffer = (uint8_t *) calloc(1, chunksize);

    DummyChunk = Mix_QuickLoad_RAW(DummyBuffer, chunksize);

    Mix_PlayChannel(2, DummyChunk, -1);

    Initialised = 1;

    return SDLErr_Ok;
}
Example #27
0
void initSound()
{
	// Initialize SDL_Mixer
	if(Mix_OpenAudio(audio_rate, audio_format, audio_channels, audio_buffers)) {
		fprintf(stderr, "Failed to initialize SDL_Mixer: %s\n", Mix_GetError());
		exit(1);
	}
	atexit(cleanupSound);
	Mix_QuerySpec(&audio_rate, &audio_format, &audio_buffers);
}
Example #28
0
void I_InitAudio(void)
{ 
	sysaudio.obtained.freq = sysaudio.desired.freq =
		SAMPLERATE;
	sysaudio.obtained.format = sysaudio.desired.format =
		AUDIO_S16SYS;
	sysaudio.obtained.channels = sysaudio.desired.channels =
		2;
	sysaudio.obtained.samples = sysaudio.desired.samples =
		SAMPLECOUNT;
	sysaudio.obtained.size = sysaudio.desired.size =
		(SAMPLECOUNT*sysaudio.obtained.channels*((sysaudio.obtained.format&0xff)>>3));

	if (!sysaudio.enabled)
		return;

#ifdef ENABLE_SDLMIXER
	{
		int freq, channels;
		Uint16 format;

		if (Mix_OpenAudio(sysaudio.desired.freq, sysaudio.desired.format,
			sysaudio.desired.channels, sysaudio.desired.samples)<0) {
			I_Error("Could not open audio: %s\n", SDL_GetError());
		}

		if (!Mix_QuerySpec(&freq, &format, &channels)) {
			I_Error("Could not open audio: %s\n", SDL_GetError());
		}

		sysaudio.obtained.freq = freq;
		sysaudio.obtained.channels = channels;
		sysaudio.obtained.format = format;
		sysaudio.obtained.size = (SAMPLECOUNT*channels*((format&0xff)>>3));

		I_InitMusic();
		I_InitSound();

		Mix_SetPostMix(I_UpdateSound, NULL);
/*		Mix_ReserveChannels(NUM_CHANNELS);*/
	}
#else
	sysaudio.desired.callback = I_UpdateAudio;
	sysaudio.desired.userdata = NULL;

	if (SDL_OpenAudio(&sysaudio.desired, &sysaudio.obtained)<0) {
		I_Error("Could not open audio: %s\n", SDL_GetError());
	}

	I_InitMusic();
	I_InitSound();

	SDL_PauseAudio(0);
#endif
}
Example #29
0
void AudioEngine::play_music(std::string file_location) {
    if(currently_playing.compare(file_location) != 0) { //only change the song if it's not already playing!
        //Initialise audio variables
        int audio_rate;      //output sampling rate (in Hz)
        Uint16 audio_format; //output sample format.
        int audio_channels;  //the number of channels for the output.
        int audio_buffers;   //the chunk size of the output, larger is better for slower machines but means the sound will be delayed more.
        int audio_volume;    //the volume at which you wish to play the music
        int looping;         //wether the music should loop or not


        // Initialize variables
        audio_rate =  MIX_DEFAULT_FREQUENCY; //22050
        audio_format = AUDIO_S16;            //Signed 16-bit samples, in little-endian byte order
        audio_channels = 2;                  //1 = mono, 2 = stereo
        audio_buffers = 4096;                //good value for slower machines and doesn't have too much delay (shouldn't matter too much for music vs sound effects anyway
        audio_volume = get_music_volume();
        looping = -1;                        //loop through the music forever

        //Initialise the audio API, returns -1 on errors so check it initialises correctly
        if(Mix_OpenAudio(audio_rate, audio_format, audio_channels, audio_buffers) < 0) {
            LOG(ERROR) << "Couldn't open audio: " << SDL_GetError(); //LOG why Audio couldn't be initialised
            audio_open = false;
            return;
        }
        //Query the auddio device for it's settings.
        Mix_QuerySpec(&audio_rate, &audio_format, &audio_channels);

        // Set the music volume
        set_music_volume(audio_volume);
    
        const char* c_file_location = file_location.c_str(); //Convert the file_location to a c string for the SDL API
        music = Mix_LoadMUS(c_file_location); //Load in the music

        if (music == nullptr ) {
            LOG(ERROR) << "Couldn't load " << c_file_location << ": " << SDL_GetError(); //print why music couldn't be loaded to the screen
            Mix_CloseAudio(); //close down the audio system
            audio_open = false;
            return;
        }

        //while(!Mix_FadeOutMusic(1000) && Mix_PlayingMusic()) {
        //	wait for any fades to complete
        //	SDL_Delay(100);
        //} //TODO: implement some sort of music (and screen!) fade

        //Start playing the music.
        if(Mix_FadeInMusic(music, looping, 2000) == -1) {
            LOG(ERROR) << "Mix_FadeInMusic: " << Mix_GetError();
            // well, there's no music, but most games don't break without music...
        }
        currently_playing = file_location;
    }
    return;
}
Example #30
0
static void print_format()
{
	int audio_channels;
	int audio_rate;
	Uint16 audio_format;

	Mix_QuerySpec(&audio_rate, &audio_format, &audio_channels);
	printf("Opened audio at %d Hz %d bit %s\n", audio_rate,
		(audio_format & 0xFF),
		(audio_channels > 2) ? "surround" : (audio_channels > 1) ? "stereo" : "mono");
}