Add a prefix for extension functions in the examples

For when static linking, to avoid duplicate symbols.

Author: kcat

examples/alconvolve.c

@@ -252,16 +252,16 @@ static ALuint CreateEffect(void)
     printf("Using Convolution\n");
 
     /* Create the effect object and set the convolution effect type. */
-    alGenEffects(1, &effect);
-    alEffecti(effect, AL_EFFECT_TYPE, AL_EFFECT_CONVOLUTION_SOFT);
+    palGenEffects(1, &effect);
+    palEffecti(effect, AL_EFFECT_TYPE, AL_EFFECT_CONVOLUTION_SOFT);
 
     /* Check if an error occurred, and clean up if so. */
     err = alGetError();
     if(err != AL_NO_ERROR)
     {
         fprintf(stderr, "OpenAL error: %s\n", alGetString(err));
-        if(alIsEffect(effect))
-            alDeleteEffects(1, &effect);
+        if(palIsEffect(effect))
+            palDeleteEffects(1, &effect);
         return 0;
     }
 
@@ -417,7 +417,7 @@ int main(int argc, char **argv)
     ir_buffer = LoadSound(argv[0]);
     if(!ir_buffer)
     {
-        alDeleteEffects(1, &effect);
+        palDeleteEffects(1, &effect);
         CloseAL();
         return 1;
     }
@@ -426,7 +426,7 @@ int main(int argc, char **argv)
      * that connect to it.
      */
     slot = 0;
-    alGenAuxiliaryEffectSlots(1, &slot);
+    palGenAuxiliaryEffectSlots(1, &slot);
 
     /* Set the impulse response sound buffer on the effect slot. This allows
      * effects to access it as needed. In this case, convolution uses it as the
@@ -445,16 +445,16 @@ int main(int argc, char **argv)
      * listener. You can use a send filter to alter a given source's
      * contribution to reverb.
      */
-    alAuxiliaryEffectSloti(slot, AL_BUFFER, (ALint)ir_buffer);
-    alAuxiliaryEffectSlotf(slot, AL_EFFECTSLOT_GAIN, 1.0f / 16.0f);
-    alAuxiliaryEffectSloti(slot, AL_EFFECTSLOT_EFFECT, (ALint)effect);
+    palAuxiliaryEffectSloti(slot, AL_BUFFER, (ALint)ir_buffer);
+    palAuxiliaryEffectSlotf(slot, AL_EFFECTSLOT_GAIN, 1.0f / 16.0f);
+    palAuxiliaryEffectSloti(slot, AL_EFFECTSLOT_EFFECT, (ALint)effect);
     assert(alGetError()==AL_NO_ERROR && "Failed to set effect slot");
 
     /* Create a filter that can silence the dry path. */
     filter = 0;
