Fast and lightweight pixel writing for active matrix digital displays based on pixel bit depth adaptation within commands

Abstract

The present invention relates to an active matrix digital display comprising a plurality of pixels, each pixel comprising a static memory storing a plurality of n bits representing the intensity of the pixel, and an interface (Int) configured to, upon receiving at least one command to write pixel intensities to a region of a screen, determine a bit depth of pixel intensity representations in a payload of the command from an identifier of the type of command and at least one of the parameters of the command, and write intensity values ​​of pixels of the region of the screen from the payload of the command to the memory according to the bit depth of the pixel intensity representations in the payload and a pixel path associated with that region of the screen, said writing including conversion between the bit depth of the pixel intensity representations in the payload and the bit depth of the pixel intensity representations in the memory if they differ, and the pixel intensity representations in the payload are concatenated for each consecutive pixel in the region according to the pixel path.

Description

[Technical Field]

[0001] The present disclosure relates to the field of active matrix digital displays, and more particularly to the field of pixel writing in active matrix digital displays. [Background technology]

[0002] An active matrix digital display is a display in which each pixel is associated with an address, has memory to store one or more pixel intensities, and can be written to independently. An active matrix display may be, for example, an LCD, an AMOLED or AMLED display, or a microdisplay.

[0003] The pixel's memory may store a single intensity value if the pixel is a grayscale pixel, or multiple intensity values ​​for multiple color layers if the pixel is a color pixel, e.g., an RGB pixel. Each pixel may further include a DAC (digital-to-analog converter) that converts the intensity values ​​stored in the pixel's memory into voltages or currents for the pixel's one or more electroluminescent elements.

[0004] The pixel's memory may be static memory, such as SRAM (Static Random Access Memory), or volatile memory. Volatile memory needs to be refreshed, while static memory stores values ​​that are retained indefinitely until they are erased and replaced with new values. A pixel with static memory is described, for example, by: Hao, D., Aiying, G., & Feng, R. (2020, November). A New Low-power Pixel Circuit for OLEDoS Microdisplay. In 2020 17th China International Forum on Solid State Lighting & 2020 International Forum on Wide Bandgap Semiconductors China (SSLChina: IFWS) (pp. 211-214). IEEE., and Vogel, U., Beyer, B., Schober, M., Wartenberg, P., Brenner, S., Bunk, G., ... & Richter, B. (2017, May). 77-1: Invited Paper: Ultra-low Power OLED Microdisplay for Extended Battery Life in NTE Displays. In SID Symposium Digest of Technical Papers (Vol. 48, No. 1, pp. 1125-1128).

[0005] Active matrix digital displays usually have an interface that receives commands and writes pixel intensities into memory accordingly. The interface can be a serial or parallel interface. Examples of serial interfaces are I2C, SPI, or CAN interfaces, but almost any type of serial interface can be used with active matrix digital displays.

[0006] When an active matrix display needs to be written, a command is typically sent containing a bitmap image of every pixel of the display to be written. Thus, every intensity value of every pixel of the image is transferred over the interface. This introduces significant delays in writing the values ​​and consumes a significant amount of energy. [Prior art documents] [Non-patent literature]

[0007] [Non-Patent Document 1] Hao, D., Aiying, G., & Feng, R. (2020, November). A New Low-power Pixel Circuit for OLEDoS Microdisplay. In 2020 17th China International Forum on Solid State Lighting & 2020 International Forum on Wide Bandgap Semiconductors China (SSLChina: IFWS) (pp. 211-214). IEEE. [Non-patent document 2] Vogel, U., Beyer, B., Schober, M., Wartenberg, P., Brenner, S., Bunk, G., ... & Richter, B. (2017, May). 77-1: Invited Paper: Ultra-low Power OLED Microdisplay for Extended Battery Life in NTE Displays. In SID Symposium Digest of Technical Papers (Vol. 48, No. 1, pp. 1125-1128). Summary of the Invention [Problem to be solved by the invention]

[0008] Therefore, there is a need to reduce the amount of data transferred for writing to an active matrix display screen. [Means for solving the problem]

[0009] The present disclosure improves this situation.

[0010] An active matrix digital display is proposed, comprising a plurality of pixels, each pixel comprising a static memory adapted to store a plurality of n bits representing the intensity of the pixel, and an interface configured to, upon receiving at least one command to write pixel intensities to a region of the screen, determine a bit depth of pixel intensity representations in a payload of the command from an identifier of the type of command and at least one of the parameters of the command, and write intensity values ​​of pixels of the region of the screen from the payload of the command to the memory according to the bit depth of the pixel intensity representations in the payload and a pixel path associated with the region of the screen, said writing including, if the bit depth of the pixel intensity representations in the payload and the bit depth of the pixel intensity representations in the memory are different, a conversion between the bit depth of the pixel intensity representations in the payload and the bit depth of the pixel intensity representations in the memory, and the pixel intensity representations in the payload are concatenated for each consecutive pixel in the region according to the pixel path.

[0011] An "interface" refers to an interface capable of receiving commands, analyzing the commands, and writing to static memory accordingly. An interface may include wires and electronic circuits. An interface may be, for example, a serial or parallel input interface. A serial interface may be, for example, an SPI interface. An interface may be an input interface or an input and output interface.

[0012] "Screen region" refers to a contiguous portion of a screen, which may be either the entire screen or a portion of the screen. Such a screen portion may be, for example, a row, a column, or a 2D shape such as a rectangle, a circle, or a predefined shape.

[0013] A "command type identifier" refers to a part of a command, such as a bit pattern, that indicates which type the command belongs to.

[0014] "One or more intensity values" refers to at least one intensity that defines the layout of a pixel.

[0015] The layout of a pixel may be defined by a single intensity value, for example if the pixel is a grayscale pixel, or by multiple intensity values ​​if the pixel is defined by multiple color channels. For example, an RGB pixel contains three subpixels, each of which is associated with an intensity value. Other color representations are also possible, such as RG (two color channels, red and green, two subpixels per pixel) or RGBW (four color channels, red, green, blue, and white, two subpixels per pixel) representations.

[0016] A "pixel path" refers to a series of absolute or relative pixel locations across a 2D shape. For example, - If the 2D shape is a rectangle, the pixel path may be constructed by writing the lines of the rectangle from top to bottom, left to right. - If the 2D shape is a mouse arrow, the pixel path may be constructed by writing the pixels of the arrow from top to bottom, left to right, with each line containing a different number of pixels. - others is.

