Example #1
0
        public MatrixFrame DecodeMatrixFrame(MatrixSettings settings)
        {
            if (DesktopFrameBuffer == null || DesktopFrameBuffer.Length <= 0 || IsDesktopImageBufferEmpty)
            {
                return(null);
            }

            if (settings == null)
            {
                throw new ArgumentNullException(nameof(settings));
            }

            if (settings.Map == null || settings.Map.Count == 0 || settings.Map.Count % 2 != 0)
            {
                throw new InvalidOperationException("The matrix map specified in the settings must be non-null and contain at least 1 point pair and have an even number of values.");
            }

            var rawData = new byte[settings.Map.Count / 2 * 3];

            var span = new ReadOnlySpan <byte>(DesktopFrameBuffer);
            var bpp  = System.Drawing.Image.GetPixelFormatSize(PixelFormat.Format32bppRgb) / 8;

            for (int i = 0; i < settings.Map.Count / 2; i++)
            {
                var x  = settings.Map[i * 2];
                var y  = settings.Map[i * 2 + 1];
                var ix = y * DesktopWidth * bpp + x * bpp;
                rawData[i * 3]     = span[ix + 2];
                rawData[i * 3 + 1] = span[ix + 1];
                rawData[i * 3 + 2] = span[ix];
            }

            return(MatrixFrame.CreateMatrixFrame(rawData, settings));
        }
Example #2
0
        public static MatrixFrame CreateMatrixFrame(byte[] rawData, MatrixSettings settings)
        {
            if (rawData == null)
            {
                throw new ArgumentNullException(nameof(rawData));
            }

            if (settings == null)
            {
                throw new ArgumentNullException(nameof(settings));
            }

            var frameIdIndex = 0;

            if (settings.FrameIdIndex.HasValue)
            {
                frameIdIndex = settings.FrameIdIndex.Value;
            }

            var metadataIndex = 1;

            if (settings.FrameMetadataIndex.HasValue)
            {
                metadataIndex = settings.FrameMetadataIndex.Value;
            }

            // Returns a read-only span of the raw data without the frame id and metadata.
            ReadOnlySpan <byte> GetRawDataSpan()
            {
                ReadOnlySpan <byte> rawDataSpan;

                if (frameIdIndex == 0 && metadataIndex == 1)
                {
                    rawDataSpan = new ReadOnlySpan <byte>(rawData, 6, rawData.Length - 6);
                }
                else
                {
                    var tempData = new List <byte>(rawData);
                    tempData.RemoveRange(frameIdIndex, 3);
                    tempData.RemoveRange(metadataIndex, 3);
                    rawDataSpan = new ReadOnlySpan <byte>(tempData.ToArray());
                }

                return(rawDataSpan);
            }

            string GetDataAsHex()
            {
                var sb = new StringBuilder(settings.Map.Count * 3);

                for (int lineNumber = 0; lineNumber < Math.Ceiling((decimal)settings.Map.Count / LineLength); lineNumber++)
                {
                    var bytes = settings.Map.Count - lineNumber * LineLength > LineLength ? LineLength : settings.Map.Count - lineNumber * LineLength;
                    var line  = new byte[bytes];
                    Array.Copy(rawData, lineNumber * LineLength * 3, line, 0, bytes);
                    sb.AppendLine(BitConverter.ToString(line).Replace("-", " ", StringComparison.OrdinalIgnoreCase));
                }

                return(sb.ToString());
            }

            string GetDataAsTextGrid()
            {
                var rawDataSpan = GetRawDataSpan();
                var sb          = new StringBuilder(settings.Map.Count * 3);

                for (int lineNumber = 0; lineNumber < Math.Ceiling((decimal)settings.Map.Count / LineLength); lineNumber++)
                {
                    var slice = rawDataSpan.Slice(lineNumber * LineLength, settings.Map.Count - lineNumber * LineLength > LineLength ? LineLength : settings.Map.Count - lineNumber * LineLength);
                    sb.AppendLine(Encoding.ASCII.GetString(slice));
                }
                return(sb.ToString());
            }

            string GetDataAsText()
            {
                var rawDataSpan = GetRawDataSpan();
                var eol         = rawDataSpan.IndexOf((byte)0x00);

                if (eol == -1)
                {
                    return(Encoding.ASCII.GetString(rawDataSpan));
                }
                else
                {
                    var slice = rawDataSpan.Slice(0, eol);
                    return(Encoding.ASCII.GetString(slice));
                }
            }

            JsonElement GetDataAsJson()
            {
                var reader = new Utf8JsonReader(GetRawDataSpan());

                try
                {
                    if (!JsonDocument.TryParseValue(ref reader, out JsonDocument jsonDoc))
                    {
                        // Couldn't deserialize, return default JsonElement
                        return(default);