bool Source_Sample::LoadWAV(const char* filename) { log_verbose("Source_Sample::LoadWAV(%s)", filename); Unload(); SDL_RWops* rw = SDL_RWFromFile(filename, "rb"); if (rw == NULL) { log_verbose("Error loading %s", filename); return false; } SDL_AudioSpec audiospec; memset(&audiospec, 0, sizeof(audiospec)); SDL_AudioSpec* spec = SDL_LoadWAV_RW(rw, false, &audiospec, &data, (Uint32*)&length); SDL_RWclose(rw); if (spec != NULL) { format.freq = spec->freq; format.format = spec->format; format.channels = spec->channels; issdlwav = true; } else { log_verbose("Error loading %s, unsupported WAV format", filename); return false; } return true; }
SDL_AudioCVT *SOUND_LoadWAV(const char *filename) { SDL_AudioCVT *wavecvt; SDL_AudioSpec wavespec, *loaded; unsigned char *buf; unsigned int len; if (!g_fAudioOpened) { return NULL; } wavecvt = (SDL_AudioCVT *)malloc(sizeof(SDL_AudioCVT)); if (wavecvt == NULL) { return NULL; } loaded = SDL_LoadWAV_RW(SDL_RWFromFile(filename, "rb"), 1, &wavespec, &buf, &len); if (loaded == NULL) { free(wavecvt); return NULL; } // Build the audio converter and create conversion buffers if (SDL_BuildAudioCVT(wavecvt, wavespec.format, wavespec.channels, wavespec.freq, audio_spec.format, audio_spec.channels, audio_spec.freq) < 0) { SDL_FreeWAV(buf); free(wavecvt); return NULL; } int samplesize = ((wavespec.format & 0xFF) / 8) * wavespec.channels; wavecvt->len = len & ~(samplesize - 1); wavecvt->buf = (unsigned char *)malloc(wavecvt->len * wavecvt->len_mult); if (wavecvt->buf == NULL) { SDL_FreeWAV(buf); free(wavecvt); return NULL; } memcpy(wavecvt->buf, buf, len); SDL_FreeWAV(buf); // Run the audio converter if (SDL_ConvertAudio(wavecvt) < 0) { free(wavecvt->buf); free(wavecvt); return NULL; } return wavecvt; }
/** * @brief Loads a wav file from the rw if possible. * * @note Closes the rw. * * @param snd Sound to load wav into. * @param rw Data for the wave. */ static int sound_al_loadWav( alSound *snd, SDL_RWops *rw ) { SDL_AudioSpec wav_spec; Uint32 wav_length; Uint8 *wav_buffer; ALenum format; SDL_RWseek( rw, 0, SEEK_SET ); /* Load WAV. */ if (SDL_LoadWAV_RW( rw, 0, &wav_spec, &wav_buffer, &wav_length) == NULL) { WARN(_("SDL_LoadWav_RW failed: %s"), SDL_GetError()); return -1; } /* Handle format. */ switch (wav_spec.format) { case AUDIO_U8: case AUDIO_S8: format = (wav_spec.channels==1) ? AL_FORMAT_MONO8 : AL_FORMAT_STEREO8; break; case AUDIO_U16LSB: case AUDIO_S16LSB: format = (wav_spec.channels==1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16; break; case AUDIO_U16MSB: case AUDIO_S16MSB: WARN( _("Big endian WAVs unsupported!") ); return -1; default: WARN( _("Invalid WAV format!") ); return -1; } /* Load into openal. */ soundLock(); /* Create new buffer. */ alGenBuffers( 1, &snd->u.al.buf ); /* Put into the buffer. */ alBufferData( snd->u.al.buf, format, wav_buffer, wav_length, wav_spec.freq ); soundUnlock(); /* Clean up. */ free( wav_buffer ); return 0; }
void cargar_sonido ( char *fichero_wav, int identificador ){ /* Variables locales */ FILE *fichero; SDL_RWops *file; char filename[LON_BUFF]; SDL_AudioSpec wav_spec; Uint32 size; Uint8 *data; /* Generamos buffer, le asignamos un identificador y comprobamos errores */ alGenBuffers( 1, &buffer[identificador] ); if ( !alIsBuffer ( buffer[identificador] )){ log_msj ( "[KO] error al crear los buffers\n"); } /* Establecemos donde estara situado el directorio para los sonidos */ strcpy(filename, "sonidos"); strcat(filename, "/"); strcat(filename, fichero_wav); log_msj("[efectos.c] Cargando sonido %s\n", filename); /* Cargamos ficheros Wave */ fichero = abre_fichero(filename, "rb"); file = SDL_RWFromFP(fichero,0); if( SDL_LoadWAV_RW(file,1, &wav_spec,&data,&size)== NULL ){ log_msj("[KO]Error al cargar %s\n",filename); return; } alBufferData ( buffer[identificador], AL_FORMAT_STEREO16, data, size, wav_spec.freq ); /* Almacenamos en buffer */ SDL_FreeWAV(data);/*Liberamos*/ fclose(fichero); /* Generamos las fuentes de sonido y comprobamos errores */ alGenSources( 1, &source[identificador] ); if ( !alIsSource ( source[identificador])){ log_msj ("[KO] No se pueden crear las fuentes de sonido\n"); } /* Pasamos el archivo wav del buffer a la fuente */ alSourcei ( source[identificador], AL_BUFFER, buffer[identificador]); }
void sound::loadWav(const char * buffer, int length) { puts("sound::loadWav"); #ifdef __USE_OPENAL__ /* Yes, I also use SDL. */ SDL_AudioSpec spec; ALenum format = NULL; if ( SDL_LoadWAV_RW(SDL_RWFromMem((char *)buffer, length), 0, &spec, &buf, &(this->length)) == NULL ) { fprintf(stderr, "Could not open thingie from memory: %s\n", SDL_GetError()); return; } printf("this->buffer: %d\n", this->buffer); alGenBuffers(1, &(this->buffer)); printf("this->buffer: %d\n", this->buffer); switch (spec.format) { case AUDIO_U8: case AUDIO_S8: format = (spec.channels==1) ? AL_FORMAT_MONO8 : AL_FORMAT_STEREO8; break; case AUDIO_U16LSB: case AUDIO_S16LSB: format = (spec.channels==1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16; break; } alBufferData(this->buffer, format, buf, this->length, spec.freq); printf("format: %d, length: %d, freq: %d\n", format, this->length, spec.freq); puts("Uploaded to buffer"); if ( alGetError() != AL_NO_ERROR) printf("load failed wat : %s\n", alGetError()); printf("this->buffer: %d\n", this->buffer); #endif /* __USE_OPENAL__ */ }
bool Sample::Load(const char* filename) { Unload(); SDL_RWops* rw = SDL_RWFromFile(filename, "rb"); if (!rw) { SDL_RWclose(rw); return false; } SDL_AudioSpec audiospec; memset(&audiospec, 0, sizeof(audiospec)); SDL_AudioSpec* spec = SDL_LoadWAV_RW(rw, false, &audiospec, &data, (Uint32*)&length); if (spec != NULL) { format.freq = spec->freq; format.format = spec->format; format.channels = spec->channels; issdlwav = true; } else { return false; } return true; }
/* * Load a sound. */ sound_t * syssnd_load(char *name) { sound_t *s; SDL_RWops *context; SDL_AudioSpec audiospec; /* alloc context */ context = malloc(sizeof(SDL_RWops)); context->seek = sdlRWops_seek; context->read = sdlRWops_read; context->write = sdlRWops_write; context->close = sdlRWops_close; /* open */ if (sdlRWops_open(context, name) == -1) return NULL; /* alloc sound */ s = malloc(sizeof(sound_t)); #ifdef DEBUG s->name = malloc(strlen(name) + 1); strncpy(s->name, name, strlen(name) + 1); #endif /* read */ /* second param == 1 -> close source once read */ if (!SDL_LoadWAV_RW(context, 1, &audiospec, &(s->buf), &(s->len))) { free(s); return NULL; } s->dispose = FALSE; return s; }
/* Load a wave file */ Mix_Chunk *Mix_LoadWAV_RW(SDL_RWops *src, int freesrc) { Uint32 magic; Mix_Chunk *chunk; SDL_AudioSpec wavespec, *loaded; SDL_AudioCVT wavecvt; int samplesize; /* rcg06012001 Make sure src is valid */ if ( ! src ) { SDL_SetError("Mix_LoadWAV_RW with NULL src"); return(NULL); } /* Make sure audio has been opened */ if ( ! audio_opened ) { SDL_SetError("Audio device hasn't been opened"); if ( freesrc && src ) { SDL_RWclose(src); } return(NULL); } /* Allocate the chunk memory */ chunk = (Mix_Chunk *)SDL_malloc(sizeof(Mix_Chunk)); if ( chunk == NULL ) { SDL_SetError("Out of memory"); if ( freesrc ) { SDL_RWclose(src); } return(NULL); } /* Find out what kind of audio file this is */ magic = SDL_ReadLE32(src); /* Seek backwards for compatibility with older loaders */ SDL_RWseek(src, -(int)sizeof(Uint32), RW_SEEK_CUR); switch (magic) { case WAVE: case RIFF: loaded = SDL_LoadWAV_RW(src, freesrc, &wavespec, (Uint8 **)&chunk->abuf, &chunk->alen); break; case FORM: loaded = Mix_LoadAIFF_RW(src, freesrc, &wavespec, (Uint8 **)&chunk->abuf, &chunk->alen); break; #ifdef OGG_MUSIC case OGGS: loaded = Mix_LoadOGG_RW(src, freesrc, &wavespec, (Uint8 **)&chunk->abuf, &chunk->alen); break; #endif #ifdef FLAC_MUSIC case FLAC: loaded = Mix_LoadFLAC_RW(src, freesrc, &wavespec, (Uint8 **)&chunk->abuf, &chunk->alen); break; #endif case CREA: loaded = Mix_LoadVOC_RW(src, freesrc, &wavespec, (Uint8 **)&chunk->abuf, &chunk->alen); break; default: SDL_SetError("Unrecognized sound file type"); if ( freesrc ) { SDL_RWclose(src); } loaded = NULL; break; } if ( !loaded ) { /* The individual loaders have closed src if needed */ SDL_free(chunk); return(NULL); } #if 0 PrintFormat("Audio device", &mixer); PrintFormat("-- Wave file", &wavespec); #endif /* Build the audio converter and create conversion buffers */ if ( wavespec.format != mixer.format || wavespec.channels != mixer.channels || wavespec.freq != mixer.freq ) { if ( SDL_BuildAudioCVT(&wavecvt, wavespec.format, wavespec.channels, wavespec.freq, mixer.format, mixer.channels, mixer.freq) < 0 ) { SDL_free(chunk->abuf); SDL_free(chunk); return(NULL); } samplesize = ((wavespec.format & 0xFF)/8)*wavespec.channels; wavecvt.len = chunk->alen & ~(samplesize-1); wavecvt.buf = (Uint8 *)SDL_calloc(1, wavecvt.len*wavecvt.len_mult); if ( wavecvt.buf == NULL ) { SDL_SetError("Out of memory"); SDL_free(chunk->abuf); SDL_free(chunk); return(NULL); } memcpy(wavecvt.buf, chunk->abuf, chunk->alen); SDL_free(chunk->abuf); /* Run the audio converter */ if ( SDL_ConvertAudio(&wavecvt) < 0 ) { SDL_free(wavecvt.buf); SDL_free(chunk); return(NULL); } chunk->abuf = wavecvt.buf; chunk->alen = wavecvt.len_cvt; } chunk->allocated = 1; chunk->volume = MIX_MAX_VOLUME; return(chunk); }
static int lua_Mix_Load(State & state){ Stack * stack = state.stack; if (stack->is<LUA_TSTRING>(1)){ AudioSpec * interfaceAS = state.getInterface<AudioSpec>("LuaSDL_AudioSpec"); SDL_AudioSpec * inputSpec = interfaceAS->get(2); if (inputSpec){ const std::string filename = stack->toLString(1); SDL_RWops * src = SDL_RWFromFile(filename.c_str(), "rb"); if (!src){ state.error("Couldn't open audio file: %s\n", filename.c_str()); } Uint32 magic; SDL_AudioSpec wavespec, *audiospec = nullptr; Uint8 *abuf = nullptr; Uint32 alen; /* note: send a copy of the mixer spec */ wavespec = *inputSpec; /* Find out what kind of audio file this is */ magic = SDL_ReadLE32(src); /* Seek backwards for compatibility with older loaders */ SDL_RWseek(src, -(int)sizeof(Uint32), RW_SEEK_CUR); switch (magic) { case WAVE: case RIFF: audiospec = SDL_LoadWAV_RW(src, 0, &wavespec, (Uint8 **)&abuf, &alen); break; case FORM: audiospec = Mix_LoadAIFF_RW(src, 0, &wavespec, (Uint8 **)&abuf, &alen); break; case OGGS: audiospec = Mix_LoadOGG_RW(src, 0, &wavespec, (Uint8 **)&abuf, &alen); break; case FLAC: audiospec = Mix_LoadFLAC_RW(src, 0, &wavespec, (Uint8 **)&abuf, &alen); break; case CREA: audiospec = Mix_LoadVOC_RW(src, 0, &wavespec, (Uint8 **)&abuf, &alen); break; default: if (detect_mp3((Uint8*)&magic)) { audiospec = Mix_LoadMP3_RW(src, 0, &wavespec, (Uint8 **)&abuf, &alen); break; } break; } SDL_RWclose(src); if (audiospec) { stack->pushLString(std::string(reinterpret_cast<char*>(abuf), alen)); interfaceAS->push(audiospec, true); return 2; } else{ state.error("Unreckonized audio file\n"); } } } return 0; }
SDL_AudioSpec *Mix_LoadWAV_RW_(SDL_RWops *src, int freesrc, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len) { /* * only process in case of 32000hz / 48000Hz (not 44100 / 22050 / 11025Hz) * part of codes were refered from bmx2wav/bmx2ogg project. */ // // these part is already checked before, so don't do error checking // // RIFF header int riffheader = sdl_read_int(src); #if 0 if (riffheader != RIFF_HEADER) { ERROR } #endif // file size sdl_read_int(src); // WAVE header int wavheader = sdl_read_int(src); #if 0 if (wavheader != WAVE_HEADER) { ERROR } #endif // skip until met fmt chunk for (;;) { if (sdl_read_int(src) == FMT_CHUNK) { break; } sdl_read_skip(src, sdl_read_int(src)); } // fmt byte size int fmt_byte_size = sdl_read_int(src); // fmt id if (sdl_read_short(src) != FMT_ID) { ERROR } // channel count int channel_count = sdl_read_short(src); if (channel_count != 1 && channel_count != 2) { ERROR } // frequency int frequency = sdl_read_int(src); // byte per second int byte_per_second = sdl_read_int(src); // block size int block_size = sdl_read_short(src); // bit rate int bit_rate = sdl_read_short(src); if (bit_rate != 4 && bit_rate != 8 && bit_rate != 16 && bit_rate != 24 && bit_rate != 32) { ERROR } // check once again (valid block size?) // as it's too minor problem, we'll gonna skip this #if STRICT_CHECK if (block_size != (bit_rate / 8) * channel_count) { ERROR } if (byte_per_second != frequency * block_size) { ERROR } #endif // // if bit is general one (8 / 16 / 32) // then use default SDL loader // otherwise (24 bit), load it by using this module. // if (bit_rate == 8 || bit_rate == 16 || bit_rate == 32) { SDL_RWseek(src, 0, RW_SEEK_SET); return SDL_LoadWAV_RW(src, freesrc, spec, audio_buf, audio_len); } // skip extended format byte if (fmt_byte_size - FMT_BYTE_SIZE > 0) { sdl_read_skip(src, fmt_byte_size - FMT_BYTE_SIZE); } // skip until met data chunk for (;;) { if (sdl_read_int(src) == DATA_CHUNK) { break; } sdl_read_skip(src, sdl_read_int(src)); } // data size int data_size = sdl_read_int(src); // data size check if (data_size % ((bit_rate / 8) * channel_count) != 0) { #if STRICT_CHECK // some WAVE file doesn't returns valid size // better fix it rather then returning ERROR ERROR #else data_size -= data_size % ((bit_rate / 8) * channel_count); #endif } // // get data size strictly by checking file size // Sint64 filetotsize = SDL_RWsize(src); Sint64 filepos = SDL_RWtell(src); if (filetotsize - filepos < data_size) data_size = filetotsize - filepos; // // now we know data size, so allocate buffer // *audio_buf = NULL; *audio_len = 0; memset(spec, '\0', sizeof(SDL_AudioSpec)); // // convert it to 16bit, always, // spec->format = AUDIO_S16; spec->channels = channel_count; spec->freq = frequency; spec->samples = 4096; /* buffer size */ int samples = data_size / (bit_rate / 8) / channel_count; /* x2 : we'll going to interpret audio data as 16bit */ *audio_len = spec->size = samples * spec->channels * 2; *audio_buf = (Uint8 *)SDL_malloc(*audio_len); if (*audio_buf == NULL) goto done; // // all metadata were gathered... start to read WAV file // store raw if freq is 44100 / 22050 / 11025Hz. // int pos = 0; int mul = 2 * spec->channels; // // before continue, if wav file is 4 bit per sample, // then extend it into 16 bit per sample. // #define READBIT read_bit_wav(src, bit_rate) if (bit_rate == 4) { // it's 2 sample per a byte, actually. bit_rate = 8; Uint16* write_buf = *audio_buf; for (int i = 0; i < samples / 2 * spec->channels; i++) { Uint16 _t = READBIT; *(write_buf++) = read_4bit_first(_t); *(write_buf++) = read_4bit_last(_t); } } else { for (int i = 0; i < samples; i++) { int bufpos = i * mul; *((Uint16*)(*audio_buf + bufpos)) = READBIT; if (spec->channels == 2) *((Uint16*)(*audio_buf + bufpos + 2)) = READBIT; } } /* * cleanup */ done: if (freesrc && src) { SDL_RWclose(src); } return(spec); }
void read_dx_file() { int i,err; char buff[80]; unzFile dat; UINT8 *buffer; unz_file_info file_info; /* int start,end; */ /* short *src; */ if (!dx_file[0]) return; if (raine_nb_samples && emudx_samples && sample_data) { return; } dat = unzOpen(dx_file); if (!dat) return; for (raine_nb_samples=1; raine_nb_samples<32; raine_nb_samples++) { sprintf(buff,"%d.wav",raine_nb_samples); err = unzLocateFile(dat,buff,2); if (err != UNZ_OK) break; } raine_nb_samples--; emudx_samples = (struct wave_spec*)AllocateMem((raine_nb_samples+1) * sizeof(struct wave_spec)); AddSaveData(ASCII_ID('S','A','M','P'), (UINT8*)emudx_samples, (raine_nb_samples+1) * sizeof(struct wave_spec)); sample_data = (struct private_data*)AllocateMem((raine_nb_samples+1)*sizeof(struct private_data)); for (i=1; i<=raine_nb_samples; i++) { sprintf(buff,"%d.wav",i); unzLocateFile(dat,buff,2); err = unzOpenCurrentFile(dat); unzGetCurrentFileInfo(dat,&file_info,NULL,0,NULL,0,NULL,0); buffer = malloc(file_info.uncompressed_size); unzReadCurrentFile(dat,buffer,file_info.uncompressed_size); emudx_samples[i].pos = emudx_samples[i].playing = 0; #ifdef SDL SDL_RWops *rw; unsigned int len_in_bytes; SDL_AudioCVT wav_cvt; SDL_AudioSpec wave; UINT8 *wav_buffer; extern SDL_AudioSpec gotspec; if (!gotspec.freq) { /* Now read_dx_file is called before the soundcard init, so we * must put sensible default values here... */ gotspec.freq = audio_sample_rate; gotspec.channels = 2; gotspec.format = AUDIO_S16; } rw = SDL_RWFromMem(buffer, file_info.uncompressed_size); if (!SDL_LoadWAV_RW(rw,1,&wave,&wav_buffer,&len_in_bytes)) { printf("couldn't load sample %d: %s\n",i,SDL_GetError()); exit(1); } unzCloseCurrentFile(dat); // Is this needed when open failed? if (SDL_BuildAudioCVT(&wav_cvt, wave.format, wave.channels, wave.freq, gotspec.format, gotspec.channels,gotspec.freq) == -1) { printf("can't build converter\n"); exit(1); } wav_cvt.buf = sample_data[i].data = AllocateMem(len_in_bytes*wav_cvt.len_mult); sample_data[i].len =len_in_bytes*wav_cvt.len_ratio; wav_cvt.len = len_in_bytes; memcpy(sample_data[i].data, wav_buffer, len_in_bytes); SDL_FreeWAV(wav_buffer); SDL_ConvertAudio(&wav_cvt); #else convert_wav((char*)buffer,file_info.uncompressed_size, (char**)&sample_data[i].data,&sample_data[i].len); #endif free(buffer); } unzClose(dat); }
bool LoadSound(const char* filename, bool sfxr) { auto it = sound_files.find(filename); Sound snd; if (it == sound_files.end()) { size_t len = 0; uchar *buf = LoadFile(filename, &len); if (!buf) return false; if (sfxr) { snd.buf = buf; snd.len = len; } else { SDL_AudioSpec wav_spec; Uint32 wav_len; auto wav_spec_ret = SDL_LoadWAV_RW(SDL_RWFromMem(buf, (int)len), true, &wav_spec, &snd.buf, &wav_len); free(buf); if (!wav_spec_ret) return false; snd.len = wav_len; SDL_AudioCVT wav_cvt; int ret = SDL_BuildAudioCVT(&wav_cvt, wav_spec.format, wav_spec.channels, wav_spec.freq, playbackspec.format, playbackspec.channels, playbackspec.freq); if (ret < 0) { SDL_FreeWAV(snd.buf); return false; } if (ret) { wav_cvt.buf = (uchar *)malloc(snd.len * wav_cvt.len_mult); wav_cvt.len = (int)snd.len; memcpy(wav_cvt.buf, snd.buf, snd.len); SDL_FreeWAV(snd.buf); SDL_ConvertAudio(&wav_cvt); snd.buf = wav_cvt.buf; // caution: len is not size of buffer anymore, but size of valid data.. // that works ok with SDL_FreeWAV/free snd.len = size_t(wav_cvt.len * wav_cvt.len_ratio); } } snd.sfxr = sfxr; sound_files[filename] = snd; } else { snd = it->second; if (sfxr != snd.sfxr) // wav file and sfxr file with same name? should be very rare :) return false; } if (sfxr) { uchar *file = snd.buf; int version = 0; fread_mem(&version, 1, sizeof(int), file); if(version!=102) return false; fread_mem(&wave_type, 1, sizeof(int), file); fread_mem(&sound_vol, 1, sizeof(float), file); fread_mem(&p_base_freq, 1, sizeof(float), file); fread_mem(&p_freq_limit, 1, sizeof(float), file); fread_mem(&p_freq_ramp, 1, sizeof(float), file); fread_mem(&p_freq_dramp, 1, sizeof(float), file); fread_mem(&p_duty, 1, sizeof(float), file); fread_mem(&p_duty_ramp, 1, sizeof(float), file); fread_mem(&p_vib_strength, 1, sizeof(float), file); fread_mem(&p_vib_speed, 1, sizeof(float), file); fread_mem(&p_vib_delay, 1, sizeof(float), file); fread_mem(&p_env_attack, 1, sizeof(float), file); fread_mem(&p_env_sustain, 1, sizeof(float), file); fread_mem(&p_env_decay, 1, sizeof(float), file); fread_mem(&p_env_punch, 1, sizeof(float), file); fread_mem(&filter_on, 1, sizeof(bool), file); fread_mem(&p_lpf_resonance, 1, sizeof(float), file); fread_mem(&p_lpf_freq, 1, sizeof(float), file); fread_mem(&p_lpf_ramp, 1, sizeof(float), file); fread_mem(&p_hpf_freq, 1, sizeof(float), file); fread_mem(&p_hpf_ramp, 1, sizeof(float), file); fread_mem(&p_pha_offset, 1, sizeof(float), file); fread_mem(&p_pha_ramp, 1, sizeof(float), file); fread_mem(&p_repeat_speed, 1, sizeof(float), file); fread_mem(&p_arp_speed, 1, sizeof(float), file); fread_mem(&p_arp_mod, 1, sizeof(float), file); } cursnd = snd; return true; }