[0017] The pixel path may be associated with a command type or may be defined by one or more parameters of the command. For example, if the command is to write a rectangle, at least one parameter may define whether the rectangle is written top-to-bottom or bottom-to-top.

[0018] "Conversion" refers to defining an equivalent value in a second bit depth from a pixel intensity value using a first bit depth.

[0019] This allows bit data to be exchanged over the interface to be written using different bit depths depending on the command and / or parameters. Thus, pixel intensities can be written using a smaller bit depth than is actually required for each command. This therefore allows for faster pixel writing and energy savings compared to writing all pixels on the screen.

[0020] In another aspect, a display device is proposed, comprising a digital display according to an embodiment of the invention and a processing unit configured to send at least one command to an interface of the digital display.

[0021] A "processing unit" refers to an electronic component capable of performing electronic or computer calculations for a function. A processing unit can refer to any type of processor or electronic component capable of performing digital calculations. For example, a processing unit can be an integrated circuit, an ASIC (from the English acronym "Application-Specific Integrated Circuit," French for "integrated circuit specific to a certain application"), a microcontroller, a microprocessor, a digital signal processor (DSP), a processor, or a graphical processing unit (GPU). A processing unit according to the present invention is not limited to a particular type of computing architecture. For example, a processor can implement a Harvard or von Neumann architecture.

[0022] In another aspect, a display device is proposed, comprising a digital display according to an embodiment of the invention and a processing unit configured to send at least one command to an interface of the digital display.

[0023] In another aspect, a method is proposed to be performed by an active matrix digital display, the active matrix digital display comprising a plurality of pixels, each pixel comprising a static memory adapted to store a plurality of n bits representing an intensity of the pixel, and an interface, the method comprising the steps of receiving by the interface at least one command to write pixel intensities to a region of a screen, determining a bit depth of pixel intensity representations in a payload of the command from an identifier of the type of command and at least one of parameters of the command, and writing intensity values ​​of pixels of the region of the screen from the payload of the command to a memory according to the at least one parameter and a pixel path associated with the region of the screen, the writing step including, if the bit depth of the pixel intensity representations in the payload and the bit depth of the pixel intensity representations in the memory are different, converting between the bit depth of the pixel intensity representations in the payload and the bit depth of the pixel intensity representations in the memory, and concatenating the pixel intensity representations in the payload for each consecutive pixel in the region according to the pixel path.

[0024] In another aspect, computer software or system firmware is proposed that includes instructions for carrying out at least part of the methods defined herein when the software or system firmware is executed by a processor.

[0025] In another aspect, a computer-readable non-transitory storage medium is proposed having registered thereon software or system firmware for performing the methods defined herein when the software or system firmware is executed by a processor.

[0026] "System firmware" refers to software that is embedded directly into a device and is responsible for the functioning of that device.

[0027] The following features may optionally be implemented separately or in combination with other features.

[0028] In some embodiments of the present invention, at least one type of command is associated with a predefined bit depth.

[0029] This allows further reduction in the size of the command, as it eliminates the need to write the bit depth in a parameter field separate from the command type.

[0030] In some embodiments of the invention, a bit depth of the pixel intensity representations in the payload is equal to 1, and the conversion includes, for each pixel, writing a maximum intensity of the pixel to memory if the pixel intensity representation of the pixel in the payload is a first possible binary value, and writing a minimum intensity of the pixel to memory if the pixel intensity representation of the pixel in the payload is a second possible binary value different from the first possible binary value.

[0031] "Possible binary values" refers to the values ​​0 or 1.

[0032] This allows each pixel intensity to be represented using a single bit representing either maximum or minimum intensity, thus significantly limiting the size of write commands for writing highly contrasty content.

[0033] The pixel intensity representations in the payload are concatenated for each successive pixel in the region, following the pixel path.

[0034] "Concatenating pixel intensity representations according to a pixel path" refers to arranging the bits representing each pixel in the bit order defined by the pixel path.

[0035] This allows obtaining the most compact representation possible of the pixel intensities, since the pixel intensities are simply concatenated in a given order.

[0036] In some embodiments of the present invention, if the pixel intensity representation in the payload of the command is equal to the bit depth of the pixel intensity representation in the pixel's memory divided by a power of two, the conversion is performed by copying bits from the payload to memory and writing the pixel's intensity value from the command's payload to memory.

[0037] This allows for a transformation that is as accurate as possible while at the same time providing low complexity, thereby further saving computational resources.

[0038] In some embodiments of the invention, if the command type of the command belongs to at least one type relating to a subset of the screen, the interface is further configured to read, at a predefined location in the payload of the command, at least one parameter relating to at least one pixel location within the screen.

[0039] "At least one parameter related to at least one pixel position in a display screen" refers to at least one parameter that allows obtaining a pixel position in the screen so that a region in the display screen can be located. The pixel position may be the position of a specific pixel in the region, for example, the top left corner of a rectangle or the tip of an arrow. However, the present invention is not limited to this example, and each pixel position that can accurately identify a zone in the screen can be used. The pixel position can be represented using, for example, a row number and a column number. In some cases, the at least one parameter may include other parameters in addition to the pixel position. Such other parameters may be, for example, - 2D shape index (for example, if the 2D shape is a square, rectangle, or triangle, if not defined by the command type) - 2D shape size - 2D shape orientation - others may include:

[0040] This allows for the location of an area that represents a subset of the screen, thus reducing the size of the pixel representation when writing does not involve the entire screen.

[0041] In some embodiments of the present invention, if the type of the command belongs to at least one type related to a 2D shape, the at least one parameter further includes at least one parameter related to at least one dimension of the 2D shape, the size of the payload of the command depends on the at least one size, and the pixel path is parameterized according to the at least one dimension.

[0042] "2D shape" refers to a shape defined as a series of pixels in two dimensions. A 2D shape can be a general shape associated with at least one dimensional parameter (e.g., rectangle, triangle, square), or a specific shape defined by a precise sequence of pixels, such as a mouse arrow.

[0043] "At least one dimension of a 2D shape" refers to at least one parameter that defines at least one dimension of the shape. Such at least one dimension may be, for example, - Height and width of the rectangle - radius of a circle, length of a side of a square - Area of ​​a square - A second pixel location from which the dimensions of the shape can be inferred - others It could be.

[0044] In some embodiments of the present invention, this type of command defines a 2D shape associated with a predefined pixel path.

[0045] A "predefined pixel path" refers to a path that is known in advance and completely defines the shape. For example, if the 2D shape is a mouse arrow, the pixels of the arrow can be numbered, and the command payload may contain the pixel numbers in ascending order, so that the pixels can be written to the appropriate relative positions based on only the command type and a single pixel location.

