Use separate structs for the dedicated dialog/lfe effects

7 files changed, 143 insertions, 56 deletions

diff --git a/al/auxeffectslot.cpp b/al/auxeffectslot.cpp
index 02c061a4..408b742b 100644
--- a/al/auxeffectslot.cpp
+++ b/al/auxeffectslot.cpp
@@ -72,8 +72,8 @@ constexpr std::array FactoryList{
     FactoryItem{EffectSlotType::RingModulator, ModulatorStateFactory_getFactory},
     FactoryItem{EffectSlotType::PitchShifter, PshifterStateFactory_getFactory},
     FactoryItem{EffectSlotType::VocalMorpher, VmorpherStateFactory_getFactory},
-    FactoryItem{EffectSlotType::DedicatedDialog, DedicatedStateFactory_getFactory},
-    FactoryItem{EffectSlotType::DedicatedLFE, DedicatedStateFactory_getFactory},
+    FactoryItem{EffectSlotType::DedicatedDialog, DedicatedDialogStateFactory_getFactory},
+    FactoryItem{EffectSlotType::DedicatedLFE, DedicatedLfeStateFactory_getFactory},
     FactoryItem{EffectSlotType::Convolution, ConvolutionStateFactory_getFactory},
 };
 
diff --git a/al/effect.cpp b/al/effect.cpp
index 7cd6a67b..005b1557 100644
--- a/al/effect.cpp
+++ b/al/effect.cpp
@@ -109,8 +109,8 @@ constexpr std::array EffectPropsList{
     EffectPropsItem{AL_EFFECT_RING_MODULATOR, ModulatorEffectProps, ModulatorEffectVtable},
     EffectPropsItem{AL_EFFECT_PITCH_SHIFTER, PshifterEffectProps, PshifterEffectVtable},
     EffectPropsItem{AL_EFFECT_VOCAL_MORPHER, VmorpherEffectProps, VmorpherEffectVtable},
-    EffectPropsItem{AL_EFFECT_DEDICATED_DIALOGUE, DedicatedEffectProps, DedicatedEffectVtable},
-    EffectPropsItem{AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT, DedicatedEffectProps, DedicatedEffectVtable},
+    EffectPropsItem{AL_EFFECT_DEDICATED_DIALOGUE, DedicatedDialogEffectProps, DedicatedDialogEffectVtable},
+    EffectPropsItem{AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT, DedicatedLfeEffectProps, DedicatedLfeEffectVtable},
     EffectPropsItem{AL_EFFECT_CONVOLUTION_SOFT, ConvolutionEffectProps, ConvolutionEffectVtable},
 };
 
