Download rfbd

Our reach continues to grow as our proven solution turns struggling readers into grade-level achievers. Eliminate the tears and stress your child with dyslexia experiences when reading or learning with Learning Ally Audiobook Solution for home.

Solutions for blind and visually impaired college students Learning Ally's College Success Program will give you the tools, including a modern version of books on tape, online resources and the support you need as you navigate your college journey and prepare for your future career. Innovation is our capstone.

Get connected! Subscribe to our newsletter Subscribe by filling out the form or call to learn more. First Name required : Please enter first name.

Last Name required : Please enter last name. Email Address required : Please enter a valid email. Please select the option that best describes you: --I am a-- Educator at school Parent Adult learner or college student Volunteer Supporter Other. The server response from a server with gii capabilities to a client declaring gii capabilities is a gii version message:.

The server response to a gii Device Creation request from the client is the following response:. A device-origin of zero indicates device creation failure. This submessage allows the server to send an audio data stream to the client.

The simplest encoding type is raw pixel data. The values simply represent each pixel in left-to-right scanline order. All RFB clients must be able to cope with pixel data in this raw encoding, and RFB servers should only produce raw encoding unless the client specifically asks for some other encoding type. The CopyRect copy rectangle encoding is a very simple and efficient encoding which can be used when the client already has the same pixel data elsewhere in its framebuffer.

The encoding on the wire simply consists of an X,Y coordinate. This gives a position in the framebuffer from which the client can copy the rectangle of pixel data. This can be used in a variety of situations, the most obvious of which are when the user moves a window across the screen, and when the contents of a window are scrolled. A less obvious use is for optimising drawing of text or other repeating patterns.

An intelligent server may be able to send a pattern explicitly only once, and knowing the previous position of the pattern in the framebuffer, send subsequent occurrences of the same pattern using the CopyRect encoding. RRE stands for rise-and-run-length encoding and as its name implies, it is essentially a two-dimensional analogue of run-length encoding.

RRE-encoded rectangles arrive at the client in a form which can be rendered immediately and efficiently by the simplest of graphics engines. RRE is not appropriate for complex desktops, but can be useful in some situations. The basic idea behind RRE is the partitioning of a rectangle of pixel data into rectangular subregions subrectangles each of which consists of pixels of a single value and the union of which comprises the original rectangular region.

The near-optimal partition of a given rectangle into such subrectangles is relatively easy to compute. The client can render the original rectangle by drawing a filled rectangle of the background pixel value and then drawing a filled rectangle corresponding to each subrectangle. CoRRE stands for compressed rise-and-run-length encoding and as its name implies, it is a variant of the above RRE Encoding and as such essentially a two-dimensional analogue of run-length encoding.

The only difference between CoRRE and RRE is that the position, width and height of the subrectangles are limited to a maximum of pixels. Because of this, the server needs to produce several rectangles in order to cover a larger area. The Hextile Encoding is probably a better choice in the majority of cases. Hextile is a variation on the RRE idea. Rectangles are split up into 16x16 tiles, allowing the dimensions of the subrectangles to be specified in 4 bits each, 16 bits in total.

The rectangle is split into tiles starting at the top left going in left-to-right, top-to-bottom order. The encoded contents of the tiles simply follow one another in the predetermined order. If the width of the whole rectangle is not an exact multiple of 16 then the width of the last tile in each row will be correspondingly smaller. Similarly if the height of the whole rectangle is not an exact multiple of 16 then the height of each tile in the final row will also be smaller.

Each tile is either encoded as raw pixel data, or as a variation on RRE. Each tile has a background pixel value, as before. The background pixel value does not need to be explicitly specified for a given tile if it is the same as the background of the previous tile. However the background pixel value may not be carried over if the previous tile was raw. If all of the subrectangles of a tile have the same pixel value, this can be specified once as a foreground pixel value for the whole tile.

As with the background, the foreground pixel value can be left unspecified, meaning it is carried over from the previous tile. The foreground pixel value may not be carried over if the previous tile was raw or had the SubrectsColored bit set.

It may, however, be carried over from a previous tile with the AnySubrects bit clear, as long as that tile itself carried over a valid foreground from its previous tile. So the data consists of each tile encoded in order. Each tile begins with a subencoding type byte, which is a mask made up of a number of bits:.