[0046] This allows for a reduction in command size for certain 2D shapes, as the command payload no longer needs to include parameters regarding the shape's dimensions to determine the pixel path, further reducing the energy consumption of digital displays.

[0047] This allows for the definition of shapes of different sizes, such as rectangles, squares, triangles, etc., and allows the command to store only the data related to the 2D shape of that size. Therefore, only useful data is sent and processed depending on the size of the shape. The combination of pixel location and shape dimensions allows for the definition of shapes of various positions and sizes.

[0048] The memory is a static memory.

[0049] "Static memory" refers to memory in which values ​​are permanently stored until further changed. Static memory may be, for example, SRAM (Static Random Access Memory). In a digital display with static memory, the static memory stores pixel intensities, and the display screen displays, at any given time, the current intensity value of each pixel stored in the static memory.

[0050] This allows commands to be sent to write pixel intensities only when a change occurs in the displayed scene, thereby further reducing the amount of data that needs to be transmitted.

[0051] In some embodiments of the present invention, the input interface is a serial peripheral interface.

[0052] In some embodiments of the invention, the processing unit is configured to calculate a bit depth of pixel intensity representations in the payload depending on a target precision of the transformation.

[0053] "Target precision of the transform" refers to the bit depth precision targeted for writing pixel intensities.

[0054] This allows obtaining the smallest possible size payload that still provides the desired accuracy of the transformation.

[0055] In some embodiments of the invention, the processing unit is configured to, when an object is moved from a first position to a second position in the 2D scene, send a first command to the interface of the digital display to write pixels of a first 2D shape containing the object at the first position and representing a background of the 2D scene, and send a second command to the interface of the digital display to write pixels of a second 2D shape containing the object and representing the object at the second position.

[0056] This allows for when an object moves from a first position to a second position in a 2D scene, the background is first redrawn at the first position, and then the object is drawn at the second position, so that the object is not displayed twice, even if the representations of the object at the first and second positions overlap.

[0057] Furthermore, this allows a minimal amount of data to be sent to represent the displacement of an object, as long as other parts of the 2D scene are not affected by the displacement.

[0058] Other features, details, and advantages are set forth in the detailed description and figures that follow. [Brief explanation of the drawings]

[0059] [Figure 1] FIG. 1 illustrates an example of a system in which the present invention may be implemented in some embodiments. [Figure 2] FIG. 1 illustrates an example of the architecture of a display system according to some embodiments of the present invention. [Figure 3] FIG. 1 illustrates an example method according to some embodiments of the present invention. [Figure 4] FIG. 2 illustrates an example command for writing a line of pixels at a bit depth of 8 bits in accordance with some embodiments of the present invention. [Figure 5] FIG. 2 illustrates an example command for writing a line of pixels at a bit depth of 4 bits in accordance with some embodiments of the present invention. [Figure 6] FIG. 2 illustrates an example command for writing a line of pixels at a bit depth of 1 bit in accordance with some embodiments of the present invention. DETAILED DESCRIPTION OF THE INVENTION

[0060] Next, refer to Figure 1.

[0061] FIG. 1 shows an example of a system Sys1 in which the present invention can be implemented.

[0062] The system Sys1 includes a user device Udev1 and a pair of glasses Glas1.

[0063] In the example of Figure 1, the user device shown is a smartphone, however, the invention is not limited to this example and different user devices with connectivity capabilities may be used, such as smart watches, tablets, etc.

[0064] The user device Udev1 is connected to the glasses Glas1 by a short-range wireless connection, for example a Bluetooth connection.

[0065] Glasses Glas1 may be glasses configured to display information superimposed on the field of view of the glasses, for example, using an OLED display. For example, Applicant has developed Activelook® glasses that use a micro-OLED display to display information superimposed on the scene the wearer sees through the glasses. Activelook glasses have lightweight memory and computational resources for processing display commands sent from user device Udev1, making them lightweight and comfortable, ideal for sports and other outdoor use.

[0066] Therefore, the user device Udev1 can send commands to the glasses Glas1 to display information superimposed on the scene the wearer sees through the glasses. For example, if the user is running, the user device Udev1 can be equipped with sensors to measure information such as running speed, the user's heart rate, and running time, and send commands representing this information to the glasses Glas1, allowing the user to check their running speed, heart rate, etc. through the glasses while running. Meanwhile, the glasses Glas1 only receive display commands and do not need to be equipped with a powerful processor to process complex information such as that provided by sensors.

[0067] One of the objectives of the system Sys1 is to minimize the amount of data transferred from the device Udev1 to the glasses Glas1 and processed by the glasses Glas1. The present invention can be used for this purpose to reduce the size of data frames sent from the user device Udev1 to the glasses Glas1.

[0068] However, system Sys1 is provided only as a non-limiting example of a system in which the present invention can be implemented. In fact, the present invention can be implemented by other systems that include active matrix displays. For example, types of near-eye display devices other than glasses may be used.

[0069] Next, refer to Figure 2.

[0070] FIG. 2 illustrates an example of the architecture of a display device according to some embodiments of the present invention.

[0071] Display Device Dev a plurality of pixels, each pixel comprising a static memory for storing one or more values ​​of the intensity of the pixel; ○Interface Int and an active matrix digital display Disp, - a processing unit configured to send at least one command to an interface of said digital display; Equipped with.

[0072] Thus, the processing unit is configured to send commands to the interface Int to write to the memory of a pixel of the display Disp, thereby modifying the display and determining what is currently displayed, for example by writing the intensity value of a pixel to the display of the connected glasses Glas1, so that the pixel is displayed superimposed on what the wearer sees through the glasses.

[0073] The interface can be a serial or parallel interface, for example a serial peripheral interface, that can process commands, read and write pixel intensities, receive pixel intensities to write, and transmit read pixel intensities.

[0074] The display device may be of various types, for example, it may be a pair of glasses such as Glass1, or it may be another kind of near-eye device.

[0075] The digital display Disp is configured to perform methods such as method P3 described below.

[0076] As will be explained in more detail below, this allows the processor Proc to send commands that modify the display screen.

[0077] As will be explained in more detail below, commands according to the invention allow for defining the bit depth of the command's payload, and the representation of pixel intensities is converted between the bit depth of the payload's pixel representation and the bit depth of the display's pixel memory. Different bit depths of the payload can be defined by multiple commands and / or command parameters.