diff --git a/al/effects/dedicated.cpp b/al/effects/dedicated.cpp
index db57003c..f5edfd51 100644
--- a/al/effects/dedicated.cpp
+++ b/al/effects/dedicated.cpp
@@ -12,61 +12,120 @@
 
 namespace {
 
-void Dedicated_setParami(EffectProps*, ALenum param, int)
+void DedicatedDialog_setParami(EffectProps*, ALenum param, int)
 { throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated integer property 0x%04x", param}; }
-void Dedicated_setParamiv(EffectProps*, ALenum param, const int*)
+void DedicatedDialog_setParamiv(EffectProps*, ALenum param, const int*)
 {
     throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated integer-vector property 0x%04x",
         param};
 }
-void Dedicated_setParamf(EffectProps *props, ALenum param, float val)
+void DedicatedDialog_setParamf(EffectProps *props, ALenum param, float val)
 {
     switch(param)
     {
     case AL_DEDICATED_GAIN:
         if(!(val >= 0.0f && std::isfinite(val)))
             throw effect_exception{AL_INVALID_VALUE, "Dedicated gain out of range"};
-        props->Dedicated.Gain = val;
+        props->DedicatedDialog.Gain = val;
         break;
 
     default:
         throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated float property 0x%04x", param};
     }
 }
-void Dedicated_setParamfv(EffectProps *props, ALenum param, const float *vals)
-{ Dedicated_setParamf(props, param, vals[0]); }
+void DedicatedDialog_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{ DedicatedDialog_setParamf(props, param, vals[0]); }
 
-void Dedicated_getParami(const EffectProps*, ALenum param, int*)
+void DedicatedDialog_getParami(const EffectProps*, ALenum param, int*)
 { throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated integer property 0x%04x", param}; }
-void Dedicated_getParamiv(const EffectProps*, ALenum param, int*)
+void DedicatedDialog_getParamiv(const EffectProps*, ALenum param, int*)
 {
     throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated integer-vector property 0x%04x",
         param};
 }
-void Dedicated_getParamf(const EffectProps *props, ALenum param, float *val)
+void DedicatedDialog_getParamf(const EffectProps *props, ALenum param, float *val)
 {
     switch(param)
     {
     case AL_DEDICATED_GAIN:
-        *val = props->Dedicated.Gain;
+        *val = props->DedicatedDialog.Gain;
         break;
 
     default:
         throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated float property 0x%04x", param};
     }
 }
-void Dedicated_getParamfv(const EffectProps *props, ALenum param, float *vals)
-{ Dedicated_getParamf(props, param, vals); }
+void DedicatedDialog_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{ DedicatedDialog_getParamf(props, param, vals); }
 
-EffectProps genDefaultProps() noexcept
+
+void DedicatedLfe_setParami(EffectProps*, ALenum param, int)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated integer property 0x%04x", param}; }
+void DedicatedLfe_setParamiv(EffectProps*, ALenum param, const int*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated integer-vector property 0x%04x",
+        param};
+}
+void DedicatedLfe_setParamf(EffectProps *props, ALenum param, float val)
+{
+    switch(param)
+    {
+    case AL_DEDICATED_GAIN:
+        if(!(val >= 0.0f && std::isfinite(val)))
+            throw effect_exception{AL_INVALID_VALUE, "Dedicated gain out of range"};
+        props->DedicatedLfe.Gain = val;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated float property 0x%04x", param};
+    }
+}
+void DedicatedLfe_setParamfv(EffectProps *props, ALenum param, const float *vals)
+{ DedicatedLfe_setParamf(props, param, vals[0]); }
+
+void DedicatedLfe_getParami(const EffectProps*, ALenum param, int*)
+{ throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated integer property 0x%04x", param}; }
+void DedicatedLfe_getParamiv(const EffectProps*, ALenum param, int*)
+{
+    throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated integer-vector property 0x%04x",
+        param};
+}
+void DedicatedLfe_getParamf(const EffectProps *props, ALenum param, float *val)
+{
+    switch(param)
+    {
+    case AL_DEDICATED_GAIN:
+        *val = props->DedicatedLfe.Gain;
+        break;
+
+    default:
+        throw effect_exception{AL_INVALID_ENUM, "Invalid dedicated float property 0x%04x", param};
+    }
+}
+void DedicatedLfe_getParamfv(const EffectProps *props, ALenum param, float *vals)
+{ DedicatedLfe_getParamf(props, param, vals); }
+
+
+EffectProps genDefaultDialogProps() noexcept
+{
+    EffectProps props{};
+    props.DedicatedDialog.Gain = 1.0f;
+    return props;
+}
+
+EffectProps genDefaultLfeProps() noexcept
 {
     EffectProps props{};
-    props.Dedicated.Gain = 1.0f;
+    props.DedicatedLfe.Gain = 1.0f;
     return props;
 }
 
 } // namespace
 
-DEFINE_ALEFFECT_VTABLE(Dedicated);
+DEFINE_ALEFFECT_VTABLE(DedicatedDialog);
+
+const EffectProps DedicatedDialogEffectProps{genDefaultDialogProps()};
+
+DEFINE_ALEFFECT_VTABLE(DedicatedLfe);
 
