void SoundMix::PlaySoundWithVolume( int sound, int volume ) { if (Config::GetSound()!=1) { return; } wave = Load( sound ); if ( !wave ) { return; } if ( wave ) { Mix_VolumeChunk( wave, volume ); if ( Mix_PlayChannel( -1, wave, 0 ) == -1 ) { printf( "Mix_PlayChannel: %s\n", Mix_GetError() ); // may be critical error, or maybe just no channels were free. // you could allocated another channel in that case... Mix_FreeChunk( wave ); wave = NULL; } } }
/*! Change volume for a sound associated with the specified sound context \pre sound_context != NULL \arg \c sound_context the sound context \i volume is a value 0-128 \return true if volume was set; false otherwise \author ehall \date Created: 2000-09-13 \date Modified: 2000-09-13 */ bool_t set_sound_volume( char *sound_context, int volume ) { int i; sound_context_data_t *data; if ( ! get_hash_entry( sound_contexts_, sound_context, (hash_entry_t*) &data ) ) { return False; } data->volume = volume; i = (int) (((double)data->num_sounds)*rand()/(RAND_MAX+1.0)); for ( i=0; i<data->num_sounds; i++ ) { if ( data->chunks[i] == NULL ) { bool_t found; found = get_sound_data( data->sound_names[i], &(data->chunks[i]) ); check_assertion( found, "sound name not found" ); check_assertion( data->chunks[i]!=NULL, "sound chunk not set" ); } Mix_VolumeChunk( data->chunks[i], data->volume ); } return True; }
extern void PlaySound(char * file, unsigned char volume, int channel, int times) { Mix_Chunk* soundeff = SoundEffects.find(file)->second; Mix_PlayChannel(channel, soundeff, times - 1); Mix_VolumeChunk(soundeff, volume); }
void THSoundEffects::setSoundArchive(THSoundArchive *pArchive) { for(size_t i = 0; i < m_iSoundCount; ++i) { Mix_FreeChunk(m_ppSounds[i]); } delete[] m_ppSounds; m_ppSounds = NULL; m_iSoundCount = 0; if(pArchive == NULL) return; m_ppSounds = new Mix_Chunk*[pArchive->getSoundCount()]; for(; m_iSoundCount < pArchive->getSoundCount(); ++m_iSoundCount) { m_ppSounds[m_iSoundCount] = NULL; SDL_RWops *pRwop = pArchive->loadSound(m_iSoundCount); if(pRwop) { m_ppSounds[m_iSoundCount] = Mix_LoadWAV_RW(pRwop, 1); if(m_ppSounds[m_iSoundCount]) Mix_VolumeChunk(m_ppSounds[m_iSoundCount], MIX_MAX_VOLUME); } } }
static void * play_sound(const char *filename, int loop, double volume) { struct player_sound *sound; unsigned long hash; int sdl_volume = (int)(volume * MIX_MAX_VOLUME); hash = crc32(0, (void *)filename, strlen(filename)); hash %= sizeof(sounds) / sizeof(sounds[0]); for (sound = sounds[hash]; sound != NULL; sound = sound->next) { if (strcmp(filename, sound->filename) == 0) break; } if (sound == NULL) { fprintf(stderr, "play_sound: %s not loaded?\n", filename); return NULL; } if (sound->chunk != NULL) { Mix_VolumeChunk(sound->chunk, sdl_volume); sound->chunk_channel = Mix_PlayChannel(-1, sound->chunk, loop ? -1 : 0); } else if (sound->music != NULL) { Mix_HaltMusic(); active_music = sound->music; Mix_VolumeMusic(sdl_volume); Mix_PlayMusic(sound->music, loop ? -1 : 1); } return sound; }
void sound_player::populate_from(sound_archive *pArchive) { for(size_t i = 0; i < sound_count; ++i) { Mix_FreeChunk(sounds[i]); } delete[] sounds; sounds = nullptr; sound_count = 0; if(pArchive == nullptr) return; sounds = new Mix_Chunk*[pArchive->get_number_of_sounds()]; for(; sound_count < pArchive->get_number_of_sounds(); ++sound_count) { sounds[sound_count] = nullptr; SDL_RWops *pRwop = pArchive->load_sound(sound_count); if(pRwop) { sounds[sound_count] = Mix_LoadWAV_RW(pRwop, 1); if(sounds[sound_count]) Mix_VolumeChunk(sounds[sound_count], MIX_MAX_VOLUME); } } }
int sdlplayer_fx(char *filename, int volume) { Mix_Chunk *sample; g_warning("sdlplayer %s\n", filename); sample=Mix_LoadWAV_RW(SDL_RWFromFile(filename, "rb"), 1); if(!sample) { return(cleanExit("Mix_LoadWAV_RW")); // handle error } Mix_VolumeChunk(sample, MIX_MAX_VOLUME); if((_channel_fx = Mix_PlayChannel(-1, sample, 0))==-1) { return(cleanExit("Mix_LoadChannel(0x%p,1)", _channel_fx)); } while( Mix_Playing( _channel_fx ) ) { SDL_Delay(50); } // free the sample // Mix_Chunk *sample; Mix_FreeChunk(sample); _channel_fx = -1; g_warning("sdlplayer complete playing of %s\n", filename); return(0); }
void noegnud_sound_play(const char *filename,float volume) { noegnud_tcollection *soundcollection; noegnud_sound_tsound *sound; int internal_volume; if (!noegnud_sound_initialised) return; soundcollection=noegnud_sound_load(filename); if (soundcollection) { if (volume<0) volume=0; if (volume>1) volume=1; sound=(noegnud_sound_tsound *)soundcollection->data; internal_volume=volume*MIX_MAX_VOLUME; if (sound->chunk) { #ifdef NOEGNUDDEBUG printf("[SOUND] noegnud_sound_play: playing chunk \"%s\" (%2.3f)\n",filename,volume); #endif Mix_VolumeChunk(sound->chunk,internal_volume); Mix_PlayChannel(-1,sound->chunk,0); } else if (sound->music) { #ifdef NOEGNUDDEBUG printf("[SOUND] noegnud_sound_play: playing music \"%s\" (%2.3f)\n",filename,volume); #endif Mix_VolumeMusic(internal_volume); Mix_PlayMusic(sound->music,0); } else { printf("[SOUND] WARNING: noegnud_sound_play: unknown file format/could not load \"%s\"\n",filename); } } else { printf("[SOUND] noegnud_sound_play: could not load/play \"%s\"\n",filename); } }
void PGE_Sounds::SND_PlaySnd(QString sndFile) { if(current!=sndFile) { #ifdef USE_QMEDIAPLAYER if(mp3Play) { mp3Play->stop(); delete mp3Play; mp3Play=NULL; } #elif USE_SDL_MIXER if(sound) { Mix_FreeChunk(sound); sound=NULL; } sound = Mix_LoadWAV(sndFile.toUtf8().data() ); if(!sound) qDebug() << QString("Mix_LoadWAV: %1").arg(SDL_GetError()); else Mix_VolumeChunk(sound, MIX_MAX_VOLUME); #endif current = sndFile; } #ifdef USE_QMEDIAPLAYER qDebug() << QString("Play Sound (QMediaPlayer)"); if(!mp3Play) { qDebug() << QString("QMediaPlayer is null"); } else mp3Play->play(); #elif USE_SDL_MIXER LogDebug(QString("Play Sound (SDL2_mixer)")); if(Mix_PlayChannel( -1, sound, 0 )==-1) { qDebug() << QString("Mix_PlayChannel: %1").arg(SDL_GetError()); } #endif }
void TempFigure::setFigure(int x, int y, Surface& image, SDL_Surface* screen, int levelWidth, int levelHeight) { Figure::setFigure(x, y, image, screen, GRAVITY_DISABLED, levelWidth, levelHeight, false, 5, 1, 1, 1); scratch.setChunk("sounds/scratch.wav"); Mix_VolumeChunk(scratch.getMix_Chunk(), 128); marker = ACTIVE; }
//------------------------------ // Sound functions //------------------------------ void sound_playfx(Mix_Chunk* snd) { if(sound_enabled == true) { Mix_VolumeChunk(snd, sound_volfx*10); Mix_PlayChannel( -1, snd, 0 ); } }
void SoundSystem::SetAllSoundEffectVolumes(int volume) { if (volume > 128) { volume = 128; } else if (volume < 0) { volume = 0; } for (auto& it : m_SoundEffect) { Mix_VolumeChunk(it.second.get(), volume); } }
void platform_support::play_sound(unsigned idx, unsigned vol) { if (idx >= max_images || !m_specific->m_sounds[idx]) { return; } Mix_VolumeChunk(m_specific->m_sounds[idx], vol); Mix_PlayChannel( -1, m_specific->m_sounds[idx], 0 ); }
void set_strings_volume(void) { int i; for(i=0;i<128;i++) { Mix_VolumeChunk(strings_note_chunk[i],(int)(MIX_MAX_VOLUME*strings_volume)); } }
void CSoundEffect::SetVolume(const u32 a_Volume) { if (a_Volume >= 0 && a_Volume <= MIX_MAX_VOLUME) { m_Volume = a_Volume; if (m_Chunk != nullptr) Mix_VolumeChunk(m_Chunk, m_Volume); } }
static mrb_value mrb_sdl2_mixer_chunk_volume(mrb_state *mrb, mrb_value self) { Mix_Chunk *c; mrb_int volume; mrb_get_args(mrb, "i", &volume); c = mrb_sdl2_chunk_get_ptr(mrb, self); return mrb_fixnum_value(Mix_VolumeChunk(c, volume)); }
void playSound(char *name) { int i; Mix_Chunk *chunk = NULL; if (game.audio == FALSE || game.sfxDefaultVolume == 0) { return; } for (i=0;i<soundIndex;i++) { if (strcmpignorecase(sound[i].name, name) == 0) { chunk = sound[i].effect; if (chunk == NULL) { return; } break; } } if (chunk == NULL) { if (soundIndex == MAX_SOUNDS) { showErrorAndExit("Ran out of space for sounds"); } chunk = loadSound(name); sound[soundIndex].effect = chunk; STRNCPY(sound[soundIndex].name, name, sizeof(sound[soundIndex].name)); soundIndex++; if (chunk == NULL) { return; } } Mix_VolumeChunk(chunk, game.sfxDefaultVolume * VOLUME_STEPS); #if DEV == 1 if (game.gameType == REPLAYING) { printf("%f %s\n", (float)game.frames / 60, name); } #endif playSoundChunk(chunk, -1, 0); }
void set_piano_volume(void) { int i; for(i=0;i<128;i++) { Mix_VolumeChunk(piano_note_chunk[i],(int)(MIX_MAX_VOLUME*piano_volume)); } }
void Sounds::Mute_Sounds() { unsigned int i; i = 0; while (i != this->sounds.size()) { Mix_VolumeChunk(this->sounds[i], 0); } }
void Sounds::Volume_Sounds_Down() { unsigned int i; i = 0; while (i != this->sounds.size()) { Mix_VolumeChunk(this->sounds[i], this->volume_sound - 8); } }
void TMASound::play(bool loop,int volume,int pan) { if (psound!=NULL) { if (volume>128) volume=128; Mix_VolumeChunk(psound,volume); ii_voice = Mix_PlayChannel(-1,psound,(loop)?(-1):0); //if (pan!=127) voice_set_pan(ii_voice,pan); } }
void Sound::PlaySound(const char *referenceName, int volume, int loops) { char DEBUGMSG3[1024]; Mix_VolumeChunk(Sound::Chunks[referenceName],volume); if(Mix_PlayChannel(-1, Sound::Chunks[referenceName], loops) == -1) { //sprintf(DEBUGMSG3,"Unable to play WAV file: %s\n", Mix_GetError()); //MessageBox (0, DEBUGMSG3, "Error", MB_ICONHAND); exit (1); } }
void SDLSound::setSoundVolume(unsigned int volume) { if ( volume > 100 ) volume = 100; unsigned int sdlvol = (volume*100)/MIX_MAX_VOLUME; chunks_t::iterator i = m_chunks.begin(); while ( i != m_chunks.end() ) { Mix_VolumeChunk(i->second->getData(), sdlvol); ++i; } }
void glSound::setVolume(int new_volume) { if (sound == nullptr) return; if (new_volume < 0) new_volume = 0; else if (new_volume > MIX_MAX_VOLUME) new_volume = MIX_MAX_VOLUME; volume = new_volume; Mix_VolumeChunk(sound,new_volume); }
void Sound::PlaySound(const char *referenceName, int volume, int loops) { char DEBUGMSG3[1024]; Mix_VolumeChunk(Sound::Chunks[referenceName],volume); if(Mix_PlayChannel(-1, Sound::Chunks[referenceName], loops) == -1) { sprintf(DEBUGMSG3,"Unable to play WAV file: %s\n", Mix_GetError()); DebugMsg(DEBUGMSG3); exit (1); } }
void SoundEffect::setVolume(float volume) noexcept { sfz_assert_debug(0.0f <= volume); sfz_assert_debug(volume <= 1.0f); if (!this->isLoaded()) return; int volumeInt = int(std::round(volume * MIX_MAX_VOLUME)); Mix_VolumeChunk(this->mChunkPtr, volumeInt); }
/* * @brief */ static void S_LoadSampleChunk(s_sample_t *sample) { char path[MAX_QPATH]; void *buf; int32_t i, len; SDL_RWops *rw; if (sample->media.name[0] == '*') // place holder return; if (sample->media.name[0] == '#') { // global path g_strlcpy(path, (sample->media.name + 1), sizeof(path)); } else { // or relative g_snprintf(path, sizeof(path), "sounds/%s", sample->media.name); } buf = NULL; rw = NULL; i = 0; while (SAMPLE_TYPES[i]) { StripExtension(path, path); g_strlcat(path, SAMPLE_TYPES[i++], sizeof(path)); if ((len = Fs_Load(path, &buf)) == -1) continue; if (!(rw = SDL_RWFromMem(buf, len))) { Fs_Free(buf); continue; } if (!(sample->chunk = Mix_LoadWAV_RW(rw, false))) Com_Warn("%s\n", Mix_GetError()); Fs_Free(buf); SDL_FreeRW(rw); if (sample->chunk) { // success break; } } if (sample->chunk) { Mix_VolumeChunk(sample->chunk, s_volume->value * MIX_MAX_VOLUME); Com_Debug("Loaded %s\n", path); } else { if (g_str_has_prefix(sample->media.name, "#players")) { Com_Debug("Failed to load player sample %s\n", sample->media.name); } else { Com_Warn("Failed to load %s\n", sample->media.name); } } }
void Audio::Play(unsigned clipid) { if (clipid >= Audio::clips.size()) { return; } Clip& clip = Audio::clips[clipid]; Mix_VolumeChunk(clip.chunk, clip.volume); Mix_PlayChannel(-1, clip.chunk, 0); }
static Sound *CustomMix_LoadWAV(char *path, char *fileName, int volume) { Sound *result; char temp[1024]; if (!sound_supported) return NULL; sprintf(temp, "%s/sfx/%s", dataFolder, fileName); result = Mix_LoadWAV(temp); if (result) Mix_VolumeChunk (result, volume); return result; }
// Add the Random Generator referance to the rest of the classes. Player::Player(boost::random::mt19937 &generator) : Entity(generator) { m_Thrust = false; m_Fire = false; m_TurnRight = false; m_TurnLeft = false; m_Active = false; m_Hit = false; m_ExplosionOn = false; m_ShipHeight = 25; m_ShipWidth = 15; m_Radius = m_ShipHeight - 7; m_Scale = 2; m_MaxThrust = 325; m_ThrustMagnitude = 1.55; m_TurnRate = 0.06; m_NumberOfShots = 4; m_ThrustDrawTimerAmount = 0.100; m_ExplosiontTimerAmount = 2.500; pTimer = new Timer(); pShip = new PlayerShip(); //Player Ship Color ShipColor.Red = 100; ShipColor.Green = 40; ShipColor.Blue = 255; ShipColor.Alpha = 255; p_Shotsound = Mix_LoadWAV("PlayerShot.wav"); Mix_VolumeChunk(p_Shotsound, MIX_MAX_VOLUME / 3); p_Thrustsound = Mix_LoadWAV("PlayerThrust.wav"); Mix_VolumeChunk(p_Thrustsound, MIX_MAX_VOLUME / 3); p_Explosionsound = Mix_LoadWAV("PlayerExplosion.wav"); Mix_VolumeChunk(p_Explosionsound, MIX_MAX_VOLUME / 4); InitializeShot(generator); pShip->InitializeLines(generator); }