[0078] Thus, the processing unit Proc can define, for each command, the bit depth of the payload that is most suitable for the command. For example, the processing unit may be configured to calculate the bit depth of the pixel intensity representation in the payload according to a target precision of the bit depth conversion between the pixel intensity representation in memory and the pixel intensity representation in the payload.

[0079] The target precision of the conversion can be used in the writing mode or can be obtained according to different needs. The target precision can be defined, for example, according to the following: - The bit depth required by the application writing the pixel intensity value. For example, if an application requires that the pixel intensity be written with a bit depth of 4 bits, the processing unit may set the bit depth of the command payload to 4 bits, even if the pixel's in-memory pixel intensity representation has a bit depth of 8 bits. - the content of the pixel to be written. For example, if the content to be displayed is purely graphical content, e.g., numbers, and each pixel is either "ON" (i.e., maximum intensity) or "OFF" (i.e., minimum intensity), the processing unit may set the bit depth of the command's payload to 1 bit, regardless of the bit depth of the pixel intensity representation in memory for the pixel. If fewer colors or grayscale levels are required, a smaller number of bits, e.g., 2 or 4 bits, may be used.

[0080] It is therefore clear that the processing unit can set the optimal bit depth of the representation of pixel intensities in the payload for each command, so that the size of the payload is the smallest size possible to transfer information between the processing unit Proc and the display Disp.

[0081] In some embodiments of the invention, some of these commands define a subset of the display screen to be written to or read from, and only include information for writing intensity values ​​for pixels in the subset of the screen. Commands for modifying a subset of the display are particularly useful when the pixels have static memory, as they limit the amount of data to be transmitted to data related to the subset of the display being modified.

[0082] According to various embodiments of the present invention, the processing unit may perform complex operations to determine the command to send, i.e., the type of command and associated payload, or may directly receive the command to send.

[0083] For example, if the display device Dev is a pair of glasses Glas1, the processing unit Proc may receive commands to send directly from the user device Udev1, or may receive higher-level commands and perform calculations to determine the commands to send to the display Disp.

[0084] for example, The processor may receive a command specifying a bit depth or may determine a bit depth to use for the command. - The processor Proc may receive a command from the user device Udev1 to display text in a corner of the display Disp. The text to be displayed may for example be the time in "HH:MM" format (hours:minutes, e.g. "17:05" for 5:05 PM). The processor Proc may receive a new command every minute that the display needs to be changed. If the pixels have a static memory, only the pixels whose intensity has changed may be modified. The processor Proc may therefore be configured to send commands to the interface Int to modify only the subset of the display whose pixels have been modified. For this purpose, the processor Proc may access the memory Mem, in which the current state of the display is stored in the form of a bitmap image, in order to keep a permanent record of the state of each pixel of the display.

[0085] As another example, the processor Proc receives the coordinates of an object, such as a mouse cursor, that moves from an initial position to a final position.

[0086] Thus, the processing unit - sending a first command to the interface Int to write pixels of a first 2D shape containing the object at an initial position and representing the background of the 2D scene; - Send a second command to the interface Int to write the pixels of a second 2D shape that encompasses and represents the object in its final position. It can be configured as follows.

[0087] In other words, to move an object in a 2D scene, the processing unit can send a first command to redraw the background of the 2D scene at an initial position, and then send a second command to draw the object at a final position.

[0088] With each command, pixels are written only within the 2D shape that contains the object, thus minimizing the amount of data sent to the interface.

[0089] These examples illustrate how some embodiments of the present invention can be used to dynamically change a display while minimizing the amount of data sent to the interface, and are provided as non-limiting examples of using the present invention to change the display of a display device Dev.

[0090] More generally, a processing unit sending commands to the interface Int can use commands to write pixels only within the 2D shape where there is a pixel intensity to write.

[0091] We now describe in more detail how commands are processed by the interface Int.

[0092] Next, refer to Figure 3.

[0093] FIG. 3 illustrates an example method according to some embodiments of the present invention.

[0094] Method P3 is a method performed by a display, such as the display Disp shown in FIG. 2, comprising a plurality of pixels, each pixel comprising a memory for storing one or more values ​​of the intensity of the pixel, and an interface.

[0095] Method P3 includes a first step S31 of receiving, by an interface, at least one command for writing a pixel intensity to a region of the screen.

[0096] The command may be a command to write a pixel intensity to a region of the screen.

[0097] The command is - The command identifier, which defines the command type and the composition of the command's payload (e.g., the position of parameters within the payload, and in some cases the size of the command) - Command payload may include:

[0098] Command types may belong to different types: for example, some commands may be used to write the entire screen, while some other commands may be used to write 2D shapes that form a subset of the screen, or lines on the screen.

[0099] The method P3 further comprises a second step S32 of reading the bit depth of the pixel intensity representation in the payload of the command from at least one of the command type identifier and the command parameters.

[0100] In other words, the bit depth of the pixel intensity representation in the payload of the command is not necessarily the same as the bit depth of the pixel intensity representation in the memory of the display's pixels, but the command type and / or parameters of the command derive the bit depth of the pixel intensity representation in the payload of the command, thereby making it possible to perform conversion between the two representations.

[0101] The pixel intensity representation in the payload of the command may be, for example, equal to or smaller than the bit depth of the pixel intensity representation in the memory of the pixels of the display, whereby the pixel intensity representation in the payload of the command is smaller than the pixel intensity representation in the memory of the pixels, thereby reducing the size of the payload and therefore the size of the command to be sent.

[0102] For example, if a pixel's memory stores intensity values ​​on an 8-bit scale, the bit depth of the pixel intensity representation in the command's payload may be any value between 1 bit and 8 bits. For example, the pixel intensity representation in the command's payload may have a bit depth of 1, 2, 4, or 8 bits.

[0103] It should be noted that the bit depth of the command payload can be adapted on a per command basis, so the bit depth of the pixel representation in the payload can be adjusted to the smallest bit depth sufficient to transmit the transmitted pixel intensities with sufficient precision.

[0104] Therefore, the size of the command can be the smallest size that provides a sufficient amount of information to write a pixel.

[0105] The bit depth of the pixel intensity representation in the payload may be defined by the type of the command itself, e.g., at least one command type may be associated with a predefined bit depth to further reduce the size of the commands.

[0106] The bit depth of a command can also be defined by a parameter of the command. For example, the same command type may be used with different bit depths. In this case, the command type is associated with at least one bit depth parameter. This provides more flexible commands that can be associated with multiple different bit depths of the payload.

[0107] Method P3 further includes step S33 of writing intensity values ​​of pixels of the region of the screen from the payload of the command to memory according to the at least one parameter and a pixel path associated with that region of the screen.