Otherwise the other bits in the mask are as follows:. The first non-raw tile in a rectangle must have this bit set. If set, a pixel value follows which specifies the foreground colour to be used for all subrectangles in this tile:. If not set, there are no subrectangles i. If set then each subrectangle is preceded by a pixel value giving the colour of that subrectangle, so a subrectangle is:. A subrectangle is:. The position and size of each subrectangle is specified in two bytes, x-and-y-position and width-and-height.

The most-significant four bits of x-and-y-position specify the X position, the least-significant specify the Y position. The most-significant four bits of width-and-height specify the width minus one, the least-significant specify the height minus one.

The zlib encoding uses zlib [3] to compress rectangles encoded according to the Raw Encoding. The zlibData , when uncompressed, represents a rectangle according to the Raw Encoding. Tight encoding provides efficient compression for pixel data. To reduce implementation complexity, the width of any Tight-encoded rectangle cannot exceed pixels.

If a wider rectangle is desired, it must be split into several rectangles and each one should be encoded separately. The least significant four bits of the compression-control byte inform the client which zlib compression streams should be reset before decoding the rectangle.

Each bit is independent and corresponds to a separate zlib stream that should be reset:. One of three possible compression methods are supported in the Tight encoding. If the bit 7 the most significant bit of the compression-control byte is 0, then the compression type is BasicCompression. In that case, bits the most significant four bits of compression-control should be interpreted as follows:. Otherwise, if the bit 7 of compression-control is set to 1, then the compression method is either FillCompression or JpegCompression , depending on other bits of the same byte:.

Note: JpegCompression may only be used when bits-per-pixel is either 16 or 32 and the client has advertized a quality level using the JPEG Quality Level Pseudo-encoding. This is the same as a PIXEL for the agreed pixel format, except where true-colour-flag is non-zero, bits-per-pixel is 32, depth is 24 and all of the bits making up the red, green and blue intensities are exactly 8 bits wide. In this case a TPIXEL is only 3 bytes long, where the first byte is the red component, the second byte is the green component, and the third byte is the blue component of the pixel color value.

If the compression type is JpegCompression , the following data stream looks like this:. Here each character denotes one bit, xxxxxxx are the least significant 7 bits of the value bits , yyyyyyy are bits , and zzzzzzzz are the most significant 8 bits bits For example, decimal value should be represented as two bytes: binary , or hexadecimal 90 4E.

If the compression type is BasicCompression and bit 6 the read-filter-id bit of the compression-control byte was set to 1, then the next second byte specifies filter-id which tells the decoder what filter type was used by the encoder to pre-process pixel data before the compression. The filter-id byte can be one of the following:.

If bit 6 of the compression-control byte is set to 0 no filter-id byte , then the CopyFilter is used. Such a technique does not affect uncompressed data size, but helps to compress photo-like images better. Pseudo-code for converting intensities to differences follows:. Here V[i,j] is the intensity of a color component for a pixel at coordinates i,j.

For pixels outside the current rectangle, V[i,j] is assumed to be zero which is relevant for P[i,0] and P[0,j]. MAX is the maximum intensity value for a color component.

Note: The GradientFilter may only be used when bits-per-pixel is either 16 or After the pixel data has been filtered with one of the above three filters, it is compressed using the zlib library. But if the data size after applying the filter but before the compression is less then 12, then the data is sent as is, uncompressed. Four separate zlib streams If the compression is not used, then the pixel data is sent as is, otherwise the data stream looks like this:. The zlibhex encoding uses zlib [3] to optionally compress subrectangles according to the Hextile Encoding.

Refer to the hextile encoding for information on how the rectangle is divided into subrectangles and other basic properties of subrectangles. If either of the ZlibRaw or the Zlib bit is set, the subrectangle is compressed using zlib, like this:. The zlibData , when uncompressed, should in this case be interpreted as the Raw data in the hextile encoding.

The zlibData , when uncompressed, represents a plain hextile rectangle according to the lower 5 bits in the subencoding. If neither the ZlibRaw nor the Zlib bit is set, the subrectangle follows the rules described in the Hextile Encoding. On the wire, the rectangle begins with a 4-byte length field, and is followed by that many bytes of zlib-compressed data. The zlibData when uncompressed represents tiles of 64x64 pixels in left-to-right, top-to-bottom order, similar to hextile.

