├── .github
    └── workflows
    │   ├── publish.yml
    │   └── pull-request.yml
├── .gitignore
├── .vscode
    ├── launch.json
    ├── settings.json
    └── tasks.json
├── Kadmium-sACN.Test
    ├── DataPacketTests.cs
    ├── IEnumerableExtensionsTest.cs
    ├── IntegrationTests.cs
    ├── Kadmium-sACN.Test.csproj
    ├── Layers
    │   ├── DMPLayerTests.cs
    │   ├── DataPacketFramingLayerTests.cs
    │   ├── RootLayerTests.cs
    │   ├── SynchronizationPacketFramingLayerTests.cs
    │   ├── UniverseDiscoveryLayerTests.cs
    │   └── UniverseDiscoveryPacketFramingLayerTests.cs
    ├── MulticastAddressProvider
    │   ├── SacnMulticastAddressProviderIPV4Tests.cs
    │   └── SacnMulticastAddressProviderIPV6Tests.cs
    ├── SACNPacketTests.cs
    ├── SacnPacketFactoryTests.cs
    ├── SynchronizationPacketTests.cs
    └── UniverseDiscoveryPacketTests.cs
├── Kadmium-sACN
    ├── Constants.cs
    ├── DataPacket.cs
    ├── IEnumerableExtensions.cs
    ├── Kadmium-sACN.csproj
    ├── Layers
    │   ├── DMPLayer.cs
    │   ├── Framing
    │   │   ├── DataPacketFramingLayer.cs
    │   │   ├── FramingLayer.cs
    │   │   ├── SynchronizationPacketFramingLayer.cs
    │   │   └── UniverseDiscoveryPacketFramingLayer.cs
    │   ├── RootLayer.cs
    │   ├── SACNLayer.cs
    │   └── UniverseDiscoveryLayer.cs
    ├── MulticastAddressProvider
    │   ├── ISacnMulticastAddressProvider.cs
    │   ├── SacnMulticastAddressProviderIPV4.cs
    │   └── SacnMulticastAddressProviderIPV6.cs
    ├── SACNPacket.cs
    ├── SacnPacketFactory.cs
    ├── SacnReceiver
    │   ├── IMulticastSacnReceiver.cs
    │   ├── ISacnReceiver.cs
    │   └── SacnReceiver.cs
    ├── SacnSender
    │   ├── ISacnSender.cs
    │   └── SacnSender.cs
    ├── SynchronizationPacket.cs
    └── UniverseDiscoveryPacket.cs
├── LICENSE
├── README.md
├── SacnSender
    ├── Program.cs
    └── SacnSender.csproj
├── SacnViewer
    ├── Program.cs
    └── SacnViewer.csproj
├── coverlet.runsettings
└── kadmium-sacn.sln


/.github/workflows/publish.yml:
--------------------------------------------------------------------------------
 1 | name: Publish to Nuget
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ master ]
 6 | 
 7 | jobs:
 8 |   publish:
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |     - uses: actions/checkout@v2
12 |     - name: Setup .NET
13 |       uses: actions/setup-dotnet@v1
14 |       with:
15 |         dotnet-version: 6.0.x
16 |     # Publish
17 |     - name: publish on version change
18 |       id: publish_nuget
19 |       uses: rohith/publish-nuget@v2
20 |       with:
21 |         # Filepath of the project to be packaged, relative to root of repository
22 |         PROJECT_FILE_PATH: Kadmium-sACN/Kadmium-sACN.csproj
23 |         
24 |         # NuGet package id, used for version detection & defaults to project name
25 |         # PACKAGE_NAME: Kadmium-Osc
26 |         
27 |         # Filepath with version info, relative to root of repository & defaults to PROJECT_FILE_PATH
28 |         VERSION_FILE_PATH: Kadmium-sACN/Kadmium-sACN.csproj
29 | 
30 |         # Regex pattern to extract version info in a capturing group
31 |         # VERSION_REGEX: ^\s*<Version>(.*)<\/Version>\s*$
32 |         
33 |         # Useful with external providers like Nerdbank.GitVersioning, ignores VERSION_FILE_PATH & VERSION_REGEX
34 |         # VERSION_STATIC: 1.0.0
35 | 
36 |         # Flag to toggle git tagging, enabled by default
37 |         TAG_COMMIT: true
38 | 
39 |         # Format of the git tag, [*] gets replaced with actual version
40 |         # TAG_FORMAT: v*
41 | 
42 |         # API key to authenticate with NuGet server
43 |         NUGET_KEY: ${{secrets.NUGET_TOKEN}}
44 | 
45 |         # NuGet server uri hosting the packages, defaults to https://api.nuget.org
46 |         # NUGET_SOURCE: https://api.nuget.org
47 | 
48 |         # Flag to toggle pushing symbols along with nuget package to the server, disabled by default
49 |         # INCLUDE_SYMBOLS: false
50 | 


--------------------------------------------------------------------------------
/.github/workflows/pull-request.yml:
--------------------------------------------------------------------------------
 1 | name: Test and Coverage
 2 | 
 3 | on:
 4 |   pull_request:
 5 |     branches: [ master ]
 6 | 
 7 | jobs:
 8 |   build:
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |     - uses: actions/checkout@v2
12 |     - name: Setup .NET
13 |       uses: actions/setup-dotnet@v1
14 |       with:
15 |         dotnet-version: 6.0.x
16 |     - name: Restore dependencies
17 |       run: dotnet restore
18 |     - name: Build
19 |       run: dotnet build --no-restore
20 |     - name: Test
21 |       run: dotnet test --no-build --verbosity normal --settings coverlet.runsettings
22 |     - name: Check coverage
23 |       uses: codecov/codecov-action@v1
24 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | 
  4 | # User-specific files
  5 | *.suo
  6 | *.user
  7 | *.userosscache
  8 | *.sln.docstates
  9 | 
 10 | # User-specific files (MonoDevelop/Xamarin Studio)
 11 | *.userprefs
 12 | 
 13 | # Build results
 14 | [Dd]ebug/
 15 | [Dd]ebugPublic/
 16 | [Rr]elease/
 17 | [Rr]eleases/
 18 | x64/
 19 | x86/
 20 | bld/
 21 | [Bb]in/
 22 | [Oo]bj/
 23 | 
 24 | # Visual Studio 2015 cache/options directory
 25 | .vs/
 26 | # Uncomment if you have tasks that create the project's static files in wwwroot
 27 | #wwwroot/
 28 | 
 29 | # MSTest test Results
 30 | [Tt]est[Rr]esult*/
 31 | [Bb]uild[Ll]og.*
 32 | 
 33 | # NUNIT
 34 | *.VisualState.xml
 35 | TestResult.xml
 36 | 
 37 | # Build Results of an ATL Project
 38 | [Dd]ebugPS/
 39 | [Rr]eleasePS/
 40 | dlldata.c
 41 | 
 42 | # DNX
 43 | project.lock.json
 44 | artifacts/
 45 | 
 46 | *_i.c
 47 | *_p.c
 48 | *_i.h
 49 | *.ilk
 50 | *.meta
 51 | *.obj
 52 | *.pch
 53 | *.pdb
 54 | *.pgc
 55 | *.pgd
 56 | *.rsp
 57 | *.sbr
 58 | *.tlb
 59 | *.tli
 60 | *.tlh
 61 | *.tmp
 62 | *.tmp_proj
 63 | *.log
 64 | *.vspscc
 65 | *.vssscc
 66 | .builds
 67 | *.pidb
 68 | *.svclog
 69 | *.scc
 70 | 
 71 | # Chutzpah Test files
 72 | _Chutzpah*
 73 | 
 74 | # Visual C++ cache files
 75 | ipch/
 76 | *.aps
 77 | *.ncb
 78 | *.opendb
 79 | *.opensdf
 80 | *.sdf
 81 | *.cachefile
 82 | 
 83 | # Visual Studio profiler
 84 | *.psess
 85 | *.vsp
 86 | *.vspx
 87 | *.sap
 88 | 
 89 | # TFS 2012 Local Workspace
 90 | $tf/
 91 | 
 92 | # Guidance Automation Toolkit
 93 | *.gpState
 94 | 
 95 | # ReSharper is a .NET coding add-in
 96 | _ReSharper*/
 97 | *.[Rr]e[Ss]harper
 98 | *.DotSettings.user
 99 | 
