void SND_BACKEND_OPENAL_GetDeviceList( void ) { char deviceName[ 256 ]; //my_strlcpy( deviceName, s_device->string, sizeof( deviceName ) ); if( alcIsExtensionPresent( NULL,"ALC_ENUMERATION_EXT") == AL_TRUE ) { // try out enumeration extension deviceList = (char *)alcGetString( NULL, ALC_DEVICE_SPECIFIER ); Log_Printf("OpenAL SND_GetDeviceList.\n",deviceList); for( numSoundDevices = 0 ; numSoundDevices < 12 ; ++numSoundDevices ) { sound_devices[ numSoundDevices ] = NULL; } for( numSoundDevices = 0 ; numSoundDevices < 12 ; ++numSoundDevices ) { sound_devices[ numSoundDevices ] = deviceList; if( strcmp( sound_devices[ numSoundDevices ], deviceName ) == 0 ) { numDefaultSoundDevice = numSoundDevices; } deviceList += strlen( deviceList ); if( deviceList[ 0 ] == 0 ) { if( deviceList[ 1 ] == 0 ) { break; } else { deviceList += 1; } } } // End for numSoundDevices = 0 ; numSoundDevices < 12 ; ++numSoundDevices } }
ALCdevice* InitOpenALCaptureDevice(ALCuint sample_frequency, ALCenum al_format, ALCsizei max_buffer_size) { ALCdevice* al_capture_device; if(!IsOpenALCaptureExtensionAvailable()) { return NULL; } const char* default_device = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER); fprintf(stderr, "default device=%s", default_device); al_capture_device = alcCaptureOpenDevice(default_device, sample_frequency, al_format, max_buffer_size); if(NULL == al_capture_device) { printf("Failed to get capture device\n"); return NULL; } // printf("Finished initializing AL capture\n"); return al_capture_device; }
ALboolean ALFWInitOpenAL() { ALDeviceList *pDeviceList = NULL; ALCcontext *pContext = NULL; ALCdevice *pDevice = NULL; ALint i; ALboolean bReturn = AL_FALSE; pDeviceList = new ALDeviceList(); if ((pDeviceList) && (pDeviceList->GetNumDevices())) { ALFWprintf("\nSelect OpenAL Device:\n"); for (i = 0; i < pDeviceList->GetNumDevices(); i++) ALFWprintf("%d. %s%s\n", i + 1, pDeviceList->GetDeviceName(i), i == pDeviceList->GetDefaultDevice() ? "(DEFAULT)" : ""); do { ALchar ch = _getch(); i = atoi(&ch); } while ((i < 1) || (i > pDeviceList->GetNumDevices())); pDevice = alcOpenDevice(pDeviceList->GetDeviceName(i - 1)); if (pDevice) { pContext = alcCreateContext(pDevice, NULL); if (pContext) { ALFWprintf("\nOpened %s Device\n", alcGetString(pDevice, ALC_DEVICE_SPECIFIER)); alcMakeContextCurrent(pContext); bReturn = AL_TRUE; } else { alcCloseDevice(pDevice); } } delete pDeviceList; } return bReturn; }
void csSndSysRendererOpenAL::Update() { // Listener is created on open, but EventHandler is setup at init, // so, in some cases we can get here without the listener having been // created yet. if (!m_Listener) return; // Get exclusive access to the OpenAL context. ScopedRendererLock lock (*this); // Make sure the context, not really necessary as we requested a async // context, but documentation recommends it, in case async contexts are not // supported. //alcProcessContext (m_Context); // Update the listeners state. bool ExternalUpdates = m_Listener->Update(); // Update the sources size_t iMax = m_Sources.GetSize(); for (size_t i=0;i<iMax;i++) { m_Sources[i]->PerformUpdate( ExternalUpdates ); if (m_Sources[i]->GetStream()->GetPauseState() == CS_SNDSYS_STREAM_PAUSED && m_Sources[i]->GetStream()->GetAutoUnregisterRequested() == true) // sound has finished and is not looping { RemoveStream(m_Sources[i]->GetStream()); RemoveSource(m_Sources[i]); i--; // changing the vector in mid-loop means we back up here iMax--; // array is also one shorter now } } // Check for any errors ALCenum err = alcGetError (m_Device); if (err != ALC_NO_ERROR) { Report (CS_REPORTER_SEVERITY_ERROR, "An OpenAL error occured: %s", alcGetString (m_Device, err)); CS_ASSERT (err == ALC_NO_ERROR); } }
/* ================= AL_StartOpenAL ================= */ static qboolean AL_StartOpenAL () { // Initialize our QAL dynamic bindings if (!QAL_Init()) return false; // Get device list if (alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT")) alConfig.deviceList = alcGetString(NULL, ALC_DEVICE_SPECIFIER); else alConfig.deviceList = "DirectSound3D\0DirectSound\0MMSYSTEM\0\0"; // Initialize the device, context, etc... if (AL_InitDriver()) return true; // Shutdown QAL QAL_Shutdown(); return false; }
bool QALContext::reset() { ALCenum error; if ((error = alcGetError(d->alcDevice)) != ALC_NO_ERROR) { qWarning() << Q_FUNC_INFO << "Error before trying to destroy the context:" << alcGetString(d->alcDevice, error); }; alcDestroyContext(d->alcContext); if ((error = alcGetError(d->alcDevice)) != ALC_NO_ERROR) { qWarning() << Q_FUNC_INFO << "Failed to destroy the context:" << alcGetString(d->alcDevice, error); return false; }; d->alcContext = 0; alcCloseDevice(d->alcDevice); d->alcDevice = 0; return true; }
FSoundManager::FSoundManager( UI32 iMaxSoundHash, I32 iDelState ) : iMaxHash( iMaxSoundHash ), iMaxSources( 0 ), lpSources( NULL ), lpSoundHash( NULL ), lpDevice( NULL ), lpContext( NULL ), iDelState( iDelState ) { const ALCchar * lpDevices = alcGetString( NULL, ALC_DEVICE_SPECIFIER ); NSLog( @"Dev: %s", lpDevices ); lpDevice = alcOpenDevice( lpDevices ); if( lpDevice ) { lpContext = alcCreateContext( lpDevice, NULL ); alcMakeContextCurrent( lpContext ); } const ALCchar * lpName = "alBufferDataStatic"; alBufferDataStatic = (alBufferDataStaticProcPtr)alcGetProcAddress( lpDevice, lpName ); lpSoundHash = (Node **)malloc( sizeof( Node * )*iMaxHash ); for( I32 i = 0;i < iMaxHash;i++ ) lpSoundHash[i] = NULL; CreateSources(); }
void AudioEngine::enumerateDevices(std::vector<std::string>& enumerated) { if (alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT")) { size_t len = 0; const ALCchar* devices = alcGetString(NULL, ALC_DEVICE_SPECIFIER); const ALCchar *device = devices, *next = devices + 1; while (device && *device != '\0' && next && *next != '\0') { enumerated.push_back(device); len = strlen(device); device += (len + 1); next += (len + 2); } } if (enumerated.empty()) enumerated.push_back(std::string()); // empty string is default device }
//-------------------------------------------------------------------------- // openal_error_string() // // Returns the human readable error string if there is an error or NULL if not // const char *openal_error_string(int get_alc) { int i; if (get_alc) { ALCdevice *device = alcGetContextsDevice( alcGetCurrentContext() ); i = alcGetError(device); if ( i != ALC_NO_ERROR ) return (const char*) alcGetString(device, i); } else { i = alGetError(); if ( i != AL_NO_ERROR ) return (const char*)alGetString(i); } return NULL; }
bool SoundEngineOpenAL::init(std::string device) { // Create logger FileLogger *logger = new FileLogger; if (logger->init("RaumKlang.htm")) { setLogger(logger); } else { delete logger; setLogger(new ConsoleLogger()); } // Get default device if (device == "") { device = alcGetString(0, ALC_DEFAULT_DEVICE_SPECIFIER); } // Setup OpenAL context ALCdevice *dev = alcOpenDevice(device.c_str()); if (!dev) return false; ALCcontext *context = alcCreateContext(dev, 0); alcMakeContextCurrent(context); if (alcGetError(dev) != ALC_NO_ERROR) return false; // Startup message getLogger()->writeLine(ELL_Information, "RaumKlang 0.0.1 (OpenAL)"); getLogger()->writeLine(ELL_Information, std::string("Device: ") + device); // Create listener listener = new ListenerOpenAL(); // Add stream loaders initStreamLoaders(); // Start update thread running = true; threadstopped = false; startUpdateThread(); return true; }
static void gst_openal_sink_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstOpenALSink *sink = GST_OPENAL_SINK (object); const ALCchar *device_name = sink->device_name; ALCdevice *device = sink->default_device; ALCcontext *context = sink->default_context; ALuint source = sink->default_source; switch (prop_id) { case PROP_DEVICE_NAME: device_name = ""; if (device) device_name = alcGetString (device, ALC_DEVICE_SPECIFIER); /* fall-through */ case PROP_DEVICE: g_value_set_string (value, device_name); break; case PROP_USER_DEVICE: if (!device) device = sink->user_device; g_value_set_pointer (value, device); break; case PROP_USER_CONTEXT: if (!context) context = sink->user_context; g_value_set_pointer (value, context); break; case PROP_USER_SOURCE: if (!source) source = sink->user_source; g_value_set_uint (value, source); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static PP_Bool Instance_DidCreate(PP_Instance instance, uint32_t argc, const char* argn[], const char* argv[]) { g_MyState.instance = instance; g_MyState.ready = 0; g_MyStateIsValid = 1; /* This sets up OpenAL with PPAPI info. */ alSetPpapiInfo(instance, g_get_browser_interface); const ALCchar* devices = alcGetString(NULL, ALC_DEVICE_SPECIFIER); setenv("ALSOFT_LOGLEVEL", "3", 0); printf("Audio devices available:\n"); while (devices[0] != '\0') { printf("\t%s\n", devices); devices = devices + strlen(devices) + 1; } InitializeOpenAL(); ogg_file_contents = (char*)malloc(BUFFER_READ_SIZE); ogg_file_alloced = BUFFER_READ_SIZE; PP_Resource request = g_MyState.request_interface->Create(instance); g_MyState.request_interface->SetProperty( request, PP_URLREQUESTPROPERTY_URL, g_MyState.var_interface->VarFromUtf8(OGG_FILE, strlen(OGG_FILE))); PP_Resource loader = g_MyState.loader_interface->Create(instance); struct PP_CompletionCallback cb = PP_MakeCompletionCallback(OpenCallback, (void*)loader); int32_t open_ret = g_MyState.loader_interface->Open(loader, request, cb); assert(open_ret == PP_OK_COMPLETIONPENDING); if (open_ret != PP_OK_COMPLETIONPENDING) return PP_FALSE; return PP_TRUE; }
//////////////////////////////////////////////////////////// /// R�cup�re la liste des noms des devices disponibles /// /// \param Devices : Tableau de cha�nes � remplir avec les noms des devices /// //////////////////////////////////////////////////////////// void GetDevices(std::vector<std::string>& Devices) { // Vidage de la liste Devices.clear(); // R�cup�ration des devices disponibles const ALCchar* DeviceList = alcGetString(NULL, ALC_DEVICE_SPECIFIER); if (DeviceList) { // Extraction des devices contenus dans la cha�ne renvoy�e while (strlen(DeviceList) > 0) { Devices.push_back(DeviceList); DeviceList += strlen(DeviceList) + 1; } } else { std::cerr << "Impossible de r�cup�rer la liste des devices" << std::endl; } }
bool cAudioCapture::initOpenALDevice() { cAudioMutexBasicLock lock(Mutex); if(CaptureDevice) shutdownOpenALDevice(); if(DeviceName.empty()) CaptureDevice = alcCaptureOpenDevice(NULL, Frequency, convertAudioFormatEnum(Format), InternalBufferSize / SampleSize); else CaptureDevice = alcCaptureOpenDevice(toUTF8(DeviceName), Frequency, convertAudioFormatEnum(Format), InternalBufferSize / SampleSize); if(CaptureDevice) { DeviceName = fromUTF8(alcGetString(CaptureDevice, ALC_CAPTURE_DEVICE_SPECIFIER)); Ready = true; checkError(); getLogger()->logDebug("AudioCapture", "OpenAL Capture Device Opened."); return true; } checkError(); return false; }
SoundManager() { error = 0; read_buf_size = 44000; play_buf_size = 44000; play_buf[0] = 0; // Инициализируем OpenAL и создаем всякие штучки out_device = alcOpenDevice (0); context = alcCreateContext(out_device, 0); alcMakeContextCurrent(context); const char * szDefaultCaptureDevice = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER); /* while(*szDefaultCaptureDevice) { ALFWprintf("%s\n", pDeviceList); pDeviceList += strlen(pDeviceList) + 1; std::cout<<"Capture devices: "<< szDefaultCaptureDevice <<std::endl ; szDefaultCaptureDevice += strlen(szDefaultCaptureDevice) + 1; //next device } */ in_device = alcCaptureOpenDevice (szDefaultCaptureDevice, 44100, AL_FORMAT_STEREO16, read_buf_size); if( (error= alcGetError(in_device)) != AL_NO_ERROR) std::cout<<error<<" alcCaptureOpenDevice "<<__LINE__<<"\n"; alGenSources(1, &al_source); alGenBuffers(BUF_COUNT, al_buffers); // Заполняем первую очередь for (int i = 0; i < BUF_COUNT; ++i) { alBufferData(al_buffers[i], AL_FORMAT_MONO16, play_buf, play_buf_size * sizeof(ALshort), play_buf_size); } // Здесь начинаем запись и воспроизведение alSourceQueueBuffers(al_source, BUF_COUNT, al_buffers); alSourcePlay(al_source); alcCaptureStart(in_device); if( (error= alcGetError(in_device)) != AL_NO_ERROR) std::cout<<error<<" alcCaptureStart "<<__LINE__<<"\n"; }
// virtual bool LLAudioEngine_OpenAL::init(const S32 num_channels, void* userdata) { mWindGen = NULL; LLAudioEngine::init(num_channels, userdata); if(!alutInit(NULL, NULL)) { LL_WARNS("OpenAL") << "LLAudioEngine_OpenAL::init() ALUT initialization failed: " << alutGetErrorString (alutGetError ()) << LL_ENDL; return false; } LL_INFOS("OpenAL") << "LLAudioEngine_OpenAL::init() OpenAL successfully initialized" << LL_ENDL; LL_INFOS("OpenAL") << "OpenAL version: " << ll_safe_string(alGetString(AL_VERSION)) << LL_ENDL; LL_INFOS("OpenAL") << "OpenAL vendor: " << ll_safe_string(alGetString(AL_VENDOR)) << LL_ENDL; LL_INFOS("OpenAL") << "OpenAL renderer: " << ll_safe_string(alGetString(AL_RENDERER)) << LL_ENDL; ALint major = alutGetMajorVersion (); ALint minor = alutGetMinorVersion (); LL_INFOS("OpenAL") << "ALUT version: " << major << "." << minor << LL_ENDL; ALCdevice *device = alcGetContextsDevice(alcGetCurrentContext()); alcGetIntegerv(device, ALC_MAJOR_VERSION, 1, &major); alcGetIntegerv(device, ALC_MAJOR_VERSION, 1, &minor); LL_INFOS("OpenAL") << "ALC version: " << major << "." << minor << LL_ENDL; LL_INFOS("OpenAL") << "ALC default device: " << ll_safe_string(alcGetString(device, ALC_DEFAULT_DEVICE_SPECIFIER)) << LL_ENDL; return true; }
Mixer::Mixer () { const ALCchar * device_name = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER); AudioError::reset(); _audio_device = _default_audio_device(); _audio_context = alcCreateContext(_audio_device, NULL); AudioError::check("Initializing Audio Context"); bool result = alcMakeContextCurrent(_audio_context); LogBuffer buffer; buffer << "OpenAL Context Initialized..." << std::endl; buffer << "OpenAL Vendor: " << alGetString(AL_VENDOR) << " " << alGetString(AL_VERSION) << std::endl; buffer << "OpenAL Device: '" << device_name << "'" << std::endl; logger()->log(LOG_INFO, buffer); //al_distance_model(AL_LINEAR_DISTANCE); set_listener_position(0); set_listener_velocity(0); set_listener_orientation(Vec3(0.0, 0.0, -1.0), Vec3(0.0, 1.0, 0.0)); DREAM_ASSERT(result && "Failed to initialize audio hardware!?"); }
av_session_t *av_init_session() { av_session_t *_retu = malloc(sizeof(av_session_t)); /* Initialize our mutex */ pthread_mutex_init ( &_retu->_mutex, NULL ); _retu->_messenger = tox_new(1); if ( !_retu->_messenger ) { fprintf ( stderr, "tox_new() failed!\n" ); return NULL; } _retu->_friends = NULL; const ALchar *_device_list = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER); int i = 0; const ALchar *device_names[20]; if ( _device_list ) { INFO("\nAvailable Capture Devices are:"); while (*_device_list ) { device_names[i] = _device_list; INFO("%d) %s", i, device_names[i]); _device_list += strlen( _device_list ) + 1; ++i; } } INFO("Enter capture device number"); char dev[2]; char *left; char *warned_ = fgets(dev, 2, stdin); (void)warned_; long selection = strtol(dev, &left, 10); if ( *left ) { printf("'%s' is not a number!", dev); fflush(stdout); exit(EXIT_FAILURE); } else { INFO("Selected: %d ( %s )", selection, device_names[selection]); } _retu->audio_capture_device = (struct ALCdevice *)alcCaptureOpenDevice( device_names[selection], AUDIO_SAMPLE_RATE, AL_FORMAT_MONO16, AUDIO_FRAME_SIZE * 4); if (alcGetError((ALCdevice *)_retu->audio_capture_device) != AL_NO_ERROR) { printf("Could not start capture device! %d\n", alcGetError((ALCdevice *)_retu->audio_capture_device)); return 0; } uint16_t height = 0, width = 0; #ifdef TOX_FFMPEG avdevice_register_all(); avcodec_register_all(); av_register_all(); _retu->video_input_format = av_find_input_format(VIDEO_DRIVER); if (avformat_open_input(&_retu->video_format_ctx, DEFAULT_WEBCAM, _retu->video_input_format, NULL) != 0) { fprintf(stderr, "Opening video_input_format failed!\n"); //return -1; goto failed_init_ffmpeg; } avformat_find_stream_info(_retu->video_format_ctx, NULL); av_dump_format(_retu->video_format_ctx, 0, DEFAULT_WEBCAM, 0); for (i = 0; i < _retu->video_format_ctx->nb_streams; ++i) { if (_retu->video_format_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) { _retu->video_stream = i; break; } } _retu->webcam_decoder_ctx = _retu->video_format_ctx->streams[_retu->video_stream]->codec; _retu->webcam_decoder = avcodec_find_decoder(_retu->webcam_decoder_ctx->codec_id); if (_retu->webcam_decoder == NULL) { fprintf(stderr, "Unsupported codec!\n"); //return -1; goto failed_init_ffmpeg; } if (_retu->webcam_decoder_ctx == NULL) { fprintf(stderr, "Init webcam_decoder_ctx failed!\n"); //return -1; goto failed_init_ffmpeg; } if (avcodec_open2(_retu->webcam_decoder_ctx, _retu->webcam_decoder, NULL) < 0) { fprintf(stderr, "Opening webcam decoder failed!\n"); //return -1; goto failed_init_ffmpeg; } width = _retu->webcam_decoder_ctx->width; height = _retu->webcam_decoder_ctx->height; failed_init_ffmpeg: ; #endif uint8_t _byte_address[TOX_FRIEND_ADDRESS_SIZE]; tox_get_address(_retu->_messenger, _byte_address ); fraddr_to_str( _byte_address, _retu->_my_public_id ); _retu->av = toxav_new(_retu->_messenger, width, height); /* ------------------ */ toxav_register_callstate_callback(callback_call_started, av_OnStart, _retu->av); toxav_register_callstate_callback(callback_call_canceled, av_OnCancel, _retu->av); toxav_register_callstate_callback(callback_call_rejected, av_OnReject, _retu->av); toxav_register_callstate_callback(callback_call_ended, av_OnEnd, _retu->av); toxav_register_callstate_callback(callback_recv_invite, av_OnInvite, _retu->av); toxav_register_callstate_callback(callback_recv_ringing, av_OnRinging, _retu->av); toxav_register_callstate_callback(callback_recv_starting, av_OnStarting, _retu->av); toxav_register_callstate_callback(callback_recv_ending, av_OnEnding, _retu->av); toxav_register_callstate_callback(callback_recv_error, av_OnError, _retu->av); toxav_register_callstate_callback(callback_requ_timeout, av_OnRequestTimeout, _retu->av); /* ------------------ */ return _retu; }
__FORCE_ALIGN_STACK__ void CSound::StartThread(int maxSounds) { { boost::recursive_mutex::scoped_lock lck(soundMutex); // alc... will create its own thread it will copy the name from the current thread. // Later we finally rename `our` audio thread. Threading::SetThreadName("openal"); // NULL -> default device const ALchar* deviceName = NULL; std::string configDeviceName = ""; // we do not want to set a default for snd_device, // so we do it like this ... if (configHandler->IsSet("snd_device")) { configDeviceName = configHandler->GetString("snd_device"); deviceName = configDeviceName.c_str(); } ALCdevice* device = alcOpenDevice(deviceName); if ((device == NULL) && (deviceName != NULL)) { LOG_L(L_WARNING, "Could not open the sound device \"%s\", trying the default device ...", deviceName); configDeviceName = ""; deviceName = NULL; device = alcOpenDevice(deviceName); } if (device == NULL) { LOG_L(L_ERROR, "Could not open a sound device, disabling sounds"); CheckError("CSound::InitAL"); return; } else { ALCcontext *context = alcCreateContext(device, NULL); if (context != NULL) { alcMakeContextCurrent(context); CheckError("CSound::CreateContext"); } else { alcCloseDevice(device); LOG_L(L_ERROR, "Could not create OpenAL audio context"); return; } } maxSounds = GetMaxMonoSources(device, maxSounds); LOG("OpenAL info:"); if(alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT")) { LOG(" Available Devices:"); const char* deviceSpecifier = alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER); while (*deviceSpecifier != '\0') { LOG(" %s", deviceSpecifier); while (*deviceSpecifier++ != '\0') ; } LOG(" Device: %s", (const char*)alcGetString(device, ALC_DEVICE_SPECIFIER)); } LOG(" Vendor: %s", (const char*)alGetString(AL_VENDOR)); LOG(" Version: %s", (const char*)alGetString(AL_VERSION)); LOG(" Renderer: %s", (const char*)alGetString(AL_RENDERER)); LOG(" AL Extensions: %s", (const char*)alGetString(AL_EXTENSIONS)); LOG(" ALC Extensions: %s", (const char*)alcGetString(device, ALC_EXTENSIONS)); // Init EFX efx = new CEFX(device); // Generate sound sources for (int i = 0; i < maxSounds; i++) { CSoundSource* thenewone = new CSoundSource(); if (thenewone->IsValid()) { sources.push_back(thenewone); } else { maxSounds = std::max(i-1, 0); LOG_L(L_WARNING, "Your hardware/driver can not handle more than %i soundsources", maxSounds); delete thenewone; break; } } LOG(" Max Sounds: %i", maxSounds); // Set distance model (sound attenuation) alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED); alDopplerFactor(0.2f); alListenerf(AL_GAIN, masterVolume); } Threading::SetThreadName("audio"); Watchdog::RegisterThread(WDT_AUDIO); while (!soundThreadQuit) { boost::this_thread::sleep(boost::posix_time::millisec(50)); //! 20Hz Watchdog::ClearTimer(WDT_AUDIO); Update(); } Watchdog::DeregisterThread(WDT_AUDIO); sources.clear(); // delete all sources delete efx; // must happen after sources and before context efx = NULL; ALCcontext* curcontext = alcGetCurrentContext(); ALCdevice* curdevice = alcGetContextsDevice(curcontext); alcMakeContextCurrent(NULL); alcDestroyContext(curcontext); alcCloseDevice(curdevice); }
//* // ======================================================================================================================= // ======================================================================================================================= // bool sound_InitLibrary(void) { int err; const ALfloat listenerVel[3] = { 0.0, 0.0, 0.0 }; const ALfloat listenerOri[6] = { 0.0, 0.0, 1.0, 0.0, 1.0, 0.0 }; char buf[512]; const ALCchar *deviceName; #if 0 // This code is disabled because enumerating devices apparently crashes PulseAudio on Fedora12 /* Get the available devices and print them. * Devices are separated by NUL chars ('\0') and the list of devices is * terminated by two NUL chars. */ deviceName = alcGetString(NULL, ALC_DEVICE_SPECIFIER); while (deviceName != NULL && *deviceName != '\0') { debug(LOG_SOUND, "available OpenAL device(s) are: %s", deviceName); deviceName += strlen(deviceName) + 1; } #endif #ifdef WZ_OS_WIN /* HACK: Select the "software" OpenAL device on Windows because it * provides 256 sound sources (unlike most Creative's default * which provides only 16), causing our lack of source-management * to be significantly less noticeable. */ device = alcOpenDevice("Generic Software"); // If the software device isn't available, fall back to default if (!device) #endif { // Open default device device = alcOpenDevice(NULL); } if (!device) { debug(LOG_ERROR, "Couldn't open audio device."); return false; } // Print current device name and add it to dump info deviceName = alcGetString(device, ALC_DEVICE_SPECIFIER); debug(LOG_SOUND, "Current audio device: %s", deviceName); ssprintf(buf, "OpenAL Device Name: %s", deviceName); addDumpInfo(buf); context = alcCreateContext(device, NULL); //NULL was contextAttributes if (!context) { debug(LOG_ERROR, "Couldn't open audio context."); return false; } alcMakeContextCurrent(context); err = sound_GetContextError(device); if (err != ALC_NO_ERROR) { debug(LOG_ERROR, "Couldn't initialize audio context: %s", alcGetString(device, err)); return false; } // Dump Open AL device info (depends on context) // to the crash handler for the dump file and debug log ssprintf(buf, "OpenAL Vendor: %s", alGetString(AL_VENDOR)); addDumpInfo(buf); debug(LOG_SOUND, "%s", buf); ssprintf(buf, "OpenAL Version: %s", alGetString(AL_VERSION)); addDumpInfo(buf); debug(LOG_SOUND, "%s", buf); ssprintf(buf, "OpenAL Renderer: %s", alGetString(AL_RENDERER)); addDumpInfo(buf); debug(LOG_SOUND, "%s", buf); ssprintf(buf, "OpenAL Extensions: %s", alGetString(AL_EXTENSIONS)); addDumpInfo(buf); debug(LOG_SOUND, "%s", buf); openal_initialized = true; // Clear Error Codes alGetError(); alcGetError(device); alListener3f(AL_POSITION, 0.f, 0.f, 0.f); alListenerfv(AL_VELOCITY, listenerVel); alListenerfv(AL_ORIENTATION, listenerOri); alDistanceModel(AL_NONE); sound_GetError(); return true; }
/* * Init call */ ALDeviceList::ALDeviceList() { ALDEVICEINFO ALDeviceInfo; char *devices; s32 index; const char *defaultDeviceName = NULL; const char *actualDeviceName = NULL; // DeviceInfo vector stores, for each enumerated device, it's device name, selection status, spec version #, and extension support vDeviceInfo.empty(); vDeviceInfo.reserve(10); defaultDeviceIndex = 0; // grab function pointers for 1.0-API functions, and if successful proceed to enumerate all devices //if (LoadOAL10Library(NULL, &ALFunction) == TRUE) { if (alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT")) { devices = (char *)alcGetString(NULL, ALC_DEVICE_SPECIFIER); defaultDeviceName = (char *)alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER); index = 0; // go through device list (each device terminated with a single NULL, list terminated with double NULL) while (devices != NULL && strlen(devices) > 0) { if (strcmp(defaultDeviceName, devices) == 0) { defaultDeviceIndex = index; } ALCdevice *device = alcOpenDevice(devices); if (device) { ALCcontext *context = alcCreateContext(device, NULL); if (context) { alcMakeContextCurrent(context); // if new actual device name isn't already in the list, then add it... actualDeviceName = alcGetString(device, ALC_DEVICE_SPECIFIER); bool bNewName = true; for (s32 i = 0; i < GetNumDevices(); i++) { if (strcmp(GetDeviceName(i), actualDeviceName) == 0) { bNewName = false; } } if ((bNewName) && (actualDeviceName != NULL) && (strlen(actualDeviceName) > 0)) { ALDeviceInfo.bSelected = true; ALDeviceInfo.strDeviceName = actualDeviceName; alcGetIntegerv(device, ALC_MAJOR_VERSION, sizeof(s32), &ALDeviceInfo.iMajorVersion); alcGetIntegerv(device, ALC_MINOR_VERSION, sizeof(s32), &ALDeviceInfo.iMinorVersion); ALDeviceInfo.pvstrExtensions = new vector<string>; // Check for ALC Extensions if (alcIsExtensionPresent(device, "ALC_EXT_CAPTURE") == AL_TRUE) ALDeviceInfo.pvstrExtensions->push_back("ALC_EXT_CAPTURE"); if (alcIsExtensionPresent(device, "ALC_EXT_EFX") == AL_TRUE) ALDeviceInfo.pvstrExtensions->push_back("ALC_EXT_EFX"); // Check for AL Extensions if (alIsExtensionPresent("AL_EXT_OFFSET") == AL_TRUE) ALDeviceInfo.pvstrExtensions->push_back("AL_EXT_OFFSET"); if (alIsExtensionPresent("AL_EXT_LINEAR_DISTANCE") == AL_TRUE) ALDeviceInfo.pvstrExtensions->push_back("AL_EXT_LINEAR_DISTANCE"); if (alIsExtensionPresent("AL_EXT_EXPONENT_DISTANCE") == AL_TRUE) ALDeviceInfo.pvstrExtensions->push_back("AL_EXT_EXPONENT_DISTANCE"); if (alIsExtensionPresent("EAX2.0") == AL_TRUE) ALDeviceInfo.pvstrExtensions->push_back("EAX2.0"); if (alIsExtensionPresent("EAX3.0") == AL_TRUE) ALDeviceInfo.pvstrExtensions->push_back("EAX3.0"); if (alIsExtensionPresent("EAX4.0") == AL_TRUE) ALDeviceInfo.pvstrExtensions->push_back("EAX4.0"); if (alIsExtensionPresent("EAX5.0") == AL_TRUE) ALDeviceInfo.pvstrExtensions->push_back("EAX5.0"); if (alIsExtensionPresent("EAX-RAM") == AL_TRUE) ALDeviceInfo.pvstrExtensions->push_back("EAX-RAM"); // Get Source Count ALDeviceInfo.uiSourceCount = GetMaxNumSources(); vDeviceInfo.push_back(ALDeviceInfo); } alcMakeContextCurrent(NULL); alcDestroyContext(context); } alcCloseDevice(device); } devices += strlen(devices) + 1; index += 1; } } //} ResetFilters(); }
void fs_emu_audio_openal_init(void) { fs_log("fs_emu_audio_openal_init\n"); register_functions(); // select the "preferred device" g_device = alcOpenDevice(NULL); if (g_device) { fs_log("[OPENAL] Opened device: %s\n", alcGetString(g_device, ALC_DEVICE_SPECIFIER)); } else { fs_log("[OPENAL] NULL from alcOpenDevice\n"); ALenum error_code = alGetError(); fs_log("[OPENAL] Error code %d\n", error_code); if (alGetString(error_code)) { fs_log("[OPENAL] %s\n", alGetString(error_code)); } fs_emu_warning("OPENAL: Could not open audio device"); } if (!g_device) { return; } log_openal_info(); log_openal_devices(); int frequencies[] = { 48000, 44100, 0 }; if (fs_config_get_int("audio_frequency") != FS_CONFIG_NONE) { frequencies[0] = fs_config_get_int("audio_frequency"); } for (int i = 0; frequencies[i]; i++) { int frequency = frequencies[i]; fs_log("OPENAL: trying frequency %d\n", frequency); ALCint attributes[] = { ALC_MONO_SOURCES, 0, ALC_STEREO_SOURCES, 2, ALC_FREQUENCY, frequency, 0 }; g_context = alcCreateContext(g_device, attributes); if (g_context) { g_audio_out_frequency = frequency; break; } } if (g_context) { fs_log("OPENAL: created context\n"); alcMakeContextCurrent(g_context); check_al_error("alcMakeContextCurrent"); fs_log("OPENAL: made context current\n"); } else { fs_emu_warning("OpenAL: no context created\n"); //check_al_error("alcCreateContext"); } int stereo_sources; alcGetIntegerv(g_device, ALC_STEREO_SOURCES, 1, &stereo_sources); fs_log("openal: number of stereo sources is %d\n", stereo_sources); // FIXME: configure elsewhere int abt = fs_config_get_int_clamped("audio_buffer_target_size", 1, 100); if (abt == FS_CONFIG_NONE) { if (fs_config_get_int("audio_buffer_target_bytes") != FS_CONFIG_NONE) { fs_emu_warning("Use audio_buffer_target_size instead\n"); } abt = 40; #if 0 if (abt == FS_CONFIG_NONE) { abt = 40; } else { abt = (int) (abt / 1000.0 * (options->frequency * 2 * 2)); } #endif } fs_log("AUDIO: Buffer target size (ms) = %d\n", abt); //abt = (int) (abt / 1000.0 * (options->frequency * 2 * 2)); // fs_log("AUDIO: Buffer target size (bytes) = %d\n", abt); /* Specifying fill target in microseconds */ g_default_fill_target = abt * 1000; }
const ALCchar* CDECL wine_alcGetString(ALCdevice *device, ALCenum param) { return alcGetString(device, param); }
void MFSound_InitModulePlatformSpecific(int *pSoundDataSize, int *pVoiceDataSize) { MFCALLSTACK; gDevices.Init(sizeof(AudioDevice), 8, 8); ALCint minor, major; alcGetIntegerv(NULL, ALC_MAJOR_VERSION, 1, &major); alcGetIntegerv(NULL, ALC_MINOR_VERSION, 1, &minor); gAPIVersion = major*100 + minor; bool bCanEnumerate, bHasCapture; if(gAPIVersion >= 101) { bCanEnumerate = true; bHasCapture = true; } else { bCanEnumerate = alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") == AL_TRUE; bHasCapture = alcIsExtensionPresent(NULL, "ALC_EXT_CAPTURE") == AL_TRUE; } if(bCanEnumerate) { const char *pDevices = alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER); const char *pDefault = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER); while(pDevices && *pDevices) { bool bIsDefault = !MFString_Compare(pDevices, pDefault); MFDebug_Log(2, MFStr("OpenAL: found output device '%s'%s", pDevices, bIsDefault ? " (default)" : "")); MFDevice *pDevice = MFDevice_AllocDevice(MFDT_AudioRender, &DestroyDevice); pDevice->pInternal = gDevices.AllocAndZero(); pDevice->state = MFDevState_Ready; AudioDevice &device = *(AudioDevice*)pDevice->pInternal; MFString_CopyN(pDevice->strings[MFDS_ID], pDevices, sizeof(pDevice->strings[MFDS_ID])-1); pDevice->strings[MFDS_ID][sizeof(pDevice->strings[MFDS_ID])-1] = 0; device.pDevice = NULL; if(bIsDefault) MFDevice_SetDefaultDevice(MFDT_AudioRender, MFDDT_All, pDevice); pDevices += MFString_Length(pDevices) + 1; } if(!MFDevice_GetDefaultDevice(MFDT_AudioRender, MFDDT_Default)) { MFDebug_Warn(2, "OpenAL: No default output device?"); // HACK: set it to the first one... MFDevice *pDevice = MFDevice_GetDeviceByIndex(MFDT_AudioRender, 0); MFDevice_SetDefaultDevice(MFDT_AudioRender, MFDDT_All, pDevice); } if(bHasCapture) { pDevices = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER); pDefault = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER); while(pDevices && *pDevices) { bool bIsDefault = !MFString_Compare(pDevices, pDefault); MFDebug_Log(2, MFStr("OpenAL: found capture device '%s'%s", pDevices, bIsDefault ? " (default)" : "")); MFDevice *pDevice = MFDevice_AllocDevice(MFDT_AudioCapture, &DestroyDevice); pDevice->pInternal = gDevices.AllocAndZero(); pDevice->state = MFDevState_Ready; AudioDevice &device = *(AudioDevice*)pDevice->pInternal; MFString_CopyN(pDevice->strings[MFDS_ID], pDevices, sizeof(pDevice->strings[MFDS_ID])-1); pDevice->strings[MFDS_ID][sizeof(pDevice->strings[MFDS_ID])-1] = 0; device.pDevice = NULL; if(bIsDefault) MFDevice_SetDefaultDevice(MFDT_AudioCapture, MFDDT_All, pDevice); pDevices += MFString_Length(pDevices) + 1; } if(!MFDevice_GetDefaultDevice(MFDT_AudioCapture, MFDDT_Default)) MFDebug_Warn(2, "OpenAL: No default capture device?"); } } // create a context Context *pContext = CreateContext(MFDevice_GetDefaultDevice(MFDT_AudioRender, MFDDT_Default)); MakeCurrent(pContext); // we need to return the size of the internal structures so the platform independant // code can make the correct allocations.. *pSoundDataSize = sizeof(MFSoundDataInternal); *pVoiceDataSize = sizeof(MFVoiceDataInternal); }
value lime_alc_get_string (value device, value param) { ALCdevice* alcDevice = (ALCdevice*)(intptr_t)val_float (device); return alloc_string (alcGetString (alcDevice, val_int (param))); }
void SetupSound() { unsigned char buf[BUFFER_SIZE]; int i; // Get handle to device. pDevice = alcOpenDevice(NULL); if(checkALCError()) { fprintf(stderr, "[SPU] alcOpenDevice failed.\n"); return; } // ALC info. const ALCubyte* UNUSED_VARIABLE deviceName = (ALCubyte*)alcGetString(pDevice, ALC_DEVICE_SPECIFIER); //printf("[SPU] ALC_DEVICE_SPECIFIER = %s.\n", deviceName); const ALCubyte* UNUSED_VARIABLE extensionList = (ALCubyte*)alcGetString(pDevice, ALC_EXTENSIONS); //printf("[SPU] ALC_EXTENSIONS = %s.\n", extensionList); // Create audio context. pContext = alcCreateContext(pDevice, NULL); if(checkALCError()) { fprintf(stderr, "[SPU] alcCreateContext failed.\n"); return; } // Set active context. alcMakeContextCurrent( pContext ); if( checkALCError() ) { fprintf(stderr, "[SPU] alcMakeContextCurrent failed.\n"); return; } // AL info. const ALubyte* UNUSED_VARIABLE version = (ALubyte*)alGetString(AL_VERSION); //printf("[SPU] AL_VERSION = %s.\n", version); const ALubyte* UNUSED_VARIABLE renderer = (ALubyte*)alGetString(AL_RENDERER); //printf("[SPU] AL_RENDERER = %s.\n", renderer); const ALubyte* UNUSED_VARIABLE vendor = (ALubyte*)alGetString(AL_VENDOR); //printf("[SPU] AL_VENDOR = %s.\n", vendor); // Create buffers. alGenBuffers(BUFFER_QUANTITY, buffers); checkALError(); // Load sound data into a buffer. memset(buf, 0x00, BUFFER_SIZE); for(i = 0; i < BUFFER_QUANTITY; ++i) { alBufferData(buffers[i], format, buf, BUFFER_SIZE, sampleRate); } checkALError(); // Create source. alGenSources(1, &source); checkALError(); // Bind buffer with a source. alSourcef (source, AL_PITCH, 1.0f ); alSourcef (source, AL_GAIN, 1.0f ); alSourcefv(source, AL_POSITION, SourcePos); alSourcefv(source, AL_VELOCITY, SourceVel); alSourcefv(source, AL_DIRECTION, SourceDir); alSourcei (source, AL_SOURCE_RELATIVE, AL_TRUE ); alSourcei (source, AL_LOOPING, AL_FALSE ); // Listener properties. alListenerfv(AL_POSITION, ListenerPos); alListenerfv(AL_VELOCITY, ListenerVel); alListenerfv(AL_ORIENTATION, ListenerOri); // Add buffers to queue. alSourceQueueBuffers(source, BUFFER_QUANTITY, buffers); checkALError(); // Enable playing. alSourcePlay(source); checkALError(); }
bool AudioEngine::SingletonInitialize() { if(!AUDIO_ENABLE) return true; const ALCchar *best_device = 0; // Will store the name of the 'best' device for audio playback ALCint highest_version = 0; // The highest version number found CheckALError(); // Clears errors CheckALCError(); // Clears errors // Find the highest-version device available, if the extension for device enumeration is present if(alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE) { const ALCchar *device_list = 0; device_list = alcGetString(0, ALC_DEVICE_SPECIFIER); // Get list of all devices (terminated with two '0') if(CheckALCError() == true) { IF_PRINT_WARNING(AUDIO_DEBUG) << "failed to retrieve the list of available audio devices: " << CreateALCErrorString() << std::endl; } while(*device_list != 0) { // Check all the detected devices ALCint major_v = 0, minor_v = 0; // Open a temporary device for reading in its version number ALCdevice *temp_device = alcOpenDevice(device_list); if(CheckALCError() || temp_device == NULL) { // If we couldn't open the device, just move on to the next IF_PRINT_WARNING(AUDIO_DEBUG) << "couldn't open device for version checking: " << device_list << std::endl; device_list += strlen(device_list) + 1; continue; } // Create a temporary context for the device ALCcontext *temp_context = alcCreateContext(temp_device, 0); if(CheckALCError() || temp_context == NULL) { // If we couldn't create the context, move on to the next device IF_PRINT_WARNING(AUDIO_DEBUG) << "couldn't create a temporary context for device: " << device_list << std::endl; alcCloseDevice(temp_device); device_list += strlen(device_list) + 1; continue; } // Retrieve the version number for the device alcMakeContextCurrent(temp_context); alcGetIntegerv(temp_device, ALC_MAJOR_VERSION, sizeof(ALCint), &major_v); alcGetIntegerv(temp_device, ALC_MINOR_VERSION, sizeof(ALCint), &minor_v); alcMakeContextCurrent(0); // Disable the temporary context alcDestroyContext(temp_context); // Destroy the temporary context alcCloseDevice(temp_device); // Close the temporary device // Check if a higher version device was found if(highest_version < (major_v * 10 + minor_v)) { highest_version = (major_v * 10 + minor_v); best_device = device_list; } device_list += strlen(device_list) + 1; // Go to the next device name in the list } // while (*device_name != 0) } // if (alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE) // Open the 'best' device we found above. If no devices were previously found, // it will try opening the default device (= 0) _device = alcOpenDevice(best_device); if(CheckALCError() || _device == NULL) { PRINT_ERROR << "failed to open an OpenAL audio device: " << CreateALCErrorString() << std::endl; return false; } // Create an OpenAL context _context = alcCreateContext(_device, NULL); if(CheckALCError() || _context == NULL) { PRINT_ERROR << "failed to create an OpenAL context: " << CreateALCErrorString() << std::endl; alcCloseDevice(_device); return false; } alcMakeContextCurrent(_context); CheckALError(); // Clear errors CheckALCError(); // Clear errors // Create as many sources as possible (we fix an upper bound of MAX_DEFAULT_AUDIO_SOURCES) ALuint source; for(uint16 i = 0; i < _max_sources; i++) { alGenSources(1, &source); if(CheckALError() == true) { _max_sources = i; _max_cache_size = i / 4; break; } _audio_sources.push_back(new private_audio::AudioSource(source)); } if(_max_sources == 0) { PRINT_ERROR << "failed to create at least one OpenAL audio source" << std::endl; return false; } return true; } // bool AudioEngine::SingletonInitialize()
bool alutInit(ALint *argc,ALbyte **argv) { ALenum errori=alGetError(); alGetError(); alGetError(); alGetError(); alGetError(); ALCcontext *Context; ALCdevice *Device; errori=alGetError(); if(errori != AL_NO_ERROR){ return false; } errori=alGetError(); if(errori != AL_NO_ERROR){ return false; } Device=alcOpenDevice(NULL); Context=alcCreateContext(Device,NULL); //Set active context alcMakeContextCurrent(Context); char* t=(char*)alcGetString(Device,ALC_DEVICE_SPECIFIER); #ifdef _WIN32 if(t==NULL){ logs().audio.write("HARDWARESTRING:''"); return false; } String lol; while(t[1]!=NULL){ lol+=t; t+=lol.size()+1; } logs().audio.write("HARDWARESTRING:'"+lol+"'"); if(lol=="" || lol==" "){ //no AL hardware return false; } #else //os x doesn't give us a hardware string? so ignore #endif int majorVersion=0; int minorVersion=0; alcGetIntegerv(Device,ALC_MAJOR_VERSION,sizeof(majorVersion),&majorVersion); alcGetIntegerv(Device,ALC_MINOR_VERSION,sizeof(minorVersion),&minorVersion); String version=String(majorVersion)+"."+String(minorVersion); logs().audio.write("HARDWAREVERSION:'"+version+"'"); if(version!="1.1"){ logs().audio.write("Error, openal not version 1.1"); //try to fallback on the software implementation alcDestroyContext(Context); alcCloseDevice(Device); logs().audio.write("searching for software dll"); ALCdevice *DeviceSoftware; DeviceSoftware=alcOpenDevice("Generic Software"); if(DeviceSoftware==NULL){ logs().audio.write("device not found!"); return false; } ALCcontext *ContextSoftware=alcCreateContext(DeviceSoftware,NULL); if(ContextSoftware==NULL){ logs().audio.write("bad context!"); return false; } //Set active context alcMakeContextCurrent(ContextSoftware); int majorVersionS=0; int minorVersionS=0; alcGetIntegerv(DeviceSoftware,ALC_MAJOR_VERSION,sizeof(majorVersionS),&majorVersionS); alcGetIntegerv(DeviceSoftware,ALC_MINOR_VERSION,sizeof(minorVersionS),&minorVersionS); String versionS=String(majorVersionS)+"."+String(minorVersionS); logs().audio.write("HARDWAREVERSION_SOFTWARE:'"+versionS+"'"); #ifdef _WIN32 char* t=(char*)alcGetString(DeviceSoftware,ALC_DEVICE_SPECIFIER); if(t==NULL){ logs().audio.write("HARDWARESTRING_SOFTWARE:''"); return false; } String lol; while(t[1]!=NULL){ lol+=t; t+=lol.size()+1; } logs().audio.write("HARDWARESTRING_SOFTWARE:'"+lol+"'"); if(lol=="" || lol==" "){ //no AL hardware return false; } #else //os x doesn't give us a hardware string? so ignore #endif if(versionS!="1.1"){ logs().audio.write("error, software version still too old"); return false; } //w0000 $$$$$$$$$$$$ return true; } errori=alGetError(); if(errori != AL_NO_ERROR){ return false; } t=(char*)alcGetString(Device,ALC_DEVICE_SPECIFIER); return true; }
/** * Initializes the audio device and creates sources. * * @warning: * * @return TRUE if initialization was successful, FALSE otherwise */ bool FALAudioDevice::InitializeHardware( void ) { // Make sure no interface classes contain any garbage Effects = NULL; DLLHandle = NULL; // Default to sensible channel count. if( MaxChannels < 1 ) { MaxChannels = 32; } // Load ogg and vorbis dlls if they haven't been loaded yet //LoadVorbisLibraries(); // Open device HardwareDevice = alcOpenDevice(nullptr); if( !HardwareDevice ) { UE_LOG(LogALAudio, Log, TEXT( "ALAudio: no OpenAL devices found." ) ); return false ; } // Display the audio device that was actually opened const ALCchar* OpenedDeviceName = alcGetString( HardwareDevice, ALC_DEVICE_SPECIFIER ); UE_LOG(LogALAudio, Log, TEXT("ALAudio device opened : %s"), StringCast<TCHAR>(static_cast<const ANSICHAR*>(OpenedDeviceName)).Get()); // Create a context int Caps[] = { ALC_FREQUENCY, 44100, ALC_STEREO_SOURCES, 4, 0, 0 }; #if PLATFORM_HTML5_WIN32 || PLATFORM_LINUX SoundContext = alcCreateContext( HardwareDevice, Caps ); #elif PLATFORM_HTML5 SoundContext = alcCreateContext( HardwareDevice, 0 ); #endif if( !SoundContext ) { return false ; } alcMakeContextCurrent(SoundContext); // Make sure everything happened correctly if( alError( TEXT( "Init" ) ) ) { UE_LOG(LogALAudio, Warning, TEXT("ALAudio: alcMakeContextCurrent failed.")); return false ; } UE_LOG(LogALAudio, Log, TEXT("AL_VENDOR : %s"), StringCast<TCHAR>(static_cast<const ANSICHAR*>(alGetString(AL_VENDOR))).Get()); UE_LOG(LogALAudio, Log, TEXT("AL_RENDERER : %s"), StringCast<TCHAR>(static_cast<const ANSICHAR*>(alGetString(AL_RENDERER))).Get()); UE_LOG(LogALAudio, Log, TEXT("AL_VERSION : %s"), StringCast<TCHAR>(static_cast<const ANSICHAR*>(alGetString(AL_VERSION))).Get()); UE_LOG(LogALAudio, Log, TEXT("AL_EXTENSIONS : %s"), StringCast<TCHAR>(static_cast<const ANSICHAR*>(alGetString(AL_EXTENSIONS))).Get()); // Get the enums for multichannel support #if !PLATFORM_HTML5 Surround40Format = alGetEnumValue( "AL_FORMAT_QUAD16" ); Surround51Format = alGetEnumValue( "AL_FORMAT_51CHN16" ); Surround61Format = alGetEnumValue( "AL_FORMAT_61CHN16" ); Surround71Format = alGetEnumValue( "AL_FORMAT_71CHN16" ); #endif // Initialize channels. alError( TEXT( "Emptying error stack" ), 0 ); for( int i = 0; i < (( MaxChannels > MAX_AUDIOCHANNELS ) ? MAX_AUDIOCHANNELS : MaxChannels); i++ ) { ALuint SourceId; alGenSources( 1, &SourceId ); if( !alError( TEXT( "Init (creating sources)" ), 0 ) ) { FALSoundSource* Source = new FALSoundSource( this ); Source->SourceId = SourceId; Sources.Add( Source ); FreeSources.Add( Source ); } else { break; } } if( Sources.Num() < 1 ) { UE_LOG(LogALAudio, Warning, TEXT("ALAudio: couldn't allocate any sources")); return false ; } // Update MaxChannels in case we couldn't create enough sources. MaxChannels = Sources.Num(); UE_LOG(LogALAudio, Verbose, TEXT("ALAudioDevice: Allocated %i sources"), MaxChannels); // Use our own distance model. alDistanceModel( AL_NONE ); // Set up a default (nop) effects manager Effects = new FAudioEffectsManager( this ); return true ; }
AUD_OpenALDevice::AUD_OpenALDevice(AUD_DeviceSpecs specs, int buffersize) { // cannot determine how many channels or which format OpenAL uses, but // it at least is able to play 16 bit stereo audio specs.channels = AUD_CHANNELS_STEREO; specs.format = AUD_FORMAT_S16; #if 0 if(alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE) { ALCchar* devices = const_cast<ALCchar*>(alcGetString(NULL, ALC_DEVICE_SPECIFIER)); printf("OpenAL devices (standard is: %s):\n", alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER)); while(*devices) { printf("%s\n", devices); devices += strlen(devices) + 1; } } #endif m_device = alcOpenDevice(NULL); if(!m_device) AUD_THROW(AUD_ERROR_OPENAL, open_error); // at least try to set the frequency ALCint attribs[] = { ALC_FREQUENCY, specs.rate, 0 }; ALCint* attributes = attribs; if(specs.rate == AUD_RATE_INVALID) attributes = NULL; m_context = alcCreateContext(m_device, attributes); alcMakeContextCurrent(m_context); alcGetIntegerv(m_device, ALC_FREQUENCY, 1, (ALCint*)&specs.rate); // check for specific formats and channel counts to be played back if(alIsExtensionPresent("AL_EXT_FLOAT32") == AL_TRUE) specs.format = AUD_FORMAT_FLOAT32; m_useMC = alIsExtensionPresent("AL_EXT_MCFORMATS") == AL_TRUE; alGetError(); alcGetError(m_device); m_specs = specs; m_buffersize = buffersize; m_playing = false; // m_bufferedFactories = new std::list<AUD_OpenALBufferedFactory*>(); pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); pthread_mutex_init(&m_mutex, &attr); pthread_mutexattr_destroy(&attr); start(false); }