If the width of the rectangle is not an exact multiple of 64 then the width of the last tile in each row is smaller, and if the height of the rectangle is not an exact multiple of 64 then the height of each tile in the final row is smaller.

This is the same as a PIXEL for the agreed pixel format, except where true-colour-flag is non-zero, bits-per-pixel is 32, depth is 24 or less and all of the bits making up the red, green and blue intensities fit in either the least significant 3 bytes or the most significant 3 bytes. In this case a CPIXEL is only 3 bytes long, and contains the least significant or the most significant 3 bytes as appropriate.

Note that for the corner case where bits-per-pixel is 32 and depth is 16 or less this is a corner case, since the client is much better off using 16 or even 8 bits-per-pixels a CPIXEL is still 3 bytes long.

By convention, the three least significant bytes are used when both the three least and the three most significant bytes would cover the used bits.

Each tile begins with a subencoding type byte. The top bit of this byte is set if the tile has been run-length encoded, clear otherwise. The bottom seven bits indicate the size of the palette used: zero means no palette, one means that the tile is of a single colour, 2 to indicate a palette of that size. The possible values of subencoding are:. Raw pixel data.

Packed palette types. Then the packed pixels follow, each pixel represented as a bit field yielding an index into the palette 0 meaning the first palette entry. For paletteSize 2, a 1-bit field is used, for paletteSize 3 or 4 a 2-bit field is used and for paletteSize from 5 to 16 a 4-bit field is used.

The bit fields are packed into bytes, the most significant bits representing the leftmost pixel i. For tiles not a multiple of 8, 4 or 2 pixels wide as appropriate , padding bits are used to align each row to an exact number of bytes.

Plain RLE. Consists of a number of runs, repeated until the tile is done. Runs may continue from the end of one row to the beginning of the next. Each run is a represented by a single pixel value followed by the length of the run. The length is represented as one or more bytes. The length is calculated as one more than the sum of all the bytes representing the length. Any byte value other than indicates the final byte. So for example length 1 is represented as [0], as [], as [,0], as [,1], as [,], as [,,0] and so on.

Palette RLE. Then as with plain RLE, consists of a number of runs, repeated until the tile is done. A run of length one is represented simply by a palette index:. A run of length more than one is represented by a palette index with the top bit set, followed by the length of the run as for plain RLE. Specifies the desired quality from the JPEG encoder. Low quality can be useful in low bandwidth situations. The quality level concerns lossy compression and hence the setting is a tradeoff between image quality and bandwidth.

The specification defines neither what bandwidth is required at a certain quality level nor what image quality you can expect. The quality level is also just a hint to the server. A client which requests the Cursor pseudo-encoding is declaring that it is capable of drawing a mouse cursor locally. This can significantly improve perceived performance over slow links.

The server sets the cursor shape by sending a pseudo-rectangle with the Cursor pseudo-encoding as part of an update. Within each byte the most significant bit represents the leftmost pixel, with a 1-bit meaning the corresponding pixel in the cursor is valid. A client which requests the X Cursor pseudo-encoding is declaring that it is capable of drawing a mouse cursor locally. The server sets the cursor shape by sending a pseudo-rectangle with the X Cursor pseudo-encoding as part of an update.

The data consists of the primary and secondary colours for the cursor, followed by one bitmap for the colour and one bitmask for the transparency. Within each byte the most significant bit represents the leftmost pixel, with a 1-bit meaning the corresponding pixel should use the primary colour, or that the pixel is valid.

The server changes the desktop size by sending a pseudo-rectangle with the DesktopSize pseudo-encoding. There is no further data associated with the pseudo-rectangle. The semantics of the DesktopSize pseudo-encoding were originally not clearly defined and as a results there are multiple differing implementations in the wild.

Both the client and server need to take special steps to ensure maximum compatibility. In the initial implementation the DesktopSize pseudo-rectangle was sent in its own update without any modifications to the framebuffer data. The client would discard the framebuffer contents upon receiving this pseudo-rectangle and the server would consider the entire framebuffer to be modified. A later implementation sent the DesktopSize pseudo-rectangle together with modifications to the framebuffer data.

It also expected the client to retain the framebuffer contents as those modifications could be from after the framebuffer resize had occurred on the server. The update containing the pseudo-rectangle should not contain any rectangles that change the framebuffer data as that will most likely be discarded by the client and will have to be resent later. The server should assume that the client discards the framebuffer data when receiving a DesktopSize pseudo-rectangle.