-    alGenFilters(1, &filter);
-    alFilteri(filter, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
-    alFilterf(filter, AL_LOWPASS_GAIN, 0.0f);
+    palGenFilters(1, &filter);
+    palFilteri(filter, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
+    palFilterf(filter, AL_LOWPASS_GAIN, 0.0f);
 
     player = NewPlayer();
     /* Connect the player's source to the effect slot. */
@@ -511,9 +511,9 @@ int main(int argc, char **argv)
     DeletePlayer(player);
     player = NULL;
 
-    alDeleteAuxiliaryEffectSlots(1, &slot);
-    alDeleteEffects(1, &effect);
-    alDeleteFilters(1, &filter);
+    palDeleteAuxiliaryEffectSlots(1, &slot);
+    palDeleteEffects(1, &effect);
+    palDeleteFilters(1, &filter);
     alDeleteBuffers(1, &ir_buffer);
 
     CloseAL();

examples/aldebug.cpp

@@ -167,7 +167,7 @@ auto main(std::span<std::string_view> args) -> int
     LoadALExtensions();
 
     /* Enable low-severity debug messages, which are disabled by default. */
-    alDebugMessageControlEXT(AL_DONT_CARE_EXT, AL_DONT_CARE_EXT, AL_DEBUG_SEVERITY_LOW_EXT, 0,
+    palDebugMessageControlEXT(AL_DONT_CARE_EXT, AL_DONT_CARE_EXT, AL_DEBUG_SEVERITY_LOW_EXT, 0,
         nullptr, AL_TRUE);
 
     fmt::println("Context flags: {:#010x}", as_unsigned(alGetInteger(AL_CONTEXT_FLAGS_EXT)));
@@ -206,7 +206,7 @@ auto main(std::span<std::string_view> args) -> int
         auto msglength = ALsizei{};
 
         /* Getting the message removes it from the log. */
-        const auto read = alGetDebugMessageLogEXT(1, maxloglength, &source, &type, &id, &severity,
+        const auto read = palGetDebugMessageLogEXT(1, maxloglength, &source, &type, &id, &severity,
             &msglength, message.data());
         if(read != 1)
         {
@@ -250,7 +250,7 @@ auto main(std::span<std::string_view> args) -> int
             "  Message: \"{}\"", GetDebugSourceName(source), GetDebugTypeName(type), id,
             GetDebugSeverityName(severity), msgstr);
     };
-    alDebugMessageCallbackEXT(debug_callback, nullptr);
+    palDebugMessageCallbackEXT(debug_callback, nullptr);
 
     if(const auto numlogs = alGetInteger(AL_DEBUG_LOGGED_MESSAGES_EXT))
         fmt::println(std::cerr, "{} left over logged message{}!", numlogs, (numlogs==1)?"":"s");
@@ -271,19 +271,19 @@ auto main(std::span<std::string_view> args) -> int
     fmt::println("");
 
     fmt::println("Pushing a debug group, making some invalid calls, and popping the debug group...");
-    alPushDebugGroupEXT(AL_DEBUG_SOURCE_APPLICATION_EXT, 0, -1, "Error test group");
+    palPushDebugGroupEXT(AL_DEBUG_SOURCE_APPLICATION_EXT, 0, -1, "Error test group");
     alSpeedOfSound(0.0f);
     /* Can't set the label of the null buffer. */
-    alObjectLabelEXT(AL_BUFFER, 0, -1, "The null buffer");
-    alPopDebugGroupEXT();
+    palObjectLabelEXT(AL_BUFFER, 0, -1, "The null buffer");
+    palPopDebugGroupEXT();
     fmt::println("");
 
     /* All done, insert a custom message and unset the callback. The context
      * and device will clean themselves up.
      */
-    alDebugMessageInsertEXT(AL_DEBUG_SOURCE_APPLICATION_EXT, AL_DEBUG_TYPE_MARKER_EXT, 0,
+    palDebugMessageInsertEXT(AL_DEBUG_SOURCE_APPLICATION_EXT, AL_DEBUG_TYPE_MARKER_EXT, 0,
         AL_DEBUG_SEVERITY_NOTIFICATION_EXT, -1, "End of run, cleaning up");
-    alDebugMessageCallbackEXT(nullptr, nullptr);
+    palDebugMessageCallbackEXT(nullptr, nullptr);
 
     return 0;
 }

examples/alffplay.cpp

@@ -588,8 +588,8 @@ auto AudioState::getClockNoLock() const -> nanoseconds
          * source offset.
          */
         auto offset = std::array<ALint64SOFT,2>{};
-        if(alGetSourcei64vSOFT)
-            alGetSourcei64vSOFT(mSource, AL_SAMPLE_OFFSET_LATENCY_SOFT, offset.data());
+        if(palGetSourcei64vSOFT)
+            palGetSourcei64vSOFT(mSource, AL_SAMPLE_OFFSET_LATENCY_SOFT, offset.data());
         else
         {
             auto ioffset = ALint{};
@@ -646,8 +646,8 @@ auto AudioState::getClockNoLock() const -> nanoseconds
     if(mSource)
     {
         auto offset = std::array<ALint64SOFT,2>{};
-        if(alGetSourcei64vSOFT)
-            alGetSourcei64vSOFT(mSource, AL_SAMPLE_OFFSET_LATENCY_SOFT, offset.data());
+        if(palGetSourcei64vSOFT)
+            palGetSourcei64vSOFT(mSource, AL_SAMPLE_OFFSET_LATENCY_SOFT, offset.data());
         else
         {
             auto ioffset = ALint{};
@@ -968,7 +968,7 @@ void AudioState::handler()
     auto srclock = std::unique_lock{mSrcMutex, std::defer_lock};
     auto sleep_time = milliseconds{AudioBufferTime / 2};
 
-    if(alEventControlSOFT)
+    if(palEventControlSOFT)
     {
         static constexpr auto callback = [](ALenum eventType, ALuint object, ALuint param,
             ALsizei length, const ALchar *message, void *userParam) noexcept -> void
@@ -977,16 +977,16 @@ void AudioState::handler()
                 std::string_view{message, gsl::narrow_cast<ALuint>(length)});
         };
 
-        alEventControlSOFT(evt_types.size(), evt_types.data(), AL_TRUE);
-        alEventCallbackSOFT(callback, this);
+        palEventControlSOFT(evt_types.size(), evt_types.data(), AL_TRUE);
+        palEventCallbackSOFT(callback, this);
         sleep_time = AudioBufferTotalTime;
     }
     const auto _ = gsl::finally([]
     {
-        if(alEventControlSOFT)
+        if(palEventControlSOFT)
         {
-            alEventControlSOFT(evt_types.size(), evt_types.data(), AL_FALSE);
-            alEventCallbackSOFT(nullptr, nullptr);
+            palEventControlSOFT(evt_types.size(), evt_types.data(), AL_FALSE);
+            palEventCallbackSOFT(nullptr, nullptr);
         }
     });
 
@@ -1338,32 +1338,32 @@ void AudioState::handler()
     {
         /* Filter to mute the dry (un-corrected) path. */
         auto mutefilter = ALuint{};
-        alGenFilters(1, &mutefilter);
-        alFilteri(mutefilter, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
-        alFilterf(mutefilter, AL_LOWPASS_GAIN, 0.0f);
+        palGenFilters(1, &mutefilter);
+        palFilteri(mutefilter, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
+        palFilterf(mutefilter, AL_LOWPASS_GAIN, 0.0f);
 
         alSourcef(mSource, AL_PITCH, TimeStretchFactor);
         alSourcei(mSource, AL_DIRECT_FILTER, static_cast<ALint>(mutefilter));
         alSource3i(mSource, AL_AUXILIARY_SEND_FILTER, static_cast<ALint>(sPShiftSlot), 0,
             AL_FILTER_NULL);
 
-        alDeleteFilters(1, &mutefilter);
+        palDeleteFilters(1, &mutefilter);
     }
 
     if(alGetError() != AL_NO_ERROR)
         return;
 
     auto samples = std::vector<uint8_t>{};
     auto callback_ok = false;
-    if(alBufferCallbackSOFT)
+    if(palBufferCallbackSOFT)
     {
         static constexpr auto callback = [](void *userptr, void *data, ALsizei size) noexcept
             -> ALsizei
         {
             return static_cast<AudioState*>(userptr)->bufferCallback(
                 std::views::counted(static_cast<ALubyte*>(data), size));
         };
-        alBufferCallbackSOFT(mBuffers[0], mFormat, mCodecCtx->sample_rate, callback, this);
+        palBufferCallbackSOFT(mBuffers[0], mFormat, mCodecCtx->sample_rate, callback, this);
 
         alSourcei(mSource, AL_BUFFER, as_signed(mBuffers[0]));
         if(alGetError() != AL_NO_ERROR)
@@ -2168,7 +2168,7 @@ struct Application {
             SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_EVENTS);
 
         if(AudioState::sPShiftSlot)
-            alDeleteAuxiliaryEffectSlots(1, &AudioState::sPShiftSlot);
+            palDeleteAuxiliaryEffectSlots(1, &AudioState::sPShiftSlot);
         AudioState::sPShiftSlot = 0;
     }
 
@@ -2406,8 +2406,8 @@ auto main(std::span<std::string_view> args) -> int
          * original pitch while maintaining the speed change.
          */
         auto effect = ALuint{};
-        alGenEffects(1, &effect);
-        alEffecti(effect, AL_EFFECT_TYPE, AL_EFFECT_PITCH_SHIFTER);
+        palGenEffects(1, &effect);
+        palEffecti(effect, AL_EFFECT_TYPE, AL_EFFECT_PITCH_SHIFTER);
         if(auto const err = alGetError(); err != AL_NO_ERROR)
         {
             fmt::print(std::cerr, "Could not create the Pitch Shifter effect: {:#06x}\n", err);
@@ -2443,15 +2443,15 @@ auto main(std::span<std::string_view> args) -> int
                 fmt::println("Speed factor: {} (pitch adj: {}; course tuning: {}, fine tuning: {})",
                     TimeStretchFactor, pitch, course_tune, fine_tune);
 
-                alEffecti(effect, AL_PITCH_SHIFTER_COARSE_TUNE, std::clamp(course_tune, -12, +12));
-                alEffecti(effect, AL_PITCH_SHIFTER_FINE_TUNE, fine_tune);
+                palEffecti(effect, AL_PITCH_SHIFTER_COARSE_TUNE, std::clamp(course_tune, -12, +12));
+                palEffecti(effect, AL_PITCH_SHIFTER_FINE_TUNE, fine_tune);
 
-                alGenAuxiliaryEffectSlots(1, &AudioState::sPShiftSlot);
-                alAuxiliaryEffectSloti(AudioState::sPShiftSlot, AL_EFFECTSLOT_EFFECT,
+                palGenAuxiliaryEffectSlots(1, &AudioState::sPShiftSlot);
+                palAuxiliaryEffectSloti(AudioState::sPShiftSlot, AL_EFFECTSLOT_EFFECT,
                     static_cast<ALint>(effect));
             }
         }
-        alDeleteEffects(1, &effect);
+        palDeleteEffects(1, &effect);
     }
 
     curarg = std::ranges::find_if(curarg, app.mArgs.end(), [&app](const std::string_view argval)

examples/allafplay.cpp

@@ -1369,26 +1369,26 @@ auto main(std::span<std::string_view> args) -> int
     {
         if(LfeSlotID)
         {
-            alDeleteAuxiliaryEffectSlots(1, &LfeSlotID);
-            alDeleteEffects(1, &LowFrequencyEffectID);
-            alDeleteFilters(1, &MuteFilterID);
+            palDeleteAuxiliaryEffectSlots(1, &LfeSlotID);
+            palDeleteEffects(1, &LowFrequencyEffectID);
+            palDeleteFilters(1, &MuteFilterID);
         }
     });
 
     if(alcIsExtensionPresent(almgr.mDevice, "ALC_EXT_EFX")
         && alcIsExtensionPresent(almgr.mDevice, "ALC_EXT_DEDICATED"))
     {
-        alGenFilters(1, &MuteFilterID);
-        alFilteri(MuteFilterID, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
-        alFilterf(MuteFilterID, AL_LOWPASS_GAIN, 0.0f);
+        palGenFilters(1, &MuteFilterID);
+        palFilteri(MuteFilterID, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
+        palFilterf(MuteFilterID, AL_LOWPASS_GAIN, 0.0f);
         MyAssert(alGetError() == AL_NO_ERROR);
 
-        alGenEffects(1, &LowFrequencyEffectID);
-        alEffecti(LowFrequencyEffectID, AL_EFFECT_TYPE, AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT);
+        palGenEffects(1, &LowFrequencyEffectID);
+        palEffecti(LowFrequencyEffectID, AL_EFFECT_TYPE, AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT);
         MyAssert(alGetError() == AL_NO_ERROR);
 
-        alGenAuxiliaryEffectSlots(1, &LfeSlotID);
-        alAuxiliaryEffectSloti(LfeSlotID, AL_EFFECTSLOT_EFFECT, as_signed(LowFrequencyEffectID));
+        palGenAuxiliaryEffectSlots(1, &LfeSlotID);
+        palAuxiliaryEffectSloti(LfeSlotID, AL_EFFECTSLOT_EFFECT, as_signed(LowFrequencyEffectID));
         MyAssert(alGetError() == AL_NO_ERROR);
     }
 

examples/allatency.c

@@ -179,7 +179,7 @@ int main(int argc, char **argv)
         /* 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);
+        palGetSourcedvSOFT(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);