-const EffectProps DedicatedEffectProps{genDefaultProps()};
+const EffectProps DedicatedLfeEffectProps{genDefaultLfeProps()};
diff --git a/al/effects/effects.h b/al/effects/effects.h
index 66fc8c44..2e49eb00 100644
--- a/al/effects/effects.h
+++ b/al/effects/effects.h
@@ -64,7 +64,8 @@ extern const EffectProps FshifterEffectProps;
 extern const EffectProps ModulatorEffectProps;
 extern const EffectProps PshifterEffectProps;
 extern const EffectProps VmorpherEffectProps;
-extern const EffectProps DedicatedEffectProps;
+extern const EffectProps DedicatedDialogEffectProps;
+extern const EffectProps DedicatedLfeEffectProps;
 extern const EffectProps ConvolutionEffectProps;
 
 /* Vtables to get/set properties for the given effect types. */
@@ -82,7 +83,8 @@ extern const EffectVtable FshifterEffectVtable;
 extern const EffectVtable ModulatorEffectVtable;
 extern const EffectVtable PshifterEffectVtable;
 extern const EffectVtable VmorpherEffectVtable;
-extern const EffectVtable DedicatedEffectVtable;
+extern const EffectVtable DedicatedDialogEffectVtable;
+extern const EffectVtable DedicatedLfeEffectVtable;
 extern const EffectVtable ConvolutionEffectVtable;
 
 #endif /* AL_EFFECTS_EFFECTS_H */
diff --git a/alc/effects/base.h b/alc/effects/base.h
index 025ac663..9bbbfc71 100644
--- a/alc/effects/base.h
+++ b/alc/effects/base.h
@@ -25,7 +25,8 @@ EffectStateFactory *ModulatorStateFactory_getFactory();
 EffectStateFactory *PshifterStateFactory_getFactory();
 EffectStateFactory* VmorpherStateFactory_getFactory();
 
-EffectStateFactory *DedicatedStateFactory_getFactory();
+EffectStateFactory *DedicatedDialogStateFactory_getFactory();
+EffectStateFactory *DedicatedLfeStateFactory_getFactory();
 
 EffectStateFactory *ConvolutionStateFactory_getFactory();
 