It should therefore not use any encoding that relies on the previous contents of the framebuffer. The server should also consider the entire framebuffer to be modified. Some early client implementations require the DesktopSize pseudo-rectangle to be the very last rectangle in an update.

Servers should make every effort to support these. The server should only send a DesktopSize pseudo-rectangle when an actual change of the framebuffer dimensions has occurred. Some clients respond to a DesktopSize pseudo-rectangle in a way that could send the system into an infinite loop if the server sent out the pseudo-rectangle for anything other than an actual change.

The client should assume that the server expects the framebuffer data to be retained when the framebuffer dimensions change. This requirement can be satisfied either by actually retaining the framebuffer data, or by making sure that incremental is set to non-zero in the next FramebufferUpdateRequest.

The principle of one framebuffer update being a transition from one valid state to another does not hold for updates with the DesktopSize pseudo-rectangle as the framebuffer contents can temporarily be partially or completely undefined. Clients should try to handle this gracefully, e. A client which requests the LastRect pseudo-encoding is declaring that it does not need the exact number of rectangles in a FramebufferUpdate message. Instead, it will stop parsing when it reaches a LastRect rectangle.

A server may thus start transmitting the FramebufferUpdate message before it knows exactly how many rectangles it is going to transmit, and the server typically advertises this situation by saying that it is going to send rectangles, but it then stops with a LastRect instead of sending all of them.

Specifies the desired compression level. Encoding number implies high compression level, implies low compression level.

Low compression level can be useful to get low latency in medium to high bandwidth situations and high compression level can be useful in low bandwidth situations. The compression level concerns lossless compression, and hence the setting is a tradoff between CPU time and bandwidth. It is therefore probably difficult to define exact cut-off points for which compression levels should be used for any given bandwidth.

The compression level is just a hint for the server, and there is no specification for what a specific compression level means. A client that supports this encoding declares that is able to send pointer motion events either as absolute coordinates, or relative deltas. The server can switch between different pointer motion modes by sending a FrameBufferUpdate message.

If the x-position in the update is 1, the server is requesting absolute coordinates, which is the RFB protocol default when this encoding is not supported. If the x-position in the update is 0, the server is requesting relative deltas. When relative delta mode is active, the semantics of the PointerEvent message are changed. The x-position and y-position fields are to be treated as S16 quantities, denoting the delta from the last position.

A client can compute the signed deltas with the logic:. If the client needs to send an updated button-mask without any associated motion, it should use the value 0x7FFF in the x-position and y-position fields of the PointerEvent.

Prior to this extension, a server with such a input device would have to perform the absolute to relative delta conversion itself. Clients are advised that when generating events in relative pointer mode, they should grab and hide the local pointer. When the local pointer hits any edge of the client window, it should be warped back by pixels. A client that supports this encoding is indicating that it is able to provide raw keycodes as an alternative to keysyms.

If a server wishes to receive raw keycodes it will send a FrameBufferUpdate with the matching psuedo-encoding and the num-rectanges field set to 1, however, no rectanges will actually be sent. A client that supports this encoding is indicating that it is able to receive an audio data stream. If a server wishes to send audio data it will send a FrameBufferUpdate with the matching psuedo-encoding and the num-rectangles field set to 1, however, no rectangles will actually be sent. A client that supports the General Input Interface extension starts by requesting the gii pseudo-encoding declaring that it is capable of accepting the gii Server Message.

The server, in turn, declares that it is capable of accepting the gii Client Message by sending a gii Server Message of subtype version. Requesting the gii pseudo-encoding is the first step when a client wants to use the gii extension of the RFB protocol. The gii extension is used to provide a more powerful input protocol for cases where the standard input model is insufficient. It supports relative mouse movements, mouses with more than 8 buttons and mouses with more than three axes.

It even supports joysticks and gamepads. A client which requests the DesktopName pseudo-encoding is declaring that it is capable of coping with a change of the desktop name. The server changes the desktop name by sending a pseudo-rectangle with the DesktopName pseudo-encoding in an update. After the rectangle header, a string with the new name follows. This encoding is used in conjunction with the SetDesktopSize message. If a server supports the ExtendedDesktopSize encoding, it must also have basic support for the SetDesktopSize message although it may deny all requests to change the screen layout.

