Avoid using old style casts

To think about:
examples/alffplay.cpp:600
OpenAL32/Include/alMain.h:295

6 files changed, 147 insertions, 141 deletions

diff --git a/OpenAL32/alBuffer.cpp b/OpenAL32/alBuffer.cpp
index 7f2085d8..9781ea0c 100644
--- a/OpenAL32/alBuffer.cpp
+++ b/OpenAL32/alBuffer.cpp
@@ -204,8 +204,9 @@ void LoadData(ALCcontext *context, ALbuffer *ALBuf, ALuint freq, ALsizei size, U
     case UserFmtBFormat2D: DstChannels = FmtBFormat2D; break;
     case UserFmtBFormat3D: DstChannels = FmtBFormat3D; break;
     }
-    if(UNLIKELY((long)SrcChannels != (long)DstChannels))
-        SETERR_RETURN(context, AL_INVALID_ENUM,, "Invalid format");
+    if (UNLIKELY(static_cast<long>(SrcChannels) !=
+                 static_cast<long>(DstChannels)))
+        SETERR_RETURN(context, AL_INVALID_ENUM, , "Invalid format");
 
     /* IMA4 and MSADPCM convert to 16-bit short. */
     FmtType DstType{FmtUByte};
@@ -227,9 +228,10 @@ void LoadData(ALCcontext *context, ALbuffer *ALBuf, ALuint freq, ALsizei size, U
      */
     if((access&MAP_READ_WRITE_FLAGS))
     {
-        if(UNLIKELY((long)SrcType != (long)DstType))
-            SETERR_RETURN(context, AL_INVALID_VALUE,, "%s samples cannot be mapped",
-                          NameFromUserFmtType(SrcType));
+        if (UNLIKELY(static_cast<long>(SrcType) != static_cast<long>(DstType)))
+          SETERR_RETURN(context, AL_INVALID_VALUE, ,
+                        "%s samples cannot be mapped",
+                        NameFromUserFmtType(SrcType));
     }
 
     ALsizei unpackalign{ALBuf->UnpackAlign.load()};
@@ -313,7 +315,7 @@ void LoadData(ALCcontext *context, ALbuffer *ALBuf, ALuint freq, ALsizei size, U
     }
     else
     {
-        assert((long)SrcType == (long)DstType);
+        assert(static_cast<long>(SrcType) == static_cast<long>(DstType));
         if(data != nullptr && !ALBuf->mData.empty())
             std::copy_n(static_cast<const ALbyte*>(data), frames*FrameSize, ALBuf->mData.begin());
         ALBuf->OriginalAlign = 1;
@@ -683,9 +685,11 @@ AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer, ALenum format, cons
     ALsizei align{SanitizeAlignment(srctype, unpack_align)};
     if(UNLIKELY(align < 1))
         alSetError(context.get(), AL_INVALID_VALUE, "Invalid unpack alignment %d", unpack_align);
-    else if(UNLIKELY((long)srcchannels != (long)albuf->mFmtChannels ||
-                    srctype != albuf->OriginalType))
-        alSetError(context.get(), AL_INVALID_ENUM, "Unpacking data with mismatched format");
+    else if (UNLIKELY(static_cast<long>(srcchannels) !=
+                          static_cast<long>(albuf->mFmtChannels) ||
+                      srctype != albuf->OriginalType))
+        alSetError(context.get(), AL_INVALID_ENUM,
+                   "Unpacking data with mismatched format");
     else if(UNLIKELY(align != albuf->OriginalAlign))
         alSetError(context.get(), AL_INVALID_VALUE,
                 "Unpacking data with alignment %u does not match original alignment %u",
@@ -730,8 +734,9 @@ AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer, ALenum format, cons
                     static_cast<const ALubyte*>(data), num_chans, length, align);
             else
             {
-                assert((long)srctype == (long)albuf->mFmtType);
-                memcpy(dst, data, length*frame_size);
+                assert(static_cast<long>(srctype) ==
+                       static_cast<long>(albuf->mFmtType));
+                memcpy(dst, data, length * frame_size);
             }
         }
     }
diff --git a/OpenAL32/alError.cpp b/OpenAL32/alError.cpp
index 303fbeac..d65b910a 100644
--- a/OpenAL32/alError.cpp
+++ b/OpenAL32/alError.cpp
@@ -43,17 +43,17 @@ void alSetError(ALCcontext *context, ALenum errorCode, const char *msg, ...)
     int msglen{vsnprintf(message, sizeof(message), msg, args)};
     va_end(args);
 