[0108] In other words, pixel intensities are read from pixel memory to payload or written from payload to pixel payload memory in a defined pixel pass. A pixel pass can consist of reading or writing an area line by line, for example, from left to right, top to bottom, etc. Of course, many other different pixel passes are possible. For example, the pixel pass can be a column-by-column pixel pass, and pixels can be read from left to right or right to left, top to bottom or bottom to top, etc.

[0109] The number of intensity values ​​to be written depends on the number of channels in the color representation of the pixel.

[0110] for example, - If the color representation of the pixel is a grayscale representation, a single intensity value can be written that represents the brightness of the pixel. If the color representation of a pixel includes multiple channels, multiple intensity values ​​can be written to multiple subpixels corresponding to each color channel. For example, an RGB representation corresponds to three intensity values ​​for red, green, and blue subpixels, an RG representation corresponds to two intensity values ​​for red and green subpixels, and an RGBW representation corresponds to four intensity values ​​for red, green, blue, and white subpixels. In various embodiments of the present invention, any color representation including multiple channels can be used.

[0111] The writing step S33 includes converting between the bit depth of the pixel intensity representation in the payload and the bit depth of the pixel intensity representation in the memory if the bit depths are different.

[0112] In other words, if the bit depth of the pixel intensity representation differs between the payload and the pixel memory, a conversion is performed by the interface. For example, if the bit depth of the pixel memory representation is 8 bits and the bit depth of the payload representation is 4 bits, the pixel intensity is converted from 8 bits to 4 bits from the representation in the payload to the representation in the pixel memory.

[0113] It should be noted that this example is provided for pixels represented using a single color channel, e.g., grayscale pixels. For pixels represented using multiple color channels, e.g., RGB pixels represented using three color channels R, G, and B, the conversion can be performed for each color channel. For example, if the pixel's in-memory representation of pixel intensity is a 24-bit RGB representation (8 bits per color channel for each pixel) and the representation of pixel intensity in the payload is a 12-bit RGB representation (4 bits per color channel for each pixel), the conversion between 8 bits and 4 bits can be performed separately for each of the three R, G, and B channels.

[0114] It is therefore clear that the present invention reduces the payload size required to write pixels in a given area of ​​the screen.

[0115] For example, if the bit depth of the pixel representation in the payload is 1 bit and the bit depth of the pixel representation in the pixel memory is 8 bits, the present invention allows the size of the pixel representation in the payload to be reduced by a factor of 8. If the pixel intensity to be written corresponds to a pixel in an "ON" or "OFF" state, this does not cause any loss of information. In other cases, there may be negligible or acceptable information loss, but a significant reduction in the size of the data to be transmitted is possible. As mentioned above, the bit depth of the payload can be adjusted for each specific command.

[0116] The invention therefore makes it possible to significantly reduce the latency and energy consumption in processing commands by the interface.

[0117] For example, the pixel intensity of a pixel (or pixel channel) may be represented by a single bit that may have a first possible binary value (e.g., 1) representing maximum intensity or a second possible binary value (e.g., 2) representing minimum intensity.

[0118] During the conversion, the interface can write values ​​representing the maximum or minimum intensity into the pixel's memory accordingly.

[0119] for example, If the pixel intensity representation of a pixel in the payload is the first possible binary value, for example 1, and the representation of the pixel intensity in the pixel's memory is an 8-bit unsigned representation, the interface may be configured to write the value "255" to the pixel's memory. If the pixel intensity representation of the pixel in the payload is the second possible binary value, for example 0, and the representation of the pixel intensity in the pixel's memory is an 8-bit unsigned representation, the interface may be configured to write the value "0" to the pixel's memory.

[0120] To obtain the most compact representation of pixel intensities possible, the pixel intensity representations in the payload are concatenated for each successive pixel in the region, following the pixel path.

[0121] Examples of such commands will now be shown with reference to Figures 4, 5 and 6.

[0122] In the examples of Figures 4 to 6, the location of each pixel is defined by a row index and a column index, and a pixel's location is expressed as (column index, row index). Each command aims to write a line starting from the pixel at location (i,j). In the convention of Figures 4 to 6, the origin of the pixel coordinate system (hence the pixel at coordinate (1,1)) is the upper left corner of the screen, and the pixel path of each command is a column-by-column pixel path from top to bottom and left to right. However, this coordinate system and pixel path are provided only as a non-limiting example, and the present invention is applicable to other coordinate systems and pixel paths.

[0123] In the examples of Figures 4-6, the pixels are grayscale pixels, and therefore each pixel is defined by a single intensity value. Of course, the examples of Figures 4-6 can be extended to other color spaces. For example, if the pixels were RGB pixels, with three color components R, G, and B, each pixel would be associated with three pixel intensity values ​​instead of one.

[0124] In Figures 4 through 6, the byte contents of the payload, which represent pixel intensities, are represented by 8 bits per byte: d0, d1, d2, d3, d4, d5, d6, d7, and d8. Even though the notation d0, d1, d2, d3, d4, d5, d6, d7, and d8 is repeated across Figures 4 through 6, each bit in the figure is linked to a byte and is therefore unambiguously defined. For example, bit d0 of byte Data_14 in Figure 4 represents the content of the bit at index 0 of byte Data_14 of payload Payl4.

[0125] Next, refer to Figure 4.

[0126] FIG. 4 illustrates an example command for writing a series of pixel columns at a bit depth of 8 bits in accordance with some embodiments of the present invention.

[0127] Command Cmd4 is a command to write a series of columns to the display screen starting from the pixel at coordinate (i,j), where i is the index of the column of pixels and j is the index of the line of pixels. - Identifier Id4 of the command (in this example the command is 0x10). In this example the command 0x10 is a command to draw a column using an 8-bit representation of the pixel intensity in the payload. - Payload Payl4 containing: ○ Parameter Param4, which contains: The pixel coordinate of the first pixel in the column to write, defined by the row index RowCor14 and the column index ColCor14. ○Pixel intensities PixInt4, containing n bytes of data Data_14 to Data_n4.

[0128] Because the bit depth of the pixel representation in the payload is 8 bits, each byte Data_14 through Data_n4 stores the intensity value of a single pixel. A pixel path is defined as a column-by-column traversal of the screen, where pixels are written by traversing the screen from pixel (i,j) to the bottom of column j, then, upon reaching the bottom of column j, moving to pixel (i;j+1) and traversing column j+1 downwards. Pixel columns are written in this manner repeatedly until all pixel intensity values ​​in the payload have been processed.

