public FramebufferManualInvalidate ( VncRectangle region ) : void | ||
region | VncRectangle | The region to invalidate. |
Résultat | void |
public bool RespondToUpdateRequest(VncServerSession session) { var fb = Framebuffer; var fbr = session.FramebufferUpdateRequest; if (fb == null || fbr == null) { return(false); } var incremental = fbr.Incremental; var region = fbr.Region; session.FramebufferManualBeginUpdate(); var buffer = fb.GetBuffer(); int bpp = fb.PixelFormat.BytesPerPixel; lock (fb.SyncRoot) { int ymax = Math.Min(region.Y + region.Height, fb.Height); int xmax = Math.Min(region.X + region.Width, fb.Width); for (int y = region.Y; y < ymax; y += TileSize) { for (int x = region.X; x < xmax; x += TileSize) { int w = Math.Min(TileSize, xmax - x); int h = Math.Min(TileSize, ymax - y); var subregion = new VncRectangle(x, y, w, h); VncPixelFormat.Copy(buffer, fb.Stride, fb.PixelFormat, subregion, _pixelBuffer, w * bpp, Framebuffer.PixelFormat); int ix = x / TileSize, iy = y / TileSize; var tileHash = _hash.ComputeHash(_pixelBuffer, 0, w * h * bpp); if (_hashes[iy, ix] == null || !_hashes[iy, ix].SequenceEqual(tileHash)) { _hashes[iy, ix] = tileHash; if (incremental) { session.FramebufferManualInvalidate(subregion); } } } } } if (!incremental) { session.FramebufferManualInvalidate(region); } return(session.FramebufferManualEndUpdate()); }
/// <summary> /// Responds to a <see cref="VncServerSession"/> update request. /// </summary> /// <param name="session"> /// The session on which the update request was received. /// </param> /// <returns> /// <see langword="true"/> if the operation completed successfully; otherwise, /// <see langword="false"/>. /// </returns> public unsafe bool RespondToUpdateRequest(VncServerSession session) { VncRectangle subregion = default(VncRectangle); var fb = this.Framebuffer; var fbr = session.FramebufferUpdateRequest; if (fb == null || fbr == null) { return false; } var incremental = fbr.Incremental; var region = fbr.Region; int bpp = fb.PixelFormat.BytesPerPixel; session.FramebufferManualBeginUpdate(); // Take a lock here, as we will modify // both buffers heavily in the next block. lock (fb.SyncRoot) { lock (this.cachedFramebuffer.SyncRoot) { // Get the buffers (byte arrays) of data. We'll compare the data one pixel at a time. var actualBuffer = this.Framebuffer.GetBuffer(); var bufferedBuffer = this.cachedFramebuffer.GetBuffer(); for (int y = region.Y; y < region.Y + region.Height; y++) { subregion.X = region.X; subregion.Y = y; subregion.Width = region.Width; subregion.Height = 1; bool isValid = true; // For a given y, the x pixels are stored sequentially in the array // starting at y * stride (number of bytes per row); for each x // value there are bpp bytes of data (4 for a 32-bit integer); we are looking // for pixels between x and x + w so this translates to // y * stride + bpp * x and y * stride + bpp * (x + w) int srcOffset = (y * this.Framebuffer.Stride) + (bpp * region.X); int length = bpp * region.Width; fixed (byte* actualLinePtr = actualBuffer, bufferedLinePtr = bufferedBuffer) { isValid = NativeMethods.memcmp(actualLinePtr + srcOffset, bufferedLinePtr + srcOffset, (uint)length) == 0; } if (!isValid) { Buffer.BlockCopy(actualBuffer, srcOffset, bufferedBuffer, srcOffset, length); } this.isLineInvalid[y - region.Y] = !isValid; } } // lock } // lock if (incremental) { int? y = null; for (int line = 0; line < region.Height; line++) { if (y == null && this.isLineInvalid[line]) { y = region.Y + line; } if (y != null && (!this.isLineInvalid[line] || line == region.Height)) { // Flush subregion.X = region.X; subregion.Y = region.Y + y.Value; subregion.Width = region.Width; subregion.Height = line - y.Value; session.FramebufferManualInvalidate(subregion); y = null; } } } else { session.FramebufferManualInvalidate(region); } return session.FramebufferManualEndUpdate(); }
/// <summary> /// Responds to a <see cref="VncServerSession"/> update request. /// </summary> /// <param name="session"> /// The session on which the update request was received. /// </param> /// <returns> /// <see langword="true"/> if the operation completed successfully; otherwise, /// <see langword="false"/>. /// </returns> public unsafe bool RespondToUpdateRequest(VncServerSession session) { VncRectangle subregion = default(VncRectangle); var fb = this.Framebuffer; var fbr = session.FramebufferUpdateRequest; if (fb == null || fbr == null) { return(false); } var incremental = fbr.Incremental; var region = fbr.Region; int bpp = fb.PixelFormat.BytesPerPixel; session.FramebufferManualBeginUpdate(); // Take a lock here, as we will modify // both buffers heavily in the next block. lock (fb.SyncRoot) { lock (this.cachedFramebuffer.SyncRoot) { // Get the buffers (byte arrays) of data. We'll compare the data one pixel at a time. var actualBuffer = this.Framebuffer.GetBuffer(); var bufferedBuffer = this.cachedFramebuffer.GetBuffer(); for (int y = region.Y; y < region.Y + region.Height; y++) { subregion.X = region.X; subregion.Y = y; subregion.Width = region.Width; subregion.Height = 1; bool isValid = true; // For a given y, the x pixels are stored sequentially in the array // starting at y * stride (number of bytes per row); for each x // value there are bpp bytes of data (4 for a 32-bit integer); we are looking // for pixels between x and x + w so this translates to // y * stride + bpp * x and y * stride + bpp * (x + w) int srcOffset = (y * this.Framebuffer.Stride) + (bpp * region.X); int length = bpp * region.Width; fixed(byte *actualLinePtr = actualBuffer, bufferedLinePtr = bufferedBuffer) { isValid = NativeMethods.memcmp(actualLinePtr + srcOffset, bufferedLinePtr + srcOffset, (uint)length) == 0; } if (!isValid) { Buffer.BlockCopy(actualBuffer, srcOffset, bufferedBuffer, srcOffset, length); } this.isLineInvalid[y - region.Y] = !isValid; } } // lock } // lock if (incremental) { int?y = null; for (int line = 0; line < region.Height; line++) { if (y == null && this.isLineInvalid[line]) { y = region.Y + line; } if (y != null && (!this.isLineInvalid[line] || line == region.Height)) { // Flush subregion.X = region.X; subregion.Y = region.Y + y.Value; subregion.Width = region.Width; subregion.Height = line - y.Value; session.FramebufferManualInvalidate(subregion); y = null; } } } else { session.FramebufferManualInvalidate(region); } return(session.FramebufferManualEndUpdate()); }
/// <summary> /// Responds to a <see cref="VncServerSession"/> update request. /// </summary> /// <param name="session"> /// The session on which the update request was received. /// </param> /// <returns> /// <see langword="true"/> if the operation completed successfully; otherwise, /// <see langword="false"/>. /// </returns> public unsafe bool RespondToUpdateRequest(VncServerSession session) { VncRectangle subregion = default(VncRectangle); var fb = this.Framebuffer; var fbr = session.FramebufferUpdateRequest; if (fb == null || fbr == null) { return(false); } var incremental = fbr.Incremental; var region = fbr.Region; int bpp = fb.PixelFormat.BytesPerPixel; Logger.Debug($"Responding to an update request for region {region}."); session.FramebufferManualBeginUpdate(); // Take a lock here, as we will modify // both buffers heavily in the next block. lock (fb.SyncRoot) { lock (this.cachedFramebuffer.SyncRoot) { var actualBuffer = this.Framebuffer.GetBuffer(); var bufferedBuffer = this.cachedFramebuffer.GetBuffer(); // In this block, we will determine which rectangles need updating. Right now, we consider // each line at once. It's not a very efficient algorithm, but it works. // We're going to start at the upper-left position of the region, and then we will work our way down, // on a line by line basis, to determine if each line is still valid. // isLineInvalid will indicate, on a line-by-line basis, whether a line is still valid or not. for (int y = region.Y; y < region.Y + region.Height; y++) { subregion.X = region.X; subregion.Y = y; subregion.Width = region.Width; subregion.Height = 1; bool isValid = true; // For a given y, the x pixels are stored sequentially in the array // starting at y * stride (number of bytes per row); for each x // value there are bpp bytes of data (4 for a 32-bit integer); we are looking // for pixels between x and x + w so this translates to // y * stride + bpp * x and y * stride + bpp * (x + w) int srcOffset = (y * this.Framebuffer.Stride) + (bpp * region.X); int length = bpp * region.Width; fixed(byte *actualLinePtr = actualBuffer, bufferedLinePtr = bufferedBuffer) { isValid = NativeMethods.memcmp(actualLinePtr + srcOffset, bufferedLinePtr + srcOffset, (uint)length) == 0; } if (!isValid) { try { Buffer.BlockCopy(actualBuffer, srcOffset, bufferedBuffer, srcOffset, length); } catch { throw; } } this.isLineInvalid[y - region.Y] = !isValid; } } // lock } // lock if (incremental) { // Determine logical group of lines which are invalid. We find the first line which is invalid, // create a new region which contains the all invalid lines which immediately follow the current line. // If we find a valid line, we'll create a new region. int?y = null; for (int line = 0; line < region.Height; line++) { if (y == null && this.isLineInvalid[line]) { y = region.Y + line; } if (y != null && (!this.isLineInvalid[line] || line == region.Height - 1)) { // Flush subregion.X = region.X; subregion.Y = region.Y + y.Value; subregion.Width = region.Width; subregion.Height = line - y.Value + 1; session.FramebufferManualInvalidate(subregion); y = null; } } } else { session.FramebufferManualInvalidate(region); } return(session.FramebufferManualEndUpdate()); }