-    if(msglen < 0 || (size_t)msglen >= sizeof(message))
+    if(msglen < 0 || static_cast<size_t>(msglen) >= sizeof(message))
     {
         message[sizeof(message)-1] = 0;
-        msglen = (int)strlen(message);
+        msglen = static_cast<int>(strlen(message));
     }
     if(msglen > 0)
         msg = message;
     else
     {
         msg = "<internal error constructing message>";
-        msglen = (int)strlen(msg);
+        msglen = static_cast<int>(strlen(msg));
     }
 
     WARN("Error generated on context %p, code 0x%04x, \"%s\"\n",
diff --git a/OpenAL32/alExtension.cpp b/OpenAL32/alExtension.cpp
index aef6f7a4..e5d4cdf1 100644
--- a/OpenAL32/alExtension.cpp
+++ b/OpenAL32/alExtension.cpp
@@ -67,6 +67,6 @@ AL_API ALvoid* AL_APIENTRY alGetProcAddress(const ALchar *funcName)
 
 AL_API ALenum AL_APIENTRY alGetEnumValue(const ALchar *enumName)
 {
-    if(!enumName) return (ALenum)0;
+    if(!enumName) return static_cast<ALenum>(0);
     return alcGetEnumValue(nullptr, enumName);
 }
diff --git a/OpenAL32/alListener.cpp b/OpenAL32/alListener.cpp
index 7ed36f14..14fc58fc 100644
--- a/OpenAL32/alListener.cpp
+++ b/OpenAL32/alListener.cpp
@@ -169,7 +169,7 @@ AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2, A
     {
     case AL_POSITION:
     case AL_VELOCITY:
-        alListener3f(param, (ALfloat)value1, (ALfloat)value2, (ALfloat)value3);
+        alListener3f(param, static_cast<ALfloat>(value1), static_cast<ALfloat>(value2), static_cast<ALfloat>(value3));
         return;
     }
 
@@ -194,16 +194,16 @@ AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values)
         {
         case AL_POSITION:
         case AL_VELOCITY:
-            alListener3f(param, (ALfloat)values[0], (ALfloat)values[1], (ALfloat)values[2]);
+            alListener3f(param, static_cast<ALfloat>(values[0]), static_cast<ALfloat>(values[1]), static_cast<ALfloat>(values[2]));
             return;
 
         case AL_ORIENTATION:
-            fvals[0] = (ALfloat)values[0];
-            fvals[1] = (ALfloat)values[1];
-            fvals[2] = (ALfloat)values[2];
-            fvals[3] = (ALfloat)values[3];
-            fvals[4] = (ALfloat)values[4];
-            fvals[5] = (ALfloat)values[5];
+            fvals[0] = static_cast<ALfloat>(values[0]);
+            fvals[1] = static_cast<ALfloat>(values[1]);
+            fvals[2] = static_cast<ALfloat>(values[2]);
+            fvals[3] = static_cast<ALfloat>(values[3]);
+            fvals[4] = static_cast<ALfloat>(values[4]);
+            fvals[5] = static_cast<ALfloat>(values[5]);
             alListenerfv(param, fvals);
             return;
         }