[0129] for example, - Byte Data_14 contains the intensity value of the pixel with coordinates (i,j) and is therefore defined by the 8 bits d0 to d7 of byte Data_14. - The last byte of the payload, Data_n4, contains the intensity value of the pixel at coordinates (i+n,j+n) and is therefore defined by the 8 bits d0 to d7 of byte Data_n4.

[0130] Thus, the representations of the pixels in the bit depth defined by the command (8 bits in this example) are concatenated in the payload in the order defined by the pixel path. The n-byte PixInt4 representing pixel intensity in the payload stores the pixel intensity values ​​of n pixels.

[0131] Figure 4 illustrates an example where the bit depth of the pixel intensity representation in the payload and the bit depth of the pixel intensity representation in memory are the same (8 bits each), and therefore no conversion occurs, while Figures 5 and 6 illustrate examples of commands where the pixel intensity representation in the payload is of a lower bit depth than the pixel intensity representation in memory. In such examples, a conversion is performed to convert intensity values ​​between the two representations.

[0132] More specifically, the examples in Figures 5 and 6 represent two cases where the bit depth of the pixel intensity representation in the command's payload is equal to the bit depth of the pixel's intensity representation in memory divided by a power of two (this is the case, for example, for an 8-bit representation of the pixel in memory and a 4-bit, 2-bit, or 1-bit bit depth representation in the payload).

[0133] In some embodiments of the present invention, when the bit depth of the pixel intensity representation in the command payload is equal to the bit depth of the pixel intensity representation in the pixel's memory divided by a power of two, the conversion can be performed by copying bits from the command payload to the pixel's memory and writing the pixel's intensity value.

[0134] Replication of bits from the payload means setting the value of the payload bits multiple times in the pixel memory. For example, in the examples of Figures 5 and 6, where the pixel is made up of two-bit subpixels, the payload bits are replicated as strings of two, four, etc. identical bits. However, this example is provided for illustrative purposes only, and other transformations are foreseeable. For example, the payload bits related to pixel intensity may define the most significant bit of the pixel.

[0135] Bit selection consists of selecting the most relevant bit from memory (usually the most significant bit) and copying it from the pixel's memory to the corresponding area of ​​the payload.

[0136] Next, refer to Figure 5.

[0137] Figure 5 illustrates an example command for writing a series of pixels at a bit depth of 4 bits in some embodiments of the invention. The pixel path is the same as described in Figure 4, but twice as many pixels can be written from the same number of bytes of payload.

[0138] The command Cmd5 is for writing a row to the display screen, starting from the pixel at coordinate (i,j). - Identifier Id5 of the command (in this example the command is 0x11). In this example, command 0x11 is a command to draw a series of columns using a 4-bit representation of pixel intensities in the payload. - Payload Payl5 containing: ○Parameter Param5, which contains: The pixel coordinate of the first pixel in the line to write, defined by the row index RowCor15 and the column index ColCor15. ○Pixel intensities PixInt5, containing n bytes of data Data_15 to Data_n5.

[0139] Since the bit depth of the pixel representation in the payload is 4 bits, each byte Data_15, Data_25...Data_n5 stores the intensity values ​​of two pixels.

[0140] for example, - byte Data_15 contains: ○ The intensity value of the pixel at coordinate (i,2*j), which is defined by the first four bits d0 to d3 of the byte Data_15. In this example, the conversion is performed as follows: the four bits d0, d1, d2, and d3 are copied from the payload to memory as a series of consecutive bits to obtain the bit representation of the pixel: d3 d3 d2 d2 d1 d1 d0 d0. A similar conversion is performed for subsequent pixels. ○The intensity value of the pixel at coordinate (i,2*j+1), which is defined by the last four bits d4 to d7 of byte Data_15. - byte Data_25 contains: The intensity value of the pixel at coordinate (i,2*j+2), which is defined by the first four bits d0 to d3 of byte Data_25. ○The intensity value of the pixel at coordinate (i,2*j+3), which is defined by the last four bits d4 to d7 of byte Data_25. - … - byte Data_n5 contains: The intensity value of the pixel at coordinate (i+n, 2*j+n), which is defined by the first four bits d0 to d3 of byte Data_n5. ○The intensity value of the pixel at coordinate (i+n,2*j+1+n), which is defined by the last four bits d4 to d7 of byte Data_n5.

[0141] Thus, the representations of the pixels in the bit depth defined by the command (a bit depth of 4 in this example) are concatenated in the payload in the order defined by the pixel path. An n-byte PixInt5 representing pixel intensity in the payload stores pixel intensity values ​​for n*2 pixels.

[0142] It should be noted that the example transformation shown in Figure 5 is provided by way of non-limiting example only. For example, in other embodiments of the present invention, the bit representation of the pixel at coordinate (i,2*j) may be d3 d2 d1 d0 d3 d2 d1 d0 or d3 d2 d1 d0 d0 d0 d0 d0 instead of d3 d3 d2 d2 d1 d1 d0 d0. In other words, the bits may define the most significant bit rather than being duplicated as a series of consecutive identical bits.

[0143] Next, refer to FIG.

[0144] FIG. 6 illustrates an example command for writing a series of pixel columns at a bit depth of 1 bit in accordance with some embodiments of the present invention.

[0145] The command Cmd6 is for writing a series of columns of pixels to the display screen, starting with the pixel at coordinate (i,j). - Identifier Id6 of the command (in this example the command is 0x12). In this example, command 0x12 is a command to draw a series of columns using 1-bit representation of pixel intensities in the payload. - Payload Payl6 containing: ○Parameter Param6, including: The pixel coordinate of the first pixel in the line to write, defined by the row index RowCor16 and the column index ColCor16. ○Pixel intensities PixInt6, containing n bytes of data Data_16 to Data_n6.

[0146] Since the bit depth of the pixel representation in the payload is 1 bit, each byte Data_16, Data_26...Data_n6 stores the intensity values ​​of two pixels.

