public void TestTally()
{
AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.FairlightMain, helper =>
{
IBMDSwitcherFairlightAudioMixer mixer = GetFairlightMixer(helper);
AtemState stateBefore = helper.Helper.BuildLibState();
for (int i = 0; i < 5; i++)
{
var cmd = new FairlightMixerTallyCommand
{
Tally = new Dictionary <Tuple <AudioSource, long>, bool>()
};
Assert.NotEmpty(stateBefore.Fairlight.Tally);
// the sdk is a bit picky about ids, so best to go with what it expects
foreach (KeyValuePair <Tuple <AudioSource, long>, bool> k in stateBefore.Fairlight.Tally)
{
bool isMixedIn = Randomiser.Range(0, 1) > 0.7;
cmd.Tally[k.Key] = isMixedIn;
}
stateBefore.Fairlight.Tally = cmd.Tally;
helper.SendAndWaitForChange(stateBefore, () => { helper.Server.SendCommands(cmd); });
}
});
}
private static IBMDSwitcherFairlightAudioEqualizer GetEqualizer(AtemMockServerWrapper helper)
{
IBMDSwitcherFairlightAudioMixer mixer = TestFairlightProgramOut.GetFairlightMixer(helper);
var equalizer = AtemSDKConverter.CastSdk <IBMDSwitcherFairlightAudioEqualizer>(mixer.GetMasterOutEffect);
Assert.NotNull(equalizer);
return(equalizer);
}
public void TestDynamicsLevelsAndPeaks()
{
AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.FairlightMain, helper =>
{
IBMDSwitcherFairlightAudioMixer mixer = GetFairlightMixer(helper);
var cb = new DynamicsLevelCallback();
var dynamics = AtemSDKConverter.CastSdk <IBMDSwitcherFairlightAudioDynamicsProcessor>(mixer.GetMasterOutEffect);
using (new UseCallback <DynamicsLevelCallback>(cb, dynamics.AddCallback, dynamics.RemoveCallback))
{
for (int i = 0; i < 5; i++)
{
cb.Reset();
AtemState expectedState = helper.Helper.BuildLibState();
FairlightAudioState.ProgramOutState pgmOutState = expectedState.Fairlight.ProgramOut;
var testCmd = new FairlightMixerMasterLevelsCommand
{
InputLeftLevel = Randomiser.Range(-100, 0),
InputRightLevel = Randomiser.Range(-100, 0),
InputLeftPeak = Randomiser.Range(-100, 0),
InputRightPeak = Randomiser.Range(-100, 0),
OutputLeftLevel = Randomiser.Range(-100, 0),
OutputRightLevel = Randomiser.Range(-100, 0),
OutputLeftPeak = Randomiser.Range(-100, 0),
OutputRightPeak = Randomiser.Range(-100, 0),
};
expectedState.Fairlight.ProgramOut.Levels = new FairlightAudioState.LevelsState
{
Levels = new double[2],
Peaks = new double[2],
DynamicsInputLevels = new[] { testCmd.InputLeftLevel, testCmd.InputRightLevel },
DynamicsInputPeaks = new[] { testCmd.InputLeftPeak, testCmd.InputRightPeak },
DynamicsOutputLevels = new[] { testCmd.OutputLeftLevel, testCmd.OutputRightLevel },
DynamicsOutputPeaks = new[] { testCmd.OutputLeftPeak, testCmd.OutputRightPeak },
};
helper.SendAndWaitForChange(expectedState, () =>
{
helper.Server.SendCommands(testCmd);
}, -1, (sdkState, libState) =>
{
sdkState.Fairlight.ProgramOut.Levels = new FairlightAudioState.LevelsState
{
Levels = new double[2],
Peaks = new double[2],
DynamicsInputLevels = cb.InputLevels,
DynamicsInputPeaks = cb.InputPeaks,
DynamicsOutputLevels = cb.OutputLevels,
DynamicsOutputPeaks = cb.OutputPeaks,
};
});
}
}
});
}
public static IBMDSwitcherFairlightAudioInput GetInput(AtemMockServerWrapper helper, long targetId)
{
IBMDSwitcherFairlightAudioMixer mixer = TestFairlightProgramOut.GetFairlightMixer(helper);
var iterator = AtemSDKConverter.CastSdk <IBMDSwitcherFairlightAudioInputIterator>(mixer.CreateIterator);
iterator.GetById(targetId, out IBMDSwitcherFairlightAudioInput input);
Assert.NotNull(input);
return(input);
}
public static IBMDSwitcherFairlightAudioHeadphoneOutput GetMonitor(AtemMockServerWrapper helper)
{
IBMDSwitcherFairlightAudioMixer mixer = TestFairlightProgramOut.GetFairlightMixer(helper);
var iterator = AtemSDKConverter.CastSdk <IBMDSwitcherFairlightAudioHeadphoneOutputIterator>(mixer.CreateIterator);
var monitors = AtemSDKConverter.IterateList <IBMDSwitcherFairlightAudioHeadphoneOutput, IBMDSwitcherFairlightAudioHeadphoneOutput>(iterator.Next, (s, i) => s);
return(monitors.SingleOrDefault());
}
public FairlightAudioMixer(IBMDSwitcherFairlightAudioMixer mixer, IMediator mediator)
{
_mixer = mixer;
_mediator = mediator;
Init();
_callback = new FairlightAudioMixerCallback(_mediator);
_mixer.AddCallback(_callback);
_hasCallback = true;
}
public static FairlightAudioState Build(IBMDSwitcherFairlightAudioMixer props)
{
var state = new FairlightAudioState();
props.GetMasterOutFaderGain(out double faderGain);
state.ProgramOut.Gain = faderGain;
props.GetMasterOutFollowFadeToBlack(out int followFTB);
state.ProgramOut.FollowFadeToBlack = followFTB != 0;
props.GetAudioFollowVideoCrossfadeTransition(out int followTransition);
state.ProgramOut.AudioFollowVideoCrossfadeTransitionEnabled = followTransition != 0;
// Effects
var dynamics = AtemSDKConverter.CastSdk <IBMDSwitcherFairlightAudioDynamicsProcessor>(props.GetMasterOutEffect);
dynamics.GetMakeupGain(out double makeupGain);
state.ProgramOut.Dynamics.MakeUpGain = makeupGain;
var compressor = AtemSDKConverter.CastSdk <IBMDSwitcherFairlightAudioCompressor>(dynamics.GetProcessor);
FairlightAudioBuilderCommon.ApplyCompressor(compressor, state.ProgramOut.Dynamics.Compressor = new FairlightAudioState.CompressorState());
var limiter = AtemSDKConverter.CastSdk <IBMDSwitcherFairlightAudioLimiter>(dynamics.GetProcessor);
FairlightAudioBuilderCommon.ApplyLimiter(limiter, state.ProgramOut.Dynamics.Limiter = new FairlightAudioState.LimiterState());
// MasterOut appears to never have an expander
//var expander = AtemSDKConverter.CastSdk<IBMDSwitcherFairlightAudioExpander>(dynamics.GetProcessor);
//FairlightAudioBuilderCommon.ApplyExpander(expander, state.ProgramOut.Dynamics.Expander = new FairlightAudioState.ExpanderState());
// Equalizer
var equalizer = AtemSDKConverter.CastSdk <IBMDSwitcherFairlightAudioEqualizer>(props.GetMasterOutEffect);
FairlightAudioBuilderCommon.ApplyEqualizer(equalizer, state.ProgramOut.Equalizer);
// Inputs
state.Tally = new Dictionary <Tuple <AudioSource, long>, bool>();
var iterator = AtemSDKConverter.CastSdk <IBMDSwitcherFairlightAudioInputIterator>(props.CreateIterator);
for (iterator.Next(out IBMDSwitcherFairlightAudioInput input); input != null; iterator.Next(out input))
{
input.GetId(out long id);
state.Inputs[id] = FairlightAudioInputStateBuilder.Build(input, (AudioSource)id, state.Tally);
}
var monIter = AtemSDKConverter.CastSdk <IBMDSwitcherFairlightAudioHeadphoneOutputIterator>(props.CreateIterator);
state.Monitors = AtemSDKConverter.IterateList <IBMDSwitcherFairlightAudioHeadphoneOutput, FairlightAudioState.MonitorOutputState>(monIter.Next, (mon, id) => BuildMonitor(mon));
return(state);
}
public void TestAudioFollowVideoCrossfadeTransitionEnabled()
{
var handler = CommandGenerator.CreateAutoCommandHandler <FairlightMixerMasterPropertiesSetCommand, FairlightMixerMasterPropertiesGetCommand>("AudioFollowVideoCrossfadeTransitionEnabled");
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.FairlightMain, helper =>
{
IBMDSwitcherFairlightAudioMixer mixer = GetFairlightMixer(helper);
AtemState stateBefore = helper.Helper.BuildLibState();
for (int i = 0; i < 5; i++)
{
stateBefore.Fairlight.ProgramOut.AudioFollowVideoCrossfadeTransitionEnabled = i % 2 > 0;
helper.SendAndWaitForChange(stateBefore,
() => { mixer.SetAudioFollowVideoCrossfadeTransition(i % 2); });
}
});
}
public void TestFollowFadeToBlack()
{
var handler = CommandGenerator.CreateAutoCommandHandler <FairlightMixerMasterSetCommand, FairlightMixerMasterGetCommand>("FollowFadeToBlack");
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.FairlightMain, helper =>
{
IBMDSwitcherFairlightAudioMixer mixer = GetFairlightMixer(helper);
AtemState stateBefore = helper.Helper.BuildLibState();
for (int i = 0; i < 5; i++)
{
stateBefore.Fairlight.ProgramOut.FollowFadeToBlack = i % 2 > 0;
helper.SendAndWaitForChange(stateBefore, () =>
{
mixer.SetMasterOutFollowFadeToBlack(i % 2);
});
}
});
}
public void TestResetAllPeaks()
{
var expected = new FairlightMixerResetPeakLevelsCommand {
All = true
};
var handler = CommandGenerator.MatchCommand(expected);
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.FairlightMain, helper =>
{
IBMDSwitcherFairlightAudioMixer mixer = GetFairlightMixer(helper);
AtemState stateBefore = helper.Helper.BuildLibState();
uint timeBefore = helper.Server.CurrentTime;
helper.SendAndWaitForChange(stateBefore, () => { mixer.ResetAllPeakLevels(); });
// It should have sent a response, but we dont expect any comparable data
Assert.NotEqual(timeBefore, helper.Server.CurrentTime);
});
}
public void TestGain()
{
var handler = CommandGenerator.CreateAutoCommandHandler <FairlightMixerMasterSetCommand, FairlightMixerMasterGetCommand>("Gain");
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.FairlightMain, helper =>
{
IBMDSwitcherFairlightAudioMixer mixer = GetFairlightMixer(helper);
AtemState stateBefore = helper.Helper.BuildLibState();
for (int i = 0; i < 5; i++)
{
double target = Randomiser.Range();
stateBefore.Fairlight.ProgramOut.Gain = target;
helper.SendAndWaitForChange(stateBefore, () =>
{
mixer.SetMasterOutFaderGain(target);
});
}
});
}
public void TestSendLevelsCommand()
{
var expected = new FairlightMixerSendLevelsCommand();
var handler = CommandGenerator.MatchCommand(expected);
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.FairlightMain, helper =>
{
IBMDSwitcherFairlightAudioMixer mixer = GetFairlightMixer(helper);
AtemState stateBefore = helper.Helper.BuildLibState();
for (int i = 0; i < 5; i++)
{
uint timeBefore = helper.Server.CurrentTime;
expected.SendLevels = i % 2 == 1;
helper.SendAndWaitForChange(stateBefore, () => { mixer.SetAllLevelNotificationsEnabled(i % 2); });
// It should have sent a response, but we dont expect any comparable data
Assert.NotEqual(timeBefore, helper.Server.CurrentTime);
}
});
}
public static IEnumerable <IBMDSwitcherFairlightAudioInput> GetFairlightAudioMixerInputs(this IBMDSwitcherFairlightAudioMixer o)
{
var result = new List <IBMDSwitcherFairlightAudioInput>();
if (o == null)
{
return(result);
}
Guid g = typeof(IBMDSwitcherFairlightAudioInputIterator).GUID;
o.CreateIterator(ref g, out IntPtr ptr);
var iterator = (IBMDSwitcherFairlightAudioInputIterator)Marshal.GetObjectForIUnknown(ptr);
iterator.Next(out IBMDSwitcherFairlightAudioInput input);
while (input != null)
{
result.Add(input);
iterator.Next(out input);
}
return(result);
}
public void TestDynamicsGainReduction()
{
AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.FairlightMain, helper =>
{
IBMDSwitcherFairlightAudioMixer mixer = GetFairlightMixer(helper);
var cbCompressor = new DynamicEffectsLevelCallback();
var cbLimiter = new DynamicEffectsLevelCallback();
var dynamics = AtemSDKConverter.CastSdk <IBMDSwitcherFairlightAudioDynamicsProcessor>(mixer.GetMasterOutEffect);
var limiter = AtemSDKConverter.CastSdk <IBMDSwitcherFairlightAudioLimiter>(dynamics.GetProcessor);
var compressor = AtemSDKConverter.CastSdk <IBMDSwitcherFairlightAudioCompressor>(dynamics.GetProcessor);
using (new UseCallback <DynamicEffectsLevelCallback>(cbCompressor, compressor.AddCallback, compressor.RemoveCallback))
using (new UseCallback <DynamicEffectsLevelCallback>(cbLimiter, limiter.AddCallback, limiter.RemoveCallback))
{
for (int i = 0; i < 5; i++)
{
cbCompressor.Reset();
cbLimiter.Reset();
AtemState expectedState = helper.Helper.BuildLibState();
var testCmd = new FairlightMixerMasterLevelsCommand
{
CompressorGainReduction = Randomiser.Range(-100, 0),
LimiterGainReduction = Randomiser.Range(-100, 0)
};
expectedState.Fairlight.ProgramOut.Levels = new FairlightAudioState.LevelsState
{
Levels = new double[2],
Peaks = new double[2],
DynamicsInputLevels = new double[2],
DynamicsInputPeaks = new double[2],
DynamicsOutputLevels = new double[2],
DynamicsOutputPeaks = new double[2],
CompressorGainReductionLevel = testCmd.CompressorGainReduction,
LimiterGainReductionLevel = testCmd.LimiterGainReduction
};
helper.SendAndWaitForChange(expectedState, () =>
{
helper.Server.SendCommands(testCmd);
}, -1, (sdkState, libState) =>
{
sdkState.Fairlight.ProgramOut.Levels = new FairlightAudioState.LevelsState
{
Levels = new double[2],
Peaks = new double[2],
DynamicsInputLevels = new double[2],
DynamicsInputPeaks = new double[2],
DynamicsOutputLevels = new double[2],
DynamicsOutputPeaks = new double[2],
CompressorGainReductionLevel = cbCompressor.GainReduction.Single(),
LimiterGainReductionLevel = cbLimiter.GainReduction.Single()
};
});
}
}
});
}
