public ArraySegment <byte> PreRender(OutputFrame frame)
        {
            var pixels       = frame.Pixels;
            var offsetX      = frame.OffsetX;
            var offsetY      = frame.OffsetY;
            var cacheId      = frame.CacheId;
            var offsetStatic = frame.OffsetStatic;

            bool offsetSupported    = ((serverCapabilities & ServerCapabilities.Offset) != 0);
            bool greyscaleSupported = ((serverCapabilities & ServerCapabilities.GreyScale) != 0);

            const int offsetLen = 7 + 4 + 1 + 4 + 1;
            const int pxLen     = 22;

            var cachingPossible = cacheId != -1 && (offsetSupported || offsetStatic);

            if (cachingPossible)
            {
                byte[] cachedFrame;

                if (!_cache.TryGetValue(cacheId, out cachedFrame))
                {
                    Console.WriteLine($"Frame {cacheId} not rendered! rendering...");
                    using (var cachems = GetBuffer(pixels.Length * pxLen))
                    {
                        RenderPixels(pixels, offsetX, offsetY, offsetSupported, greyscaleSupported, cachems);
                        var    rendered      = cachems.ToArraySegment();
                        byte[] renderedArray = rendered.ToArray();
                        _cache[cacheId] = renderedArray;
                        cachedFrame     = renderedArray;
                    }
                }

                if (!offsetStatic)
                {
                    using (var ms = GetBuffer(pixels.Length * pxLen + offsetLen))
                    {
                        WriteOffset(offsetX, offsetY, ms);
                        ms.Write(cachedFrame, cachedFrame.Length);
                        return(ms.ToArraySegment());
                    }
                }
                else
                {
                    return(new ArraySegment <byte>(cachedFrame));
                }
            }
            else
            {
                using (var ms = GetBuffer(pixels.Length * pxLen + (offsetSupported ? offsetLen : 0)))
                {
                    if (offsetSupported)
                    {
                        WriteOffset(offsetX, offsetY, ms);
                    }
                    RenderPixels(pixels, offsetX, offsetY, offsetSupported, greyscaleSupported, ms);
                    return(ms.ToArraySegment());
                }
            }
        }
        public ArraySegment <byte> PreRender(OutputFrame frame)
        {
            const int pxLen = 22;

            var canvasWidth  = _canvasSize.Width;
            var canvasHeight = _canvasSize.Height;

            using (var ms = new MemoryStream(pxLen * frame.Pixels.Length))
            {
                using (var sw = new StreamWriter(ms))
                {
                    sw.NewLine = "\n";
                    foreach (var pixel in frame.Pixels)
                    {
                        uint color   = pixel.Color;
                        var  renderX = pixel.X + frame.OffsetX;
                        var  renderY = pixel.Y + frame.OffsetY;
                        if (renderX < 0 || renderY < 0 || renderX >= canvasWidth || renderY >= canvasHeight)
                        {
                            continue;
                        }

                        if (color < 0xFF000000)
                        {
                            sw.WriteLine($"PX {pixel.X + frame.OffsetX} {pixel.Y + frame.OffsetY} {color & 0x00FFFFFF:X6}{color >> 24:X2}");
                        }
                        else
                        {
                            sw.Write("PX ");
                            sw.Write((pixel.X + frame.OffsetX).ToString());
                            sw.Write(" ");
                            sw.Write((pixel.Y + frame.OffsetY).ToString());
                            sw.Write(" ");
                            sw.WriteLine((color & 0x00FFFFFF).ToString("X6"));
                        }
                    }
                    sw.Flush();
                    return(new ArraySegment <byte>(ms.GetBuffer(), 0, (int)ms.Length));
                }
            }
        }