[0147] for example, - Byte Data_16 ○ The intensity value of the pixel with coordinates (i,8*j), which is defined by the first bit d0 of the byte Data_16; in this example, the transformation is performed by duplicating the value of bit d0 of Data_16 eight times into the memory of the pixel with coordinates (i,8*j). For example, if d0 is 0, the transformation writes the binary value 00000000 (or hexadecimal value 0x00) into the memory of the pixel with coordinates (i,8*j), and if d0 is 1, the transformation writes the binary value 11111111 (or hexadecimal value 0xFF) into the memory of the pixel with coordinates (i,8*j). The intensity value of the pixel with coordinates (i, 8*j+1), which is defined by the second bit d1 of the byte Data_16, in this example the conversion is performed by duplicating the value of bit d1 of Data_16 eight times into the memory of the pixel with coordinates (i, 8*j+1). The intensity value of the pixel with coordinates (i, 8*j+2), which is defined by the second bit d2 of byte Data_16. In this example, the transformation is performed by copying the value of bit d2 of Data_16 eight times into the memory of the pixel with coordinates (i, 8*j+2). The intensity value of the pixel with coordinates (i, 8*j+3), which is defined by the second bit d3 of byte Data_16, in this example the conversion is performed by copying the value of bit d3 of Data_16 8 times into the memory of the pixel with coordinates (i, 8*j+3). The intensity value of the pixel with coordinates (i, 8*j+4), which is defined by the second bit d4 of byte Data_16, in this example the conversion is performed by copying the value of bit d4 of Data_16 8 times into the memory of the pixel with coordinates (i, 8*j+4). ○ The intensity value of the pixel with coordinates (i, 8*j+5), which is defined by the second bit d5 of byte Data_16, in this example the conversion is performed by duplicating the value of bit d5 of Data_16 8 times into the memory of the pixel with coordinates (i, 8*j+5). ○ The intensity value of the pixel with coordinates (i, 8*j+6), which is defined by the second bit d6 of byte Data_16, in this example the conversion is performed by duplicating the value of bit d6 of Data_16 8 times into the memory of the pixel with coordinates (i, 8*j+6). The intensity value of the pixel with coordinates (i, 8*j+7), which is defined by the second bit d1 of byte Data_17, in this example the conversion is performed by duplicating the value of bit d1 of Data_17 8 times into the memory of the pixel with coordinates (i, 8*j+7). - etc.

[0148] Thus, the representations of pixels at the bit depth defined by the command (a bit depth of 1 in this example) are concatenated in the payload in the order defined by the pixel path. An n-byte PixInt6 representing pixel intensity in the payload stores pixel intensity values ​​for n*8 pixels.

[0149] These examples show that the present invention allows for a significant reduction in the amount of data required to transmit the intensities of the same number of pixels, or conversely, allows for a much larger number of pixels to be written with the same size command. For example, using n bytes of data: - n pixels are written using the 8-bit defined command Cmd4. - n*2 pixels are written using the 4-bit defined command Cmd5. - n*8 pixels are written using the 8-bit defined command Cmd6.

[0150] Commands Cmd4 through Cmd6 are provided as non-limiting examples of commands in some embodiments of the present invention. Other commands may be defined. For example, these may be commands for drawing shapes other than lines. For example, there may be commands for drawing 2D shapes such as rectangles, triangles, squares, circles, etc. across the entire screen.

[0151] The examples in Figures 4, 5, and 6 show example commands for drawing a series of columns.

[0152] However, the invention is not limited to these examples and may be applied to commands for writing the entire screen or 2D shapes.

[0153] Commands for writing 2D shapes are particularly useful for writing only specific portions of the screen, for example the part of the screen where a change occurred. Thus, the pixel path for writing pixels within a 2D shape representing a subset of the screen, and the pixel intensities can be obtained from within the payload according to the bit depth of the payload.

[0154] To this end, the second step S32 may further comprise reading, at a predefined position in the payload of the command, at least one parameter relating to at least one pixel position in the display screen.

[0155] In other words, in an embodiment where the command is a command for writing a 2D shape, depending on the type of command, it is possible to obtain a predefined type and position of at least one parameter of the command, and step S32 consists of reading the at least one parameter of the command at the predefined position. The pixel position may be represented, for example, by a row and column index within the screen.

[0156] At least one parameter of the command includes at least one pixel location within the display screen, and may also include other parameters, for example relating to the size, shape, or orientation of the 2D shape.

[0157] Thus, the size and shape of the 2D shape is known from either at least one parameter, command type, or a combination thereof, at the output of step S32.

[0158] for example, - A command type may define a precise shape, for example an object with a known size, so the use of parameters relating to a defined pixel of the shape (for example the pixel at the tip of the mouse cursor) is sufficient to accurately determine all pixels on the screen that belong to the shape. The command type may define a shape type, e.g. a rectangle, and at least one parameter may define the size of the rectangle, e.g. height and width. In combination with the position of at least one pixel, this may also allow to precisely determine all pixels on the screen that belong to the shape.

[0159] Thus, in embodiments where the command is to write a 2D shape that represents a subset of the screen, at the end of step S32 the size and position of the 2D shape is known.

[0160] In embodiments in which the command is a command to write a 2D shape representing a subset of the screen, a third step S33 includes writing intensity values ​​of the subset of pixels of the screen to a memory for the subset of pixels based at least on the at least one parameter, wherein a transformation is applied to the intensity values ​​of each pixel of the 2D shape.

[0161] In other words, pixel intensities are written only to pixels within the 2D shape defined by the command's identifier and at least one parameter, thus reducing the amount of data transferred, which further shortens pixel write times and saves energy in the process of writing pixel intensities.

[0162] Generally, writing a pixel is based on reading the payload and writing the pixel intensity accordingly into the pixel's memory.

[0163] Writing pixel intensities may be performed in a variety of ways.

[0164] In an embodiment where the command is a command to write a 2D shape representing a subset of the screen, the payload of the command includes intensity values ​​for that subset of pixels, and the interface is configured to write the intensity values ​​according to a pixel path associated with the 2D shape.

[0165] In other words, the payload of the command therefore contains the intensities of the pixels themselves in a predefined order corresponding to the pixel path in the 2D shape, and the pixel intensities are written in the payload after transformation in the order defined by the pixel path.

[0166] For example, a command type may define a 2D shape associated with a predefined pixel path.

[0167] In some embodiments of the present invention, the command type may correspond to a predefined 2D shape, defined pixel by pixel by a known predefined pixel path.

[0168] This is useful for representing specific 2D shapes: for example, a specific command can be defined to write a mouse pointer of a defined size, where the payload only needs to contain the intensities of each pixel of the mouse cursor, in the defined order.

[0169] In another embodiment of the present invention, the payload further comprises at least one parameter relating to at least one dimension of the 2D shape. The size of the command payload depends on said at least one dimension. The pixel path is parameterized according to said at least one dimension.

[0170] Such an embodiment relates to writing shapes of variable size, for example, the 2D shape can be a rectangle that can have different sizes, a mouse cursor that can have different sizes, etc.