Servers and clients should support both for maximum compatibility, but a server must only send the extended version to a client asking for both. The semantics of DesktopSize are not as well-defined as for ExtendedDesktopSize and handling both at the same time would require needless complexity in the client. The server must send an ExtendedDesktopSize rectangle in response to a FramebufferUpdateRequest with incremental set to zero, assuming the client has requested the ExtendedDesktopSize pseudo-encoding using the SetEncodings message.

This requirement is needed so that the client has a reliable way of fetching the initial screen configuration, and to determine if the server supports the SetDesktopSize message. A consequence of this is that a client must not respond to an ExtendedDesktopSize rectangle by sending a FramebufferUpdateRequest with incremental set to zero.

Doing so would make the system go into an infinite loop. The server must also send an ExtendedDesktopSize rectangle in response to a SetDesktopSize message, indicating the result. Rectangles sent as a result of a SetDesktopSize message must be sent as soon as possible.

Rectangles sent for other reasons may be subjected to delays imposed by the server. An update containing an ExtendedDesktopSize rectangle must not contain any changes to the framebuffer data, neither before nor after the ExtendedDesktopSize rectangle.

More reasons may be added in the future. Clients should treat an unknown value as a server-side change i. This field shall be set to zero by the server and ignored by clients when not defined. Other error codes may be added in the future and clients must treat them as an unknown failure. The number-of-screens field indicates the number of active screens and allows for multi head configurations. These are defined as:. The id field contains an arbitrary value that the server and client can use to map RFB screens to physical screens.

The value must be unique in the current set of screens and must be preserved for the lifetime of that RFB screen. New ids are assigned by whichever side creates the screen. An id may be reused if there has been a subsequent update of the screen layout where the id was not used. The flags field is currently unused.

Clients and servers must ignore, but preserve, any bits it does not understand. For new screens, those bits must be set to zero. Note that a simple client which does not support multi head does not need to parse the list of screens and can simply display the entire framebuffer. A client which requests the xvp pseudo-encoding is declaring that it wishes to use the xvp extension. This informs the client that it may then subsequently send messages of type xvp Client Message.

The server should send a ServerFence the first time it sees a SetEncodings message with the Fence pseudo-encoding, in order to inform the client that this extension is supported. The message can use any flags or payload. A client which requests the ContinuousUpdates pseudo-encoding is declaring that it wishes to use the EnableContinuousUpdates extension.

The server must send a EndOfContinuousUpdates message the first time it sees a SetEncodings message with the ContinuousUpdates pseudo-encoding, in order to inform the client that the extension is supported. The JPEG Fine-Grained Quality Level pseudo-encoding allows the image quality to be specified on a 0 to scale, with corresponding to image quality 0 and corresponding to image quality This pseudo-encoding was originally intended for use with JPEG-encoded subrectangles, but it could be used with other types of image encoding as well.

Since the human eye is more sensitive to spatial changes in brightness than to spatial changes in color, the chrominance components Cb, Cr can be subsampled to save bandwidth without losing much image quality on smooth images, such as photographs, chrominance subsampling is often not distinguishable by the human eye.

Subsampling can be implemented either by averaging together groups of chrominance components or by simply picking one component from the group and discarding the rest. Enter search terms or a module, class or function name. Existing clients will never request the new encoding so will never see rectangles encoded that way.

See Pseudo-encodings for a description of current pseudo-encodings. New security types Adding a new security type gives the ultimate flexibility in modifying the behaviour of the protocol without sacrificing compatibility with existing clients and servers.

Version 3. This is followed by a string describing the reason where a string is specified as a length followed by that many ASCII characters : No. The server sends a random byte challenge: No. Authentication The Tight security type allows for flexible authentication of the client, which is typically one of the other security types.

Server capabilities As a last step the Tight security type extends the ServerInit message and enables the server to let the client know about the server capabilities in terms of encodings and supported message types. After the Tight security type has been selected, the server starts by sending a list of supported tunnels, in order of preference: No. For example, to find the red value between 0 and red-max from a given pixel, do the following: Swap the pixel value according to big-endian-flag e.

Shift right by red-shift. AND with red-max in host byte order. If the Tight Security Type is activated, the server init message is extended with an interaction capabilities section: No. F12 0xffc9 Shift left 0xffe1 Shift right 0xffe2 Control left 0xffe3 Control right 0xffe4 Meta left 0xffe7 Meta right 0xffe8 Alt left 0xffe9 Alt right 0xffea The interpretation of keysyms is a complex area.

