public void TestJog() { var expectedCmd = new HyperDeckPlayerSetCommand { Mask = HyperDeckPlayerSetCommand.MaskFlags.Jog, }; var handler = CommandGenerator.MatchCommand(expectedCmd, true); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.HyperDecks, helper => { foreach (IBMDSwitcherHyperDeck deck in GetHyperDecks(helper)) { deck.GetId(out long id); expectedCmd.Id = (uint)id; expectedCmd.Jog = Randomiser.RangeInt(-100, 100); AtemState stateBefore = helper.Helper.BuildLibState(); helper.SendAndWaitForChange(stateBefore, () => { deck.Jog(expectedCmd.Jog); }); } }); }
public void TestGetSelection() { bool tested = false; AtemMockServerWrapper.Each(Output, Pool, null, DeviceTestCases.All, helper => { EachMixEffect <IBMDSwitcherTransitionParameters>(helper, (stateBefore, meBefore, sdk, meId, i) => { tested = true; uint maxSelectionValue = (uint)1 << meBefore.Keyers.Count; uint maxSelection = (maxSelectionValue << 1) - 1; uint target = 1 + Randomiser.RangeInt(maxSelection - 1); meBefore.Transition.Properties.Selection = (TransitionLayer)target; helper.SendAndWaitForChange(stateBefore, () => { helper.Server.SendCommands(new TransitionPropertiesGetCommand { Index = meId, NextStyle = meBefore.Transition.Properties.NextStyle, Style = meBefore.Transition.Properties.Style, NextSelection = meBefore.Transition.Properties.NextSelection, Selection = (TransitionLayer)target, }); }); }); }); Assert.True(tested); }
public void TestAutoRollFrameDelay() { var handler = CommandGenerator.CreateAutoCommandHandler <HyperDeckSettingsSetCommand, HyperDeckSettingsGetCommand>( "AutoRollFrameDelay"); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.HyperDecks, helper => { foreach (IBMDSwitcherHyperDeck deck in GetHyperDecks(helper)) { for (int i = 0; i < 5; i++) { deck.GetId(out long id); AtemState stateBefore = helper.Helper.BuildLibState(); HyperdeckState hyperdeckState = stateBefore.Hyperdecks[(int)id]; hyperdeckState.Settings.AutoRollFrameDelay = Randomiser.RangeInt(60); helper.SendAndWaitForChange(stateBefore, () => { deck.SetAutoRollOnTakeFrameDelay((ushort)hyperdeckState.Settings.AutoRollFrameDelay); }); } } }); }
public void TestDiskRemoval() { var handler = CommandGenerator.CreateAutoCommandHandler <RecordingStatusSetCommand, RecordingStatusGetCommand>("IsRecording", true); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.Streaming, helper => { var switcher = helper.SdkClient.SdkSwitcher as IBMDSwitcherStreamRTMP; Assert.NotNull(switcher); AtemState stateBefore = helper.Helper.BuildLibState(); // Init a disk that will persit InitDisk(helper, stateBefore, 99); for (int i = 0; i < 10; i++) { var id = Randomiser.RangeInt(20); var cmd = InitDisk(helper, stateBefore, id); // Simulate removal cmd.IsDelete = true; stateBefore.Recording.Disks.Remove(id); helper.SendFromServerAndWaitForChange(stateBefore, cmd); } }); }
public void TestStorageMediaCount() { AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.HyperDecks, helper => { List <HyperDeckSettingsGetCommand> settingsCommands = helper.Server.GetParsedDataDump().OfType <HyperDeckSettingsGetCommand>().ToList(); foreach (IBMDSwitcherHyperDeck deck in GetHyperDecks(helper)) { deck.GetId(out long id); HyperDeckSettingsGetCommand cmd = settingsCommands.Single(c => c.Id == id); // Force it to be connected AtemState stateBefore = helper.Helper.BuildLibState(); cmd.Status = HyperDeckConnectionStatus.Connected; stateBefore.Hyperdecks[(int)id].Settings.Status = HyperDeckConnectionStatus.Connected; stateBefore.Hyperdecks[(int)id].Player.State = HyperDeckPlayerState.Idle; helper.SendFromServerAndWaitForChange(stateBefore, cmd); stateBefore = helper.Helper.BuildLibState(); HyperdeckState hyperdeckState = stateBefore.Hyperdecks[(int)id]; for (int i = 0; i < 5; i++) { hyperdeckState.Settings.StorageMediaCount = cmd.StorageMediaCount = (uint)Randomiser.RangeInt(1, 5); helper.SendFromServerAndWaitForChange(stateBefore, cmd); } } }); }
public void TestAudioInputId() { var handler = CommandGenerator.CreateAutoCommandHandler <MixMinusOutputSetCommand, MixMinusOutputGetCommand>("Mode"); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.MixMinusOutputs, helper => { var previousCommands = helper.Server.GetParsedDataDump().OfType <MixMinusOutputGetCommand>().ToList(); for (int i = 0; i < 10; i++) { AtemState stateBefore = helper.Helper.BuildLibState(); uint id = Randomiser.RangeInt((uint)stateBefore.Settings.MixMinusOutputs.Count - 1); SettingsState.MixMinusOutputState mixMinusState = stateBefore.Settings.MixMinusOutputs[(int)id]; MixMinusOutputGetCommand cmd = previousCommands.Single(c => c.Id == id); uint newValue = Randomiser.RangeInt(9) + 1; cmd.HasAudioInputId = i % 2 == 0; cmd.AudioInputId = cmd.HasAudioInputId ? (AudioSource)newValue : 0; mixMinusState.HasAudioInputId = cmd.HasAudioInputId; mixMinusState.AudioInputId = cmd.AudioInputId; helper.SendFromServerAndWaitForChange(stateBefore, cmd); } }); }
public void TestIsRunning() { bool tested = false; AtemMockServerWrapper.Each(Output, Pool, null, DeviceTestCases.All, helper => { SelectionOfKeyers <IBMDSwitcherKeyFlyParameters>(helper, (stateBefore, keyerBefore, sdkKeyer, meId, keyId, i) => { tested = true; var cmd = helper.Server.GetParsedDataDump().OfType <MixEffectKeyFlyPropertiesGetCommand>() .Single(c => c.MixEffectIndex == meId && c.KeyerIndex == keyId); for (int o = 0; o < 5; o++) { var targetFrame = Randomiser.RangeInt(10) > 7 ? FlyKeyKeyFrameType.RunToInfinite : Randomiser.EnumValue <FlyKeyKeyFrameType>(); var targetInfinite = Randomiser.EnumValue <FlyKeyLocation>(); keyerBefore.FlyProperties.RunningToKeyFrame = cmd.RunningToKeyFrame = targetFrame; keyerBefore.FlyProperties.RunningToInfinite = cmd.RunningToInfinite = targetFrame == FlyKeyKeyFrameType.RunToInfinite ? targetInfinite : 0; helper.SendFromServerAndWaitForChange(stateBefore, cmd); } }); }); Assert.True(tested); }
public void TestShuttle() { var expectedCmd = new HyperDeckPlayerSetCommand { Mask = HyperDeckPlayerSetCommand.MaskFlags.State | HyperDeckPlayerSetCommand.MaskFlags.PlaybackSpeed, State = HyperDeckPlayerState.Playing, }; var handler = CommandGenerator.MatchCommand(expectedCmd, true); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.HyperDecks, helper => { AtemState stateBefore = helper.Helper.BuildLibState(); foreach (IBMDSwitcherHyperDeck deck in GetHyperDecks(helper)) { deck.GetId(out long id); expectedCmd.Id = (uint)id; for (int i = 0; i < 5; i++) { expectedCmd.PlaybackSpeed = Randomiser.RangeInt(-100, 200); helper.SendAndWaitForChange(stateBefore, () => { deck.Shuttle(expectedCmd.PlaybackSpeed); }); } } }); }
public void TestDuration() { AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.Streaming, helper => { var switcher = helper.SdkClient.SdkSwitcher as IBMDSwitcherStreamRTMP; Assert.NotNull(switcher); AtemState stateBefore = helper.Helper.BuildLibState(); for (int i = 0; i < 5; i++) { var durationCommand = new StreamingDurationCommand { Hour = Randomiser.RangeInt(23), Minute = Randomiser.RangeInt(59), Second = Randomiser.RangeInt(59), Frame = Randomiser.RangeInt(59), IsDropFrame = i % 2 != 0 }; stateBefore.Streaming.Status.Duration = new Timecode { Hour = durationCommand.Hour, Minute = durationCommand.Minute, Second = durationCommand.Second, Frame = durationCommand.Frame, DropFrame = durationCommand.IsDropFrame, }; helper.SendFromServerAndWaitForChange(stateBefore, durationCommand); } }); }
public void TestRecordStatus() { AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.All, helper => { var control = helper.SdkClient.SdkSwitcher as IBMDSwitcherMacroControl; Assert.NotNull(control); AtemState stateBefore = helper.Helper.BuildLibState(); for (int i = 0; i < 5; i++) { uint index = Randomiser.RangeInt((uint)stateBefore.Macros.Pool.Count); bool recording = Randomiser.RangeInt(1) == 1; stateBefore.Macros.RecordStatus.RecordIndex = index; stateBefore.Macros.RecordStatus.IsRecording = recording; helper.SendAndWaitForChange(stateBefore, () => { helper.Server.SendCommands(new MacroRecordingStatusGetCommand() { Index = index, IsRecording = recording, }); }); } }); }
public void TestClipFrame() { try { _pool.StateSettings.TrackMediaClipFrames = true; var handler = CommandGenerator.CreateAutoCommandHandler <MediaPlayerClipStatusSetCommand, MediaPlayerClipStatusGetCommand>("ClipFrame"); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.MediaPlayerClips, helper => { var tested = false; var players = GetMediaPlayers(helper); foreach (Tuple <uint, IBMDSwitcherMediaPlayer> player in players) { tested = true; AtemState stateBefore = helper.Helper.BuildLibState(); MediaPlayerState playerState = stateBefore.MediaPlayers[(int)player.Item1]; for (int i = 0; i < 5; i++) { uint frame = playerState.ClipStatus.ClipFrame = Randomiser.RangeInt(40); helper.SendAndWaitForChange(stateBefore, () => { player.Item2.SetClipFrame(frame); }); } } Assert.True(tested); }); } finally { _pool.StateSettings.TrackMediaClipFrames = false; } }
public void TestSource() { AtemMockServerWrapper.Each(_output, _pool, SourceCommandHandler, DeviceTestCases.MediaPlayer, helper => { var tested = false; var players = GetMediaPlayers(helper); foreach (Tuple <uint, IBMDSwitcherMediaPlayer> player in players) { tested = true; AtemState stateBefore = helper.Helper.BuildLibState(); MediaPlayerState playerState = stateBefore.MediaPlayers[(int)player.Item1]; for (int i = 0; i < 5; i++) { MediaPlayerSource type = playerState.Source.SourceType = stateBefore.MediaPool.Clips.Count > 0 ? Randomiser.EnumValue <MediaPlayerSource>() : MediaPlayerSource.Still; uint index = playerState.Source.SourceIndex = Randomiser.RangeInt(20) + 1; helper.SendAndWaitForChange(stateBefore, () => { player.Item2.SetSource(AtemEnumMaps.MediaPlayerSourceMap[type], index); }); } } Assert.True(tested); }); }
public void TestSetInvalid() { AtemMockServerWrapper.Each(_output, _pool, ClearCommandHandler, DeviceTestCases.MediaPlayer, helper => { IBMDSwitcherStills stills = GetStillsPool(helper); ImmutableList <ICommand> previousCommands = helper.Server.GetParsedDataDump(); for (int i = 0; i < 5; i++) { AtemState stateBefore = helper.Helper.BuildLibState(); uint index = Randomiser.RangeInt((uint)stateBefore.MediaPool.Stills.Count); MediaPoolFrameDescriptionCommand cmd = previousCommands.OfType <MediaPoolFrameDescriptionCommand>().Single(c => c.Index == index && c.Bank == MediaPoolFileType.Still); cmd.IsUsed = true; // Set it to true first stateBefore.MediaPool.Stills[(int)index].IsUsed = true; helper.SendFromServerAndWaitForChange(stateBefore, cmd); // Now set invalid stateBefore.MediaPool.Stills[(int)index].IsUsed = false; stateBefore.MediaPool.Stills[(int)index].Filename = ""; stateBefore.MediaPool.Stills[(int)index].Hash = new byte[16]; helper.SendAndWaitForChange(stateBefore, () => { stills.SetInvalid(index); }); } }); }
public void TestClipSetValid() { AtemMockServerWrapper.Each(_output, _pool, SetValidCommandHandler, DeviceTestCases.MediaPlayerClips, helper => { for (int i = 0; i < 3; i++) { AtemState stateBefore = helper.Helper.BuildLibState(); uint index = Randomiser.RangeInt((uint)stateBefore.MediaPool.Clips.Count); IBMDSwitcherClip clip = GetClip(helper, index); string name = Guid.NewGuid().ToString(); uint frameCount = Randomiser.RangeInt(5) + 3; var cb = new LockCallback(); helper.SendAndWaitForChange(stateBefore, () => { clip.Lock(cb); }); Assert.True(cb.Wait.WaitOne(2000)); var clipState = stateBefore.MediaPool.Clips[(int)index]; clipState.IsUsed = true; clipState.Name = name; clipState.FrameCount = frameCount; helper.SendAndWaitForChange(stateBefore, () => { clip.SetValid(name, frameCount); }); helper.SendAndWaitForChange(stateBefore, () => { clip.Unlock(cb); }); } }); }
public void TestTransitionFramesRemaining() { bool tested = false; AtemMockServerWrapper.Each(Output, Pool, null, DeviceTestCases.All, helper => { EachMixEffect <IBMDSwitcherMixEffectBlock>(helper, (stateBefore, meBefore, sdk, meId, i) => { tested = true; uint target = Randomiser.RangeInt(250); meBefore.Transition.Position.RemainingFrames = target; helper.SendAndWaitForChange(stateBefore, () => { helper.Server.SendCommands(new TransitionPositionGetCommand { Index = meId, RemainingFrames = target, InTransition = meBefore.Transition.Position.InTransition, HandlePosition = meBefore.Transition.Position.HandlePosition }); }); }); }); Assert.True(tested); }
public void TestTally() { AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.All, helper => { List <VideoSource> inputIds = helper.Helper.BuildLibState().Settings.Inputs .Where(i => i.Value.Properties.InternalPortType == InternalPortType.External).Select(i => i.Key) .ToList(); TallyBySourceCommand tallyCmd = helper.Server.GetParsedDataDump().OfType <TallyBySourceCommand>().Single(); foreach (VideoSource id in Randomiser.SelectionOfGroup(inputIds)) { AtemState stateBefore = helper.Helper.BuildLibState(); InputState.TallyState tallyState = stateBefore.Settings.Inputs[id].Tally; for (int i = 0; i < 5; i++) { bool isProgram = tallyState.ProgramTally = Randomiser.RangeInt(10) > 5; bool isPreview = tallyState.PreviewTally = Randomiser.RangeInt(10) > 5; tallyCmd.Tally[id] = Tuple.Create(isProgram, isPreview); helper.SendFromServerAndWaitForChange(stateBefore, tallyCmd); } } }); }
public void TestCurrentClipId() { var handler = CommandGenerator.CreateAutoCommandHandler <HyperDeckStorageSetCommand, HyperDeckStorageGetCommand>( "CurrentClipId"); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.HyperDecks, helper => { foreach (IBMDSwitcherHyperDeck deck in GetHyperDecks(helper)) { deck.GetId(out long id); AtemState stateBefore = helper.Helper.BuildLibState(); HyperdeckState deckState = stateBefore.Hyperdecks[(int)id]; for (int i = 0; i < 5; i++) { deckState.Storage.CurrentClipId = Randomiser.RangeInt(-1, 3); helper.SendAndWaitForChange(stateBefore, () => { deck.SetCurrentClip(deckState.Storage.CurrentClipId); }); } } }); }
public void TestHasUnsupportedOps() { AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.MacroTransfer, helper => { var pool = helper.SdkClient.SdkSwitcher as IBMDSwitcherMacroPool; Assert.NotNull(pool); ImmutableList <ICommand> previousCommands = helper.Server.GetParsedDataDump(); for (int i = 0; i < 10; i++) { AtemState stateBefore = helper.Helper.BuildLibState(); uint index = Randomiser.RangeInt((uint)stateBefore.Macros.Pool.Count); MacroPropertiesGetCommand cmd = previousCommands.OfType <MacroPropertiesGetCommand>().Single(c => c.Index == index); cmd.HasUnsupportedOps = i % 2 == 0; stateBefore.Macros.Pool[(int)index].HasUnsupportedOps = cmd.HasUnsupportedOps; helper.SendAndWaitForChange(stateBefore, () => { helper.Server.SendCommands(cmd); }); } }); }
public void TestCacheUsed() { AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.Streaming, helper => { var switcher = helper.SdkClient.SdkSwitcher as IBMDSwitcherStreamRTMP; Assert.NotNull(switcher); AtemState stateBefore = helper.Helper.BuildLibState(); // Set streaming var streamCmd = new StreamingStatusGetCommand { Status = StreamingStatus.Streaming, Error = StreamingError.None }; stateBefore.Streaming.Status.State = StreamingStatus.Streaming; helper.SendFromServerAndWaitForChange(stateBefore, streamCmd); for (int i = 0; i < 5; i++) { var cmd = new StreamingStatsCommand { CacheUsed = (uint)Randomiser.RangeInt(0, 100) }; stateBefore.Streaming.Stats.CacheUsed = cmd.CacheUsed; helper.SendFromServerAndWaitForChange(stateBefore, cmd); } }); }
public void TestRunStatus() { AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.All, helper => { var control = helper.SdkClient.SdkSwitcher as IBMDSwitcherMacroControl; Assert.NotNull(control); AtemState stateBefore = helper.Helper.BuildLibState(); for (int i = 0; i < 5; i++) { uint index = Randomiser.RangeInt((uint)stateBefore.Macros.Pool.Count); var status = Randomiser.EnumValue <MacroState.MacroRunStatus>(); stateBefore.Macros.RunStatus.RunIndex = index; stateBefore.Macros.RunStatus.RunStatus = status; helper.SendAndWaitForChange(stateBefore, () => { helper.Server.SendCommands(new MacroRunStatusGetCommand { Index = index, IsWaiting = status == MacroState.MacroRunStatus.UserWait, IsRunning = status == MacroState.MacroRunStatus.Running, Loop = stateBefore.Macros.RunStatus.Loop, }); }); } }); }
public void TestPeriodicFlushInterval() { var handler = CommandGenerator.CreateAutoCommandHandler <CameraControlSettingsSetCommand, CameraControlSettingsGetCommand>("Interval", true); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.CameraControl, helper => { helper.Helper.StateSettings.IgnoreUnknownCameraControlProperties = true; IBMDSwitcherCameraControl camera = helper.SdkClient.SdkSwitcher as IBMDSwitcherCameraControl; Assert.NotNull(camera); for (int i = 0; i < 5; i++) { AtemState stateBefore = helper.Helper.BuildLibState(); uint interval = Randomiser.RangeInt(int.MaxValue); stateBefore.CameraControl.PeriodicFlushInterval = interval; helper.SendAndWaitForChange(stateBefore, () => { camera.SetPeriodicFlushInterval(interval); }); } }); }
public void TestRecordPause() { var expectedCommand = new MacroAddTimedPauseCommand(); var handler = CommandGenerator.MatchCommand(expectedCommand); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.All, helper => { var control = helper.SdkClient.SdkSwitcher as IBMDSwitcherMacroControl; Assert.NotNull(control); AtemState stateBefore = helper.Helper.BuildLibState(); for (int i = 0; i < 5; i++) { uint frames = Randomiser.RangeInt(2500); expectedCommand.Frames = frames; uint timeBefore = helper.Server.CurrentTime; helper.SendAndWaitForChange(stateBefore, () => { control.RecordPause(frames); }); // It should have sent a response, but we dont expect any comparable data Assert.NotEqual(timeBefore, helper.Server.CurrentTime); } }); }
public void TestRun() { var expectedCommand = RunThroughSerialize(new MacroActionCommand { Action = MacroActionCommand.MacroAction.Run }); var handler = CommandGenerator.MatchCommand(expectedCommand); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.All, helper => { var control = helper.SdkClient.SdkSwitcher as IBMDSwitcherMacroControl; Assert.NotNull(control); AtemState stateBefore = helper.Helper.BuildLibState(); for (int i = 0; i < 5; i++) { uint index = Randomiser.RangeInt((uint)stateBefore.Macros.Pool.Count); expectedCommand.Index = index; uint timeBefore = helper.Server.CurrentTime; helper.SendAndWaitForChange(stateBefore, () => { control.Run(index); }); // It should have sent a response, but we dont expect any comparable data Assert.NotEqual(timeBefore, helper.Server.CurrentTime); } }); }
public void TestAudioUpload() { UploadJobWorker worker = null; AtemMockServerWrapper.Each(_output, _pool, (a, b) => worker?.HandleCommand(a, b), DeviceTestCases.MediaPlayerClips, helper => { helper.DisposeSdkClient = true; var pidCmd = helper.Server.GetParsedDataDump().OfType <ProductIdentifierCommand>().Single(); IBMDSwitcherMediaPool pool = GetMediaPool(helper); for (int i = 0; i < 3; i++) { AtemState stateBefore = helper.Helper.BuildLibState(); uint index = Randomiser.RangeInt((uint)stateBefore.MediaPool.Clips.Count); IBMDSwitcherClip clip = GetClip(helper, index); uint sampleCount = 10000; string name = Guid.NewGuid().ToString(); worker = new UploadJobWorker(sampleCount * 4, _output, index + 1, 0, DataTransferUploadRequestCommand.TransferMode.Write2, false); var cb = new LockCallback(); helper.SendAndWaitForChange(stateBefore, () => { clip.Lock(cb); }); Assert.True(cb.Wait.WaitOne(2000)); byte[] bytes = MediaPoolUtil.RandomFrame(sampleCount); pool.CreateAudio((uint)bytes.Length, out IBMDSwitcherAudio frame); MediaPoolUtil.FillSdkAudio(frame, bytes); var clipState = stateBefore.MediaPool.Clips[(int)index]; clipState.Audio.IsUsed = true; clipState.Audio.Name = name; var uploadCb = new TransferCallback(); clip.AddCallback(uploadCb); clip.UploadAudio(name, frame); helper.HandleUntil(uploadCb.Wait, 5000); Assert.True(uploadCb.Wait.WaitOne(500)); Assert.Equal(_BMDSwitcherMediaPoolEventType.bmdSwitcherMediaPoolEventTypeTransferCompleted, uploadCb.Result); // TODO - this needs a better rule that can be properly exposed via the lib byte[] flippedBytes = pidCmd.Model >= ModelId.PS4K ? MediaPoolUtil.FlipAudio(bytes) : bytes; Assert.Equal(BitConverter.ToString(flippedBytes), BitConverter.ToString(worker.Buffer)); helper.SendAndWaitForChange(stateBefore, () => { clip.Unlock(cb); }); } }); }
private static byte[] RandomIP() { return(new[] { (byte)Randomiser.RangeInt(255), (byte)Randomiser.RangeInt(255), (byte)Randomiser.RangeInt(255), (byte)Randomiser.RangeInt(255), }); }
public void TestUpload() { UploadJobWorker worker = null; AtemMockServerWrapper.Each(_output, _pool, (a, b) => worker?.HandleCommand(a, b), DeviceTestCases.MacroTransfer, helper => { helper.DisposeSdkClient = true; var pool = helper.SdkClient.SdkSwitcher as IBMDSwitcherMacroPool; Assert.NotNull(pool); for (int i = 0; i < 5; i++) { AtemState stateBefore = helper.Helper.BuildLibState(); uint index = Randomiser.RangeInt((uint)stateBefore.Macros.Pool.Count); string name = Guid.NewGuid().ToString(); byte[] op = new CutTransitionMacroOp { Index = MixEffectBlockId.One }.ToByteArray(); byte[] fakeOp = { 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; byte[] combined = op.Concat(fakeOp).ToArray(); worker = new UploadJobWorker((uint)combined.Length, _output, 0xffff, index, DataTransferUploadRequestCommand.TransferMode.Write2 | DataTransferUploadRequestCommand.TransferMode.Clear2); // var cb = new TestMediaPoolStills.LockCallback(); // helper.SendAndWaitForChange(stateBefore, () => { .Lock(cb); }); // Assert.True(cb.Wait.WaitOne(2000)); pool.CreateMacro((uint)combined.Length, out IBMDSwitcherMacro macro); macro.GetBytes(out IntPtr buffer); Marshal.Copy(combined, 0, buffer, combined.Length); var uploadCb = new TransferCallback(); pool.AddCallback(uploadCb); pool.Upload(index, name, "not now", macro, out IBMDSwitcherTransferMacro transfer); MacroState.ItemState macroState = stateBefore.Macros.Pool[(int)index]; macroState.Name = name; macroState.Description = "not now"; macroState.HasUnsupportedOps = true; macroState.IsUsed = true; helper.HandleUntil(uploadCb.Wait, 1000); Assert.True(uploadCb.Wait.WaitOne(500)); Assert.Equal(_BMDSwitcherMacroPoolEventType.bmdSwitcherMacroPoolEventTypeTransferCompleted, uploadCb.Result); Assert.Equal(BitConverter.ToString(combined), BitConverter.ToString(worker.Buffer)); helper.Helper.CheckStateChanges(stateBefore); } }); }
private void DoUpload(int iterations, int timeout, Func <uint, uint, byte[]> frameBytes) { UploadJobWorker worker = null; AtemMockServerWrapper.Each(_output, _pool, (a, b) => worker?.HandleCommand(a, b), DeviceTestCases.MediaPlayer, helper => { helper.DisposeSdkClient = true; IBMDSwitcherMediaPool pool = GetMediaPool(helper); IBMDSwitcherStills stills = GetStillsPool(helper); for (int i = 0; i < iterations; i++) { AtemState stateBefore = helper.Helper.BuildLibState(); Tuple <uint, uint> resolution = stateBefore.Settings.VideoMode.GetResolution().GetSize(); uint index = Randomiser.RangeInt((uint)stateBefore.MediaPool.Stills.Count); string name = Guid.NewGuid().ToString(); worker = new UploadJobWorker(resolution.Item1 * resolution.Item2 * 4, _output, (uint)MediaPoolFileType.Still, index, DataTransferUploadRequestCommand.TransferMode.Write); var cb = new LockCallback(); helper.SendAndWaitForChange(stateBefore, () => { stills.Lock(cb); }); Assert.True(cb.Wait.WaitOne(2000)); pool.CreateFrame(_BMDSwitcherPixelFormat.bmdSwitcherPixelFormat10BitYUVA, resolution.Item1, resolution.Item2, out IBMDSwitcherFrame frame); byte[] bytes = frameBytes(resolution.Item1, resolution.Item2); if (bytes.Length > 0) { MediaPoolUtil.FillSdkFrame(frame, bytes); } var stillState = stateBefore.MediaPool.Stills[(int)index]; stillState.IsUsed = true; stillState.Filename = name; var uploadCb = new TransferCallback(); stills.AddCallback(uploadCb); stills.Upload(index, name, frame); helper.HandleUntil(uploadCb.Wait, timeout); Assert.True(uploadCb.Wait.WaitOne(500)); Assert.Equal(_BMDSwitcherMediaPoolEventType.bmdSwitcherMediaPoolEventTypeTransferCompleted, uploadCb.Result); Assert.Equal(BitConverter.ToString(bytes), BitConverter.ToString(worker.Buffer)); helper.SendAndWaitForChange(stateBefore, () => { stills.Unlock(cb); }); } }); }
private static void FillRandomData(CameraControlGetCommand cmd, params CameraControlDataType[] omitTypes) { cmd.Input = (VideoSource)(Randomiser.RangeInt(20) + 50); cmd.Category = Randomiser.RangeInt(10) + 20; cmd.Parameter = Randomiser.RangeInt(10) + 15; cmd.Type = Randomiser.EnumValue <CameraControlDataType>(omitTypes); switch (cmd.Type) { case CameraControlDataType.Bool: cmd.BoolData = Enumerable.Range(0, Randomiser.RangeInt(8, 8)) // TODO - higher has issues .Select(i => Randomiser.Range(0, 10) >= 5) .ToArray(); break; case CameraControlDataType.SInt8: cmd.IntData = Enumerable.Range(0, Randomiser.RangeInt(1, 8)) // TODO - higher has issues .Select(i => Randomiser.RangeInt(sbyte.MinValue, sbyte.MaxValue)) .ToArray(); break; case CameraControlDataType.SInt16: cmd.IntData = Enumerable.Range(0, Randomiser.RangeInt(1, 4)) .Select(i => Randomiser.RangeInt(short.MinValue, short.MaxValue)) .ToArray(); break; case CameraControlDataType.SInt32: cmd.IntData = Enumerable.Range(0, Randomiser.RangeInt(1, 2)) .Select(i => Randomiser.RangeInt(-500000, 500000)) .ToArray(); break; case CameraControlDataType.SInt64: cmd.LongData = Enumerable.Range(0, 1) .Select(i => (long)Randomiser.RangeInt(-5000000, 5000000)) .ToArray(); break; case CameraControlDataType.String: cmd.StringData = Randomiser.String(32); break; case CameraControlDataType.Float: cmd.FloatData = Enumerable.Range(0, Randomiser.RangeInt(1, 4)) .Select(i => Randomiser.Range(0, 1)) .ToArray(); break; default: throw new ArgumentOutOfRangeException(); } }
public void TestClipFrameUpload() { UploadJobWorker worker = null; AtemMockServerWrapper.Each(_output, _pool, (a, b) => worker?.HandleCommand(a, b), DeviceTestCases.MediaPlayerClips, helper => { helper.DisposeSdkClient = true; IBMDSwitcherMediaPool pool = GetMediaPool(helper); for (int i = 0; i < 3; i++) { AtemState stateBefore = helper.Helper.BuildLibState(); Tuple <uint, uint> resolution = stateBefore.Settings.VideoMode.GetResolution().GetSize(); uint index = Randomiser.RangeInt((uint)stateBefore.MediaPool.Clips.Count); uint frameIndex = Randomiser.RangeInt(stateBefore.MediaPool.Clips[(int)index].MaxFrames); IBMDSwitcherClip clip = GetClip(helper, index); worker = new UploadJobWorker(resolution.Item1 * resolution.Item2 * 4, _output, index + 1, frameIndex, DataTransferUploadRequestCommand.TransferMode.Write); var cb = new LockCallback(); helper.SendAndWaitForChange(stateBefore, () => { clip.Lock(cb); }); Assert.True(cb.Wait.WaitOne(2000)); pool.CreateFrame(_BMDSwitcherPixelFormat.bmdSwitcherPixelFormat10BitYUVA, resolution.Item1, resolution.Item2, out IBMDSwitcherFrame frame); byte[] bytes = MediaPoolUtil.SolidColour(resolution.Item1 * resolution.Item2, 100, 0, 0, 255); MediaPoolUtil.FillSdkFrame(frame, bytes); var clipState = stateBefore.MediaPool.Clips[(int)index]; clipState.Frames[(int)frameIndex].IsUsed = true; //clipState.Audio.Name = name; var uploadCb = new TransferCallback(); clip.AddCallback(uploadCb); clip.UploadFrame(frameIndex, frame); helper.HandleUntil(uploadCb.Wait, 5000); Assert.True(uploadCb.Wait.WaitOne(500)); Assert.Equal(_BMDSwitcherMediaPoolEventType.bmdSwitcherMediaPoolEventTypeTransferCompleted, uploadCb.Result); Assert.Equal(BitConverter.ToString(bytes), BitConverter.ToString(worker.Buffer)); helper.SendAndWaitForChange(stateBefore, () => { clip.Unlock(cb); }); } }); }
public void TestRate() { var handler = CommandGenerator.CreateAutoCommandHandler <DownstreamKeyRateSetCommand, DownstreamKeyPropertiesGetCommand>("Rate", true); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.All, helper => { EachKeyer(helper, (stateBefore, state, props, id, i) => { uint target = Randomiser.RangeInt(250); state.Properties.Rate = target; helper.SendAndWaitForChange(stateBefore, () => { props.SetRate(target); }); }); }); }