@@ -345,15 +345,15 @@ AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint *value1, ALint *valu
     else switch(param)
     {
     case AL_POSITION:
-        *value1 = (ALint)listener.Position[0];
-        *value2 = (ALint)listener.Position[1];
-        *value3 = (ALint)listener.Position[2];
+        *value1 = static_cast<ALint>(listener.Position[0]);
+        *value2 = static_cast<ALint>(listener.Position[1]);
+        *value3 = static_cast<ALint>(listener.Position[2]);
         break;
 
     case AL_VELOCITY:
-        *value1 = (ALint)listener.Velocity[0];
-        *value2 = (ALint)listener.Velocity[1];
-        *value3 = (ALint)listener.Velocity[2];
+        *value1 = static_cast<ALint>(listener.Velocity[0]);
+        *value2 = static_cast<ALint>(listener.Velocity[1]);
+        *value3 = static_cast<ALint>(listener.Velocity[2]);
         break;
 
     default:
@@ -383,12 +383,12 @@ AL_API void AL_APIENTRY alGetListeneriv(ALenum param, ALint* values)
     {
     case AL_ORIENTATION:
         // AT then UP
-        values[0] = (ALint)listener.OrientAt[0];
-        values[1] = (ALint)listener.OrientAt[1];
-        values[2] = (ALint)listener.OrientAt[2];
-        values[3] = (ALint)listener.OrientUp[0];
-        values[4] = (ALint)listener.OrientUp[1];
-        values[5] = (ALint)listener.OrientUp[2];
+        values[0] = static_cast<ALint>(listener.OrientAt[0]);
+        values[1] = static_cast<ALint>(listener.OrientAt[1]);
+        values[2] = static_cast<ALint>(listener.OrientAt[2]);
+        values[3] = static_cast<ALint>(listener.OrientUp[0]);
+        values[4] = static_cast<ALint>(listener.OrientUp[1]);
+        values[5] = static_cast<ALint>(listener.OrientUp[2]);
         break;
 
     default:
diff --git a/OpenAL32/alSource.cpp b/OpenAL32/alSource.cpp
index 639d1c37..a04ef6b7 100644
--- a/OpenAL32/alSource.cpp
+++ b/OpenAL32/alSource.cpp
@@ -173,8 +173,8 @@ ALint64 GetSourceSampleOffset(ALsource *Source, ALCcontext *context, std::chrono
         {
             Current = voice->current_buffer.load(std::memory_order_relaxed);
 
-            readPos  = (ALuint64)voice->position.load(std::memory_order_relaxed) << 32;
-            readPos |= (ALuint64)voice->position_fraction.load(std::memory_order_relaxed) <<
+            readPos  = static_cast<ALuint64>(voice->position.load(std::memory_order_relaxed)) << 32;
+            readPos |= static_cast<ALuint64>(voice->position_fraction.load(std::memory_order_relaxed)) <<
                        (32-FRACTIONBITS);
         }
         std::atomic_thread_fence(std::memory_order_acquire);
@@ -185,13 +185,13 @@ ALint64 GetSourceSampleOffset(ALsource *Source, ALCcontext *context, std::chrono
         const ALbufferlistitem *BufferList{Source->queue};
         while(BufferList && BufferList != Current)
         {
-            readPos += (ALuint64)BufferList->max_samples << 32;
+            readPos += static_cast<ALuint64>(BufferList->max_samples) << 32;
             BufferList = BufferList->next.load(std::memory_order_relaxed);
         }
         readPos = minu64(readPos, 0x7fffffffffffffff_u64);
     }
 
-    return (ALint64)readPos;
+    return static_cast<ALint64>(readPos);
 }
 
 /* GetSourceSecOffset
@@ -219,7 +219,7 @@ ALdouble GetSourceSecOffset(ALsource *Source, ALCcontext *context, std::chrono::
         {
             Current = voice->current_buffer.load(std::memory_order_relaxed);
 
-            readPos  = (ALuint64)voice->position.load(std::memory_order_relaxed) << FRACTIONBITS;
+            readPos  = static_cast<ALuint64>(voice->position.load(std::memory_order_relaxed)) << FRACTIONBITS;
             readPos |= voice->position_fraction.load(std::memory_order_relaxed);
         }
         std::atomic_thread_fence(std::memory_order_acquire);
@@ -234,7 +234,7 @@ ALdouble GetSourceSecOffset(ALsource *Source, ALCcontext *context, std::chrono::
         {
             for(ALsizei i{0};!BufferFmt && i < BufferList->num_buffers;++i)
                 BufferFmt = BufferList->buffers[i];
-            readPos += (ALuint64)BufferList->max_samples << FRACTIONBITS;
+            readPos += static_cast<ALuint64>(BufferList->max_samples) << FRACTIONBITS;
             BufferList = BufferList->next.load(std::memory_order_relaxed);
         }
 
@@ -246,8 +246,8 @@ ALdouble GetSourceSecOffset(ALsource *Source, ALCcontext *context, std::chrono::
         }
         assert(BufferFmt != nullptr);
 
-        offset = (ALdouble)readPos / (ALdouble)FRACTIONONE /
-                 (ALdouble)BufferFmt->Frequency;
+        offset = static_cast<ALdouble>(readPos) / static_cast<ALdouble>FRACTIONONE /
+                 static_cast<ALdouble>(BufferFmt->Frequency);
     }
 
     return offset;
@@ -318,11 +318,11 @@ ALdouble GetSourceOffset(ALsource *Source, ALenum name, ALCcontext *context)
         switch(name)
         {
             case AL_SEC_OFFSET:
-                offset = (readPos + (ALdouble)readPosFrac/FRACTIONONE) / BufferFmt->Frequency;
+                offset = (readPos + static_cast<ALdouble>(readPosFrac)/FRACTIONONE) / BufferFmt->Frequency;
                 break;
 
             case AL_SAMPLE_OFFSET:
-                offset = readPos + (ALdouble)readPosFrac/FRACTIONONE;
+                offset = readPos + static_cast<ALdouble>(readPosFrac)/FRACTIONONE;
                 break;
 
             case AL_BYTE_OFFSET:
@@ -333,7 +333,7 @@ ALdouble GetSourceOffset(ALsource *Source, ALenum name, ALCcontext *context)
                     ALuint FrameBlockSize = BufferFmt->OriginalAlign;
 
                     /* Round down to nearest ADPCM block */
-                    offset = (ALdouble)(readPos / FrameBlockSize * BlockSize);
+                    offset = static_cast<ALdouble>(readPos / FrameBlockSize * BlockSize);
                 }
                 else if(BufferFmt->OriginalType == UserFmtMSADPCM)
                 {
@@ -342,13 +342,13 @@ ALdouble GetSourceOffset(ALsource *Source, ALenum name, ALCcontext *context)
                     ALuint FrameBlockSize = BufferFmt->OriginalAlign;
 
                     /* Round down to nearest ADPCM block */
-                    offset = (ALdouble)(readPos / FrameBlockSize * BlockSize);
+                    offset = static_cast<ALdouble>(readPos / FrameBlockSize * BlockSize);
                 }
                 else
                 {
                     const ALsizei FrameSize{FrameSizeFromFmt(BufferFmt->mFmtChannels,
                         BufferFmt->mFmtType)};
-                    offset = (ALdouble)(readPos * FrameSize);
+                    offset = static_cast<ALdouble>(readPos * FrameSize);
                 }
                 break;
         }