The difference between upper and lower case keysyms is significant. This is unlike some of the keyboard processing in the X Window System which treats them as the same. Instead they should interpret each character-based keysym according to its case. Unlike Shift, the state of modifier keys such as Control and Alt should be taken as modifying the interpretation of other keysyms. In the RFB protocol the latter approach is preferred.

However, to be backwards-compatible with existing viewers, servers should also recognise ISO Left Tab as meaning a shifted Tab. BlockBefore All messages preceeding this one must have finished processing and taken effect before the response is sent. BlockAfter All messages following this one must not start processing until the response is sent. SyncNext The message following this one must be executed in an atomic manner so that anything preceeding the fence response must not be affected by the message, and anything following the fence response must be affected by the message.

Request Indicates that this is a new request and that a response is expected. If this bit is cleared then this message is a response to an earlier request. The event reports count valuators starting with first. Possible values for submessage-type and their associated psuedo encodings are Submessage Type Psuedo Encoding Description 0 Extended key events 1 Audio 1. The full message is: No. The first operation enables audio capture from the server: No.

The second operation is the inverse, to disable audio capture on the server: No. This should be set before audio capture is enabled on the server, otherwise the client will not be able to reliably interpret the receiving audio buffers: No.

Each rectangle consists of: No. The first operation informs the client that an audio stream is about to start No. On the wire, the data begins with the header: No. Each tile begins with a subencoding type byte, which is a mask made up of a number of bits: No. Otherwise the other bits in the mask are as follows: BackgroundSpecified If set, a pixel value follows which specifies the background colour for this tile: No.

ForegroundSpecified If set, a pixel value follows which specifies the foreground colour to be used for all subrectangles in this tile: No. AnySubrects If set, a single byte follows giving the number of subrectangles following: No. SubrectsColoured If set then each subrectangle is preceded by a pixel value giving the colour of that subrectangle, so a subrectangle is: No.

A subrectangle is: No. The first byte of each Tight-encoded rectangle is a compression-control byte: No. Each bit is independent and corresponds to a separate zlib stream that should be reset: Bit Description 0 Reset stream 0 1 Reset stream 1 2 Reset stream 2 3 Reset stream 3 One of three possible compression methods are supported in the Tight encoding.

In that case, bits the most significant four bits of compression-control should be interpreted as follows: Bits Binary value Description 00 Use stream 0 01 Use stream 1 10 Use stream 2 11 Use stream 3 6 0 — 1 read-filter-id 7 0 BasicCompression Otherwise, if the bit 7 of compression-control is set to 1, then the compression method is either FillCompression or JpegCompression , depending on other bits of the same byte: Bits Binary value Description FillCompression JpegCompression any other Invalid Note: JpegCompression may only be used when bits-per-pixel is either 16 or 32 and the client has advertized a quality level using the JPEG Quality Level Pseudo-encoding.

The data following the compression-control byte depends on the compression method. This value applies to all pixels of the rectangle. JpegCompression If the compression type is JpegCompression , the following data stream looks like this: No. The jpeg-data is a JFIF stream. BasicCompression If the compression type is BasicCompression and bit 6 the read-filter-id bit of the compression-control byte was set to 1, then the next second byte specifies filter-id which tells the decoder what filter type was used by the encoder to pre-process pixel data before the compression.

The filter-id byte can be one of the following: No. See below for details on the compression. PaletteFilter The PaletteFilter converts true-color pixel data to indexed colors and a palette which can consist of If the number of colors is 2, then each pixel is encoded in 1 bit, otherwise 8 bits are used to encode one pixel.

When the PaletteFilter is used, the palette is sent before the pixel data. The palette begins with an unsigned byte which value is the number of colors in the palette minus 1 i. The hextile subencoding bitfield is extended with these bits: No. The possible values of subencoding are: 0 Raw pixel data. The pixel value follows: No. A run of length one is represented simply by a palette index: No. The semantics defined here retain compatibility with both of two older implementations.

For example the server may have provided means for server-side applications to manipulate the screen layout. The change may or may not have happened depending on server policy or available resources. The status code in the y-position field must be used to determine which.

A rectangle with this code is never sent if the server denied the request. The width and height indicates the new width and height of the framebuffer. The encoding data is defined as: No.