100 | # JustCode is a .NET coding add-in
101 | .JustCode
102 | 
103 | # TeamCity is a build add-in
104 | _TeamCity*
105 | 
106 | # DotCover is a Code Coverage Tool
107 | *.dotCover
108 | 
109 | # NCrunch
110 | _NCrunch_*
111 | .*crunch*.local.xml
112 | nCrunchTemp_*
113 | 
114 | # MightyMoose
115 | *.mm.*
116 | AutoTest.Net/
117 | 
118 | # Web workbench (sass)
119 | .sass-cache/
120 | 
121 | # Installshield output folder
122 | [Ee]xpress/
123 | 
124 | # DocProject is a documentation generator add-in
125 | DocProject/buildhelp/
126 | DocProject/Help/*.HxT
127 | DocProject/Help/*.HxC
128 | DocProject/Help/*.hhc
129 | DocProject/Help/*.hhk
130 | DocProject/Help/*.hhp
131 | DocProject/Help/Html2
132 | DocProject/Help/html
133 | 
134 | # Click-Once directory
135 | publish/
136 | 
137 | # Publish Web Output
138 | *.[Pp]ublish.xml
139 | *.azurePubxml
140 | # TODO: Comment the next line if you want to checkin your web deploy settings 
141 | # but database connection strings (with potential passwords) will be unencrypted
142 | *.pubxml
143 | *.publishproj
144 | 
145 | # NuGet Packages
146 | *.nupkg
147 | # The packages folder can be ignored because of Package Restore
148 | **/packages/*
149 | # except build/, which is used as an MSBuild target.
150 | !**/packages/build/
151 | # Uncomment if necessary however generally it will be regenerated when needed
152 | #!**/packages/repositories.config
153 | # NuGet v3's project.json files produces more ignoreable files
154 | *.nuget.props
155 | *.nuget.targets
156 | 
157 | # Microsoft Azure Build Output
158 | csx/
159 | *.build.csdef
160 | 
161 | # Microsoft Azure Emulator
162 | ecf/
163 | rcf/
164 | 
165 | # Microsoft Azure ApplicationInsights config file
166 | ApplicationInsights.config
167 | 
168 | # Windows Store app package directory
169 | AppPackages/
170 | BundleArtifacts/
171 | 
172 | # Visual Studio cache files
173 | # files ending in .cache can be ignored
174 | *.[Cc]ache
175 | # but keep track of directories ending in .cache
176 | !*.[Cc]ache/
177 | 
178 | # Others
179 | ClientBin/
180 | ~$*
181 | *~
182 | *.dbmdl
183 | *.dbproj.schemaview
184 | *.pfx
185 | *.publishsettings
186 | node_modules/
187 | orleans.codegen.cs
188 | 
189 | # RIA/Silverlight projects
190 | Generated_Code/
191 | 
192 | # Backup & report files from converting an old project file
193 | # to a newer Visual Studio version. Backup files are not needed,
194 | # because we have git ;-)
195 | _UpgradeReport_Files/
196 | Backup*/
197 | UpgradeLog*.XML
198 | UpgradeLog*.htm
199 | 
200 | # SQL Server files
201 | *.mdf
202 | *.ldf
203 | 
204 | # Business Intelligence projects
205 | *.rdl.data
206 | *.bim.layout
207 | *.bim_*.settings
208 | 
209 | # Microsoft Fakes
210 | FakesAssemblies/
211 | 
212 | # GhostDoc plugin setting file
213 | *.GhostDoc.xml
214 | 
215 | # Node.js Tools for Visual Studio
216 | .ntvs_analysis.dat
217 | 
218 | # Visual Studio 6 build log
219 | *.plg
220 | 
221 | # Visual Studio 6 workspace options file
222 | *.opt
223 | 
224 | # Visual Studio LightSwitch build output
225 | **/*.HTMLClient/GeneratedArtifacts
226 | **/*.DesktopClient/GeneratedArtifacts
227 | **/*.DesktopClient/ModelManifest.xml
228 | **/*.Server/GeneratedArtifacts
229 | **/*.Server/ModelManifest.xml
230 | _Pvt_Extensions
231 | 
232 | # Paket dependency manager
233 | .paket/paket.exe
234 | 
235 | # FAKE - F# Make
236 | .fake/
237 | 


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	// Use IntelliSense to learn about possible attributes.
 3 | 	// Hover to view descriptions of existing attributes.
 4 | 	// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
 5 | 	"version": "0.2.0",
 6 | 	"configurations": [
 7 | 		{
 8 | 			"name": "Debug Viewer",
 9 | 			"type": "coreclr",
10 | 			"request": "launch",
11 | 			"preLaunchTask": "build",
12 | 			"program": "${workspaceFolder}/SacnViewer/bin/Debug/net6.0/SacnViewer.dll",
13 | 			"args": [],
14 | 			"cwd": "${workspaceFolder}/SacnViewer",
15 | 			"console": "internalConsole",
16 | 			"stopAtEntry": false
17 | 		},
18 | 		{
19 | 			"name": "Debug Sender",
20 | 			"type": "coreclr",
21 | 			"request": "launch",
22 | 			"preLaunchTask": "build",
23 | 			"program": "${workspaceFolder}/SacnSender/bin/Debug/net6.0/SacnSender.dll",
24 | 			"args": [],
25 | 			"cwd": "${workspaceFolder}/SacnViewer",
26 | 			"console": "internalConsole",
27 | 			"stopAtEntry": false
28 | 		},
29 | 		{
30 | 			"name": ".NET Core Attach",
31 | 			"type": "coreclr",
32 | 			"request": "attach"
33 | 		}
34 | 	]
35 | }


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 | 	"cSpell.words": [
3 | 		"Dgram",
4 | 		"Kadmium",
5 | 		"Sacn"
6 | 	]
7 | }


--------------------------------------------------------------------------------
/.vscode/tasks.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"version": "2.0.0",
 3 | 	"tasks": [
 4 | 		{
 5 | 			"label": "build",
 6 | 			"command": "dotnet",
 7 | 			"type": "process",
 8 | 			"args": [
 9 | 				"build",
10 | 				"${workspaceFolder}/kadmium-sacn.sln",
11 | 				"/property:GenerateFullPaths=true",
12 | 				"/consoleloggerparameters:NoSummary"
13 | 			],
14 | 			"problemMatcher": "$msCompile"
15 | 		},
16 | 		{
17 | 			"label": "publish",
18 | 			"command": "dotnet",
19 | 			"type": "process",
20 | 			"args": [
21 | 				"publish",
22 | 				"${workspaceFolder}/kadmium-sacn.sln",
23 | 				"/property:GenerateFullPaths=true",
24 | 				"/consoleloggerparameters:NoSummary"
25 | 			],
26 | 			"problemMatcher": "$msCompile"
27 | 		},
28 | 		{
29 | 			"label": "watch",
30 | 			"command": "dotnet",
31 | 			"type": "process",
32 | 			"args": [
33 | 				"watch",
34 | 				"run",
35 | 				"--project",
36 | 				"${workspaceFolder}/SacnViewer/SacnViewer.csproj"
37 | 			],
38 | 			"problemMatcher": "$msCompile"
39 | 		}
40 | 	]
41 | }


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/DataPacketTests.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN.Layers;
 2 | using Kadmium_sACN.Layers.Framing;
 3 | using System;
 4 | using System.Buffers;
 5 | using System.Collections.Generic;
 6 | using System.Linq;
 7 | using System.Text;
 8 | using System.Threading.Tasks;
 9 | using Xunit;
10 | 
11 | namespace Kadmium_sACN.Test
12 | {
13 | 	public class DataPacketTests
14 | 	{
15 | 		[Fact]
16 | 		public void When_WriteIsCalled_Then_TheDataIsCorrect()
17 | 		{
18 | 			byte[] CID = Enumerable.Range(1, 12).Select(x => (byte)x).ToArray();
19 | 			string sourceName = "Source name";
20 | 			UInt16 universe = 1050;
21 | 			byte[] properties = Enumerable.Range(0, 200).Select(x => (byte)x).ToArray();
22 | 
23 | 			DataPacket packet = new DataPacket();
24 | 			packet.RootLayer.CID = CID;
25 | 			packet.FramingLayer.SourceName = sourceName;
26 | 			packet.FramingLayer.Universe = universe;
27 | 			packet.DMPLayer.PropertyValues = properties;
28 | 
29 | 			using var owner = MemoryPool<byte>.Shared.Rent(packet.Length);
30 | 			var bytes = owner.Memory.Span.Slice(0, packet.Length);
31 | 			packet.Write(bytes);
32 | 
33 | 			var expectedBytes = GetDataPacket(CID, sourceName, universe, properties);
34 | 		}
35 | 
36 | 		public static Span<byte> GetDataPacket(byte[] CID, string sourceName, UInt16 universe, byte[] properties)
37 | 		{
38 | 			var rootLayer = new RootLayer
39 | 			{
40 | 				CID = CID,
41 | 				Vector = RootLayerVector.VECTOR_ROOT_E131_DATA
42 | 			};
43 | 
44 | 			var framingLayer = new DataPacketFramingLayer
45 | 			{
46 | 				SourceName = sourceName,
47 | 				Universe = universe
48 | 			};
49 | 
50 | 			var dmpLayer = new DMPLayer
51 | 			{
52 | 				PropertyValues = properties
53 | 			};
54 | 
55 | 			int totalLength = dmpLayer.Length + DataPacketFramingLayer.Length + RootLayer.Length;
56 | 			using var owner = MemoryPool<byte>.Shared.Rent(totalLength);
57 | 			var bytes = owner.Memory.Span.Slice(0, totalLength);
58 | 
59 | 			rootLayer.Write(bytes, (UInt16)(DataPacketFramingLayer.Length + dmpLayer.Length));
60 | 			framingLayer.Write(bytes.Slice(RootLayer.Length), dmpLayer.Length);
61 | 			dmpLayer.Write(bytes.Slice(RootLayer.Length + DataPacketFramingLayer.Length));
62 | 
63 | 			return bytes;
64 | 		}
65 | 	}
66 | }
67 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/IEnumerableExtensionsTest.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | using System.Threading.Tasks;
 6 | using Xunit;
 7 | 
 8 | namespace Kadmium_sACN.Test
 9 | {
10 | 	public class IEnumerableExtensionsTest
11 | 	{
12 | 		[Fact]
13 | 		public void Given_TheCollectionIsSmallerThanTheChunkSize_When_ChunkIsCalled_Then_OneChunkIsReturned()
14 | 		{
15 | 			var collection = Enumerable.Range(1, 3);
16 | 			var chunks = collection.Chunk(10);
17 | 			Assert.Single(chunks);
18 | 		}
19 | 
20 | 		[Fact]
21 | 		public void When_ChunkIsCalled_Then_TheChunkCountIsAsExpected()
22 | 		{
23 | 			var collection = Enumerable.Range(1, 10);
24 | 			var chunks = collection.Chunk(2);
25 | 			Assert.Equal(5, chunks.Count());
26 | 		}
27 | 
28 | 		[Fact]
29 | 		public void When_ChunkIsCalled_Then_TheChunksContainTheExpectedValue()
30 | 		{
31 | 			var collection = Enumerable.Range(1, 10);
32 | 			var chunks = collection.Chunk(2);
33 | 			var expectedValues = new[]
34 | 			{
35 | 				new [] {1, 2},
36 | 				new [] {3, 4},
37 | 				new [] {5, 6},
38 | 				new [] {7, 8},
39 | 				new [] {9, 10},
40 | 			};
41 | 			Assert.Equal(expectedValues, chunks);
42 | 		}
43 | 	}
44 | }
45 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/IntegrationTests.cs:
--------------------------------------------------------------------------------
  1 | using Kadmium_sACN.SacnReceiver;
  2 | using Kadmium_sACN.SacnSender;
  3 | using System;
  4 | using System.Collections.Generic;
  5 | using System.Linq;
  6 | using System.Net;
  7 | using System.Net.Sockets;
  8 | using System.Text;
  9 | using System.Threading.Tasks;
 10 | using Xunit;
 11 | 
 12 | namespace Kadmium_sACN.Test
 13 | {
 14 | 	public class IntegrationTests
 15 | 	{
 16 | 		[Fact]
 17 | 		public async Task When_ListeningAndSendingUnicastWithIPV4_Then_MessagesAreSentAndReceived()
 18 | 		{
 19 | 			var hostname = Dns.GetHostName();
 20 | 			var ipAddresses = await Dns.GetHostAddressesAsync(hostname);
 21 | 			var address = ipAddresses.First(x => x.AddressFamily == AddressFamily.InterNetwork);
 22 | 
 23 | 			using (var sender = new Kadmium_sACN.SacnSender.SacnSender())
 24 | 			{
 25 | 				using (var receiver = new Kadmium_sACN.SacnReceiver.SacnReceiver())
 26 | 				{
 27 | 					DataPacket received = null;
 28 | 
 29 | 					receiver.OnDataPacketReceived += (sender, packet) =>
 30 | 					{
 31 | 						received = packet;
 32 | 					};
 33 | 					receiver.Listen(address);
 34 | 
 35 | 					var packet = new DataPacket();
 36 | 					packet.FramingLayer.SourceName = "Source name";
 37 | 					packet.FramingLayer.Universe = 25;
 38 | 					packet.DMPLayer.PropertyValues = new byte[] { 1, 2, 3, 4 };
 39 | 
 40 | 					await sender.SendUnicast(packet, address);
 41 | 					await Task.Delay(250);
 42 | 					Assert.NotNull(received);
 43 | 				}
 44 | 			}
 45 | 		}
 46 | 
 47 | 		[Fact]
 48 | 		public async Task When_ListeningAndSendingUnicastWithIPV6_Then_MessagesAreSentAndReceived()
 49 | 		{
 50 | 			var hostname = Dns.GetHostName();
 51 | 			var ipAddresses = await Dns.GetHostAddressesAsync(hostname);
 52 | 			var address = ipAddresses.First(x => x.AddressFamily == AddressFamily.InterNetworkV6);
 53 | 
 54 | 			using (var sender = new Kadmium_sACN.SacnSender.SacnSender())
 55 | 			{
 56 | 				using (var receiver = new Kadmium_sACN.SacnReceiver.SacnReceiver())
 57 | 				{
 58 | 					DataPacket received = null;
 59 | 
 60 | 					receiver.OnDataPacketReceived += (sender, packet) =>
 61 | 					{
 62 | 						received = packet;
 63 | 					};
 64 | 					receiver.Listen(address);
 65 | 
 66 | 					var packet = new DataPacket();
 67 | 					packet.FramingLayer.SourceName = "Source name";
 68 | 					packet.FramingLayer.Universe = 25;
 69 | 					packet.DMPLayer.PropertyValues = new byte[] { 1, 2, 3, 4 };
 70 | 
 71 | 					await sender.SendUnicast(packet, address);
 72 | 					await Task.Delay(250);
 73 | 					Assert.NotNull(received);
 74 | 				}
 75 | 			}
 76 | 		}
 77 | 
 78 | 		// [Fact]
 79 | 		// public async Task When_ListeningAndSendingMulticastOnIPV4_Then_MessagesAreSentAndReceived()
 80 | 		// {
 81 | 		// 	UInt16 universe = 1;
 82 | 		// 	using (var sender = new SacnSender.SacnSender())
 83 | 		// 	{
 84 | 		// 		using (var receiver = new SacnReceiver.SacnReceiver())
 85 | 		// 		{
 86 | 		// 			DataPacket received = null;
 87 | 
 88 | 		// 			receiver.OnDataPacketReceived += (sender, packet) =>
 89 | 		// 			{
 90 | 		// 				received = packet;
 91 | 		// 			};
 92 | 		// 			receiver.Listen(IPAddress.Any);
 93 | 		// 			await Task.Delay(250);
 94 | 		// 			receiver.JoinMulticastGroup(universe, false);
 95 | 
 96 | 		// 			var packet = new DataPacket();
 97 | 		// 			packet.FramingLayer.SourceName = "Source name";
 98 | 		// 			packet.FramingLayer.Universe = universe;
 99 | 		// 			packet.DMPLayer.PropertyValues = new byte[] { 1, 2, 3, 4 };
100 | 
101 | 		// 			await sender.SendMulticast(packet, false);
102 | 		// 			await Task.Delay(250);
103 | 		// 			Assert.NotNull(received);
104 | 		// 		}
105 | 		// 	}
106 | 		// }
107 | 
108 | 		[Fact]
109 | 		public async Task When_ListeningAndSendingMulticastOnIPV6_Then_MessagesAreSentAndReceived()
110 | 		{
111 | 			UInt16 universe = 1;
112 | 			using (var sender = new SacnSender.SacnSender())
113 | 			{
114 | 				using (var receiver = new SacnReceiver.SacnReceiver())
115 | 				{
116 | 					DataPacket received = null;
117 | 
118 | 					receiver.OnDataPacketReceived += (sender, packet) =>
119 | 					{
120 | 						received = packet;
121 | 					};
122 | 					receiver.Listen(IPAddress.IPv6Any);
123 | 					await Task.Delay(250);
124 | 					receiver.JoinMulticastGroup(universe, true);
125 | 
126 | 					var packet = new DataPacket();
127 | 					packet.FramingLayer.SourceName = "Source name";
128 | 					packet.FramingLayer.Universe = universe;
129 | 					packet.DMPLayer.PropertyValues = new byte[] { 1, 2, 3, 4 };
130 | 
131 | 					await sender.SendMulticast(packet, true);
132 | 					await Task.Delay(250);
133 | 					Assert.NotNull(received);
134 | 				}
135 | 			}
136 | 		}
137 | 	}
138 | }
139 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/Kadmium-sACN.Test.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>net6.0</TargetFramework>
 5 |     <RootNamespace>Kadmium_sACN.Test</RootNamespace>
 6 | 
 7 |     <IsPackable>false</IsPackable>
 8 |   </PropertyGroup>
 9 | 
10 |   <ItemGroup>
11 |     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
12 |     <PackageReference Include="Moq" Version="4.16.1" />
13 |     <PackageReference Include="xunit" Version="2.4.1" />
14 |     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
15 |       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
16 |       <PrivateAssets>all</PrivateAssets>
17 |     </PackageReference>
18 |     <PackageReference Include="coverlet.collector" Version="3.0.3">
19 |       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
20 |       <PrivateAssets>all</PrivateAssets>
21 |     </PackageReference>
22 |   </ItemGroup>
23 | 
24 |   <ItemGroup>
25 |     <ProjectReference Include="..\Kadmium-sACN\Kadmium-sACN.csproj" />
26 |   </ItemGroup>
27 | 
28 | </Project>


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/Layers/DMPLayerTests.cs:
--------------------------------------------------------------------------------
  1 | using Kadmium_sACN.Layers;
  2 | using System;
  3 | using System.Buffers;
  4 | using System.Collections.Generic;
  5 | using System.Linq;
  6 | using System.Text;
  7 | using System.Threading.Tasks;
  8 | using Xunit;
  9 | 
 10 | namespace Kadmium_sACN.Test.Layers
 11 | {
 12 | 	public class DMPLayerTests
 13 | 	{
 14 | 		[Fact]
 15 | 		public void Given_TheDataIsCorrect_When_ParseIsCalled_Then_TheDataIsParsedAsExpected()
 16 | 		{
 17 | 			UInt16 propertyCount = 5;
 18 | 			var expectedProperties = Enumerable.Range(0, propertyCount).Select(x => (byte)x);
 19 | 			var bytes = GetDMPLayer(expectedProperties);
 20 | 
 21 | 			var dmpLayer = DMPLayer.Parse(bytes.ToArray());
 22 | 			Assert.Equal(DMPLayerVector.VECTOR_DMP_SET_PROPERTY, dmpLayer.Vector);
 23 | 			Assert.Equal(propertyCount, dmpLayer.PropertyValues.Count());
 24 | 			Assert.Equal(expectedProperties.ToArray(), dmpLayer.PropertyValues);
 25 | 		}
 26 | 
 27 | 		[Fact]
 28 | 		public void Given_TheAddressTypeAndDataTypeAreIncorrect_When_ParseIsCalled_Then_NullIsReturned()
 29 | 		{
 30 | 			List<byte> bytes = new List<byte>();
 31 | 			UInt16 propertyCount = 5;
 32 | 			byte length = (byte)(DMPLayer.MinLength + propertyCount);
 33 | 			UInt16 expectedFlagsAndLength = (UInt16)(0x7 << 12 | length);
 34 | 			bytes.AddRange(new byte[] { 0x7 << 4, (length) }); // flags and length
 35 | 			DMPLayerVector expectedVector = DMPLayerVector.VECTOR_DMP_SET_PROPERTY;
 36 | 			bytes.Add((byte)expectedVector); // Vector
 37 | 			byte expectedAddressAndDataType = 25;
 38 | 			bytes.Add(expectedAddressAndDataType);
 39 | 
 40 | 			bytes.AddRange(new byte[] { 0, 0 }); // first property address
 41 | 			bytes.AddRange(new byte[] { 0, 1 }); // address increment
 42 | 			bytes.AddRange(new byte[] { 0, (byte)propertyCount }); // property count
 43 | 
 44 | 			var expectedProperties = Enumerable.Range(0, propertyCount).Select(x => (byte)x);
 45 | 			bytes.Add(0); // start code
 46 | 			bytes.AddRange(expectedProperties);
 47 | 
 48 | 			var dmpLayer = DMPLayer.Parse(bytes.ToArray());
 49 | 			Assert.Null(dmpLayer);
 50 | 		}
 51 | 
 52 | 		[Fact]
 53 | 		public void Given_TheFirstPropertyAddressIsIncorrect_When_ParseIsCalled_Then_NullIsReturned()
 54 | 		{
 55 | 			List<byte> bytes = new List<byte>();
 56 | 			UInt16 propertyCount = 5;
 57 | 			byte length = (byte)(DMPLayer.MinLength + propertyCount);
 58 | 			UInt16 expectedFlagsAndLength = (UInt16)(0x7 << 12 | length);
 59 | 			bytes.AddRange(new byte[] { 0x7 << 4, (length) }); // flags and length
 60 | 			DMPLayerVector expectedVector = DMPLayerVector.VECTOR_DMP_SET_PROPERTY;
 61 | 			bytes.Add((byte)expectedVector); // Vector
 62 | 			byte expectedAddressAndDataType = DMPLayer.AddressTypeAndDataType;
 63 | 			bytes.Add(expectedAddressAndDataType);
 64 | 
 65 | 			bytes.AddRange(new byte[] { 0, 42 }); // first property address
 66 | 			bytes.AddRange(new byte[] { 0, 1 }); // address increment
 67 | 			bytes.AddRange(new byte[] { 0, (byte)propertyCount }); // property count
 68 | 
 69 | 			var expectedProperties = Enumerable.Range(0, propertyCount).Select(x => (byte)x);
 70 | 			bytes.Add(0); // start code
 71 | 			bytes.AddRange(expectedProperties);
 72 | 
 73 | 			var dmpLayer = DMPLayer.Parse(bytes.ToArray());
 74 | 			Assert.Null(dmpLayer);
 75 | 		}
 76 | 
 77 | 		[Fact]
 78 | 		public void Given_TheAddressIncrementIsIncorrect_When_ParseIsCalled_Then_NullIsReturned()
 79 | 		{
 80 | 			List<byte> bytes = new List<byte>();
 81 | 			UInt16 propertyCount = 5;
 82 | 			byte length = (byte)(DMPLayer.MinLength + propertyCount);
 83 | 			UInt16 expectedFlagsAndLength = (UInt16)(0x7 << 12 | length);
 84 | 			bytes.AddRange(new byte[] { 0x7 << 4, (length) }); // flags and length
 85 | 			DMPLayerVector expectedVector = DMPLayerVector.VECTOR_DMP_SET_PROPERTY;
 86 | 			bytes.Add((byte)expectedVector); // Vector
 87 | 			byte expectedAddressAndDataType = DMPLayer.AddressTypeAndDataType;
 88 | 			bytes.Add(expectedAddressAndDataType);
 89 | 
 90 | 			bytes.AddRange(new byte[] { 0, 0 }); // first property address
 91 | 			bytes.AddRange(new byte[] { 0, 42 }); // address increment
 92 | 			bytes.AddRange(new byte[] { 0, (byte)propertyCount }); // property count
 93 | 
 94 | 			var expectedProperties = Enumerable.Range(0, propertyCount).Select(x => (byte)x);
 95 | 			bytes.Add(0); // start code
 96 | 			bytes.AddRange(expectedProperties);
 97 | 
 98 | 			var dmpLayer = DMPLayer.Parse(bytes.ToArray());
 99 | 			Assert.Null(dmpLayer);
100 | 		}
101 | 
102 | 		[Fact]
103 | 		public void When_WriteIsCalled_Then_TheDataIsCorrect()
104 | 		{
105 | 			var properties = Enumerable.Range(0, 200).Select(x => (byte)x).ToArray();
106 | 
107 | 			var dmpLayer = new DMPLayer()
108 | 			{
109 | 				PropertyValues = properties
110 | 			};
111 | 
112 | 			var expectedBytes = GetDMPLayer(properties);
113 | 
114 | 			using var owner = MemoryPool<byte>.Shared.Rent(DMPLayer.MinLength + properties.Length);
115 | 			var actualBytes = owner.Memory.Span.Slice(0, DMPLayer.MinLength + properties.Length);
116 | 			dmpLayer.Write(actualBytes);
117 | 			Assert.Equal(expectedBytes.ToArray(), actualBytes.ToArray());
118 | 		}
119 | 
120 | 		public static List<byte> GetDMPLayer(IEnumerable<byte> properties)
121 | 		{
122 | 			List<byte> bytes = new List<byte>();
123 | 			UInt16 propertyCount = (UInt16)properties.Count();
124 | 			byte length = (byte)(DMPLayer.MinLength + propertyCount);
125 | 			bytes.AddRange(new byte[] { 0x7 << 4, (length) }); // flags and length
126 | 			DMPLayerVector expectedVector = DMPLayerVector.VECTOR_DMP_SET_PROPERTY;
127 | 			bytes.Add((byte)expectedVector); // Vector
128 | 			byte expectedAddressAndDataType = DMPLayer.AddressTypeAndDataType;
129 | 			bytes.Add(expectedAddressAndDataType);
130 | 
131 | 			bytes.AddRange(new byte[] { 0, 0 }); // first property address
132 | 			bytes.AddRange(new byte[] { 0, 1 }); // address increment
133 | 			bytes.AddRange(new byte[] { 0, (byte)(propertyCount + 1) }); // property count
134 | 
135 | 			bytes.Add(0); // start code
136 | 			bytes.AddRange(properties);
137 | 
138 | 			return bytes;
139 | 		}
140 | 	}
141 | }
142 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/Layers/DataPacketFramingLayerTests.cs:
--------------------------------------------------------------------------------
  1 | using Kadmium_sACN.Layers;
  2 | using Kadmium_sACN.Layers.Framing;
  3 | using System;
  4 | using System.Buffers;
  5 | using System.Collections.Generic;
  6 | using System.Linq;
  7 | using System.Text;
  8 | using System.Threading.Tasks;
  9 | using Xunit;
 10 | 
 11 | namespace Kadmium_sACN.Test.Layers
 12 | {
 13 | 	public class DataPacketFramingLayerTests
 14 | 	{
 15 | 		[Fact]
 16 | 		public void Given_TheDataIsCorrect_When_ParseIsCalled_Then_TheDataIsParsedAsExpected()
 17 | 		{
 18 | 			var expectedVector = FramingLayerVector.VECTOR_E131_DATA_PACKET;
 19 | 			byte expectedPriority = 27;
 20 | 			UInt16 expectedSyncAddress = 25;
 21 | 			byte expectedSequenceNumber = 127;
 22 | 			bool previewData = true;
 23 | 			bool streamTerminated = true;
 24 | 			bool forceSynchronization = true;
 25 | 			byte expectedOptions = 0b0000_1110;
 26 | 			UInt16 universe = 258;
 27 | 			string expectedSourceName = "This is the source name";
 28 | 
 29 | 			var bytes = GetDataPacketFramingLayer(expectedSourceName, expectedPriority, expectedSyncAddress, expectedSequenceNumber, expectedOptions, universe);
 30 | 
 31 | 			var framingLayer = DataPacketFramingLayer.Parse(bytes.ToArray());
 32 | 			Assert.Equal(expectedVector, framingLayer.Vector);
 33 | 			Assert.Equal(expectedPriority, framingLayer.Priority);
 34 | 			Assert.Equal(expectedSyncAddress, framingLayer.SynchronizationAddress);
 35 | 			Assert.Equal(expectedSequenceNumber, framingLayer.SequenceNumber);
 36 | 			Assert.Equal(previewData, framingLayer.PreviewData);
 37 | 			Assert.Equal(streamTerminated, framingLayer.StreamTerminated);
 38 | 			Assert.Equal(forceSynchronization, framingLayer.ForceSynchronization);
 39 | 			Assert.Equal(expectedOptions, framingLayer.Options);
 40 | 			Assert.Equal(universe, framingLayer.Universe);
 41 | 		}
 42 | 
 43 | 		[Theory]
 44 | 		[InlineData(true, true, true, 0b0000_1110)]
 45 | 		[InlineData(true, true, false, 0b0000_1100)]
 46 | 		[InlineData(true, false, true, 0b0000_1010)]
 47 | 		[InlineData(true, false, false, 0b0000_1000)]
 48 | 		[InlineData(false, true, true, 0b0000_0110)]
 49 | 		[InlineData(false, true, false, 0b0000_0100)]
 50 | 		[InlineData(false, false, true, 0b0000_0010)]
 51 | 		[InlineData(false, false, false, 0b0000_0000)]
 52 | 		public void When_TheOptionsFlagsAreSet_Then_TheResultsAreAsExpected(bool forceSynchronization, bool streamTerminated, bool previewData, byte expectedOptions)
 53 | 		{
 54 | 			DataPacketFramingLayer framingLayer = new DataPacketFramingLayer();
 55 | 			framingLayer.ForceSynchronization = forceSynchronization;
 56 | 			framingLayer.StreamTerminated = streamTerminated;
 57 | 			framingLayer.PreviewData = previewData;
 58 | 
 59 | 			Assert.Equal(expectedOptions, framingLayer.Options);
 60 | 		}
 61 | 
 62 | 		[Fact]
 63 | 		public void When_WriteIsCalled_Then_TheDataIsCorrect()
 64 | 		{
 65 | 			string sourceName = "My source name";
 66 | 			byte priority = 134;
 67 | 			UInt16 syncAddress = 1023;
 68 | 			byte sequenceNumber = 135;
 69 | 			byte options = 0;
 70 | 			UInt16 universe = 1953;
 71 | 
 72 | 			var framingLayer = new DataPacketFramingLayer()
 73 | 			{
 74 | 				SourceName = sourceName,
 75 | 				Priority = priority,
 76 | 				SynchronizationAddress = syncAddress,
 77 | 				SequenceNumber = sequenceNumber,
 78 | 				Options = options,
 79 | 				Universe = universe
 80 | 			};
 81 | 
 82 | 			var expectedBytes = GetDataPacketFramingLayer(sourceName, priority, syncAddress, sequenceNumber, options, universe);
 83 | 
 84 | 			using var owner = MemoryPool<byte>.Shared.Rent(DataPacketFramingLayer.Length);
 85 | 			var actualBytes = owner.Memory.Span.Slice(0, DataPacketFramingLayer.Length);
 86 | 			framingLayer.Write(actualBytes, 0);
 87 | 			Assert.Equal(expectedBytes.ToArray(), actualBytes.ToArray());
 88 | 		}
 89 | 
 90 | 		[Fact]
 91 | 		public void When_TheUniverseIsTooHigh_Then_AnExceptionIsThrown()
 92 | 		{
 93 | 			var framingLayer = new DataPacketFramingLayer();
 94 | 			Assert.Throws<ArgumentOutOfRangeException>(() => framingLayer.Universe = Constants.Universe_MaxValue + 1);
 95 | 		}
 96 | 
 97 | 		[Fact]
 98 | 		public void When_TheUniverseIsTooLow_Then_AnExceptionIsThrown()
 99 | 		{
100 | 			var framingLayer = new DataPacketFramingLayer();
101 | 			Assert.Throws<ArgumentOutOfRangeException>(() => framingLayer.Universe = Constants.Universe_MinValue - 1);
102 | 		}
103 | 
104 | 		[Fact]
105 | 		public void When_ThePriorityIsTooHigh_Then_AnExceptionIsThrown()
106 | 		{
107 | 			var framingLayer = new DataPacketFramingLayer();
108 | 			Assert.Throws<ArgumentOutOfRangeException>(() => framingLayer.Priority = Constants.Priority_MaxValue + 1);
109 | 		}
110 | 
111 | 		public static List<byte> GetDataPacketFramingLayer(string sourceName, byte priority, UInt16 syncAddress, byte sequenceNumber, byte options, UInt16 universe)
112 | 		{
113 | 			var bytes = new List<byte>(new byte[] {
114 | 				(0x7 << 4), DataPacketFramingLayer.Length, // flags and length
115 | 				0x00, 0x00, 0x00, (byte)FramingLayerVector.VECTOR_E131_DATA_PACKET,
116 | 			});
117 | 
118 | 			bytes.AddRange(Encoding.UTF8.GetBytes(sourceName));
119 | 			bytes.AddRange(Enumerable.Repeat((byte)0, 64 - sourceName.Length));
120 | 			bytes.Add(priority);
121 | 			bytes.AddRange(new byte[] { (byte)((syncAddress & 0xFF00) >> 8), (byte)(syncAddress & 0xFF) });
122 | 			bytes.Add(sequenceNumber);
123 | 			bytes.Add(options);
124 | 			bytes.AddRange(new byte[] { (byte)((universe & 0xFF00) >> 8), (byte)(universe & 0xFF) });
125 | 
126 | 			return bytes;
127 | 		}
128 | 
129 | 	}
130 | }
131 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/Layers/RootLayerTests.cs:
--------------------------------------------------------------------------------
  1 | using Kadmium_sACN.Layers;
  2 | using System;
  3 | using System.Buffers;
  4 | using System.Buffers.Binary;
  5 | using System.Collections.Generic;
  6 | using System.Linq;
  7 | using System.Text;
  8 | using System.Threading.Tasks;
  9 | using Xunit;
 10 | 
 11 | namespace Kadmium_sACN.Test.Layers
 12 | {
 13 | 	public class RootLayerTests
 14 | 	{
 15 | 		[Fact]
 16 | 		public void Given_TheDataIsValid_When_ParseIsCalled_Then_TheLayerParsesCorrectly()
 17 | 		{
 18 | 			var expectedCid = new byte[]
 19 | 			{
 20 | 				1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
 21 | 			};
 22 | 			var expectedVector = RootLayerVector.VECTOR_ROOT_E131_DATA;
 23 | 			var bytes = GetRootLayer(expectedCid, expectedVector);
 24 | 
 25 | 			var rootLayer = RootLayer.Parse(bytes.ToArray());
 26 | 
 27 | 			Assert.Equal(expectedVector, rootLayer.Vector);
 28 | 			Assert.Equal(expectedCid, rootLayer.CID);
 29 | 		}
 30 | 
 31 | 		[Fact]
 32 | 		public void Given_ThePreambleSizeIsWrong_When_ParseIsCalled_Then_NullIsReturned()
 33 | 		{
 34 | 			var expectedVector = RootLayerVector.VECTOR_ROOT_E131_DATA;
 35 | 			var expectedFlags = RootLayer.FLAGS;
 36 | 			var expectedLength = RootLayer.Length - 16;
 37 | 
 38 | 			var bytes = new List<byte>
 39 | 			{
 40 | 				0x00, 0x99, // preamble size
 41 | 				0x00, 0x00, // postamble size
 42 | 			};
 43 | 			bytes.AddRange(RootLayer.ACNIdentifier);
 44 | 			bytes.AddRange(new byte[]
 45 | 			{
 46 | 				(byte)(expectedFlags << 4), (byte)expectedLength, // flags and length
 47 | 				0x00, 0x00, 0x00, (byte)expectedVector, // vector
 48 | 			});
 49 | 
 50 | 			var expectedCid = new List<byte>
 51 | 			{
 52 | 				1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
 53 | 			};
 54 | 			bytes.AddRange(expectedCid);
 55 | 
 56 | 			Assert.Null(RootLayer.Parse(bytes.ToArray()));
 57 | 		}
 58 | 
 59 | 		[Fact]
 60 | 		public void Given_ThePostambleSizeIsWrong_When_ParseIsCalled_Then_NullIsReturned()
 61 | 		{
 62 | 			var expectedVector = RootLayerVector.VECTOR_ROOT_E131_DATA;
 63 | 			var expectedFlags = RootLayer.FLAGS;
 64 | 			var expectedLength = RootLayer.Length - 16;
 65 | 
 66 | 			var bytes = new List<byte>
 67 | 			{
 68 | 				0x00, 0x10, // preamble size
 69 | 				0x00, 0x99, // postamble size
 70 | 			};
 71 | 			bytes.AddRange(RootLayer.ACNIdentifier);
 72 | 			bytes.AddRange(new byte[]
 73 | 			{
 74 | 				(byte)(expectedFlags << 4), (byte)expectedLength, // flags and length
 75 | 				0x00, 0x00, 0x00, (byte)expectedVector, // vector
 76 | 			});
 77 | 
 78 | 			var expectedCid = new List<byte>
 79 | 			{
 80 | 				1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
 81 | 			};
 82 | 			bytes.AddRange(expectedCid);
 83 | 
 84 | 			Assert.Null(RootLayer.Parse(bytes.ToArray()));
 85 | 		}
 86 | 
 87 | 		[Fact]
 88 | 		public void Given_TheSequenceIdentifierIsWrong_When_ParseIsCalled_Then_NullIsReturned()
 89 | 		{
 90 | 			var expectedVector = RootLayerVector.VECTOR_ROOT_E131_DATA;
 91 | 			var expectedFlags = RootLayer.FLAGS;
 92 | 			var expectedLength = RootLayer.Length - 16;
 93 | 
 94 | 			var bytes = new List<byte>
 95 | 			{
 96 | 				0x00, 0x10, // preamble size
 97 | 				0x00, 0x00, // postamble size
 98 | 			};
 99 | 			bytes.AddRange(new byte[]
100 | 			{
101 | 				0x41, 0x53, 0x43, 0x2d, 0x45, 0x31, 0x2e, 0x31, 0x37, 0x00, 0x00, 0x32
102 | 			});
103 | 			bytes.AddRange(new byte[]
104 | 			{
105 | 				(byte)(expectedFlags << 4), (byte)expectedLength, // flags and length
106 | 				0x00, 0x00, 0x00, (byte)expectedVector, // vector
107 | 			});
108 | 
109 | 			var expectedCid = new List<byte>
110 | 			{
111 | 				1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
112 | 			};
113 | 			bytes.AddRange(expectedCid);
114 | 
115 | 			Assert.Null(RootLayer.Parse(bytes.ToArray()));
116 | 		}
117 | 
118 | 		[Fact]
119 | 		public void When_WriteIsCalled_Then_TheDataIsCorrect()
120 | 		{
121 | 			var expectedCid = new byte[]
122 | 			{
123 | 				1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
124 | 			};
125 | 			var expectedVector = RootLayerVector.VECTOR_ROOT_E131_DATA;
126 | 			var expectedBytes = GetRootLayer(expectedCid, expectedVector);
127 | 
128 | 			RootLayer rootLayer = new RootLayer()
129 | 			{
130 | 				CID = expectedCid,
131 | 				Vector = RootLayerVector.VECTOR_ROOT_E131_DATA
132 | 			};
133 | 
134 | 			using var owner = MemoryPool<byte>.Shared.Rent(RootLayer.Length);
135 | 			var actualBytes = owner.Memory.Span.Slice(0, RootLayer.Length);
136 | 			rootLayer.Write(actualBytes, 0);
137 | 			Assert.Equal(expectedBytes, actualBytes.ToArray());
138 | 		}
139 | 
140 | 		public static List<byte> GetRootLayer(byte[] cid, RootLayerVector vector)
141 | 		{
142 | 			var expectedVector = vector;
143 | 			var expectedFlags = RootLayer.FLAGS;
144 | 			var expectedLength = RootLayer.Length - 16;
145 | 
146 | 			var bytes = new List<byte>
147 | 			{
148 | 				0x00, 0x10, // preamble size
149 | 				0x00, 0x00, // postamble size
150 | 			};
151 | 			bytes.AddRange(RootLayer.ACNIdentifier);
152 | 			bytes.AddRange(new byte[]
153 | 			{
154 | 				(byte)(expectedFlags << 4), (byte)expectedLength, // flags and length
155 | 				0x00, 0x00, 0x00, (byte)expectedVector, // vector
156 | 			});
157 | 
158 | 			bytes.AddRange(cid);
159 | 
160 | 			return bytes;
161 | 		}
162 | 	}
163 | }
164 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/Layers/SynchronizationPacketFramingLayerTests.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN.Layers;
 2 | using Kadmium_sACN.Layers.Framing;
 3 | using System;
 4 | using System.Buffers;
 5 | using System.Collections.Generic;
 6 | using System.Linq;
 7 | using System.Text;
 8 | using System.Threading.Tasks;
 9 | using Xunit;
10 | 
11 | namespace Kadmium_sACN.Test.Layers
12 | {
13 | 	public class SynchronizationPacketFramingLayerTests
14 | 	{
15 | 		[Fact]
16 | 		public void Given_TheDataIsCorrect_When_ParseIsCalled_Then_TheDataIsParsedAsExpected()
17 | 		{
18 | 			UInt16 synchronizationAddress = 1028;
19 | 			byte sequenceNumber = 67;
20 | 			var bytes = GetSynchronizationPacketFramingLayer(sequenceNumber, synchronizationAddress);
21 | 			
22 | 			var framingLayer = SynchronizationPacketFramingLayer.Parse(bytes.ToArray());
23 | 			Assert.Equal(FramingLayerVector.VECTOR_E131_EXTENDED_SYNCHRONIZATION, framingLayer.Vector);
24 | 			Assert.Equal(sequenceNumber, framingLayer.SequenceNumber);
25 | 			Assert.Equal(synchronizationAddress, framingLayer.SynchronizationAddress);
26 | 		}
27 | 
28 | 		[Fact]
29 | 		public void When_WriteIsCalled_Then_TheDataIsCorrect()
30 | 		{
31 | 			UInt16 syncAddress = 1023;
32 | 			byte sequenceNumber = 135;
33 | 			
34 | 			var framingLayer = new SynchronizationPacketFramingLayer()
35 | 			{
36 | 				SynchronizationAddress = syncAddress,
37 | 				SequenceNumber = sequenceNumber
38 | 			};
39 | 
40 | 			var expectedBytes = GetSynchronizationPacketFramingLayer(sequenceNumber, syncAddress);
41 | 
42 | 			using var owner = MemoryPool<byte>.Shared.Rent(SynchronizationPacketFramingLayer.Length);
43 | 			var actualBytes = owner.Memory.Span.Slice(0, SynchronizationPacketFramingLayer.Length);
44 | 			framingLayer.Write(actualBytes);
45 | 			Assert.Equal(expectedBytes.ToArray(), actualBytes.ToArray());
46 | 		}
47 | 
48 | 		public static List<byte> GetSynchronizationPacketFramingLayer(byte sequenceNumber, UInt16 synchronizationAddress)
49 | 		{
50 | 			List<byte> bytes = new List<byte>();
51 | 			bytes.AddRange(new byte[] { 0x7 << 4, 11 }); // flags and length
52 | 			bytes.AddRange(new byte[] { 0, 0, 0, (byte)FramingLayerVector.VECTOR_E131_EXTENDED_SYNCHRONIZATION }); // Vector
53 | 			bytes.Add(sequenceNumber);
54 | 			bytes.AddRange(new byte[] { (byte)((synchronizationAddress & 0xFF00) >> 8) , (byte)(synchronizationAddress & 0xFF) });
55 | 			bytes.AddRange(new byte[] { 0, 0 }); // reserved
56 | 
57 | 			return bytes;
58 | 		}
59 | 	}
60 | }
61 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/Layers/UniverseDiscoveryLayerTests.cs:
--------------------------------------------------------------------------------
  1 | using Kadmium_sACN.Layers;
  2 | using System;
  3 | using System.Buffers;
  4 | using System.Collections.Generic;
  5 | using System.Linq;
  6 | using System.Text;
  7 | using System.Threading.Tasks;
  8 | using Xunit;
  9 | 
 10 | namespace Kadmium_sACN.Test.Layers
 11 | {
 12 | 	public class UniverseDiscoveryLayerTests
 13 | 	{
 14 | 		[Fact]
 15 | 		public void Given_TheDataIsCorrect_When_ParseIsCalled_Then_TheDataIsParsedAsExpected()
 16 | 		{
 17 | 			byte page = 27;
 18 | 			byte lastPage = 28;
 19 | 			
 20 | 			var expectedUniverses = Enumerable.Range(byte.MaxValue, 1023)
 21 | 				.Select(x => (UInt16)x)
 22 | 				.ToArray();
 23 | 
 24 | 			var bytes = GetUniverseDiscoveryLayer(expectedUniverses, page, lastPage);
 25 | 
 26 | 			var universeDiscoveryLayer = UniverseDiscoveryLayer.Parse(bytes.ToArray());
 27 | 			Assert.Equal(UniverseDiscoveryLayerVector.VECTOR_UNIVERSE_DISCOVERY_UNIVERSE_LIST, universeDiscoveryLayer.Vector);
 28 | 			Assert.Equal(page, universeDiscoveryLayer.Page);
 29 | 			Assert.Equal(lastPage, universeDiscoveryLayer.LastPage);
 30 | 			Assert.Equal(expectedUniverses, universeDiscoveryLayer.Universes);
 31 | 		}
 32 | 
 33 | 		[Fact]
 34 | 		public void Given_TheDataContainsTheWrongVector_When_ParseIsCalled_Then_NullIsReturned()
 35 | 		{
 36 | 			List<byte> bytes = new List<byte>();
 37 | 			int universeCount = 5;
 38 | 			byte length = (byte)(UniverseDiscoveryLayer.MinLength + (universeCount << 1));
 39 | 			bytes.AddRange(new byte[] { 0x7 << 4, (length) }); // flags and length
 40 | 			UInt32 expectedVector = 250;
 41 | 			bytes.AddRange(new byte[] { 0, 0, 0, (byte)expectedVector }); // Vector
 42 | 
 43 | 			byte page = 27;
 44 | 			bytes.Add(page);
 45 | 			byte lastPage = 28;
 46 | 			bytes.Add(lastPage);
 47 | 
 48 | 			var expectedUniverses = new UInt16[]
 49 | 			{
 50 | 				1,
 51 | 				2,
 52 | 				3,
 53 | 				4,
 54 | 				5
 55 | 			};
 56 | 
 57 | 			foreach (var expectedUniverse in expectedUniverses)
 58 | 			{
 59 | 				bytes.Add(0);
 60 | 				bytes.Add((byte)expectedUniverse);
 61 | 			}
 62 | 
 63 | 			Assert.Null(UniverseDiscoveryLayer.Parse(bytes.ToArray()));
 64 | 		}
 65 | 
 66 | 		[Fact]
 67 | 		public void When_WriteIsCalled_Then_TheDataIsCorrect()
 68 | 		{
 69 | 			var universes = Enumerable.Range(byte.MaxValue, byte.MaxValue + 1023)
 70 | 				.Select(x => (UInt16)x)
 71 | 				.ToArray();
 72 | 			byte page = 36;
 73 | 			byte lastPage = 230;
 74 | 			var expectedBytes = GetUniverseDiscoveryLayer(universes, page, lastPage);
 75 | 
 76 | 			var universeDiscoveryLayer = new UniverseDiscoveryLayer()
 77 | 			{
 78 | 				Universes = universes,
 79 | 				Page = page,
 80 | 				LastPage = lastPage
 81 | 			};
 82 | 
 83 | 			using var owner = MemoryPool<byte>.Shared.Rent(UniverseDiscoveryLayer.MinLength + (universes.Length << 1));
 84 | 			var actualBytes = owner.Memory.Span.Slice(0, UniverseDiscoveryLayer.MinLength + (universes.Length << 1));
 85 | 			universeDiscoveryLayer.Write(actualBytes);
 86 | 			Assert.Equal(expectedBytes, actualBytes.ToArray());
 87 | 		}
 88 | 
 89 | 		private static List<byte> GetUniverseDiscoveryLayer(IEnumerable<UInt16> universes, byte page, byte lastPage)
 90 | 		{
 91 | 			List<byte> bytes = new List<byte>();
 92 | 			int universeCount = universes.Count();
 93 | 			UInt16 length = (UInt16)(UniverseDiscoveryLayer.MinLength + (universeCount << 1));
 94 | 			bytes.AddRange(new byte[] { (byte)((0x7 << 4) | (length & 0x0F00) >> 8), (byte)(length & 0xFF) }); // flags and length
 95 | 			bytes.AddRange(new byte[] { 0, 0, 0, (byte)UniverseDiscoveryLayerVector.VECTOR_UNIVERSE_DISCOVERY_UNIVERSE_LIST }); // Vector
 96 | 
 97 | 			bytes.Add(page);
 98 | 			bytes.Add(lastPage);
 99 | 
100 | 			foreach(var universe in universes)
101 | 			{
102 | 				bytes.AddRange(BitConverter.IsLittleEndian ? BitConverter.GetBytes(universe).Reverse() : BitConverter.GetBytes(universe));
103 | 			}
104 | 
105 | 			return bytes;
106 | 		}
107 | 	}
108 | }
109 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/Layers/UniverseDiscoveryPacketFramingLayerTests.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN.Layers;
 2 | using Kadmium_sACN.Layers.Framing;
 3 | using System;
 4 | using System.Buffers;
 5 | using System.Collections.Generic;
 6 | using System.Linq;
 7 | using System.Text;
 8 | using System.Threading.Tasks;
 9 | using Xunit;
10 | 
11 | namespace Kadmium_sACN.Test.Layers
12 | {
13 | 	public class UniverseDiscoveryPacketFramingLayerTests
14 | 	{
15 | 		[Fact]
16 | 		public void Given_TheDataIsCorrect_When_ParseIsCalled_Then_TheDataIsParsedAsExpected()
17 | 		{
18 | 			string sourceName = "This is the source name";
19 | 			var bytes = GetUniverseDiscoveryPacketFramingLayer(sourceName);
20 | 
21 | 			var framingLayer = UniverseDiscoveryPacketFramingLayer.Parse(bytes.ToArray());
22 | 			Assert.Equal(FramingLayerVector.VECTOR_E131_EXTENDED_DISCOVERY, framingLayer.Vector);
23 | 			Assert.Equal(sourceName, framingLayer.SourceName);
24 | 		}
25 | 
26 | 		[Fact]
27 | 		public void Given_TheVectorIsIncorrect_When_ParseIsCalled_Then_NullIsReturned()
28 | 		{
29 | 			List<byte> bytes = new List<byte>();
30 | 			bytes.AddRange(new byte[] { 0x7 << 4, UniverseDiscoveryPacketFramingLayer.Length }); // flags and length
31 | 			bytes.AddRange(new byte[] { 0, 0, 0, (byte)42}); // Vector
32 | 
33 | 			string sourceName = "This is the source name";
34 | 			bytes.AddRange(Encoding.UTF8.GetBytes(sourceName));
35 | 			bytes.AddRange(Enumerable.Repeat((byte)0, 64 - sourceName.Length));
36 | 			bytes.AddRange(new byte[] { 0, 0, 0, 0 }); // reserved
37 | 
38 | 			Assert.Null(UniverseDiscoveryPacketFramingLayer.Parse(bytes.ToArray()));
39 | 		}
40 | 
41 | 		[Fact]
42 | 		public void When_WriteIsCalled_Then_TheDataIsCorrect()
43 | 		{
44 | 			string sourceName = "My source name";
45 | 			
46 | 			var framingLayer = new UniverseDiscoveryPacketFramingLayer()
47 | 			{
48 | 				SourceName = sourceName
49 | 			};
50 | 
51 | 			var expectedBytes = GetUniverseDiscoveryPacketFramingLayer(sourceName);
52 | 
53 | 			using var owner = MemoryPool<byte>.Shared.Rent(UniverseDiscoveryPacketFramingLayer.Length);
54 | 			var actualBytes = owner.Memory.Span.Slice(0, UniverseDiscoveryPacketFramingLayer.Length);
55 | 			framingLayer.Write(actualBytes, 0);
56 | 			Assert.Equal(expectedBytes.ToArray(), actualBytes.ToArray());
57 | 		}
58 | 
59 | 		public static List<byte> GetUniverseDiscoveryPacketFramingLayer(string sourceName)
60 | 		{
61 | 			List<byte> bytes = new List<byte>();
62 | 			bytes.AddRange(new byte[] { 0x7 << 4, UniverseDiscoveryPacketFramingLayer.Length }); // flags and length
63 | 			FramingLayerVector expectedVector = FramingLayerVector.VECTOR_E131_EXTENDED_DISCOVERY;
64 | 			bytes.AddRange(new byte[] { 0, 0, 0, (byte)expectedVector }); // Vector
65 | 
66 | 			bytes.AddRange(Encoding.UTF8.GetBytes(sourceName));
67 | 			bytes.AddRange(Enumerable.Repeat((byte)0, 64 - sourceName.Length));
68 | 			bytes.AddRange(new byte[] { 0, 0, 0, 0 }); // reserved
69 | 
70 | 			return bytes;
71 | 		}
72 | 	}
73 | }
74 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/MulticastAddressProvider/SacnMulticastAddressProviderIPV4Tests.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN.MulticastAddressProvider;
 2 | using Moq;
 3 | using System;
 4 | using System.Collections.Generic;
 5 | using System.Linq;
 6 | using System.Net;
 7 | using System.Text;
 8 | using System.Threading.Tasks;
 9 | using Xunit;
10 | 
11 | namespace Kadmium_sACN.Test.MulticastAddressProvider
12 | {
13 | 	public class SacnMulticastAddressProviderIPV4Tests
14 | 	{
15 | 		[Theory]
16 | 		[InlineData(1, "239.255.0.1")]
17 | 		[InlineData(256, "239.255.1.0")]
18 | 		[InlineData(63999, "239.255.249.255")]
19 | 		public void When_GetIPV4MulticastAddressIsCalled_Then_TheResultIsAsExpected(UInt16 universe, string expectedAddressString)
20 | 		{
21 | 			var addressProvider = new SacnMulticastAddressProviderIPV4();
22 | 			var actual = addressProvider.GetMulticastAddress(universe);
23 | 			var expected = IPAddress.Parse(expectedAddressString);
24 | 
25 | 			Assert.Equal(expected, actual);
26 | 		}
27 | 	}
28 | }
29 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/MulticastAddressProvider/SacnMulticastAddressProviderIPV6Tests.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN.MulticastAddressProvider;
 2 | using Moq;
 3 | using System;
 4 | using System.Collections.Generic;
 5 | using System.Linq;
 6 | using System.Net;
 7 | using System.Text;
 8 | using System.Threading.Tasks;
 9 | using Xunit;
10 | 
11 | namespace Kadmium_sACN.Test.MulticastAddressProvider
12 | {
13 | 	public class SacnMulticastAddressProviderIPV6Tests
14 | 	{
15 | 		[Theory]
16 | 		[InlineData(1, "FF18::83:00:00:01")]
17 | 		[InlineData(256, "FF18::83:00:01:00")]
18 | 		[InlineData(63999, "FF18::83:00:F9:FF")]
19 | 		public void When_GetIPV6MulticastAddressIsCalled_Then_TheResultIsAsExpected(UInt16 universe, string expectedAddressString)
20 | 		{
21 | 			var addressProvider = new SacnMulticastAddressProviderIPV6();
22 | 			var actual = addressProvider.GetMulticastAddress(universe);
23 | 			var expected = IPAddress.Parse(expectedAddressString);
24 | 
25 | 			Assert.Equal(expected, actual);
26 | 		}
27 | 	}
28 | }
29 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/SACNPacketTests.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN.Layers;
 2 | using Kadmium_sACN.Layers.Framing;
 3 | using System;
 4 | using System.Buffers;
 5 | using System.Collections.Generic;
 6 | using System.Linq;
 7 | using System.Text;
 8 | using System.Threading.Tasks;
 9 | using Xunit;
10 | 
11 | namespace Kadmium_sACN.Test
12 | {
13 | 	public class SacnPacketTests
14 | 	{
15 | 		[Fact]
16 | 		public void Given_ThePacketIsAValidDataPacket_When_ParseIsCalled_Then_ThePacketIsParsedCorrectly()
17 | 		{
18 | 			byte[] CID = Enumerable.Range(1, 12).Select(x => (byte)x).ToArray();
19 | 			string sourceName = "Source name";
20 | 			UInt16 universe = 1050;
21 | 			byte[] properties = Enumerable.Range(0, 200).Select(x => (byte)x).ToArray();
22 | 
23 | 			var bytes = DataPacketTests.GetDataPacket(CID, sourceName, universe, properties);
24 | 			
25 | 			var packet = SacnPacket.Parse(bytes);
26 | 
27 | 			Assert.NotNull(packet);
28 | 			Assert.IsType<DataPacket>(packet);
29 | 		}
30 | 
31 | 		[Fact]
32 | 		public void Given_ThePacketIsAValidUniverseDiscoveryPacket_When_ParseIsCalled_Then_ThePacketIsParsedCorrectly()
33 | 		{
34 | 			byte[] CID = Enumerable.Range(1, 12).Select(x => (byte)x).ToArray();
35 | 			var rootLayer = new RootLayer
36 | 			{
37 | 				CID = CID,
38 | 				Vector = RootLayerVector.VECTOR_ROOT_E131_EXTENDED
39 | 			};
40 | 
41 | 			string sourceName = "Source name";
42 | 			
43 | 			var framingLayer = new UniverseDiscoveryPacketFramingLayer
44 | 			{
45 | 				SourceName = sourceName
46 | 			};
47 | 
48 | 			UInt16[] universes = Enumerable.Range(200, 1000)
49 | 				.Select(x => (UInt16)x)
50 | 				.ToArray();
51 | 
52 | 			var discoveryLayer = new UniverseDiscoveryLayer
53 | 			{
54 | 				Universes = universes,
55 | 				Page = 25,
56 | 				LastPage = 25
57 | 			};
58 | 
59 | 			int totalLength = discoveryLayer.Length + UniverseDiscoveryPacketFramingLayer.Length + RootLayer.Length;
60 | 			using var owner = MemoryPool<byte>.Shared.Rent(totalLength);
61 | 			var bytes = owner.Memory.Span.Slice(0, totalLength);
62 | 
63 | 			rootLayer.Write(bytes, (UInt16)(UniverseDiscoveryPacketFramingLayer.Length + discoveryLayer.Length));
64 | 			framingLayer.Write(bytes.Slice(RootLayer.Length), discoveryLayer.Length);
65 | 			discoveryLayer.Write(bytes.Slice(RootLayer.Length + UniverseDiscoveryPacketFramingLayer.Length));
66 | 
67 | 			var packet = SacnPacket.Parse(bytes);
68 | 
69 | 			Assert.NotNull(packet);
70 | 			Assert.IsType<UniverseDiscoveryPacket>(packet);
71 | 		}
72 | 
73 | 		[Fact]
74 | 		public void Given_ThePacketIsAValidSynchronizationPacket_When_ParseIsCalled_Then_ThePacketIsParsedCorrectly()
75 | 		{
76 | 			byte[] CID = Enumerable.Range(1, 12).Select(x => (byte)x).ToArray();
77 | 			byte sequenceNumber = 124;
78 | 			var bytes = SynchronizationPacketTests.GetSynchronizationPacket(CID, sequenceNumber);
79 | 			
80 | 			var packet = SacnPacket.Parse(bytes);
81 | 
82 | 			Assert.NotNull(packet);
83 | 			Assert.IsType<SynchronizationPacket>(packet);
84 | 		}
85 | 	}
86 | }
87 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/SacnPacketFactoryTests.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text;
  5 | using System.Threading.Tasks;
  6 | using Xunit;
  7 | 
  8 | namespace Kadmium_sACN.Test
  9 | {
 10 | 	public class SacnPacketFactoryTests
 11 | 	{
 12 | 		[Fact]
 13 | 		public void When_NewDataPacketsAreCreated_Then_TheirSequenceNumbersAreIncremented()
 14 | 		{
 15 | 			var sacnPacketFactory = GetPacketFactory();
 16 | 			var first = sacnPacketFactory.CreateDataPacket(1, new byte[] { 0 });
 17 | 			var second = sacnPacketFactory.CreateDataPacket(1, new byte[] { 255 });
 18 | 
 19 | 			var expectedFirstSequenceNumber = 0;
 20 | 			var expectedSecondSequenceNumber = 1;
 21 | 
 22 | 			Assert.Equal(expectedFirstSequenceNumber, first.FramingLayer.SequenceNumber);
 23 | 			Assert.Equal(expectedSecondSequenceNumber, second.FramingLayer.SequenceNumber);
 24 | 		}
 25 | 
 26 | 		[Fact]
 27 | 		public void Given_TheSequenceNumberIs255_When_NewDataPacketsAreCreated_Then_TheirSequenceNumbersAreReset()
 28 | 		{
 29 | 			var sacnPacketFactory = GetPacketFactory();
 30 | 			for(int i = 0; i < 255; i++)
 31 | 			{
 32 | 				sacnPacketFactory.CreateDataPacket(1, new byte[] { 0 });
 33 | 			}
 34 | 			var first = sacnPacketFactory.CreateDataPacket(1, new byte[] { 0 });
 35 | 			var second = sacnPacketFactory.CreateDataPacket(1, new byte[] { 255 });
 36 | 
 37 | 			var expectedFirstSequenceNumber = 255;
 38 | 			var expectedSecondSequenceNumber = 0;
 39 | 
 40 | 			Assert.Equal(expectedFirstSequenceNumber, first.FramingLayer.SequenceNumber);
 41 | 			Assert.Equal(expectedSecondSequenceNumber, second.FramingLayer.SequenceNumber);
 42 | 		}
 43 | 
 44 | 		[Fact]
 45 | 		public void When_NewDataPacketsAreCreated_Then_TheCIDIsSet()
 46 | 		{
 47 | 			var cid = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
 48 | 			var sourceName = "This is a source";
 49 | 			var sacnPacketFactory = new SacnPacketFactory(cid, sourceName);
 50 | 			var packet = sacnPacketFactory.CreateDataPacket(1, new byte[] { 0 });
 51 | 			
 52 | 			Assert.Equal(cid, packet.RootLayer.CID);
 53 | 		}
 54 | 
 55 | 		[Fact]
 56 | 		public void When_NewDataPacketsAreCreated_Then_TheSourceNameIsSet()
 57 | 		{
 58 | 			var cid = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
 59 | 			var sourceName = "This is a source";
 60 | 			var sacnPacketFactory = new SacnPacketFactory(cid, sourceName);
 61 | 			var packet = sacnPacketFactory.CreateDataPacket(1, new byte[] { 0 });
 62 | 
 63 | 			Assert.Equal(sourceName, packet.FramingLayer.SourceName);
 64 | 		}
 65 | 
 66 | 		[Fact]
 67 | 		public void When_NewDataPacketsAreCreated_Then_TheUniverseIsSet()
 68 | 		{
 69 | 			var expectedUniverse = (UInt16)25;
 70 | 			var sacnPacketFactory = GetPacketFactory();
 71 | 			var packet = sacnPacketFactory.CreateDataPacket(expectedUniverse, new byte[] { 0 });
 72 | 
 73 | 			Assert.Equal(expectedUniverse, packet.FramingLayer.Universe);
 74 | 		}
 75 | 
 76 | 		[Fact]
 77 | 		public void When_NewDataPacketsAreCreated_Then_ThePriorityIsSet()
 78 | 		{
 79 | 			var expectedPriority = (byte)195;
 80 | 			var sacnPacketFactory = GetPacketFactory();
 81 | 			var packet = sacnPacketFactory.CreateDataPacket(1, new byte[] { 0 }, priority: expectedPriority);
 82 | 
 83 | 			Assert.Equal(expectedPriority, packet.FramingLayer.Priority);
 84 | 		}
 85 | 
 86 | 		[Fact]
 87 | 		public void When_NewDataPacketsAreCreated_Then_TheStartCodeIsSet()
 88 | 		{
 89 | 			var expectedStartCode = (byte)202;
 90 | 			var sacnPacketFactory = GetPacketFactory();
 91 | 			var packet = sacnPacketFactory.CreateDataPacket(1, new byte[] { 0 }, startCode: expectedStartCode);
 92 | 
 93 | 			Assert.Equal(expectedStartCode, packet.DMPLayer.StartCode);
 94 | 		}
 95 | 
 96 | 		[Fact]
 97 | 		public void When_NewDataPacketsAreCreated_Then_ThePropertiesAreSet()
 98 | 		{
 99 | 			var expectedProperties = Enumerable.Range(0, 255)
100 | 				.Select(x => (byte)x);
101 | 
102 | 			var sacnPacketFactory = GetPacketFactory();
103 | 			var packet = sacnPacketFactory.CreateDataPacket(1, expectedProperties);
104 | 
105 | 			Assert.Equal(expectedProperties, packet.DMPLayer.PropertyValues);
106 | 		}
107 | 
108 | 		[Theory]
109 | 		[InlineData(UniverseDiscoveryPacket.PageSize, 1)]
110 | 		[InlineData(UniverseDiscoveryPacket.PageSize + 1, 2)]
111 | 		[InlineData(63999, 125)]
112 | 		public void When_NewDiscoveryPacketsAreCreated_Then_TheNumberOfPacketsIsAsExpected(int universeCount, int expectedPacketCount)
113 | 		{
114 | 			var sacnPacketFactory = GetPacketFactory();
115 | 			var universes = Enumerable.Range(1, universeCount)
116 | 				.Select(x => (UInt16)x);
117 | 			var packets = sacnPacketFactory.CreateUniverseDiscoveryPackets(universes);
118 | 
119 | 			Assert.Equal(expectedPacketCount, packets.Count());
120 | 		}
121 | 
122 | 		private static SacnPacketFactory GetPacketFactory()
123 | 		{
124 | 			var cid = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
125 | 			var sourceName = "This is a source";
126 | 			var sacnPacketFactory = new SacnPacketFactory(cid, sourceName);
127 | 			return sacnPacketFactory;
128 | 		}
129 | 	}
130 | }
131 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/SynchronizationPacketTests.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN.Layers;
 2 | using Kadmium_sACN.Layers.Framing;
 3 | using System;
 4 | using System.Buffers;
 5 | using System.Collections.Generic;
 6 | using System.Linq;
 7 | using System.Text;
 8 | using System.Threading.Tasks;
 9 | using Xunit;
10 | 
11 | namespace Kadmium_sACN.Test
12 | {
13 | 	public class SynchronizationPacketTests
14 | 	{
15 | 		[Fact]
16 | 		public void When_WriteIsCalled_Then_TheDataIsCorrect()
17 | 		{
18 | 			byte[] CID = Enumerable.Range(1, 12).Select(x => (byte)x).ToArray();
19 | 			byte sequenceNumber = 124;
20 | 
21 | 			SynchronizationPacket packet = new SynchronizationPacket();
22 | 			packet.RootLayer.CID = CID;
23 | 			packet.FramingLayer.SequenceNumber = sequenceNumber;
24 | 			
25 | 			var expectedBytes = GetSynchronizationPacket(CID, sequenceNumber);
26 | 
27 | 			using var owner = MemoryPool<byte>.Shared.Rent(packet.Length);
28 | 			var bytes = owner.Memory.Span.Slice(0, packet.Length);
29 | 			packet.Write(bytes);
30 | 
31 | 			Assert.Equal(expectedBytes.ToArray(), bytes.ToArray());
32 | 
33 | 		}
34 | 
35 | 		public static Span<byte> GetSynchronizationPacket(byte[] CID, byte sequenceNumber)
36 | 		{
37 | 			var rootLayer = new RootLayer
38 | 			{
39 | 				CID = CID,
40 | 				Vector = RootLayerVector.VECTOR_ROOT_E131_EXTENDED
41 | 			};
42 | 
43 | 			var framingLayer = new SynchronizationPacketFramingLayer
44 | 			{
45 | 				SequenceNumber = sequenceNumber
46 | 			};
47 | 
48 | 			int totalLength = SynchronizationPacketFramingLayer.Length + RootLayer.Length;
49 | 			using var owner = MemoryPool<byte>.Shared.Rent(totalLength);
50 | 			var bytes = owner.Memory.Span.Slice(0, totalLength);
51 | 
52 | 			rootLayer.Write(bytes, (UInt16)(SynchronizationPacketFramingLayer.Length));
53 | 			framingLayer.Write(bytes.Slice(RootLayer.Length));
54 | 
55 | 			return bytes;
56 | 		}
57 | 	}
58 | }
59 | 


--------------------------------------------------------------------------------
/Kadmium-sACN.Test/UniverseDiscoveryPacketTests.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN.Layers;
 2 | using Kadmium_sACN.Layers.Framing;
 3 | using System;
 4 | using System.Buffers;
 5 | using System.Collections.Generic;
 6 | using System.Linq;
 7 | using System.Text;
 8 | using System.Threading.Tasks;
 9 | using Xunit;
10 | 
11 | namespace Kadmium_sACN.Test
12 | {
13 | 	public class UniverseDiscoveryPacketTests
14 | 	{
15 | 		[Fact]
16 | 		public void When_WriteIsCalled_Then_TheDataIsCorrect()
17 | 		{
18 | 			byte[] CID = Enumerable.Range(1, 12).Select(x => (byte)x).ToArray();
19 | 			var sourceName = "This is a good enough source name";
20 | 			byte page = 1;
21 | 			byte lastPage = 45;
22 | 			UInt16[] universes = Enumerable.Range(25, 25)
23 | 				.Select(x => (UInt16)x)
24 | 				.ToArray();
25 | 
26 | 			var packet = new UniverseDiscoveryPacket();
27 | 			packet.RootLayer.CID = CID;
28 | 			packet.FramingLayer.SourceName = sourceName;
29 | 			packet.UniverseDiscoveryLayer.Page = page;
30 | 			packet.UniverseDiscoveryLayer.LastPage = page;
31 | 			packet.UniverseDiscoveryLayer.Universes = universes;
32 | 
33 | 			var expectedBytes = GetUniverseDiscoveryPacket(CID, sourceName, page, lastPage, universes);
34 | 
35 | 			using var owner = MemoryPool<byte>.Shared.Rent(packet.Length);
36 | 			var bytes = owner.Memory.Span.Slice(0, packet.Length);
37 | 			packet.Write(bytes);
38 | 
39 | 			Assert.Equal(expectedBytes.ToArray(), bytes.ToArray());
40 | 
41 | 		}
42 | 
43 | 		public static Span<byte> GetUniverseDiscoveryPacket(byte[] CID, string sourceName, byte page, byte lastPage, UInt16[] universes)
44 | 		{
45 | 			var rootLayer = new RootLayer
46 | 			{
47 | 				CID = CID,
48 | 				Vector = RootLayerVector.VECTOR_ROOT_E131_EXTENDED
49 | 			};
50 | 
51 | 			var framingLayer = new UniverseDiscoveryPacketFramingLayer
52 | 			{
53 | 				SourceName = sourceName
54 | 			};
55 | 
56 | 			var universeDiscoveryLayer = new UniverseDiscoveryLayer
57 | 			{
58 | 				Page = page,
59 | 				LastPage = lastPage,
60 | 				Universes = universes
61 | 			};
62 | 
63 | 
64 | 			int totalLength = RootLayer.Length + UniverseDiscoveryPacketFramingLayer.Length + universeDiscoveryLayer.Length;
65 | 			using var owner = MemoryPool<byte>.Shared.Rent(totalLength);
66 | 			var bytes = owner.Memory.Span.Slice(0, totalLength);
67 | 
68 | 			rootLayer.Write(bytes, (UInt16)(SynchronizationPacketFramingLayer.Length + universeDiscoveryLayer.Length));
69 | 			framingLayer.Write(bytes.Slice(RootLayer.Length), universeDiscoveryLayer.Length);
70 | 			universeDiscoveryLayer.Write(bytes.Slice(RootLayer.Length + UniverseDiscoveryPacketFramingLayer.Length));
71 | 
72 | 			return bytes;
73 | 		}
74 | 	}
75 | }
76 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/Constants.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text;
 4 | 
 5 | namespace Kadmium_sACN
 6 | {
 7 | 	public static class Constants
 8 | 	{
 9 | 		public const int Port = 5568;
10 | 		public const int MaxPacketLength = 1444;
11 | 		public const int Universe_MinValue = 1;
12 | 		public const int Universe_MaxValue = 63999;
13 | 		public const int Priority_MaxValue = 200;
14 | 		public const byte Priority_Default = 100;
15 | 	}
16 | }
17 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/DataPacket.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN.Layers;
 2 | using Kadmium_sACN.Layers.Framing;
 3 | using System;
 4 | using System.Collections.Generic;
 5 | using System.Text;
 6 | 
 7 | namespace Kadmium_sACN
 8 | {
 9 | 	public class DataPacket : SacnPacket
10 | 	{
11 | 		public DataPacketFramingLayer FramingLayer { get; set; }
12 | 		public DMPLayer DMPLayer { get; set; }
13 | 		public override int Length => RootLayer.Length + DataPacketFramingLayer.Length + DMPLayer.Length;
14 | 		public const int MAX_LENGTH = 1143;
15 | 
16 | 		public DataPacket()
17 | 		{
18 | 			RootLayer = new RootLayer
19 | 			{
20 | 				Vector = RootLayerVector.VECTOR_ROOT_E131_DATA
21 | 			};
22 | 			FramingLayer = new DataPacketFramingLayer();
23 | 			DMPLayer = new DMPLayer();
24 | 		}
25 | 
26 | 		public static DataPacket Parse(ReadOnlySpan<byte> bytes, RootLayer rootLayer, DataPacketFramingLayer framingLayer)
27 | 		{
28 | 			DataPacket dataPacket = new DataPacket
29 | 			{
30 | 				RootLayer = rootLayer,
31 | 				FramingLayer = framingLayer,
32 | 				DMPLayer = DMPLayer.Parse(bytes)
33 | 			};
34 | 
35 | 			return dataPacket;
36 | 		}
37 | 
38 | 		public override void Write(Span<byte> bytes)
39 | 		{
40 | 			RootLayer.Write(bytes, (UInt16)(DataPacketFramingLayer.Length + DMPLayer.Length));
41 | 			FramingLayer.Write(bytes.Slice(RootLayer.Length), (UInt16)(DMPLayer.Length));
42 | 			DMPLayer.Write(bytes.Slice(RootLayer.Length + DataPacketFramingLayer.Length));
43 | 		}
44 | 	}
45 | }
46 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/IEnumerableExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | 
 6 | namespace Kadmium_sACN
 7 | {
 8 | 	public static class IEnumerableExtensions
 9 | 	{
10 | 		public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> collection, int chunkSize)
11 | 		{
12 | 			int count = collection.Count();
13 | 			int chunkCount = count / chunkSize;
14 | 			if (count % chunkSize > 0)
15 | 			{
16 | 				chunkCount++;
17 | 			}
18 | 			for (int i = 0; i < chunkCount; i++)
19 | 			{
20 | 				yield return collection.Skip(chunkSize * i).Take(chunkSize);
21 | 			}
22 | 		}
23 | 	}
24 | }
25 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/Kadmium-sACN.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>netstandard2.1</TargetFramework>
 5 |     <RootNamespace>Kadmium_sACN</RootNamespace>
 6 |   </PropertyGroup>
 7 | 
 8 |   <PropertyGroup>
 9 |     <Title>Kadmium sACN</Title>
10 |     <Description>A fairly lightweight sACN package for .Net Standard</Description>
11 |     <PackageLicenseExpression>MIT</PackageLicenseExpression>
12 |     <Version>3.0.1</Version>
13 |     <Authors>Jesse Higginson</Authors>
14 |     <PackageProjectUrl>https://github.com/iKadmium/kadmium-sacn</PackageProjectUrl>
15 |     <RepositoryUrl>https://github.com/iKadmium/kadmium-sacn.git</RepositoryUrl>
16 |     <RepositoryType>git</RepositoryType>
17 |   </PropertyGroup>
18 | 
19 |   <ItemGroup>
20 |     <PackageReference Include="System.IO.Pipelines" Version="5.0.1" />
21 |     <PackageReference Include="System.Memory" Version="4.5.4" />
22 |     <InternalsVisibleTo Include="Kadmium-sACN.Test" />
23 |     <InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
24 |   </ItemGroup>
25 | 
26 | </Project>


--------------------------------------------------------------------------------
/Kadmium-sACN/Layers/DMPLayer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Buffers.Binary;
 3 | using System.Collections.Generic;
 4 | using System.Collections.Specialized;
 5 | using System.Linq;
 6 | using System.Text;
 7 | 
 8 | namespace Kadmium_sACN.Layers
 9 | {
10 | 	public enum DMPLayerVector
11 | 	{
12 | 		VECTOR_DMP_SET_PROPERTY = 0x02
13 | 	}
14 | 
15 | 	public class DMPLayer : SACNLayer
16 | 	{
17 | 		public const UInt16 MinLength = 11;
18 | 
19 | 		public const byte AddressTypeAndDataType = 0xa1;
20 | 		public const UInt16 FirstPropertyAddress = 0x00;
21 | 		public const UInt16 AddressIncrement = 0x01;
22 | 
23 | 		public DMPLayerVector Vector { get; set; }
24 | 		public byte StartCode { get; set; }
25 | 		public IEnumerable<byte> PropertyValues { get; set; }
26 | 		public UInt16 Length => (UInt16)(MinLength + PropertyValues.Count());
27 | 
28 | 		public DMPLayer()
29 | 		{
30 | 			Vector = DMPLayerVector.VECTOR_DMP_SET_PROPERTY;
31 | 		}
32 | 
33 | 		public void Write(Span<byte> bytes)
34 | 		{
35 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, GetFlagsAndLength(Length));
36 | 			bytes = bytes.Slice(sizeof(UInt16));
37 | 			bytes[0] = (byte)Vector;
38 | 			bytes = bytes.Slice(sizeof(byte));
39 | 			bytes[0] = AddressTypeAndDataType;
40 | 			bytes = bytes.Slice(sizeof(byte));
41 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, FirstPropertyAddress);
42 | 			bytes = bytes.Slice(sizeof(UInt16));
43 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, AddressIncrement);
44 | 			bytes = bytes.Slice(sizeof(UInt16));
45 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, (UInt16)(PropertyValues.Count() + 1));
46 | 			bytes = bytes.Slice(sizeof(UInt16));
47 | 			bytes[0] = StartCode;
48 | 			bytes = bytes.Slice(sizeof(byte));
49 | 			PropertyValues.ToArray().CopyTo(bytes);
50 | 		}
51 | 
52 | 		public static DMPLayer Parse(ReadOnlySpan<byte> bytes)
53 | 		{
54 | 			DMPLayer dmpLayer = new DMPLayer();
55 | 
56 | 			var flagsAndLength = BinaryPrimitives.ReadUInt16BigEndian(bytes);
57 | 			bytes = bytes.Slice(sizeof(UInt16));
58 | 
59 | 			dmpLayer.Vector = (DMPLayerVector)bytes[0];
60 | 			bytes = bytes.Slice(sizeof(byte));
61 | 
62 | 			var addressTypeAndDataType = bytes[0];
63 | 			bytes = bytes.Slice(sizeof(byte));
64 | 			if (addressTypeAndDataType != AddressTypeAndDataType)
65 | 			{
66 | 				return null;
67 | 			}
68 | 
69 | 			var firstPropertyAddress = BinaryPrimitives.ReadUInt16BigEndian(bytes);
70 | 			bytes = bytes.Slice(sizeof(UInt16));
71 | 			if (firstPropertyAddress != FirstPropertyAddress)
72 | 			{
73 | 				return null;
74 | 			}
75 | 
76 | 			var addressIncrement = BinaryPrimitives.ReadUInt16BigEndian(bytes);
77 | 			bytes = bytes.Slice(sizeof(UInt16));
78 | 			if (addressIncrement != AddressIncrement)
79 | 			{
80 | 				return null;
81 | 			}
82 | 
83 | 			var propertyValueCount = BinaryPrimitives.ReadUInt16BigEndian(bytes);
84 | 			bytes = bytes.Slice(sizeof(UInt16));
85 | 
86 | 			dmpLayer.StartCode = bytes[0];
87 | 			bytes = bytes.Slice(sizeof(byte));
88 | 
89 | 			var propertyValues = new byte[propertyValueCount - 1];
90 | 
91 | 			var propertyValuesSlice = bytes.Slice(0, propertyValueCount - 1);
92 | 			propertyValuesSlice.CopyTo(propertyValues);
93 | 			dmpLayer.PropertyValues = propertyValues;
94 | 
95 | 			return dmpLayer;
96 | 		}
97 | 	}
98 | }
99 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/Layers/Framing/DataPacketFramingLayer.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Buffers.Binary;
  3 | using System.Collections.Generic;
  4 | using System.Text;
  5 | 
  6 | namespace Kadmium_sACN.Layers.Framing
  7 | {
  8 | 	public class DataPacketFramingLayer : FramingLayer
  9 | 	{
 10 | 		public const byte PreviewDataMask = 0b00000010;
 11 | 		public const byte StreamTerminatedMask = 0b00000100;
 12 | 		public const byte ForceSynchronizationMask = 0b00001000;
 13 | 
 14 | 		public const int Length = 77;
 15 | 
 16 | 
 17 | 		public string SourceName { get; set; }
 18 | 		private byte priority = Constants.Priority_Default;
 19 | 		public byte Priority
 20 | 		{
 21 | 			get { return priority; }
 22 | 			set
 23 | 			{
 24 | 				if (value > Constants.Priority_MaxValue)
 25 | 				{
 26 | 					throw new ArgumentOutOfRangeException($"Priority may not exceed {Constants.Priority_MaxValue}");
 27 | 				}
 28 | 				priority = value;
 29 | 			}
 30 | 		}
 31 | 		public UInt16 SynchronizationAddress { get; set; }
 32 | 		public byte SequenceNumber { get; set; }
 33 | 		public bool PreviewData { get; set; }
 34 | 		public bool StreamTerminated { get; set; }
 35 | 		public bool ForceSynchronization { get; set; }
 36 | 		private UInt16 universe;
 37 | 		public UInt16 Universe
 38 | 		{
 39 | 			get { return universe; }
 40 | 			set
 41 | 			{
 42 | 				if (value < Constants.Universe_MinValue || value > Constants.Universe_MaxValue)
 43 | 				{
 44 | 					throw new ArgumentOutOfRangeException($"Universe must be between {Constants.Universe_MinValue} and {Constants.Universe_MaxValue}");
 45 | 				}
 46 | 				universe = value;
 47 | 			}
 48 | 		}
 49 | 
 50 | 		public byte Options
 51 | 		{
 52 | 			get
 53 | 			{
 54 | 				byte options = 0;
 55 | 				if (PreviewData)
 56 | 				{
 57 | 					options |= PreviewDataMask;
 58 | 				}
 59 | 				if (StreamTerminated)
 60 | 				{
 61 | 					options |= StreamTerminatedMask;
 62 | 				}
 63 | 				if (ForceSynchronization)
 64 | 				{
 65 | 					options |= ForceSynchronizationMask;
 66 | 				}
 67 | 				return options;
 68 | 			}
 69 | 			set
 70 | 			{
 71 | 				PreviewData = (value & PreviewDataMask) != 0;
 72 | 				StreamTerminated = (value & StreamTerminatedMask) != 0;
 73 | 				ForceSynchronization = (value & ForceSynchronizationMask) != 0;
 74 | 			}
 75 | 		}
 76 | 
 77 | 
 78 | 
 79 | 		public DataPacketFramingLayer()
 80 | 		{
 81 | 			Vector = FramingLayerVector.VECTOR_E131_DATA_PACKET;
 82 | 		}
 83 | 
 84 | 		public void Write(Span<byte> bytes, ushort remainingLength)
 85 | 		{
 86 | 			UInt16 pduLength = (UInt16)(remainingLength + Length);
 87 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, GetFlagsAndLength(pduLength));
 88 | 			bytes = bytes.Slice(sizeof(UInt16));
 89 | 			BinaryPrimitives.WriteUInt32BigEndian(bytes, (UInt32)Vector);
 90 | 			bytes = bytes.Slice(sizeof(UInt32));
 91 | 			var sourceNameBytes = Encoding.UTF8.GetBytes(SourceName);
 92 | 			sourceNameBytes.CopyTo(bytes);
 93 | 			bytes = bytes.Slice(sourceNameBytes.Length);
 94 | 			var paddingLength = 64 - sourceNameBytes.Length;
 95 | 			bytes.Slice(0, paddingLength).Fill(0);
 96 | 			bytes = bytes.Slice(paddingLength);
 97 | 			bytes[0] = Priority;
 98 | 			bytes = bytes.Slice(sizeof(byte));
 99 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, SynchronizationAddress);
100 | 			bytes = bytes.Slice(sizeof(UInt16));
101 | 			bytes[0] = SequenceNumber;
102 | 			bytes = bytes.Slice(sizeof(byte));
103 | 			bytes[0] = Options;
104 | 			bytes = bytes.Slice(sizeof(byte));
105 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, Universe);
106 | 		}
107 | 
108 | 		public static DataPacketFramingLayer Parse(ReadOnlySpan<byte> bytes)
109 | 		{
110 | 			DataPacketFramingLayer framingLayer = new DataPacketFramingLayer();
111 | 
112 | 			var flagsAndLength = BinaryPrimitives.ReadUInt16BigEndian(bytes);
113 | 			bytes = bytes.Slice(sizeof(UInt16));
114 | 
115 | 			framingLayer.Vector = (FramingLayerVector)BinaryPrimitives.ReadUInt32BigEndian(bytes);
116 | 			bytes = bytes.Slice(sizeof(UInt32));
117 | 
118 | 			var sourceNameBytes = bytes.Slice(0, 64);
119 | 			bytes = bytes.Slice(64);
120 | 			framingLayer.SourceName = Encoding.UTF8.GetString(sourceNameBytes);
121 | 
122 | 			framingLayer.Priority = bytes[0];
123 | 			bytes = bytes.Slice(sizeof(byte));
124 | 
125 | 			framingLayer.SynchronizationAddress = BinaryPrimitives.ReadUInt16BigEndian(bytes);
126 | 			bytes = bytes.Slice(sizeof(UInt16));
127 | 
128 | 			framingLayer.SequenceNumber = bytes[0];
129 | 			bytes = bytes.Slice(sizeof(byte));
130 | 
131 | 			framingLayer.Options = bytes[0];
132 | 			bytes = bytes.Slice(sizeof(byte));
133 | 
134 | 			framingLayer.Universe = BinaryPrimitives.ReadUInt16BigEndian(bytes);
135 | 			bytes = bytes.Slice(sizeof(UInt16));
136 | 
137 | 			return framingLayer;
138 | 		}
139 | 
140 | 
141 | 	}
142 | }
143 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/Layers/Framing/FramingLayer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Buffers.Binary;
 3 | using System.Collections.Generic;
 4 | using System.Text;
 5 | 
 6 | namespace Kadmium_sACN.Layers.Framing
 7 | {
 8 | 	public enum FramingLayerVector
 9 | 	{
10 | 		VECTOR_E131_DATA_PACKET = 0x00000002,
11 | 		VECTOR_E131_EXTENDED_SYNCHRONIZATION = 0x00000001,
12 | 		VECTOR_E131_EXTENDED_DISCOVERY = 0x00000002
13 | 	}
14 | 
15 | 	public abstract class FramingLayer : SACNLayer
16 | 	{
17 | 		public FramingLayerVector Vector { get; set; }
18 | 
19 | 		public static FramingLayer Parse(ReadOnlySpan<byte> bytes, RootLayerVector rootLayerVector)
20 | 		{
21 | 			var vector = (FramingLayerVector)BinaryPrimitives.ReadUInt32BigEndian(bytes.Slice(sizeof(UInt16)));
22 | 
23 | 			switch (rootLayerVector)
24 | 			{
25 | 				case RootLayerVector.VECTOR_ROOT_E131_DATA:
26 | 					switch(vector)
27 | 					{
28 | 						case FramingLayerVector.VECTOR_E131_DATA_PACKET:
29 | 							return DataPacketFramingLayer.Parse(bytes);
30 | 					}
31 | 					break;
32 | 				case RootLayerVector.VECTOR_ROOT_E131_EXTENDED:
33 | 					switch(vector)
34 | 					{
35 | 						case FramingLayerVector.VECTOR_E131_EXTENDED_SYNCHRONIZATION:
36 | 							return SynchronizationPacketFramingLayer.Parse(bytes);
37 | 						case FramingLayerVector.VECTOR_E131_EXTENDED_DISCOVERY:
38 | 							return UniverseDiscoveryPacketFramingLayer.Parse(bytes);
39 | 					}
40 | 					break;
41 | 			}
42 | 
43 | 			return null;
44 | 		}
45 | 	}
46 | }
47 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/Layers/Framing/SynchronizationPacketFramingLayer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Buffers.Binary;
 3 | using System.Collections.Generic;
 4 | using System.Text;
 5 | 
 6 | namespace Kadmium_sACN.Layers.Framing
 7 | {
 8 | 	public class SynchronizationPacketFramingLayer : FramingLayer
 9 | 	{
10 | 		public const int Length = 11;
11 | 		public byte SequenceNumber { get; set; }
12 | 		public UInt16 SynchronizationAddress { get; set; }
13 | 
14 | 		public SynchronizationPacketFramingLayer()
15 | 		{
16 | 			Vector = FramingLayerVector.VECTOR_E131_EXTENDED_SYNCHRONIZATION;
17 | 		}
18 | 
19 | 		public void Write(Span<byte> bytes)
20 | 		{
21 | 			UInt16 pduLength = (UInt16)(Length);
22 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, GetFlagsAndLength(pduLength));
23 | 			bytes = bytes.Slice(sizeof(UInt16));
24 | 			BinaryPrimitives.WriteUInt32BigEndian(bytes, (UInt32)Vector);
25 | 			bytes = bytes.Slice(sizeof(UInt32));
26 | 			bytes[0] = SequenceNumber;
27 | 			bytes = bytes.Slice(sizeof(byte));
28 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, SynchronizationAddress);
29 | 			bytes = bytes.Slice(sizeof(UInt16));
30 | 			bytes.Slice(0, 2).Fill(0); // reserved
31 | 		}
32 | 
33 | 		public static SynchronizationPacketFramingLayer Parse(ReadOnlySpan<byte> bytes)
34 | 		{
35 | 			SynchronizationPacketFramingLayer framingLayer = new SynchronizationPacketFramingLayer();
36 | 
37 | 			var flagsAndLength = BinaryPrimitives.ReadUInt16BigEndian(bytes);
38 | 			bytes = bytes.Slice(sizeof(UInt16));
39 | 
40 | 			framingLayer.Vector = (FramingLayerVector)BinaryPrimitives.ReadUInt32BigEndian(bytes);
41 | 			bytes = bytes.Slice(sizeof(UInt32));
42 | 
43 | 			framingLayer.SequenceNumber = bytes[0];
44 | 			bytes = bytes.Slice(sizeof(byte));
45 | 
46 | 			framingLayer.SynchronizationAddress = BinaryPrimitives.ReadUInt16BigEndian(bytes);
47 | 			bytes = bytes.Slice(sizeof(UInt16));
48 | 
49 | 			return framingLayer;
50 | 		}
51 | 	}
52 | }
53 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/Layers/Framing/UniverseDiscoveryPacketFramingLayer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Buffers.Binary;
 3 | using System.Collections.Generic;
 4 | using System.Text;
 5 | 
 6 | namespace Kadmium_sACN.Layers.Framing
 7 | {
 8 | 	public class UniverseDiscoveryPacketFramingLayer : FramingLayer
 9 | 	{
10 | 		public const int Length = 74;
11 | 		public string SourceName { get; set; }
12 | 
13 | 		public UniverseDiscoveryPacketFramingLayer()
14 | 		{
15 | 			Vector = FramingLayerVector.VECTOR_E131_EXTENDED_DISCOVERY;
16 | 		}
17 | 
18 | 		public void Write(Span<byte> bytes, ushort remainingLength)
19 | 		{
20 | 			UInt16 pduLength = (UInt16)(remainingLength + Length);
21 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, GetFlagsAndLength(pduLength));
22 | 			bytes = bytes.Slice(sizeof(UInt16));
23 | 			BinaryPrimitives.WriteUInt32BigEndian(bytes, (UInt32)Vector);
24 | 			bytes = bytes.Slice(sizeof(UInt32));
25 | 			var sourceNameBytes = Encoding.UTF8.GetBytes(SourceName);
26 | 			sourceNameBytes.CopyTo(bytes);
27 | 			bytes = bytes.Slice(sourceNameBytes.Length);
28 | 			var paddingLength = 64 - sourceNameBytes.Length;
29 | 			bytes.Slice(0, paddingLength).Fill(0);
30 | 			bytes = bytes.Slice(paddingLength);
31 | 			bytes.Slice(0, 4).Fill(0); // reserved
32 | 		}
33 | 
34 | 		public static UniverseDiscoveryPacketFramingLayer Parse(ReadOnlySpan<byte> bytes)
35 | 		{
36 | 			UniverseDiscoveryPacketFramingLayer framingLayer = new UniverseDiscoveryPacketFramingLayer();
37 | 
38 | 			var flagsAndLength = BinaryPrimitives.ReadUInt16BigEndian(bytes);
39 | 			bytes = bytes.Slice(sizeof(UInt16));
40 | 
41 | 			framingLayer.Vector = (FramingLayerVector)BinaryPrimitives.ReadUInt32BigEndian(bytes);
42 | 			if (framingLayer.Vector != FramingLayerVector.VECTOR_E131_EXTENDED_DISCOVERY)
43 | 			{
44 | 				return null;
45 | 			}
46 | 			bytes = bytes.Slice(sizeof(UInt32));
47 | 
48 | 			var sourceNameBytes = bytes.Slice(0, 64);
49 | 			bytes = bytes.Slice(64);
50 | 			var endOfString = sourceNameBytes.IndexOf((byte)0);
51 | 			framingLayer.SourceName = Encoding.UTF8.GetString(sourceNameBytes.Slice(0, endOfString));
52 | 
53 | 			return framingLayer;
54 | 		}
55 | 	}
56 | }
57 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/Layers/RootLayer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Buffers.Binary;
 3 | using System.Collections;
 4 | using System.Collections.Specialized;
 5 | 
 6 | namespace Kadmium_sACN.Layers
 7 | {
 8 | 	public enum RootLayerVector
 9 | 	{
10 | 		VECTOR_ROOT_E131_DATA = 0x00000004,
11 | 		VECTOR_ROOT_E131_EXTENDED = 0x00000008
12 | 	}
13 | 
14 | 	public class RootLayer : SACNLayer
15 | 	{
16 | 		public const UInt16 PREAMBLE_SIZE =				0x0010;
17 | 		public const UInt16 POSTAMBLE_SIZE =			0;
18 | 		public const int Length =						38;
19 | 
20 | 		public static readonly byte[] ACNIdentifier = new byte[]
21 | 		{
22 | 			0x41, 0x53, 0x43, 0x2d, 0x45, 0x31, 0x2e, 0x31, 0x37, 0x00, 0x00, 0x00
23 | 		};
24 | 
25 | 		public RootLayerVector Vector { get; set; }
26 | 		public byte[] CID { get; set; } = new byte[16];
27 | 		
28 | 		public void Write(Span<byte> bytes, UInt16 remainingLength)
29 | 		{
30 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, PREAMBLE_SIZE);
31 | 			bytes = bytes.Slice(sizeof(UInt16));
32 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, POSTAMBLE_SIZE);
33 | 			bytes = bytes.Slice(sizeof(UInt16));
34 | 			ACNIdentifier.CopyTo(bytes);
35 | 			bytes = bytes.Slice(ACNIdentifier.Length);
36 | 			UInt16 pduLength = (UInt16)(remainingLength + Length - 16);
37 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, GetFlagsAndLength(pduLength));
38 | 			bytes = bytes.Slice(sizeof(UInt16));
39 | 			BinaryPrimitives.WriteUInt32BigEndian(bytes, (UInt32)Vector);
40 | 			bytes = bytes.Slice(sizeof(UInt32));
41 | 			CID.CopyTo(bytes);
42 | 		}
43 | 
44 | 		public static RootLayer Parse(ReadOnlySpan<byte> bytes)
45 | 		{
46 | 			RootLayer rootLayer = new RootLayer();
47 | 			bytes = bytes.Slice(0, RootLayer.Length);
48 | 
49 | 			var preambleSize = BinaryPrimitives.ReadUInt16BigEndian(bytes);
50 | 			bytes = bytes.Slice(sizeof(UInt16));
51 | 			if (preambleSize != PREAMBLE_SIZE)
52 | 			{
53 | 				return null;
54 | 			}
55 | 
56 | 			var postambleSize = BinaryPrimitives.ReadUInt16BigEndian(bytes);
57 | 			bytes = bytes.Slice(sizeof(UInt16));
58 | 			if (postambleSize != POSTAMBLE_SIZE)
59 | 			{
60 | 				return null;
61 | 			}
62 | 
63 | 			var acnIdentifier = bytes.Slice(0, ACNIdentifier.Length);
64 | 			bytes = bytes.Slice(ACNIdentifier.Length);
65 | 			if (!acnIdentifier.SequenceEqual(ACNIdentifier))
66 | 			{
67 | 				return null;
68 | 			}
69 | 
70 | 			var flagsAndLength = BinaryPrimitives.ReadUInt16BigEndian(bytes);
71 | 			bytes = bytes.Slice(sizeof(UInt16));
72 | 			
73 | 			rootLayer.Vector = (RootLayerVector)BinaryPrimitives.ReadUInt32BigEndian(bytes);
74 | 			bytes = bytes.Slice(sizeof(UInt32));
75 | 
76 | 			var cid = bytes.Slice(0, 16);
77 | 			cid.CopyTo(rootLayer.CID);
78 | 
79 | 			return rootLayer;
80 | 		}
81 | 	}
82 | }
83 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/Layers/SACNLayer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Buffers.Binary;
 3 | using System.Collections.Generic;
 4 | using System.Collections.Specialized;
 5 | using System.Text;
 6 | 
 7 | namespace Kadmium_sACN.Layers
 8 | {
 9 | 	public abstract class SACNLayer
10 | 	{
11 | 		public const byte FLAGS = 0x7;
12 | 		public const UInt16 LengthMask = 0x0FFF;
13 | 
14 | 		protected UInt16 GetFlagsAndLength(UInt16 length)
15 | 		{
16 | 			return (UInt16)((FLAGS << 12) | length);
17 | 		}
18 | 	}
19 | }
20 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/Layers/UniverseDiscoveryLayer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Buffers.Binary;
 3 | using System.Collections.Generic;
 4 | using System.Linq;
 5 | using System.Text;
 6 | 
 7 | namespace Kadmium_sACN.Layers
 8 | {
 9 | 	public enum UniverseDiscoveryLayerVector
10 | 	{
11 | 		VECTOR_UNIVERSE_DISCOVERY_UNIVERSE_LIST = 0x00000001
12 | 	}
13 | 
14 | 	public class UniverseDiscoveryLayer : SACNLayer
15 | 	{
16 | 		public const int MinLength = 8;
17 | 
18 | 		public UniverseDiscoveryLayerVector Vector { get; set; }
19 | 		public byte Page { get; set; }
20 | 		public byte LastPage { get; set; }
21 | 		public IEnumerable<UInt16> Universes { get; set; }
22 | 		public UInt16 Length => (UInt16)(MinLength + (Universes.Count() << 1));
23 | 
24 | 		public UniverseDiscoveryLayer()
25 | 		{
26 | 			Vector = UniverseDiscoveryLayerVector.VECTOR_UNIVERSE_DISCOVERY_UNIVERSE_LIST;
27 | 		}
28 | 
29 | 		public void Write(Span<byte> bytes)
30 | 		{
31 | 			BinaryPrimitives.WriteUInt16BigEndian(bytes, GetFlagsAndLength(Length));
32 | 			bytes = bytes.Slice(sizeof(UInt16));
33 | 			BinaryPrimitives.WriteUInt32BigEndian(bytes, (UInt32)Vector);
34 | 			bytes = bytes.Slice(sizeof(UInt32));
35 | 			bytes[0] = Page;
36 | 			bytes = bytes.Slice(sizeof(byte));
37 | 			bytes[0] = LastPage;
38 | 			bytes = bytes.Slice(sizeof(byte));
39 | 			foreach (var universe in Universes)
40 | 			{
41 | 				BinaryPrimitives.WriteUInt16BigEndian(bytes, universe);
42 | 				bytes = bytes.Slice(sizeof(UInt16));
43 | 			}
44 | 		}
45 | 
46 | 		public static UniverseDiscoveryLayer Parse(ReadOnlySpan<byte> bytes)
47 | 		{
48 | 			UniverseDiscoveryLayer discoveryLayer = new UniverseDiscoveryLayer();
49 | 
50 | 			var flagsAndLength = BinaryPrimitives.ReadUInt16BigEndian(bytes);
51 | 			var pduLength = flagsAndLength & SACNLayer.LengthMask;
52 | 			bytes = bytes.Slice(sizeof(UInt16));
53 | 
54 | 			discoveryLayer.Vector = (UniverseDiscoveryLayerVector)BinaryPrimitives.ReadUInt32BigEndian(bytes);
55 | 			bytes = bytes.Slice(sizeof(UInt32));
56 | 			if (discoveryLayer.Vector != UniverseDiscoveryLayerVector.VECTOR_UNIVERSE_DISCOVERY_UNIVERSE_LIST)
57 | 			{
58 | 				return null;
59 | 			}
60 | 
61 | 			discoveryLayer.Page = bytes[0];
62 | 			bytes = bytes.Slice(sizeof(byte));
63 | 
64 | 			discoveryLayer.LastPage = bytes[0];
65 | 			bytes = bytes.Slice(sizeof(byte));
66 | 
67 | 			var listLength = pduLength - 8;
68 | 			var universeCount = listLength / sizeof(UInt16);
69 | 			var universes = new UInt16[universeCount];
70 | 
71 | 			for (int i = 0; i < universeCount; i++)
72 | 			{
73 | 				universes[i] = BinaryPrimitives.ReadUInt16BigEndian(bytes);
74 | 				bytes = bytes.Slice(sizeof(UInt16));
75 | 			}
76 | 
77 | 			discoveryLayer.Universes = universes;
78 | 
79 | 			return discoveryLayer;
80 | 		}
81 | 	}
82 | }
83 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/MulticastAddressProvider/ISacnMulticastAddressProvider.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Net;
 4 | using System.Text;
 5 | 
 6 | namespace Kadmium_sACN.MulticastAddressProvider
 7 | {
 8 | 	public interface ISacnMulticastAddressProvider
 9 | 	{
10 | 		IPAddress GetMulticastAddress(UInt16 universe);
11 | 	}
12 | }
13 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/MulticastAddressProvider/SacnMulticastAddressProviderIPV4.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Buffers.Binary;
 3 | using System.Collections.Generic;
 4 | using System.IO;
 5 | using System.Net;
 6 | using System.Text;
 7 | 
 8 | namespace Kadmium_sACN.MulticastAddressProvider
 9 | {
10 | 	public class SacnMulticastAddressProviderIPV4 : ISacnMulticastAddressProvider
11 | 	{
12 | 		public IPAddress GetMulticastAddress(UInt16 universe)
13 | 		{
14 | 			var universeBytes = GetUniverseBytes(universe);
15 | 			IPAddress address = new IPAddress(new byte[] { 239, 255, universeBytes[0], universeBytes[1] });
16 | 			return address;
17 | 		}
18 | 
19 | 		private static Span<byte> GetUniverseBytes(UInt16 universe)
20 | 		{
21 | 			byte[] universeBytes = new byte[2];
22 | 			BinaryPrimitives.WriteUInt16BigEndian(universeBytes, universe);
23 | 			return universeBytes;
24 | 		}
25 | 	}
26 | }
27 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/MulticastAddressProvider/SacnMulticastAddressProviderIPV6.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Buffers.Binary;
 3 | using System.Collections.Generic;
 4 | using System.Net;
 5 | using System.Text;
 6 | 
 7 | namespace Kadmium_sACN.MulticastAddressProvider
 8 | {
 9 | 	public class SacnMulticastAddressProviderIPV6 : ISacnMulticastAddressProvider
10 | 	{
11 | 		public IPAddress GetMulticastAddress(UInt16 universe)
12 | 		{
13 | 			var universeBytes = GetUniverseBytes(universe);
14 | 			string ipString = $"FF18::83:00:{universeBytes[0].ToString("X2")}:{universeBytes[1].ToString("X2")}";
15 | 			IPAddress address = IPAddress.Parse(ipString);
16 | 			return address;
17 | 		}
18 | 
19 | 		private static Span<byte> GetUniverseBytes(UInt16 universe)
20 | 		{
21 | 			byte[] universeBytes = new byte[2];
22 | 			BinaryPrimitives.WriteUInt16BigEndian(universeBytes, universe);
23 | 			return universeBytes;
24 | 		}
25 | 	}
26 | }
27 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/SACNPacket.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN.Layers;
 2 | using Kadmium_sACN.Layers.Framing;
 3 | using System;
 4 | using System.Collections.Generic;
 5 | using System.Text;
 6 | 
 7 | namespace Kadmium_sACN
 8 | {
 9 | 	public abstract class SacnPacket
10 | 	{
11 | 		public RootLayer RootLayer { get; set; }
12 | 		public abstract int Length { get; }
13 | 		public abstract void Write(Span<byte> bytes);
14 | 
15 | 		public static SacnPacket Parse(ReadOnlySpan<byte> bytes)
16 | 		{
17 | 			RootLayer rootLayer = RootLayer.Parse(bytes);
18 | 			if (rootLayer == null)
19 | 			{
20 | 				return null;
21 | 			}
22 | 			bytes = bytes.Slice(RootLayer.Length);
23 | 
24 | 			FramingLayer framingLayer = FramingLayer.Parse(bytes, rootLayer.Vector);
25 | 			
26 | 			switch(framingLayer)
27 | 			{
28 | 				case DataPacketFramingLayer dataLayer:
29 | 					bytes = bytes.Slice(DataPacketFramingLayer.Length);
30 | 					return DataPacket.Parse(bytes, rootLayer, dataLayer);
31 | 				case SynchronizationPacketFramingLayer syncLayer:
32 | 					bytes = bytes.Slice(SynchronizationPacketFramingLayer.Length);
33 | 					return SynchronizationPacket.Parse(bytes, rootLayer, syncLayer);
34 | 				case UniverseDiscoveryPacketFramingLayer discoveryLayer:
35 | 					bytes = bytes.Slice(UniverseDiscoveryPacketFramingLayer.Length);
36 | 					return UniverseDiscoveryPacket.Parse(bytes, rootLayer, discoveryLayer);
37 | 				default:
38 | 					return null;
39 | 			}
40 | 		}
41 | 	}
42 | }
43 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/SacnPacketFactory.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Net.Sockets;
 5 | using System.Text;
 6 | 
 7 | namespace Kadmium_sACN
 8 | {
 9 | 	public class SacnPacketFactory
10 | 	{
11 | 		public byte[] CID { get; set; }
12 | 		public string SourceName { get; set; }
13 | 		private byte SequenceNumber { get; set; }
14 | 		
15 | 		public SacnPacketFactory(byte[] cid, string sourceName)
16 | 		{
17 | 			CID = cid;
18 | 			SourceName = sourceName;
19 | 		}
20 | 
21 | 		public DataPacket CreateDataPacket(UInt16 universe, IEnumerable<byte> properties, byte priority = Constants.Priority_Default, byte startCode = 0)
22 | 		{
23 | 			DataPacket dataPacket = new DataPacket();
24 | 			dataPacket.RootLayer.CID = CID;
25 | 			dataPacket.FramingLayer.SourceName = SourceName;
26 | 			dataPacket.FramingLayer.SequenceNumber = SequenceNumber;
27 | 			dataPacket.FramingLayer.Universe = universe;
28 | 			dataPacket.FramingLayer.Priority = priority;
29 | 			dataPacket.DMPLayer.StartCode = startCode;
30 | 			dataPacket.DMPLayer.PropertyValues = properties;
31 | 
32 | 			SequenceNumber = (SequenceNumber == byte.MaxValue) ? byte.MinValue : (byte)(SequenceNumber + 1);
33 | 
34 | 			return dataPacket;
35 | 		}
36 | 
37 | 		public IEnumerable<UniverseDiscoveryPacket> CreateUniverseDiscoveryPackets(IEnumerable<UInt16> universes)
38 | 		{
39 | 			var chunks = universes.Chunk(UniverseDiscoveryPacket.PageSize);
40 | 
41 | 			byte page = 0;
42 | 			byte lastPage = (byte)chunks.Count();
43 | 
44 | 			foreach(var chunk in chunks)
45 | 			{
46 | 				yield return CreateUniverseDiscoveryPage(chunk, page, lastPage);
47 | 				page++;
48 | 			}
49 | 		}
50 | 
51 | 		private UniverseDiscoveryPacket CreateUniverseDiscoveryPage(IEnumerable<UInt16> universes, byte page, byte lastPage)
52 | 		{
53 | 			UniverseDiscoveryPacket packet = new UniverseDiscoveryPacket();
54 | 			packet.RootLayer.CID = CID;
55 | 			packet.FramingLayer.SourceName = SourceName;
56 | 			packet.UniverseDiscoveryLayer.Page = page;
57 | 			packet.UniverseDiscoveryLayer.LastPage = lastPage;
58 | 			packet.UniverseDiscoveryLayer.Universes = universes.ToArray();
59 | 			return packet;
60 | 		}
61 | 	}
62 | }
63 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/SacnReceiver/IMulticastSacnReceiver.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | 
 4 | namespace Kadmium_sACN.SacnReceiver
 5 | {
 6 | 	public interface IMulticastSacnReceiver : ISacnReceiver
 7 | 	{
 8 | 		void JoinMulticastGroups(IEnumerable<UInt16> universes, bool ipv6);
 9 | 		void JoinMulticastGroup(UInt16 universe, bool ipv6);
10 | 		void DropMulticastGroups(IEnumerable<UInt16> universes, bool ipv6);
11 | 		void DropMulticastGroup(UInt16 universe, bool ipv6);
12 | 	}
13 | }


--------------------------------------------------------------------------------
/Kadmium-sACN/SacnReceiver/ISacnReceiver.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Net;
 3 | 
 4 | namespace Kadmium_sACN.SacnReceiver
 5 | {
 6 | 	public interface ISacnReceiver : IDisposable
 7 | 	{
 8 | 		event EventHandler<DataPacket> OnDataPacketReceived;
 9 | 		event EventHandler<SynchronizationPacket> OnSynchronizationPacketReceived;
10 | 		event EventHandler<UniverseDiscoveryPacket> OnUniverseDiscoveryPacketReceived;
11 | 		void Listen(IPAddress address);
12 | 		IPEndPoint HostEndPoint { get; }
13 | 	}
14 | }


--------------------------------------------------------------------------------
/Kadmium-sACN/SacnReceiver/SacnReceiver.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Buffers.Binary;
  3 | using System.Collections.Generic;
  4 | using System.Linq;
  5 | using System.Net;
  6 | using System.Net.Sockets;
  7 | using System.Text;
  8 | using System.IO.Pipelines;
  9 | using System.Threading;
 10 | using System.Threading.Tasks;
 11 | using Kadmium_sACN.MulticastAddressProvider;
 12 | 
 13 | namespace Kadmium_sACN.SacnReceiver
 14 | {
 15 | 	public class SacnReceiver : IDisposable, ISacnReceiver
 16 | 	{
 17 | 		protected Socket Socket { get; private set; }
 18 | 		public event EventHandler<DataPacket> OnDataPacketReceived;
 19 | 		public event EventHandler<SynchronizationPacket> OnSynchronizationPacketReceived;
 20 | 		public event EventHandler<UniverseDiscoveryPacket> OnUniverseDiscoveryPacketReceived;
 21 | 
 22 | 		public IPEndPoint HostEndPoint => Socket?.LocalEndPoint as IPEndPoint;
 23 | 		private CancellationTokenSource CancellationTokenSource { get; } = new CancellationTokenSource();
 24 | 
 25 | 		public SacnReceiver() : this(new SacnMulticastAddressProviderIPV4(), new SacnMulticastAddressProviderIPV6())
 26 | 		{
 27 | 		}
 28 | 
 29 | 		protected SacnReceiver(ISacnMulticastAddressProvider ipv4Provider, ISacnMulticastAddressProvider ipv6Provider)
 30 | 		{
 31 | 			IPv4MulticastAddressProvider = ipv4Provider;
 32 | 			IPv6MulticastAddressProvider = ipv6Provider;
 33 | 		}
 34 | 
 35 | 		public void Listen(IPAddress address)
 36 | 		{
 37 | 			var endpoint = new IPEndPoint(address, Constants.Port);
 38 | 
 39 | 			Pipe pipe = new Pipe();
 40 | 			Socket = new Socket(endpoint.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
 41 | 			Socket.Bind(endpoint);
 42 | 
 43 | 			Task.Run(async () =>
 44 | 			{
 45 | 				while (!CancellationTokenSource.IsCancellationRequested)
 46 | 				{
 47 | 					var listenTask = ListenAsync(pipe.Writer, endpoint);
 48 | 					var processTask = ProcessPackets(pipe.Reader);
 49 | 
 50 | 					await Task.WhenAll(listenTask, processTask);
 51 | 				}
 52 | 			});
 53 | 
 54 | 		}
 55 | 
 56 | 		private async Task ListenAsync(PipeWriter writer, IPEndPoint endPoint)
 57 | 		{
 58 | 			while (true)
 59 | 			{
 60 | 				var memory = writer.GetMemory(DataPacket.MAX_LENGTH);
 61 | 				try
 62 | 				{
 63 | 					var bytesRead = await Socket.ReceiveAsync(memory, SocketFlags.None);
 64 | 					if (bytesRead == 0)
 65 | 					{
 66 | 						break;
 67 | 					}
 68 | 					writer.Advance(bytesRead);
 69 | 				}
 70 | 				catch (Exception e)
 71 | 				{
 72 | 					await Console.Error.WriteLineAsync(e.ToString());
 73 | 					break;
 74 | 				}
 75 | 
 76 | 				var result = await writer.FlushAsync();
 77 | 
 78 | 				if (result.IsCompleted)
 79 | 				{
 80 | 					break;
 81 | 				}
 82 | 			}
 83 | 			await writer.CompleteAsync();
 84 | 		}
 85 | 
 86 | 		private async Task ProcessPackets(PipeReader reader)
 87 | 		{
 88 | 			var token = CancellationTokenSource.Token;
 89 | 			while (true)
 90 | 			{
 91 | 				var result = await reader.ReadAsync(token);
 92 | 
 93 | 				var buffer = result.Buffer;
 94 | 				var packet = SacnPacket.Parse(buffer.FirstSpan);
 95 | 				switch (packet)
 96 | 				{
 97 | 					case DataPacket dataPacket:
 98 | 						OnDataPacketReceived?.Invoke(this, dataPacket);
 99 | 						break;
100 | 					case SynchronizationPacket syncPacket:
101 | 						OnSynchronizationPacketReceived?.Invoke(this, syncPacket);
102 | 						break;
103 | 					case UniverseDiscoveryPacket discoveryPacket:
104 | 						OnUniverseDiscoveryPacketReceived?.Invoke(this, discoveryPacket);
105 | 						break;
106 | 				}
107 | 
108 | 				buffer = buffer.Slice(0, packet.Length);
109 | 
110 | 				reader.AdvanceTo(buffer.Start, buffer.End);
111 | 
112 | 				if (result.IsCompleted)
113 | 				{
114 | 					break;
115 | 				}
116 | 			}
117 | 			reader.Complete();
118 | 		}
119 | 
120 | 		public void Dispose()
121 | 		{
122 | 			CancellationTokenSource.Cancel();
123 | 			Socket?.Dispose();
124 | 		}
125 | 
126 | 		private ISacnMulticastAddressProvider IPv4MulticastAddressProvider { get; }
127 | 		private ISacnMulticastAddressProvider IPv6MulticastAddressProvider { get; }
128 | 
129 | 
130 | 
131 | 		public void JoinMulticastGroups(IEnumerable<UInt16> universes, bool ipv6 = false)
132 | 		{
133 | 			foreach (var universe in universes)
134 | 			{
135 | 				JoinMulticastGroup(universe, ipv6);
136 | 			}
137 | 		}
138 | 
139 | 		public void JoinMulticastGroup(UInt16 universe, bool ipv6 = false)
140 | 		{
141 | 			if (universe < Constants.Universe_MinValue || universe > Constants.Universe_MaxValue)
142 | 			{
143 | 				throw new ArgumentOutOfRangeException($"Universe must be between {Constants.Universe_MinValue} and {Constants.Universe_MaxValue} inclusive");
144 | 			}
145 | 
146 | 			if (ipv6)
147 | 			{
148 | 				var multicastAddress = IPv6MulticastAddressProvider.GetMulticastAddress(universe);
149 | 				var level = SocketOptionLevel.IPv6;
150 | 				var option = new IPv6MulticastOption(multicastAddress);
151 | 				Socket.SetSocketOption(level, SocketOptionName.AddMembership, option);
152 | 			}
153 | 			else
154 | 			{
155 | 				var multicastAddress = IPv4MulticastAddressProvider.GetMulticastAddress(universe);
156 | 				var level = SocketOptionLevel.IP;
157 | 				var option = new MulticastOption(multicastAddress, this.HostEndPoint.Address);
158 | 				Socket.SetSocketOption(level, SocketOptionName.AddMembership, option);
159 | 			}
160 | 		}
161 | 
162 | 		public void DropMulticastGroups(IEnumerable<ushort> universes, bool ipv6 = false)
163 | 		{
164 | 			foreach (var universe in universes)
165 | 			{
166 | 				DropMulticastGroup(universe, ipv6);
167 | 			}
168 | 		}
169 | 
170 | 		public void DropMulticastGroup(ushort universe, bool ipv6 = false)
171 | 		{
172 | 			if (universe < Constants.Universe_MinValue || universe > Constants.Universe_MaxValue)
173 | 			{
174 | 				throw new ArgumentOutOfRangeException($"Universe must be between {Constants.Universe_MinValue} and {Constants.Universe_MaxValue} inclusive");
175 | 			}
176 | 
177 | 			if (ipv6)
178 | 			{
179 | 				var multicastAddress = IPv6MulticastAddressProvider.GetMulticastAddress(universe);
180 | 				var level = SocketOptionLevel.IPv6;
181 | 				var option = new IPv6MulticastOption(multicastAddress);
182 | 				Socket.SetSocketOption(level, SocketOptionName.DropMembership, option);
183 | 			}
184 | 			else
185 | 			{
186 | 				var multicastAddress = IPv4MulticastAddressProvider.GetMulticastAddress(universe);
187 | 				var level = SocketOptionLevel.IP;
188 | 				var option = new MulticastOption(multicastAddress, this.HostEndPoint.Address);
189 | 				Socket.SetSocketOption(level, SocketOptionName.DropMembership, option);
190 | 			}
191 | 
192 | 		}
193 | 	}
194 | 
195 | }
196 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/SacnSender/ISacnSender.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text;
 4 | using System.Threading.Tasks;
 5 | 
 6 | namespace Kadmium_sACN.SacnSender
 7 | {
 8 | 	interface ISacnSender : IDisposable
 9 | 	{
10 | 		Task Send(DataPacket packet);
11 | 		Task Send(UniverseDiscoveryPacket packet);
12 | 		Task Send(SynchronizationPacket packet);
13 | 	}
14 | }
15 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/SacnSender/SacnSender.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN.MulticastAddressProvider;
 2 | using System;
 3 | using System.Buffers;
 4 | using System.Collections.Generic;
 5 | using System.Linq;
 6 | using System.Net;
 7 | using System.Net.Sockets;
 8 | using System.Text;
 9 | using System.Threading.Tasks;
10 | 
11 | namespace Kadmium_sACN.SacnSender
12 | {
13 | 	public class SacnSender : IDisposable
14 | 	{
15 | 		private ISacnMulticastAddressProvider Ipv4MulticastAddressProvider { get; }
16 | 		private ISacnMulticastAddressProvider Ipv6MulticastAddressProvider { get; }
17 | 		private Socket Ipv4Socket { get; } = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
18 | 		private Socket Ipv6Socket { get; } = new Socket(AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp);
19 | 
20 | 		public SacnSender() : this(new SacnMulticastAddressProviderIPV4(), new SacnMulticastAddressProviderIPV6())
21 | 		{ }
22 | 
23 | 		protected SacnSender(ISacnMulticastAddressProvider ipv4AddressProvider, ISacnMulticastAddressProvider ipv6AddressProvider)
24 | 		{
25 | 			Ipv4MulticastAddressProvider = ipv4AddressProvider;
26 | 			Ipv6MulticastAddressProvider = ipv6AddressProvider;
27 | 		}
28 | 
29 | 		protected async Task SendInternal(IPAddress address, SacnPacket packet)
30 | 		{
31 | 			var endpoint = new IPEndPoint(address, Constants.Port);
32 | 			using (var owner = MemoryPool<byte>.Shared.Rent(packet.Length))
33 | 			{
34 | 				var bytes = owner.Memory.Slice(0, packet.Length);
35 | 				packet.Write(bytes.Span);
36 | 				var socket = address.AddressFamily == AddressFamily.InterNetworkV6 ? Ipv6Socket : Ipv4Socket;
37 | 
38 | 				var args = new SocketAsyncEventArgs
39 | 				{
40 | 					SocketFlags = SocketFlags.None,
41 | 					RemoteEndPoint = endpoint
42 | 				};
43 | 				args.SetBuffer(bytes);
44 | 				var tsc = new TaskCompletionSource<SocketAsyncEventArgs>();
45 | 				args.Completed += (_, args) =>
46 | 				{
47 | 					tsc.SetResult(args);
48 | 				};
49 | 				bool result = socket.SendToAsync(args);
50 | 				if (result)
51 | 				{
52 | 					await tsc.Task;
53 | 				}
54 | 
55 | 			}
56 | 		}
57 | 
58 | 		public Task SendUnicast(DataPacket packet, IPAddress remoteHost)
59 | 		{
60 | 			return SendInternal(remoteHost, packet);
61 | 		}
62 | 
63 | 		public Task SendUnicast(UniverseDiscoveryPacket packet, IPAddress remoteHost)
64 | 		{
65 | 			return SendInternal(remoteHost, packet);
66 | 		}
67 | 
68 | 		public Task SendUnicast(SynchronizationPacket packet, IPAddress remoteHost)
69 | 		{
70 | 			return SendInternal(remoteHost, packet);
71 | 		}
72 | 
73 | 		public Task SendMulticast(DataPacket packet, bool ipv6 = false)
74 | 		{
75 | 			return SendInternal(Ipv6MulticastAddressProvider.GetMulticastAddress(packet.FramingLayer.Universe), packet);
76 | 		}
77 | 
78 | 		public Task SendMulticast(UniverseDiscoveryPacket packet, bool ipv6 = false)
79 | 		{
80 | 			return SendInternal(Ipv6MulticastAddressProvider.GetMulticastAddress(UniverseDiscoveryPacket.DiscoveryUniverse), packet);
81 | 		}
82 | 
83 | 		public Task SendMulticast(SynchronizationPacket packet, bool ipv6 = false)
84 | 		{
85 | 			return SendInternal(Ipv6MulticastAddressProvider.GetMulticastAddress(packet.FramingLayer.SynchronizationAddress), packet);
86 | 		}
87 | 
88 | 		public void Dispose()
89 | 		{
90 | 			Ipv4Socket.Dispose();
91 | 			Ipv6Socket.Dispose();
92 | 		}
93 | 	}
94 | }
95 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/SynchronizationPacket.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN.Layers;
 2 | using Kadmium_sACN.Layers.Framing;
 3 | using System;
 4 | using System.Collections.Generic;
 5 | using System.Text;
 6 | 
 7 | namespace Kadmium_sACN
 8 | {
 9 | 	public class SynchronizationPacket : SacnPacket
10 | 	{
11 | 		public SynchronizationPacketFramingLayer FramingLayer { get; set; }
12 | 		public override int Length => RootLayer.Length + SynchronizationPacketFramingLayer.Length;
13 | 
14 | 		public SynchronizationPacket()
15 | 		{
16 | 			RootLayer = new RootLayer
17 | 			{
18 | 				Vector = RootLayerVector.VECTOR_ROOT_E131_EXTENDED
19 | 			};
20 | 			FramingLayer = new SynchronizationPacketFramingLayer();
21 | 		}
22 | 
23 | 		public static SynchronizationPacket Parse(ReadOnlySpan<byte> bytes, RootLayer rootLayer, SynchronizationPacketFramingLayer framingLayer)
24 | 		{
25 | 			SynchronizationPacket packet = new SynchronizationPacket
26 | 			{
27 | 				RootLayer = rootLayer,
28 | 				FramingLayer = framingLayer
29 | 			};
30 | 
31 | 			return packet;
32 | 		}
33 | 
34 | 		public override void Write(Span<byte> bytes)
35 | 		{
36 | 			RootLayer.Write(bytes, SynchronizationPacketFramingLayer.Length);
37 | 			FramingLayer.Write(bytes.Slice(RootLayer.Length));
38 | 		}
39 | 	}
40 | }
41 | 


--------------------------------------------------------------------------------
/Kadmium-sACN/UniverseDiscoveryPacket.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN.Layers;
 2 | using Kadmium_sACN.Layers.Framing;
 3 | using System;
 4 | using System.Collections.Generic;
 5 | using System.Text;
 6 | 
 7 | namespace Kadmium_sACN
 8 | {
 9 | 	public class UniverseDiscoveryPacket : SacnPacket
10 | 	{
11 | 		public const int PageSize = 512;
12 | 		public const UInt16 DiscoveryUniverse = 64214;
13 | 
14 | 		public UniverseDiscoveryPacketFramingLayer FramingLayer { get; set; }
15 | 		public UniverseDiscoveryLayer UniverseDiscoveryLayer { get; set; }
16 | 		public override int Length => RootLayer.Length + UniverseDiscoveryPacketFramingLayer.Length + UniverseDiscoveryLayer.Length;
17 | 
18 | 		public UniverseDiscoveryPacket()
19 | 		{
20 | 			RootLayer = new RootLayer
21 | 			{
22 | 				Vector = RootLayerVector.VECTOR_ROOT_E131_EXTENDED
23 | 			};
24 | 			FramingLayer = new UniverseDiscoveryPacketFramingLayer();
25 | 			UniverseDiscoveryLayer = new UniverseDiscoveryLayer();
26 | 		}
27 | 
28 | 		public static UniverseDiscoveryPacket Parse(ReadOnlySpan<byte> bytes, RootLayer rootLayer, UniverseDiscoveryPacketFramingLayer framingLayer)
29 | 		{
30 | 			UniverseDiscoveryPacket dataPacket = new UniverseDiscoveryPacket
31 | 			{
32 | 				RootLayer = rootLayer,
33 | 				FramingLayer = framingLayer,
34 | 				UniverseDiscoveryLayer = UniverseDiscoveryLayer.Parse(bytes)
35 | 			};
36 | 
37 | 			return dataPacket;
38 | 		}
39 | 
40 | 		public override void Write(Span<byte> bytes)
41 | 		{
42 | 			RootLayer.Write(bytes, (UInt16)(UniverseDiscoveryPacketFramingLayer.Length + UniverseDiscoveryLayer.Length));
43 | 			FramingLayer.Write(bytes.Slice(RootLayer.Length), UniverseDiscoveryLayer.Length);
44 | 			UniverseDiscoveryLayer.Write(bytes.Slice(RootLayer.Length + UniverseDiscoveryPacketFramingLayer.Length));
45 | 		}
46 | 	}
47 | }
48 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Jesse Higginson
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # kadmium-sacn
 2 | An sACN library for .NET 6.0 and above.
 3 | 
 4 | [![codecov](https://codecov.io/gh/iKadmium/kadmium-sacn/branch/master/graph/badge.svg?token=ZSK119NBC5)](https://codecov.io/gh/iKadmium/kadmium-sacn)
 5 | ![build status](https://github.com/iKadmium/kadmium-sacn/actions/workflows/publish.yml/badge.svg)
 6 | 
 7 | ## Installation
 8 | ```
 9 | dotnet add package kadmium-sacn
10 | ```
11 | 
12 | ## Usage
13 | ### Sending sACN packets
14 | ```c#
15 | byte[] cid = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
16 | UInt16 universe = 1;
17 | string sourceName = "My lovely source";
18 | var factory = new SacnPacketFactory(cid, sourceName);
19 | using var sacnSender = new MulticastSacnSenderIPV4(); // IPv6 is also supported
20 | 
21 | byte[] values = new byte[512] { 0, 1, 2, 3, 4, 5 };
22 | var packet = factory.CreateDataPacket(universe, values);
23 | await sacnSender.Send(packet);
24 | ```
25 | 
26 | It's also good manners to send Universe Discovery packets every 10 seconds.
27 | 
28 | ```c#
29 | using Timer timer = new Timer(10000);
30 | timer.Elapsed += async (sender, e) =>
31 | {
32 | 	var packets = factory.CreateUniverseDiscoveryPackets(new UInt16[] { universe });
33 | 	foreach (var packet in packets)
34 | 	{
35 | 		await sacnSender.Send(packet);
36 | 	}
37 | };
38 | timer.Start();
39 | ```
40 | 
41 | ### Listening for sACN Packets
42 | ```c#
43 | using var receiver = new MulticastSacnReceiverIPV4(); // IPv6 is also supported
44 | receiver.OnDataPacketReceived += (sender, packet) =>
45 | {
46 | 	Console.WriteLine(packet.FramingLayer.Universe + ": ");
47 | 	Console.WriteLine(string.Join(", ", packet.DMPLayer.PropertyValues));
48 | };
49 | receiver.OnSynchronizationPacketReceived += (sender, packet) =>
50 | {
51 | 	Console.WriteLine("Sync!");
52 | };
53 | receiver.OnUniverseDiscoveryPacketReceived += (sender, packet) =>
54 | {
55 | 	Console.WriteLine("Discovery!");
56 | };
57 | receiver.Listen(IPAddress.Any);
58 | receiver.JoinMulticastGroup(1);
59 | ```


--------------------------------------------------------------------------------
/SacnSender/Program.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN;
 2 | using Kadmium_sACN.SacnSender;
 3 | using System;
 4 | using System.Linq;
 5 | using System.Net;
 6 | using System.Threading.Tasks;
 7 | using System.Timers;
 8 | 
 9 | namespace SacnSenderTestUtil
10 | {
11 | 	class Program
12 | 	{
13 | 		static async Task Main(string[] args)
14 | 		{
15 | 			byte[] cid = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
16 | 			UInt16 universe = 1;
17 | 			string sourceName = "My lovely source";
18 | 			SacnPacketFactory factory = new SacnPacketFactory(cid, sourceName);
19 | 			using var sacnSender = new SacnSender();
20 | 
21 | 			using Timer timer = new Timer(10000);
22 | 			timer.Elapsed += async (sender, e) =>
23 | 			{
24 | 				var packets = factory.CreateUniverseDiscoveryPackets(new UInt16[] { universe });
25 | 				foreach (var packet in packets)
26 | 				{
27 | 					await sacnSender.SendMulticast(packet);
28 | 				}
29 | 			};
30 | 			timer.Start();
31 | 
32 | 			byte[] values = new byte[512];
33 | 			while (true)
34 | 			{
35 | 				for (byte i = 0; i < 255; i++)
36 | 				{
37 | 					Array.Fill(values, i);
38 | 					var packet = factory.CreateDataPacket(universe, values);
39 | 					await sacnSender.SendMulticast(packet);
40 | 					await Task.Delay(1000 / 40);
41 | 				}
42 | 			}
43 | 		}
44 | 	}
45 | }
46 | 


--------------------------------------------------------------------------------
/SacnSender/SacnSender.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <OutputType>Exe</OutputType>
 5 |     <TargetFramework>net6.0</TargetFramework>
 6 |   </PropertyGroup>
 7 | 
 8 |   <ItemGroup>
 9 |     <ProjectReference Include="..\Kadmium-sACN\Kadmium-sACN.csproj" />
10 |   </ItemGroup>
11 | 
12 | </Project>


--------------------------------------------------------------------------------
/SacnViewer/Program.cs:
--------------------------------------------------------------------------------
 1 | using Kadmium_sACN;
 2 | using Kadmium_sACN.SacnReceiver;
 3 | using System;
 4 | using System.Net;
 5 | using System.Threading.Tasks;
 6 | 
 7 | namespace SacnViewer
 8 | {
 9 | 	class Program
10 | 	{
11 | 		static void Main(string[] args)
12 | 		{
13 | 			using var receiver = new SacnReceiver();
14 | 			receiver.OnDataPacketReceived += (sender, packet) =>
15 | 			{
16 | 				Console.WriteLine(packet.FramingLayer.Universe + ": ");
17 | 				Console.WriteLine(string.Join(", ", packet.DMPLayer.PropertyValues));
18 | 			};
19 | 			receiver.OnSynchronizationPacketReceived += (sender, packet) =>
20 | 			{
21 | 				Console.WriteLine("Sync!");
22 | 			};
23 | 			receiver.OnUniverseDiscoveryPacketReceived += (sender, packet) =>
24 | 			{
25 | 				Console.WriteLine("Discovery!");
26 | 			};
27 | 			receiver.Listen(IPAddress.Any);
28 | 			receiver.JoinMulticastGroup(1);
29 | 			Console.WriteLine("Listening. Press enter to exit");
30 | 			Console.ReadLine();
31 | 		}
32 | 	}
33 | }
34 | 


--------------------------------------------------------------------------------
/SacnViewer/SacnViewer.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <OutputType>Exe</OutputType>
 5 |     <TargetFramework>net6.0</TargetFramework>
 6 |   </PropertyGroup>
 7 | 
 8 |   <ItemGroup>
 9 |     <ProjectReference Include="..\Kadmium-sACN\Kadmium-sACN.csproj" />
10 |   </ItemGroup>
11 | 
12 | </Project>


--------------------------------------------------------------------------------
/coverlet.runsettings:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8" ?>
 2 | <RunSettings>
 3 | 	<DataCollectionRunSettings>
 4 | 		<DataCollectors>
 5 | 			<DataCollector friendlyName="XPlat code coverage">
 6 | 				<Configuration>
 7 | 					<Format>lcov</Format>
 8 | 				</Configuration>
 9 | 			</DataCollector>
10 | 		</DataCollectors>
11 | 	</DataCollectionRunSettings>
12 | </RunSettings>


--------------------------------------------------------------------------------
/kadmium-sacn.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 16
 4 | VisualStudioVersion = 16.0.31025.194
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Kadmium-sACN", "Kadmium-sACN\Kadmium-sACN.csproj", "{21DF3CAD-01CC-4874-B0C4-BFB45BD9D046}"
 7 | EndProject
 8 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Kadmium-sACN.Test", "Kadmium-sACN.Test\Kadmium-sACN.Test.csproj", "{5F7609A7-E75D-4EDE-AE6E-E41BAD125B5C}"
 9 | EndProject
10 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SacnSender", "SacnSender\SacnSender.csproj", "{E582FA6A-F75A-470D-9179-C7FD3E479FBE}"
11 | EndProject
12 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SacnViewer", "SacnViewer\SacnViewer.csproj", "{FC09A689-ABC0-42FE-A854-708C8ED86829}"
13 | EndProject
14 | Global
15 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
16 | 		Debug|Any CPU = Debug|Any CPU
17 | 		Release|Any CPU = Release|Any CPU
18 | 	EndGlobalSection
19 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
20 | 		{21DF3CAD-01CC-4874-B0C4-BFB45BD9D046}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
21 | 		{21DF3CAD-01CC-4874-B0C4-BFB45BD9D046}.Debug|Any CPU.Build.0 = Debug|Any CPU
22 | 		{21DF3CAD-01CC-4874-B0C4-BFB45BD9D046}.Release|Any CPU.ActiveCfg = Release|Any CPU
23 | 		{21DF3CAD-01CC-4874-B0C4-BFB45BD9D046}.Release|Any CPU.Build.0 = Release|Any CPU
24 | 		{5F7609A7-E75D-4EDE-AE6E-E41BAD125B5C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
25 | 		{5F7609A7-E75D-4EDE-AE6E-E41BAD125B5C}.Debug|Any CPU.Build.0 = Debug|Any CPU
26 | 		{5F7609A7-E75D-4EDE-AE6E-E41BAD125B5C}.Release|Any CPU.ActiveCfg = Release|Any CPU
27 | 		{5F7609A7-E75D-4EDE-AE6E-E41BAD125B5C}.Release|Any CPU.Build.0 = Release|Any CPU
28 | 		{E582FA6A-F75A-470D-9179-C7FD3E479FBE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
29 | 		{E582FA6A-F75A-470D-9179-C7FD3E479FBE}.Debug|Any CPU.Build.0 = Debug|Any CPU
30 | 		{E582FA6A-F75A-470D-9179-C7FD3E479FBE}.Release|Any CPU.ActiveCfg = Release|Any CPU
31 | 		{E582FA6A-F75A-470D-9179-C7FD3E479FBE}.Release|Any CPU.Build.0 = Release|Any CPU
32 | 		{FC09A689-ABC0-42FE-A854-708C8ED86829}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
33 | 		{FC09A689-ABC0-42FE-A854-708C8ED86829}.Debug|Any CPU.Build.0 = Debug|Any CPU
34 | 		{FC09A689-ABC0-42FE-A854-708C8ED86829}.Release|Any CPU.ActiveCfg = Release|Any CPU
35 | 		{FC09A689-ABC0-42FE-A854-708C8ED86829}.Release|Any CPU.Build.0 = Release|Any CPU
36 | 	EndGlobalSection
37 | 	GlobalSection(SolutionProperties) = preSolution
38 | 		HideSolutionNode = FALSE
39 | 	EndGlobalSection
40 | 	GlobalSection(ExtensibilityGlobals) = postSolution
41 | 		SolutionGuid = {22A0276E-9944-4EE7-8C5D-9D3CE84F9B1E}
42 | 	EndGlobalSection
43 | EndGlobal
44 | 


--------------------------------------------------------------------------------