diff --git a/alc/effects/dedicated.cpp b/alc/effects/dedicated.cpp
index a3d4298d..1629aaea 100644
--- a/alc/effects/dedicated.cpp
+++ b/alc/effects/dedicated.cpp
@@ -42,7 +42,7 @@ namespace {
 
 using uint = unsigned int;
 
-struct DedicatedState final : public EffectState {
+struct DedicatedState : public EffectState {
     /* The "dedicated" effect can output to the real output, so should have
      * gains for all possible output channels and not just the main ambisonic
      * buffer.
@@ -51,11 +51,16 @@ struct DedicatedState final : public EffectState {
     std::array<float,MaxOutputChannels> mTargetGains{};
 
 
-    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) override;
+    void deviceUpdate(const DeviceBase *device, const BufferStorage *buffer) final;
     void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
         const EffectTarget target) override;
     void process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn,
-        const al::span<FloatBufferLine> samplesOut) override;
+        const al::span<FloatBufferLine> samplesOut) final;
+};
+
+struct DedicatedLfeState final : public DedicatedState {
+    void update(const ContextBase *context, const EffectSlot *slot, const EffectProps *props,
+        const EffectTarget target) final;
 };
 
 void DedicatedState::deviceUpdate(const DeviceBase*, const BufferStorage*)
@@ -68,35 +73,39 @@ void DedicatedState::update(const ContextBase*, const EffectSlot *slot,
 {
     std::fill(mTargetGains.begin(), mTargetGains.end(), 0.0f);
 
-    const float Gain{slot->Gain * props->Dedicated.Gain};
+    const float Gain{slot->Gain * props->DedicatedDialog.Gain};
 
-    if(slot->EffectType == EffectSlotType::DedicatedLFE)
+    /* Dialog goes to the front-center speaker if it exists, otherwise it plays
+     * from the front-center location.
+     */
+    const size_t idx{target.RealOut ? target.RealOut->ChannelIndex[FrontCenter]
+        : InvalidChannelIndex};
+    if(idx != InvalidChannelIndex)
     {
-        const size_t idx{target.RealOut ? target.RealOut->ChannelIndex[LFE] : InvalidChannelIndex};
-        if(idx != InvalidChannelIndex)
-        {
-            mOutTarget = target.RealOut->Buffer;
-            mTargetGains[idx] = Gain;
-        }
+        mOutTarget = target.RealOut->Buffer;
+        mTargetGains[idx] = Gain;
     }
-    else if(slot->EffectType == EffectSlotType::DedicatedDialog)
+    else
     {
-        /* Dialog goes to the front-center speaker if it exists, otherwise it
-         * plays from the front-center location. */
-        const size_t idx{target.RealOut ? target.RealOut->ChannelIndex[FrontCenter]
-            : InvalidChannelIndex};
-        if(idx != InvalidChannelIndex)
-        {
-            mOutTarget = target.RealOut->Buffer;
-            mTargetGains[idx] = Gain;
-        }
-        else
-        {
-            static constexpr auto coeffs = CalcDirectionCoeffs(std::array{0.0f, 0.0f, -1.0f});
-
-            mOutTarget = target.Main->Buffer;
-            ComputePanGains(target.Main, coeffs, Gain, mTargetGains);
-        }
+        static constexpr auto coeffs = CalcDirectionCoeffs(std::array{0.0f, 0.0f, -1.0f});
+
+        mOutTarget = target.Main->Buffer;
+        ComputePanGains(target.Main, coeffs, Gain, mTargetGains);
+    }
+}
+
+void DedicatedLfeState::update(const ContextBase*, const EffectSlot *slot,
+    const EffectProps *props, const EffectTarget target)
+{
+    std::fill(mTargetGains.begin(), mTargetGains.end(), 0.0f);
+
+    const float Gain{slot->Gain * props->DedicatedLfe.Gain};
+
+    const size_t idx{target.RealOut ? target.RealOut->ChannelIndex[LFE] : InvalidChannelIndex};
+    if(idx != InvalidChannelIndex)
+    {
+        mOutTarget = target.RealOut->Buffer;
+        mTargetGains[idx] = Gain;
     }
 }
 
@@ -107,15 +116,26 @@ void DedicatedState::process(const size_t samplesToDo, const al::span<const Floa
 }
 
 
-struct DedicatedStateFactory final : public EffectStateFactory {
+struct DedicatedDialogStateFactory final : public EffectStateFactory {
     al::intrusive_ptr<EffectState> create() override
     { return al::intrusive_ptr<EffectState>{new DedicatedState{}}; }
 };
 
+struct DedicatedLfeStateFactory final : public EffectStateFactory {
+    al::intrusive_ptr<EffectState> create() override
+    { return al::intrusive_ptr<EffectState>{new DedicatedLfeState{}}; }
+};
+
 } // namespace
 
-EffectStateFactory *DedicatedStateFactory_getFactory()
+EffectStateFactory *DedicatedDialogStateFactory_getFactory()
+{
+    static DedicatedDialogStateFactory DedicatedFactory{};
+    return &DedicatedFactory;
+}
+
+EffectStateFactory *DedicatedLfeStateFactory_getFactory()
 {
-    static DedicatedStateFactory DedicatedFactory{};
+    static DedicatedLfeStateFactory DedicatedFactory{};
     return &DedicatedFactory;
 }
diff --git a/core/effects/base.h b/core/effects/base.h
index 672d3f04..66182bf5 100644
--- a/core/effects/base.h
+++ b/core/effects/base.h
@@ -171,7 +171,11 @@ struct VmorpherProps {
     VMorpherWaveform Waveform;
 };
 
-struct DedicatedProps {
+struct DedicatedDialogProps {
+    float Gain;
+};
+
+struct DedicatedLfeProps {
     float Gain;
 };
 
@@ -193,7 +197,8 @@ union EffectProps {
     ModulatorProps Modulator;
     PshifterProps Pshifter;
     VmorpherProps Vmorpher;
-    DedicatedProps Dedicated;
+    DedicatedDialogProps DedicatedDialog;
+    DedicatedLfeProps DedicatedLfe;
     ConvolutionProps Convolution;
 };