// This should probably move to another c file but for now ... ALCAPI ALCdevice* ALCAPIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize) { ALCboolean DeviceFound = ALC_FALSE; ALCdevice *pDevice = NULL; ALCint i; InitAL(); if(deviceName && !deviceName[0]) deviceName = NULL; pDevice = malloc(sizeof(ALCdevice)); if (pDevice) { if (SampleSize > 0) { //Initialise device structure memset(pDevice, 0, sizeof(ALCdevice)); //Validate device pDevice->InUse = AL_TRUE; pDevice->IsCaptureDevice = AL_TRUE; pDevice->Frequency = frequency; pDevice->Format = format; pDevice->Channels = aluChannelsFromFormat(format); pDevice->FrameSize = aluBytesFromFormat(format) * pDevice->Channels; for(i = 0;BackendList[i].Init;i++) { pDevice->Funcs = &BackendList[i].Funcs; if(ALCdevice_OpenCapture(pDevice, deviceName, frequency, format, SampleSize)) { SuspendContext(NULL); pDevice->next = g_pDeviceList; g_pDeviceList = pDevice; g_ulDeviceCount++; ProcessContext(NULL); DeviceFound = ALC_TRUE; break; } } } else SetALCError(ALC_INVALID_VALUE); if(!DeviceFound) { free(pDevice); pDevice = NULL; } } else SetALCError(ALC_OUT_OF_MEMORY); return pDevice; }
int main(int argc, char **argv) { StreamPlayer *player; int i; /* Print out usage if no file was specified */ if(argc < 2) { fprintf(stderr, "Usage: %s <filenames...>\n", argv[0]); return 1; } if(InitAL() != 0) return 1; if(alIsExtensionPresent("AL_SOFT_buffer_samples")) { printf("AL_SOFT_buffer_samples supported!\n"); alBufferSamplesSOFT = alGetProcAddress("alBufferSamplesSOFT"); alIsBufferFormatSupportedSOFT = alGetProcAddress("alIsBufferFormatSupportedSOFT"); } else printf("AL_SOFT_buffer_samples not supported\n"); player = NewPlayer(); /* Play each file listed on the command line */ for(i = 1;i < argc;i++) { if(!OpenPlayerFile(player, argv[i])) continue; printf("Playing %s (%s, %s, %dhz)\n", argv[i], TypeName(player->type), ChannelsName(player->channels), player->rate); fflush(stdout); if(!StartPlayer(player)) { ClosePlayerFile(player); continue; } while(UpdatePlayer(player)) Sleep(10); /* All done with this file. Close it and go to the next */ ClosePlayerFile(player); } printf("Done.\n"); /* All files done. Delete the player, and close OpenAL */ DeletePlayer(player); player = NULL; CloseAL(); return 0; }
/* alcGetContextsDevice Returns the Device that a particular Context is attached to */ ALCAPI ALCdevice* ALCAPIENTRY alcGetContextsDevice(ALCcontext *pContext) { ALCdevice *pDevice = NULL; InitAL(); SuspendContext(NULL); if (IsContext(pContext)) pDevice = pContext->Device; else SetALCError(ALC_INVALID_CONTEXT); ProcessContext(NULL); return pDevice; }
/* alcGetCurrentContext Returns the currently active Context */ ALCAPI ALCcontext * ALCAPIENTRY alcGetCurrentContext(ALCvoid) { ALCcontext *pContext = NULL; InitAL(); SuspendContext(NULL); pContext = g_pContextList; while ((pContext) && (!pContext->InUse)) pContext = pContext->next; ProcessContext(NULL); return pContext; }
/* alcDestroyContext Remove a Context */ ALCAPI ALCvoid ALCAPIENTRY alcDestroyContext(ALCcontext *context) { ALCcontext **list; InitAL(); // Lock context list SuspendContext(NULL); if (IsContext(context)) { // Lock context SuspendContext(context); ReleaseALSources(context); ReleaseALAuxiliaryEffectSlots(context); context->Device->Context = NULL; list = &g_pContextList; while(*list != context) list = &(*list)->next; *list = (*list)->next; g_ulContextCount--; // Unlock context ProcessContext(context); ExitContext(context); // Free memory (MUST do this after ProcessContext) memset(context, 0, sizeof(ALCcontext)); free(context); } else SetALCError(ALC_INVALID_CONTEXT); ProcessContext(NULL); }
/* alcMakeContextCurrent Makes the given Context the active Context */ ALCAPI ALCboolean ALCAPIENTRY alcMakeContextCurrent(ALCcontext *context) { ALCcontext *ALContext; ALboolean bReturn = AL_TRUE; InitAL(); SuspendContext(NULL); // context must be a valid Context or NULL if ((IsContext(context)) || (context == NULL)) { if ((ALContext=alcGetCurrentContext())) { SuspendContext(ALContext); ALContext->InUse=AL_FALSE; ProcessContext(ALContext); } if ((ALContext=context) && (ALContext->Device)) { SuspendContext(ALContext); ALContext->InUse=AL_TRUE; ProcessContext(ALContext); } } else { SetALCError(ALC_INVALID_CONTEXT); bReturn = AL_FALSE; } ProcessContext(NULL); return bReturn; }
INT WINAPI wWinMain( HINSTANCE hInst, HINSTANCE, LPWSTR, INT ) { g_ogg.open("../sample video/trailer_400p.ogg",AF_S16,2,44100,VF_BGRA); if(g_ogg.fail()) { return -1; } // Register the window class WNDCLASSEX wc = { sizeof( WNDCLASSEX ), CS_CLASSDC, MsgProc, 0L, 0L, GetModuleHandle( NULL ), NULL, NULL, NULL, NULL, L"liboggstream", NULL }; RegisterClassEx( &wc ); int width=g_ogg.width(); int height=g_ogg.height(); // Create the application's window RECT rect; rect.left = 100; rect.top = 100; rect.right = width+rect.left; rect.bottom = height+rect.top; AdjustWindowRect(&rect,WS_OVERLAPPEDWINDOW,FALSE); HWND hWnd = CreateWindow( L"liboggstream", L"D3D9 Theora Player", WS_OVERLAPPEDWINDOW, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, NULL, NULL, wc.hInstance, NULL ); // Initialize Direct3D and OpenAL if( SUCCEEDED( InitD3D( hWnd ) ) && InitAL()) { // Show the window ShowWindow( hWnd, SW_SHOWDEFAULT ); UpdateWindow( hWnd ); // Start the playback g_ogg.play(); // Run MixAudio in another thread HANDLE h_mixaudio= CreateThread(NULL,0,MixAudio,NULL,0,NULL); // Enter the message loop MSG msg; ZeroMemory( &msg, sizeof( msg ) ); while( msg.message != WM_QUIT && g_ogg.playing() ) { if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) ) { TranslateMessage( &msg ); DispatchMessage( &msg ); }else { Render(); Sleep(0); } } g_ogg.close(); WaitForSingleObject(h_mixaudio,INFINITE); alutExit(); } UnregisterClass( L"liboggstream", wc.hInstance ); return 0; }
/* alcGetIntegerv Returns information about the Device and the version of Open AL */ ALCAPI ALCvoid ALCAPIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsizei size,ALCint *data) { InitAL(); if ((device)&&(device->IsCaptureDevice)) { SuspendContext(NULL); // Capture device switch (param) { case ALC_CAPTURE_SAMPLES: if ((size) && (data)) *data = ALCdevice_AvailableSamples(device); else SetALCError(ALC_INVALID_VALUE); break; default: SetALCError(ALC_INVALID_ENUM); break; } ProcessContext(NULL); } else { if(data) { // Playback Device switch (param) { case ALC_MAJOR_VERSION: if(!size) SetALCError(ALC_INVALID_VALUE); else *data = alcMajorVersion; break; case ALC_MINOR_VERSION: if(!size) SetALCError(ALC_INVALID_VALUE); else *data = alcMinorVersion; break; case ALC_EFX_MAJOR_VERSION: if(!size) SetALCError(ALC_INVALID_VALUE); else *data = alcEFXMajorVersion; break; case ALC_EFX_MINOR_VERSION: if(!size) SetALCError(ALC_INVALID_VALUE); else *data = alcEFXMinorVersion; break; case ALC_MAX_AUXILIARY_SENDS: if(!size) SetALCError(ALC_INVALID_VALUE); else *data = MAX_SENDS; break; case ALC_ATTRIBUTES_SIZE: if(!device) SetALCError(ALC_INVALID_DEVICE); else if(!size) SetALCError(ALC_INVALID_VALUE); else *data = 12; break; case ALC_ALL_ATTRIBUTES: if(!device) SetALCError(ALC_INVALID_DEVICE); else if (size < 7) SetALCError(ALC_INVALID_VALUE); else { int i = 0; data[i++] = ALC_FREQUENCY; data[i++] = device->Frequency; data[i++] = ALC_REFRESH; data[i++] = device->Frequency / device->UpdateSize; data[i++] = ALC_SYNC; data[i++] = ALC_FALSE; SuspendContext(NULL); if(device->Context && size >= 12) { data[i++] = ALC_MONO_SOURCES; data[i++] = device->Context->lNumMonoSources; data[i++] = ALC_STEREO_SOURCES; data[i++] = device->Context->lNumStereoSources; data[i++] = ALC_MAX_AUXILIARY_SENDS; data[i++] = MAX_SENDS; } ProcessContext(NULL); data[i++] = 0; } break; case ALC_FREQUENCY: if(!device) SetALCError(ALC_INVALID_DEVICE); else if(!size) SetALCError(ALC_INVALID_VALUE); else *data = device->Frequency; break; case ALC_REFRESH: if(!device) SetALCError(ALC_INVALID_DEVICE); else if(!size) SetALCError(ALC_INVALID_VALUE); else *data = device->Frequency / device->UpdateSize; break; case ALC_SYNC: if(!device) SetALCError(ALC_INVALID_DEVICE); else if(!size) SetALCError(ALC_INVALID_VALUE); else *data = ALC_FALSE; break; case ALC_MONO_SOURCES: if(!device || !device->Context) SetALCError(ALC_INVALID_DEVICE); else if (size != 1) SetALCError(ALC_INVALID_VALUE); else *data = device->Context->lNumMonoSources; break; case ALC_STEREO_SOURCES: if(!device || !device->Context) SetALCError(ALC_INVALID_DEVICE); else if (size != 1) SetALCError(ALC_INVALID_VALUE); else *data = device->Context->lNumStereoSources; break; default: SetALCError(ALC_INVALID_ENUM); break; } } else if(size) SetALCError(ALC_INVALID_VALUE); } return; }
/* alcGetString Returns information about the Device, and error strings */ ALCAPI const ALCchar* ALCAPIENTRY alcGetString(ALCdevice *pDevice,ALCenum param) { const ALCchar *value = NULL; InitAL(); switch (param) { case ALC_NO_ERROR: value = alcNoError; break; case ALC_INVALID_ENUM: value = alcErrInvalidEnum; break; case ALC_INVALID_VALUE: value = alcErrInvalidValue; break; case ALC_INVALID_DEVICE: value = alcErrInvalidDevice; break; case ALC_INVALID_CONTEXT: value = alcErrInvalidContext; break; case ALC_OUT_OF_MEMORY: value = alcErrOutOfMemory; break; case ALC_DEFAULT_DEVICE_SPECIFIER: value = alcDefaultDeviceSpecifier; break; case ALC_DEVICE_SPECIFIER: if (pDevice) value = pDevice->szDeviceName; else value = alcDeviceList; break; case ALC_ALL_DEVICES_SPECIFIER: value = alcAllDeviceList; break; case ALC_DEFAULT_ALL_DEVICES_SPECIFIER: value = alcDefaultAllDeviceSpecifier; break; case ALC_CAPTURE_DEVICE_SPECIFIER: if (pDevice) value = pDevice->szDeviceName; else value = alcCaptureDeviceList; break; case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER: value = alcCaptureDefaultDeviceSpecifier; break; case ALC_EXTENSIONS: value = alcExtensionList; break; default: SetALCError(ALC_INVALID_ENUM); break; } return value; }
/* alcOpenDevice Open the Device specified. */ ALCAPI ALCdevice* ALCAPIENTRY alcOpenDevice(const ALCchar *deviceName) { ALboolean bDeviceFound = AL_FALSE; ALCdevice *device; ALint i; InitAL(); if(deviceName && !deviceName[0]) deviceName = NULL; device = malloc(sizeof(ALCdevice)); if (device) { const char *fmt; //Initialise device structure memset(device, 0, sizeof(ALCdevice)); //Validate device device->IsCaptureDevice = AL_FALSE; //Set output format device->Frequency = GetConfigValueInt(NULL, "frequency", SWMIXER_OUTPUT_RATE); if((ALint)device->Frequency <= 0) device->Frequency = SWMIXER_OUTPUT_RATE; fmt = GetConfigValue(NULL, "format", "AL_FORMAT_STEREO16"); if(fmt[0]) device->Format = alGetEnumValue(fmt); if(!aluChannelsFromFormat(device->Format)) device->Format = AL_FORMAT_STEREO16; device->UpdateSize = GetConfigValueInt(NULL, "refresh", 4096); if((ALint)device->UpdateSize <= 0) device->UpdateSize = 4096; device->MaxNoOfSources = GetConfigValueInt(NULL, "sources", 256); if((ALint)device->MaxNoOfSources <= 0) device->MaxNoOfSources = 256; // Find a playback device to open for(i = 0;BackendList[i].Init;i++) { device->Funcs = &BackendList[i].Funcs; if(ALCdevice_OpenPlayback(device, deviceName)) { SuspendContext(NULL); device->next = g_pDeviceList; g_pDeviceList = device; g_ulDeviceCount++; ProcessContext(NULL); bDeviceFound = AL_TRUE; break; } } if (!bDeviceFound) { // No suitable output device found SetALCError(ALC_INVALID_VALUE); free(device); device = NULL; } } else SetALCError(ALC_OUT_OF_MEMORY); return device; }
int main(int argc, char *argv[]) { enum WaveType wavetype = WT_Sine; ALuint source, buffer; ALint last_pos, num_loops; ALint max_loops = 4; ALint srate = -1; ALint tone_freq = 1000; ALCint dev_rate; ALenum state; int i; for(i = 1;i < argc;i++) { if(strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { fprintf(stderr, "OpenAL Tone Generator\n" "\n" "Usage: %s <options>\n" "\n" "Available options:\n" " --help/-h This help text\n" " -t <seconds> Time to play a tone (default 5 seconds)\n" " --waveform/-w <type> Waveform type: sine (default), square, sawtooth,\n" " triangle, impulse\n" " --freq/-f <hz> Tone frequency (default 1000 hz)\n" " --srate/-s <sample rate> Sampling rate (default output rate)\n", argv[0] ); return 1; } else if(i+1 < argc && strcmp(argv[i], "-t") == 0) { i++; max_loops = atoi(argv[i]) - 1; } else if(i+1 < argc && (strcmp(argv[i], "--waveform") == 0 || strcmp(argv[i], "-w") == 0)) { i++; if(strcmp(argv[i], "sine") == 0) wavetype = WT_Sine; else if(strcmp(argv[i], "square") == 0) wavetype = WT_Square; else if(strcmp(argv[i], "sawtooth") == 0) wavetype = WT_Sawtooth; else if(strcmp(argv[i], "triangle") == 0) wavetype = WT_Triangle; else if(strcmp(argv[i], "impulse") == 0) wavetype = WT_Impulse; else fprintf(stderr, "Unhandled waveform: %s\n", argv[i]); } else if(i+1 < argc && (strcmp(argv[i], "--freq") == 0 || strcmp(argv[i], "-f") == 0)) { i++; tone_freq = atoi(argv[i]); if(tone_freq < 1) { fprintf(stderr, "Invalid tone frequency: %s (min: 1hz)\n", argv[i]); tone_freq = 1; } } else if(i+1 < argc && (strcmp(argv[i], "--srate") == 0 || strcmp(argv[i], "-s") == 0)) { i++; srate = atoi(argv[i]); if(srate < 40) { fprintf(stderr, "Invalid sample rate: %s (min: 40hz)\n", argv[i]); srate = 40; } } } InitAL(); if(!alIsExtensionPresent("AL_EXT_FLOAT32")) { fprintf(stderr, "Required AL_EXT_FLOAT32 extension not supported on this device!\n"); CloseAL(); return 1; } { ALCdevice *device = alcGetContextsDevice(alcGetCurrentContext()); alcGetIntegerv(device, ALC_FREQUENCY, 1, &dev_rate); assert(alcGetError(device)==ALC_NO_ERROR && "Failed to get device sample rate"); } if(srate < 0) srate = dev_rate; /* Load the sound into a buffer. */ buffer = CreateWave(wavetype, tone_freq, srate); if(!buffer) { CloseAL(); return 1; } printf("Playing %dhz %s-wave tone with %dhz sample rate and %dhz output, for %d second%s...\n", tone_freq, GetWaveTypeName(wavetype), srate, dev_rate, max_loops+1, max_loops?"s":""); fflush(stdout); /* Create the source to play the sound with. */ source = 0; alGenSources(1, &source); alSourcei(source, AL_BUFFER, buffer); assert(alGetError()==AL_NO_ERROR && "Failed to setup sound source"); /* Play the sound for a while. */ num_loops = 0; last_pos = 0; alSourcei(source, AL_LOOPING, (max_loops > 0) ? AL_TRUE : AL_FALSE); alSourcePlay(source); do { ALint pos; al_nssleep(10000000); alGetSourcei(source, AL_SAMPLE_OFFSET, &pos); alGetSourcei(source, AL_SOURCE_STATE, &state); if(pos < last_pos && state == AL_PLAYING) { ++num_loops; if(num_loops >= max_loops) alSourcei(source, AL_LOOPING, AL_FALSE); printf("%d...\n", max_loops - num_loops + 1); fflush(stdout); } last_pos = pos; } while(alGetError() == AL_NO_ERROR && state == AL_PLAYING); /* All done. Delete resources, and close OpenAL. */ alDeleteSources(1, &source); alDeleteBuffers(1, &buffer); /* Close up OpenAL. */ CloseAL(); return 0; }
int main(int argc, char **argv) { ALCdevice *device; ALuint source, buffer; const char *soundname; const char *hrtfname; ALCint hrtf_state; ALCint num_hrtf; ALdouble angle; ALenum state; /* Print out usage if no file was specified */ if(argc < 2 || (strcmp(argv[1], "-hrtf") == 0 && argc < 4)) { fprintf(stderr, "Usage: %s [-hrtf <name>] <soundfile>\n", argv[0]); return 1; } /* Initialize OpenAL with the default device, and check for HRTF support. */ if(InitAL() != 0) return 1; if(strcmp(argv[1], "-hrtf") == 0) { hrtfname = argv[2]; soundname = argv[3]; } else { hrtfname = NULL; soundname = argv[1]; } device = alcGetContextsDevice(alcGetCurrentContext()); if(!alcIsExtensionPresent(device, "ALC_SOFT_HRTF")) { fprintf(stderr, "Error: ALC_SOFT_HRTF not supported\n"); CloseAL(); return 1; } /* Define a macro to help load the function pointers. */ #define LOAD_PROC(d, x) ((x) = alcGetProcAddress((d), #x)) LOAD_PROC(device, alcGetStringiSOFT); LOAD_PROC(device, alcResetDeviceSOFT); #undef LOAD_PROC /* Enumerate available HRTFs, and reset the device using one. */ alcGetIntegerv(device, ALC_NUM_HRTF_SPECIFIERS_SOFT, 1, &num_hrtf); if(!num_hrtf) printf("No HRTFs found\n"); else { ALCint attr[5]; ALCint index = -1; ALCint i; printf("Available HRTFs:\n"); for(i = 0; i < num_hrtf; i++) { const ALCchar *name = alcGetStringiSOFT(device, ALC_HRTF_SPECIFIER_SOFT, i); printf(" %d: %s\n", i, name); /* Check if this is the HRTF the user requested. */ if(hrtfname && strcmp(name, hrtfname) == 0) index = i; } i = 0; attr[i++] = ALC_HRTF_SOFT; attr[i++] = ALC_TRUE; if(index == -1) { if(hrtfname) printf("HRTF \"%s\" not found\n", hrtfname); printf("Using default HRTF...\n"); } else { printf("Selecting HRTF %d...\n", index); attr[i++] = ALC_HRTF_ID_SOFT; attr[i++] = index; } attr[i] = 0; if(!alcResetDeviceSOFT(device, attr)) printf("Failed to reset device: %s\n", alcGetString(device, alcGetError(device))); } /* Check if HRTF is enabled, and show which is being used. */ alcGetIntegerv(device, ALC_HRTF_SOFT, 1, &hrtf_state); if(!hrtf_state) printf("HRTF not enabled!\n"); else { const ALchar *name = alcGetString(device, ALC_HRTF_SPECIFIER_SOFT); printf("HRTF enabled, using %s\n", name); } fflush(stdout); /* Load the sound into a buffer. */ buffer = LoadSound(soundname); if(!buffer) { CloseAL(); return 1; } /* Create the source to play the sound with. */ source = 0; alGenSources(1, &source); alSourcei(source, AL_SOURCE_RELATIVE, AL_TRUE); alSource3f(source, AL_POSITION, 0.0f, 0.0f, -1.0f); alSourcei(source, AL_BUFFER, buffer); assert(alGetError()==AL_NO_ERROR && "Failed to setup sound source"); /* Play the sound until it finishes. */ angle = 0.0; alSourcePlay(source); do { al_nssleep(10000000); /* Rotate the source around the listener by about 1/4 cycle per second. * Only affects mono sounds. */ angle += 0.01 * M_PI * 0.5; alSource3f(source, AL_POSITION, (ALfloat)sin(angle), 0.0f, -(ALfloat)cos(angle)); alGetSourcei(source, AL_SOURCE_STATE, &state); } while(alGetError() == AL_NO_ERROR && state == AL_PLAYING); /* All done. Delete resources, and close OpenAL. */ alDeleteSources(1, &source); alDeleteBuffers(1, &buffer); CloseAL(); return 0; }
int main(int argc, char **argv) { ALuint source, buffer; ALdouble offsets[2]; ALenum state; /* Print out usage if no arguments were specified */ if(argc < 2) { fprintf(stderr, "Usage: %s [-device <name>] <filename>\n", argv[0]); return 1; } /* Initialize OpenAL, and check for source_latency support. */ argv++; argc--; if(InitAL(&argv, &argc) != 0) return 1; if(!alIsExtensionPresent("AL_SOFT_source_latency")) { fprintf(stderr, "Error: AL_SOFT_source_latency not supported\n"); CloseAL(); return 1; } /* Define a macro to help load the function pointers. */ #define LOAD_PROC(x) ((x) = alGetProcAddress(#x)) LOAD_PROC(alSourcedSOFT); LOAD_PROC(alSource3dSOFT); LOAD_PROC(alSourcedvSOFT); LOAD_PROC(alGetSourcedSOFT); LOAD_PROC(alGetSource3dSOFT); LOAD_PROC(alGetSourcedvSOFT); LOAD_PROC(alSourcei64SOFT); LOAD_PROC(alSource3i64SOFT); LOAD_PROC(alSourcei64vSOFT); LOAD_PROC(alGetSourcei64SOFT); LOAD_PROC(alGetSource3i64SOFT); LOAD_PROC(alGetSourcei64vSOFT); if(alIsExtensionPresent("AL_SOFT_buffer_samples")) { LOAD_PROC(alBufferSamplesSOFT); LOAD_PROC(alIsBufferFormatSupportedSOFT); } #undef LOAD_PROC /* Load the sound into a buffer. */ buffer = LoadSound(argv[0]); if(!buffer) { CloseAL(); return 1; } /* Create the source to play the sound with. */ source = 0; alGenSources(1, &source); alSourcei(source, AL_BUFFER, buffer); assert(alGetError()==AL_NO_ERROR && "Failed to setup sound source"); /* Play the sound until it finishes. */ alSourcePlay(source); do { al_nssleep(10000000); alGetSourcei(source, AL_SOURCE_STATE, &state); /* Get the source offset and latency. AL_SEC_OFFSET_LATENCY_SOFT will * place the offset (in seconds) in offsets[0], and the time until that * offset will be heard (in seconds) in offsets[1]. */ alGetSourcedvSOFT(source, AL_SEC_OFFSET_LATENCY_SOFT, offsets); printf("\rOffset: %f - Latency:%3u ms ", offsets[0], (ALuint)(offsets[1]*1000)); fflush(stdout); } while(alGetError() == AL_NO_ERROR && state == AL_PLAYING); printf("\n"); /* All done. Delete resources, and close OpenAL. */ alDeleteSources(1, &source); alDeleteBuffers(1, &buffer); CloseAL(); return 0; }