[0171] As mentioned above, the at least one parameter for the at least one dimension can be any kind of parameter from which the dimension can be estimated (the dimension itself, the area of ​​the shape, the second pixel location, etc.).

[0172] For example, if the 2D shape is a rectangle, the at least one parameter for the at least one pixel location represents a first pixel location of a first corner of the rectangle, and the at least one parameter for the at least one dimension represents - pixel position of the corner opposite the first corner of the rectangle, - Height and width of the rectangle may include:

[0173] Thus, in either case, the size and position of the rectangle can be inferred from a first pixel location representing a first corner and at least one dimensional parameter.

[0174] Thus, at least one dimension can determine which pixels belong to the 2D shape, and the pixel path can be parameterized accordingly. For example, the pixel path can include pixel intensities of pixels line by line in a predefined direction (e.g., from left to right and from top to bottom).

[0175] The command may also define other shapes defined by position and size parameters.

[0176] for example, A command may define a discus by the location of a given point (e.g., the center, top, bottom, leftmost, or edgemost point of the disc, a corner of a square that contains a square, or more generally, any point that can be located relative to the disc) and the size of the disc (e.g., the radius, diameter, area, or perimeter of the disc). A single command may define a triangle, with parameters defining the positions of the three corners of the triangle. - etc.

[0177] Each of these commands allows to deterministically define whether a pixel belongs to a shape or not. Once the pixels that belong to the shape are known, a predefined pixel path can be applied, for example traversing the pixels that belong to the shape line by line or column by column to write the shape.

[0178] The present disclosure is not limited to the digital displays, devices, methods, computer software, and computer-readable non-transitory recording media described herein, which are merely examples, and the present invention encompasses all alternatives that would occur to one skilled in the art upon reading this specification. [Explanation of symbols]

[0179] Cmd4, Cmd5, Cmd6 commands Dev Display Device Disp Active matrix digital display Glas1 glasses Int interface Mem memory Payl4, Payl5, Payl6 payloads Proc Processor Sys1 system Udev1 user device

Claims

1. a plurality of pixels, each pixel comprising a static memory adapted to store a plurality of n bits representing an intensity of said pixel; Upon receiving at least one command (Cmd4, Cmd5) to write pixel intensities to an area of ​​the screen, determining a bit depth of pixel intensity representations in the payload (Payl4, Payl5, Payl6) of said command from an identifier of the type of said command (Ind4, Ind5, Ind6) and at least one of the parameters of said command; write intensity values ​​(PixIn4, PixInt5, PixInt6) of pixels of the region of the screen from the payload of the command to the memory according to the bit depth of the pixel intensity representation in the payload and the pixel path associated with the region of the screen; and an interface (Int) configured as follows: the writing includes, if the bit depth of the pixel intensity representations in the payload and the bit depth of the pixel intensity representations in the memory differ, converting between the bit depth of the pixel intensity representations in the payload and the bit depth of the pixel intensity representations in the memory; the pixel intensity representations in the payload are concatenated for each successive pixel in the region according to the pixel path; Active matrix digital display (Disp).

2. 10. The digital display of claim 1, wherein at least one type of command is associated with a predefined bit depth.

3. the bit depth of the pixel intensity representation in the payload is equal to 1; The transformation is, for each pixel, if the pixel intensity representation of the pixel in the payload is a first possible binary value, then write a maximum intensity of the pixel to the memory; if the pixel intensity representation of the pixel in the payload is a second possible binary value different from the first possible binary value, writing a minimum intensity of the pixel to the memory; Including, 3. A digital display according to claim 1 or 2.

4. 4. A digital display according to claim 1, wherein if the pixel intensity representation in the payload of the command is equal to the bit depth of the pixel intensity representation in the memory of the pixel divided by a power of two, the conversion is performed by copying the bits from the payload to the memory and writing the pixel intensity value from the payload of the command to the memory.

5. 5. The digital display of claim 1, wherein the interface is further configured to read at least one parameter (Param4, Param5, Param6) related to at least one pixel position in the screen at a predefined position in the payload (Payl4, Payl5, Payl6) of the command if the type of the command belongs to at least one type related to a subset of the screen.

6. If the type of the command belongs to at least one type related to 2D shapes, the at least one parameter further comprises at least one parameter related to at least one dimension of the 2D shape; The size of the payload of the command depends on the size of the at least one the pixel path is parameterized according to the at least one dimension; 6. The digital display of claim 5.

7. 7. A digital display according to any one of claims 1 to 6, wherein the input interface is a serial peripheral interface.

8. A digital display according to any one of claims 1 to 7; a processing unit (Proc) configured to send at least one command to the interface of the digital display; A display device (Dev) comprising:

9. The display device of claim 8 , wherein the processing unit is configured to calculate a bit depth of the pixel intensity representations in the payload according to a target precision of the conversion.

10. When the object is moved from a first position to a second position in the 2D scene, the processing unit: sending a first command to the interface of the digital display to write pixels of a first 2D shape encompassing the object at the first location and representing a background of the 2D scene; sending a second command to the interface of the digital display to write pixels of a second 2D shape encompassing and representing the object at the second location; 10. The display device according to claim 8, wherein the display device is configured so as to:

11. A method (P3) performed by an active matrix digital display (Disp), said active matrix digital display (Disp) comprising: a plurality of pixels, each pixel comprising a static memory adapted to store a plurality of n bits representing an intensity of said pixel; and an interface (Int), The method comprises: receiving (S31) by said interface at least one command (Cmd4, Cmd5, Cmd6) for writing pixel intensities to an area of ​​the screen; determining (S32) the bit depth of pixel intensity representations in the payload (Payl4, Payl5, Payl6) of said command from an identifier of the type of said command (Ind4, Ind5, Ind6) and at least one of the parameters of said command; writing (S33) intensity values ​​of pixels (PixIn4, PixInt5, PixInt6) of said area of ​​said screen from said payload of said command to said memory according to said at least one parameter and a pixel path associated with said area of ​​said screen; Including, the writing step includes, if the bit depth of the pixel intensity representations in the payload and the bit depth of the pixel intensity representations in the memory differ, converting between the bit depth of the pixel intensity representations in the payload and the bit depth of the pixel intensity representations in the memory; the pixel intensity representations in the payload are concatenated for each successive pixel in the region according to the pixel path; Method (P3).

12. 12. Computer software or system firmware comprising instructions for performing at least a portion of the method of claim 11 when the software is executed by a processor.

13. 12. A computer-readable, non-transitory storage medium having registered thereon software for performing the method of claim 11 when said software is executed by a processor.

Images