@@ -390,7 +390,7 @@ ALboolean GetSampleOffset(ALsource *Source, ALuint *offset, ALsizei *frac)
     {
     case AL_BYTE_OFFSET:
         /* Determine the ByteOffset (and ensure it is block aligned) */
-        *offset = (ALuint)Source->Offset;
+        *offset = static_cast<ALuint>(Source->Offset);
         if(BufferFmt->OriginalType == UserFmtIMA4)
         {
             ALsizei align = (BufferFmt->OriginalAlign-1)/2 + 4;
@@ -410,14 +410,14 @@ ALboolean GetSampleOffset(ALsource *Source, ALuint *offset, ALsizei *frac)
 
     case AL_SAMPLE_OFFSET:
         dblfrac = modf(Source->Offset, &dbloff);
-        *offset = (ALuint)mind(dbloff, std::numeric_limits<unsigned int>::max());
-        *frac = (ALsizei)mind(dblfrac*FRACTIONONE, FRACTIONONE-1.0);
+        *offset = static_cast<ALuint>(mind(dbloff, std::numeric_limits<unsigned int>::max()));
+        *frac = static_cast<ALsizei>(mind(dblfrac*FRACTIONONE, FRACTIONONE-1.0));
         break;
 
     case AL_SEC_OFFSET:
         dblfrac = modf(Source->Offset*BufferFmt->Frequency, &dbloff);
-        *offset = (ALuint)mind(dbloff, std::numeric_limits<unsigned int>::max());
-        *frac = (ALsizei)mind(dblfrac*FRACTIONONE, FRACTIONONE-1.0);
+        *offset = static_cast<ALuint>(mind(dbloff, std::numeric_limits<unsigned int>::max()));
+        *frac = static_cast<ALsizei>(mind(dblfrac*FRACTIONONE, FRACTIONONE-1.0));
         break;
     }
     Source->OffsetType = AL_NONE;
@@ -443,7 +443,7 @@ ALboolean ApplyOffset(ALsource *Source, ALvoice *voice)
     ALbufferlistitem *BufferList{Source->queue};
     while(BufferList && totalBufferLen <= offset)
     {
-        if((ALuint)BufferList->max_samples > offset-totalBufferLen)
+        if(static_cast<ALuint>(BufferList->max_samples) > offset-totalBufferLen)
         {
             /* Offset is in this buffer */
             voice->position.store(offset - totalBufferLen, std::memory_order_relaxed);
@@ -1174,12 +1174,12 @@ ALboolean SetSourcefv(ALsource *Source, ALCcontext *Context, SourceProp prop, co
         case AL_DIRECT_CHANNELS_SOFT:
         case AL_SOURCE_RESAMPLER_SOFT:
         case AL_SOURCE_SPATIALIZE_SOFT:
-            ival = (ALint)values[0];
+            ival = static_cast<ALint>(values[0]);
             return SetSourceiv(Source, Context, prop, &ival);
 
         case AL_BUFFERS_QUEUED:
         case AL_BUFFERS_PROCESSED:
-            ival = (ALint)((ALuint)values[0]);
+            ival = static_cast<ALint>(static_cast<ALuint>(values[0]));
             return SetSourceiv(Source, Context, prop, &ival);
 
         case AL_BUFFER:
@@ -1219,14 +1219,14 @@ ALboolean SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, co
         case AL_SOURCE_RELATIVE:
             CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
 
-            Source->HeadRelative = (ALboolean)*values;
+            Source->HeadRelative = static_cast<ALboolean>(*values);
             DO_UPDATEPROPS();
             return AL_TRUE;
 
         case AL_LOOPING:
             CHECKVAL(*values == AL_FALSE || *values == AL_TRUE);
 
-            Source->Looping = (ALboolean)*values;
+            Source->Looping = static_cast<ALboolean>(*values);
             if(IsPlayingOrPaused(Source))
             {
                 ALvoice *voice{GetSourceVoice(Source, Context)};
@@ -1413,7 +1413,7 @@ ALboolean SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, co
             if(!(values[0] == 0 || (slot=LookupEffectSlot(Context, values[0])) != nullptr))
                 SETERR_RETURN(Context, AL_INVALID_VALUE, AL_FALSE, "Invalid effect ID %u",
                               values[0]);
-            if((ALuint)values[1] >= (ALuint)device->NumAuxSends)
+            if(static_cast<ALuint>(values[1]) >= static_cast<ALuint>(device->NumAuxSends))
                 SETERR_RETURN(Context, AL_INVALID_VALUE, AL_FALSE, "Invalid send %u", values[1]);
 
             filtlock = std::unique_lock<std::mutex>{device->FilterLock};
@@ -1483,26 +1483,26 @@ ALboolean SetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, co
         case AL_AIR_ABSORPTION_FACTOR:
         case AL_ROOM_ROLLOFF_FACTOR:
         case AL_SOURCE_RADIUS:
-            fvals[0] = (ALfloat)*values;
+            fvals[0] = static_cast<ALfloat>(*values);
             return SetSourcefv(Source, Context, prop, fvals);
 
         /* 3x float */
         case AL_POSITION:
         case AL_VELOCITY:
         case AL_DIRECTION:
-            fvals[0] = (ALfloat)values[0];
-            fvals[1] = (ALfloat)values[1];
-            fvals[2] = (ALfloat)values[2];
+            fvals[0] = static_cast<ALfloat>(values[0]);
+            fvals[1] = static_cast<ALfloat>(values[1]);
+            fvals[2] = static_cast<ALfloat>(values[2]);
             return SetSourcefv(Source, Context, prop, fvals);
 
         /* 6x float */
         case AL_ORIENTATION:
-            fvals[0] = (ALfloat)values[0];
-            fvals[1] = (ALfloat)values[1];
-            fvals[2] = (ALfloat)values[2];
-            fvals[3] = (ALfloat)values[3];
-            fvals[4] = (ALfloat)values[4];
-            fvals[5] = (ALfloat)values[5];
+            fvals[0] = static_cast<ALfloat>(values[0]);
+            fvals[1] = static_cast<ALfloat>(values[1]);
+            fvals[2] = static_cast<ALfloat>(values[2]);
+            fvals[3] = static_cast<ALfloat>(values[3]);
+            fvals[4] = static_cast<ALfloat>(values[4]);
+            fvals[5] = static_cast<ALfloat>(values[5]);
             return SetSourcefv(Source, Context, prop, fvals);
 
         case AL_SAMPLE_OFFSET_LATENCY_SOFT:
@@ -1550,7 +1550,7 @@ ALboolean SetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop,
         case AL_SOURCE_SPATIALIZE_SOFT:
             CHECKVAL(*values <= INT_MAX && *values >= INT_MIN);
 
-            ivals[0] = (ALint)*values;
+            ivals[0] = static_cast<ALint>(*values);
             return SetSourceiv(Source, Context, prop, ivals);
 
         /* 1x uint */
@@ -1558,7 +1558,7 @@ ALboolean SetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop,
         case AL_DIRECT_FILTER:
             CHECKVAL(*values <= UINT_MAX && *values >= 0);
 
-            ivals[0] = (ALuint)*values;
+            ivals[0] = static_cast<ALuint>(*values);
             return SetSourceiv(Source, Context, prop, ivals);
 
         /* 3x uint */
@@ -1567,9 +1567,9 @@ ALboolean SetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop,
                      values[1] <= UINT_MAX && values[1] >= 0 &&
                      values[2] <= UINT_MAX && values[2] >= 0);
 
-            ivals[0] = (ALuint)values[0];
-            ivals[1] = (ALuint)values[1];
-            ivals[2] = (ALuint)values[2];
+            ivals[0] = static_cast<ALuint>(values[0]);
+            ivals[1] = static_cast<ALuint>(values[1]);
+            ivals[2] = static_cast<ALuint>(values[2]);
             return SetSourceiv(Source, Context, prop, ivals);
 
         /* 1x float */
@@ -1588,26 +1588,26 @@ ALboolean SetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop,
         case AL_AIR_ABSORPTION_FACTOR:
         case AL_ROOM_ROLLOFF_FACTOR:
         case AL_SOURCE_RADIUS:
-            fvals[0] = (ALfloat)*values;
+            fvals[0] = static_cast<ALfloat>(*values);
             return SetSourcefv(Source, Context, prop, fvals);
 
         /* 3x float */
         case AL_POSITION:
         case AL_VELOCITY:
         case AL_DIRECTION:
-            fvals[0] = (ALfloat)values[0];
-            fvals[1] = (ALfloat)values[1];
-            fvals[2] = (ALfloat)values[2];
+            fvals[0] = static_cast<ALfloat>(values[0]);
+            fvals[1] = static_cast<ALfloat>(values[1]);
+            fvals[2] = static_cast<ALfloat>(values[2]);
             return SetSourcefv(Source, Context, prop, fvals);
 
         /* 6x float */
         case AL_ORIENTATION:
-            fvals[0] = (ALfloat)values[0];
-            fvals[1] = (ALfloat)values[1];
-            fvals[2] = (ALfloat)values[2];
-            fvals[3] = (ALfloat)values[3];
-            fvals[4] = (ALfloat)values[4];
-            fvals[5] = (ALfloat)values[5];
+            fvals[0] = static_cast<ALfloat>(values[0]);
+            fvals[1] = static_cast<ALfloat>(values[1]);
+            fvals[2] = static_cast<ALfloat>(values[2]);
+            fvals[3] = static_cast<ALfloat>(values[3]);
+            fvals[4] = static_cast<ALfloat>(values[4]);
+            fvals[5] = static_cast<ALfloat>(values[5]);
             return SetSourcefv(Source, Context, prop, fvals);
 
         case AL_SEC_OFFSET_LATENCY_SOFT:
@@ -1718,7 +1718,7 @@ ALboolean GetSourcedv(ALsource *Source, ALCcontext *Context, SourceProp prop, AL
                 clocktime = GetClockLatency(device);
             }
             if(srcclock == clocktime.ClockTime)
-                values[1] = (ALdouble)clocktime.Latency.count() / 1000000000.0;
+                values[1] = static_cast<ALdouble>(clocktime.Latency.count()) / 1000000000.0;
             else
             {
                 /* If the clock time incremented, reduce the latency by that
@@ -1726,7 +1726,7 @@ ALboolean GetSourcedv(ALsource *Source, ALCcontext *Context, SourceProp prop, AL
                  * earlier.
                  */
                 std::chrono::nanoseconds diff = clocktime.ClockTime - srcclock;
-                values[1] = (ALdouble)(clocktime.Latency - std::min(clocktime.Latency, diff)).count() /
+                values[1] = static_cast<ALdouble>((clocktime.Latency - std::min(clocktime.Latency, diff)).count()) /
                             1000000000.0;
             }
             return AL_TRUE;
@@ -1778,7 +1778,7 @@ ALboolean GetSourcedv(ALsource *Source, ALCcontext *Context, SourceProp prop, AL
         case AL_SOURCE_RESAMPLER_SOFT:
         case AL_SOURCE_SPATIALIZE_SOFT:
             if((err=GetSourceiv(Source, Context, prop, ivals)) != AL_FALSE)
-                *values = (ALdouble)ivals[0];
+                *values = static_cast<ALdouble>(ivals[0]);
             return err;
 
         case AL_BUFFER:
@@ -1914,7 +1914,7 @@ ALboolean GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, AL
         case AL_CONE_OUTER_GAINHF:
         case AL_SOURCE_RADIUS:
             if((err=GetSourcedv(Source, Context, prop, dvals)) != AL_FALSE)
-                *values = (ALint)dvals[0];
+                *values = static_cast<ALint>(dvals[0]);
             return err;
 
         /* 3x float/double */
@@ -1923,9 +1923,9 @@ ALboolean GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, AL
         case AL_DIRECTION:
             if((err=GetSourcedv(Source, Context, prop, dvals)) != AL_FALSE)
             {
-                values[0] = (ALint)dvals[0];
-                values[1] = (ALint)dvals[1];
-                values[2] = (ALint)dvals[2];
+                values[0] = static_cast<ALint>(dvals[0]);
+                values[1] = static_cast<ALint>(dvals[1]);
+                values[2] = static_cast<ALint>(dvals[2]);
             }
             return err;
 
@@ -1933,12 +1933,12 @@ ALboolean GetSourceiv(ALsource *Source, ALCcontext *Context, SourceProp prop, AL
         case AL_ORIENTATION:
             if((err=GetSourcedv(Source, Context, prop, dvals)) != AL_FALSE)
             {
-                values[0] = (ALint)dvals[0];
-                values[1] = (ALint)dvals[1];
-                values[2] = (ALint)dvals[2];
-                values[3] = (ALint)dvals[3];
-                values[4] = (ALint)dvals[4];
-                values[5] = (ALint)dvals[5];
+                values[0] = static_cast<ALint>(dvals[0]);
+                values[1] = static_cast<ALint>(dvals[1]);
+                values[2] = static_cast<ALint>(dvals[2]);
+                values[3] = static_cast<ALint>(dvals[3]);
+                values[4] = static_cast<ALint>(dvals[4]);
+                values[5] = static_cast<ALint>(dvals[5]);
             }
             return err;
 
@@ -2018,7 +2018,7 @@ ALboolean GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop,
         case AL_CONE_OUTER_GAINHF:
         case AL_SOURCE_RADIUS:
             if((err=GetSourcedv(Source, Context, prop, dvals)) != AL_FALSE)
-                *values = (ALint64)dvals[0];
+                *values = static_cast<ALint64>(dvals[0]);
             return err;
 
         /* 3x float/double */
@@ -2027,9 +2027,9 @@ ALboolean GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop,
         case AL_DIRECTION:
             if((err=GetSourcedv(Source, Context, prop, dvals)) != AL_FALSE)
             {
-                values[0] = (ALint64)dvals[0];
-                values[1] = (ALint64)dvals[1];
-                values[2] = (ALint64)dvals[2];
+                values[0] = static_cast<ALint64>(dvals[0]);
+                values[1] = static_cast<ALint64>(dvals[1]);
+                values[2] = static_cast<ALint64>(dvals[2]);
             }
             return err;
 
@@ -2037,12 +2037,12 @@ ALboolean GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop,
         case AL_ORIENTATION:
             if((err=GetSourcedv(Source, Context, prop, dvals)) != AL_FALSE)
             {
-                values[0] = (ALint64)dvals[0];
-                values[1] = (ALint64)dvals[1];
-                values[2] = (ALint64)dvals[2];
-                values[3] = (ALint64)dvals[3];
-                values[4] = (ALint64)dvals[4];
-                values[5] = (ALint64)dvals[5];
+                values[0] = static_cast<ALint64>(dvals[0]);
+                values[1] = static_cast<ALint64>(dvals[1]);
+                values[2] = static_cast<ALint64>(dvals[2]);
+                values[3] = static_cast<ALint64>(dvals[3]);
+                values[4] = static_cast<ALint64>(dvals[4]);
+                values[5] = static_cast<ALint64>(dvals[5]);
             }
             return err;
 
@@ -2068,16 +2068,16 @@ ALboolean GetSourcei64v(ALsource *Source, ALCcontext *Context, SourceProp prop,
         case AL_BUFFER:
         case AL_DIRECT_FILTER:
             if((err=GetSourceiv(Source, Context, prop, ivals)) != AL_FALSE)
-                *values = (ALuint)ivals[0];
+                *values = static_cast<ALuint>(ivals[0]);
             return err;
 
         /* 3x uint */
         case AL_AUXILIARY_SEND_FILTER:
             if((err=GetSourceiv(Source, Context, prop, ivals)) != AL_FALSE)
             {
-                values[0] = (ALuint)ivals[0];
-                values[1] = (ALuint)ivals[1];
-                values[2] = (ALuint)ivals[2];
+                values[0] = static_cast<ALuint>(ivals[0]);
+                values[1] = static_cast<ALuint>(ivals[1]);
+                values[2] = static_cast<ALuint>(ivals[2]);
             }
             return err;
 
@@ -2246,7 +2246,7 @@ AL_API ALvoid AL_APIENTRY alSourcedSOFT(ALuint source, ALenum param, ALdouble va
         alSetError(context.get(), AL_INVALID_ENUM, "Invalid double property 0x%04x", param);
     else
     {
-        ALfloat fval = (ALfloat)value;
+        ALfloat fval = static_cast<ALfloat>(value);
         SetSourcefv(Source, context.get(), static_cast<SourceProp>(param), &fval);
     }
 }
@@ -2263,9 +2263,10 @@ AL_API ALvoid AL_APIENTRY alSource3dSOFT(ALuint source, ALenum param, ALdouble v
         alSetError(context.get(), AL_INVALID_NAME, "Invalid source ID %u", source);
     else if(DoubleValsByProp(param) != 3)
         alSetError(context.get(), AL_INVALID_ENUM, "Invalid 3-double property 0x%04x", param);
-    else
-    {
-        ALfloat fvals[3] = { (ALfloat)value1, (ALfloat)value2, (ALfloat)value3 };
+    else {
+        ALfloat fvals[3] = {static_cast<ALfloat>(value1),
+                            static_cast<ALfloat>(value2),
+                            static_cast<ALfloat>(value3)};
         SetSourcefv(Source, context.get(), static_cast<SourceProp>(param), fvals);
     }
 }
@@ -2293,7 +2294,7 @@ AL_API ALvoid AL_APIENTRY alSourcedvSOFT(ALuint source, ALenum param, const ALdo
             ALint i;
 
             for(i = 0;i < count;i++)
-                fvals[i] = (ALfloat)values[i];
+                fvals[i] = static_cast<ALfloat>(values[i]);
             SetSourcefv(Source, context.get(), static_cast<SourceProp>(param), fvals);
         }
     }
@@ -2425,7 +2426,7 @@ AL_API ALvoid AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *val
     {
         ALdouble dval;
         if(GetSourcedv(Source, context.get(), static_cast<SourceProp>(param), &dval))
-            *value = (ALfloat)dval;
+            *value = static_cast<ALfloat>(dval);
     }
 }
 
@@ -2448,9 +2449,9 @@ AL_API ALvoid AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *va
         ALdouble dvals[3];
         if(GetSourcedv(Source, context.get(), static_cast<SourceProp>(param), dvals))
         {
-            *value1 = (ALfloat)dvals[0];
-            *value2 = (ALfloat)dvals[1];
-            *value3 = (ALfloat)dvals[2];
+            *value1 = static_cast<ALfloat>(dvals[0]);
+            *value2 = static_cast<ALfloat>(dvals[1]);
+            *value3 = static_cast<ALfloat>(dvals[2]);
         }
     }
 }
@@ -2478,7 +2479,7 @@ AL_API ALvoid AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *va
             if(GetSourcedv(Source, context.get(), static_cast<SourceProp>(param), dvals))
             {
                 for(ALint i{0};i < count;i++)
-                    values[i] = (ALfloat)dvals[i];
+                    values[i] = static_cast<ALfloat>(dvals[i]);
             }
         }
     }
diff --git a/OpenAL32/alState.cpp b/OpenAL32/alState.cpp
index 3f55687d..c6dd171e 100644
--- a/OpenAL32/alState.cpp
+++ b/OpenAL32/alState.cpp
@@ -195,36 +195,36 @@ AL_API ALdouble AL_APIENTRY alGetDouble(ALenum pname)
     switch(pname)
     {
     case AL_DOPPLER_FACTOR:
-        value = (ALdouble)context->DopplerFactor;
+        value = static_cast<ALdouble>(context->DopplerFactor);
         break;
 
     case AL_DOPPLER_VELOCITY:
-        value = (ALdouble)context->DopplerVelocity;
+        value = static_cast<ALdouble>(context->DopplerVelocity);
         break;
 
     case AL_DISTANCE_MODEL:
-        value = (ALdouble)context->mDistanceModel;
+        value = static_cast<ALdouble>(context->mDistanceModel);
         break;
 
     case AL_SPEED_OF_SOUND:
-        value = (ALdouble)context->SpeedOfSound;
+        value = static_cast<ALdouble>(context->SpeedOfSound);
         break;
 
     case AL_DEFERRED_UPDATES_SOFT:
         if(context->DeferUpdates.load(std::memory_order_acquire))
-            value = (ALdouble)AL_TRUE;
+            value = static_cast<ALdouble>(AL_TRUE);
         break;
 
     case AL_GAIN_LIMIT_SOFT:
-        value = (ALdouble)GAIN_MIX_MAX/context->GainBoost;
+        value = static_cast<ALdouble>GAIN_MIX_MAX/context->GainBoost;
         break;
 
     case AL_NUM_RESAMPLERS_SOFT:
-        value = (ALdouble)(ResamplerMax + 1);
+        value = static_cast<ALdouble>(ResamplerMax + 1);
         break;
 
     case AL_DEFAULT_RESAMPLER_SOFT:
-        value = (ALdouble)ResamplerDefault;
+        value = static_cast<ALdouble>(ResamplerDefault);
         break;
 
     default:
@@ -252,7 +252,7 @@ AL_API ALfloat AL_APIENTRY alGetFloat(ALenum pname)
         break;
 
     case AL_DISTANCE_MODEL:
-        value = (ALfloat)context->mDistanceModel;
+        value = static_cast<ALfloat>(context->mDistanceModel);
         break;
 
     case AL_SPEED_OF_SOUND:
@@ -261,7 +261,7 @@ AL_API ALfloat AL_APIENTRY alGetFloat(ALenum pname)
 
     case AL_DEFERRED_UPDATES_SOFT:
         if(context->DeferUpdates.load(std::memory_order_acquire))
-            value = (ALfloat)AL_TRUE;
+            value = static_cast<ALfloat>(AL_TRUE);
         break;
 
     case AL_GAIN_LIMIT_SOFT:
@@ -269,11 +269,11 @@ AL_API ALfloat AL_APIENTRY alGetFloat(ALenum pname)
         break;
 
     case AL_NUM_RESAMPLERS_SOFT:
-        value = (ALfloat)(ResamplerMax + 1);
+        value = static_cast<ALfloat>(ResamplerMax + 1);
         break;
 
     case AL_DEFAULT_RESAMPLER_SOFT:
-        value = (ALfloat)ResamplerDefault;
+        value = static_cast<ALfloat>(ResamplerDefault);
         break;
 
     default:
@@ -293,28 +293,28 @@ AL_API ALint AL_APIENTRY alGetInteger(ALenum pname)
     switch(pname)
     {
     case AL_DOPPLER_FACTOR:
-        value = (ALint)context->DopplerFactor;
+        value = static_cast<ALint>(context->DopplerFactor);
         break;
 
     case AL_DOPPLER_VELOCITY:
-        value = (ALint)context->DopplerVelocity;
+        value = static_cast<ALint>(context->DopplerVelocity);
         break;
 
     case AL_DISTANCE_MODEL:
-        value = (ALint)context->mDistanceModel;
+        value = static_cast<ALint>(context->mDistanceModel);
         break;
 
     case AL_SPEED_OF_SOUND:
-        value = (ALint)context->SpeedOfSound;
+        value = static_cast<ALint>(context->SpeedOfSound);
         break;
 
     case AL_DEFERRED_UPDATES_SOFT:
         if(context->DeferUpdates.load(std::memory_order_acquire))
-            value = (ALint)AL_TRUE;
+            value = static_cast<ALint>(AL_TRUE);
         break;
 
     case AL_GAIN_LIMIT_SOFT:
-        value = (ALint)(GAIN_MIX_MAX/context->GainBoost);
+        value = static_cast<ALint>(GAIN_MIX_MAX/context->GainBoost);
         break;
 
     case AL_NUM_RESAMPLERS_SOFT:
@@ -663,7 +663,7 @@ AL_API ALvoid AL_APIENTRY alDopplerVelocity(ALfloat value)
     {
         static constexpr ALCchar msg[] =
             "alDopplerVelocity is deprecated in AL1.1, use alSpeedOfSound";
-        const ALsizei msglen = (ALsizei)strlen(msg);
+        const ALsizei msglen = static_cast<ALsizei>(strlen(msg));
         std::lock_guard<std::mutex> _{context->EventCbLock};
         ALbitfieldSOFT enabledevts{context->EnabledEvts.load(std::memory_order_relaxed)};
         if((enabledevts&EventType_Deprecated) && context->EventCb)
@@ -749,7 +749,7 @@ AL_API const ALchar* AL_APIENTRY alGetStringiSOFT(ALenum pname, ALsizei index)
     switch(pname)
     {
     case AL_RESAMPLER_NAME_SOFT:
-        if(index < 0 || (size_t)index >= COUNTOF(ResamplerNames))
+        if(index < 0 || static_cast<size_t>(index) >= COUNTOF(ResamplerNames))
             alSetError(context.get(), AL_INVALID_VALUE, "Resampler name index %d out of range",
                        index);
         else