Bitmap primitive based graphics processing system, method and GPU

Abstract

This invention discloses a graphics processing system, method, and GPU based on bitmap primitives. By dividing the data information of a bitmap into primitive data and primitive formatting data, and storing them separately in different SRAMs that can be accessed in parallel, the GPU can obtain the primitive data and primitive formatting data in parallel. Adaptive processing methods are applied to bitmap primitives of different primitive formats, thereby achieving the goal of using the smallest area of ​​SRAM and achieving better display effect, reducing hardware costs and system power consumption, and eliminating the need for DRAM display cache.

Description

Technical Field

[0001] This invention relates to the field of computer graphics processing technology, and more particularly to graphics processing systems, methods, and GPUs based on bitmap primitives. Background Technology

[0002] A Graphics Processing Unit (GPU) is a microprocessor that performs graphics processing tasks on a variety of intelligent computing devices, such as computer workstations, mobile phones, embedded systems, personal computers, tablet computers, and video game consoles. The primary purpose of a GPU is to convert and drive the display information required by the intelligent computing device, providing line scanning signals to the monitor and controlling its correct display. GPUs typically include arithmetic units and storage units; the more arithmetic units and storage units a GPU has, the faster its processing speed, but also the higher its price.

[0003] Technical issues

[0004] The technical problem to be solved by the present invention is to provide a graphics processing system, method and GPU based on bitmap primitives, which can achieve better display effect at a lower cost and significantly reduce power consumption.

[0005] Technical solutions

[0006] According to one embodiment, a bitmap primitive-based GPU includes one or more subprocessors connected via a GPU bus, providing the subprocessors with a first cache and a second cache for parallel access, and a timing generator connecting the subprocessors, the first cache, and the second cache. Each subprocessor includes at least one primitive filter, at least one depth processor, at least one command parser, multiple primitive processors, at least one color processor controlling the operation of the multiple primitive processors, and at least one pixel shader. The color processor, based on primitive data and primitive formatting data of one or more bitmap primitives containing the pixel to be drawn, initiates one or more primitive processors capable of processing the primitive format of the bitmap primitive containing the pixel to be drawn, obtains the pixel ARGB value generated by the one or more primitive processors, and provides the pixel ARGB value to the pixel shader. The pixel shader, based on the pixel to be drawn... The system calculates the pixel composite ARGB value of the pixel to be drawn from the pixel composite command of one or more bitmap primitives and the ARGB value of the pixel, and provides the pixel composite ARGB value to the timing generator; the first cache is configured with a bitmap primitive data cache area for caching the primitive data of the bitmap primitive; the second cache is configured with a primitive cache area for caching the primitive formatting data of the bitmap primitive; wherein, the primitive data of the bitmap primitive includes at least data recording the primitive format of the bitmap primitive, data recording the ARGB value of the bitmap primitive, and data recording the storage address and size of the primitive data of the bitmap primitive; the primitive formatting data includes at least object index data for identifying the bitmap primitive, data recording the region position and size of the bitmap primitive, data recording the layer overlay display relationship of the bitmap primitive with other bitmap primitives, and data recording the pixel composite command of the bitmap primitive with other bitmap primitives.

[0007] According to another embodiment, a graphics processing system based on bitmap primitives includes a CPU, a first static random access memory (SRAM), a second SRAM, a third SRAM providing parallel access, and a GPU connected to the CPU and the first SRAM, the second SRAM, and the third SRAM; the second SRAM is configured with a bitmap primitive data buffer for storing primitive data of the bitmap primitives; the third SRAM is configured with a buffer for storing primitive formatting data of the bitmap primitives.

[0008] According to another embodiment, a graphics processing method based on bitmap primitives includes dividing the data information of the bitmap primitives into at least primitive data and primitive formatting data; the primitive data includes at least data recording the primitive format of the bitmap primitive, data recording the ARGB value of the bitmap primitive, and data recording the storage address and size of the primitive data of the bitmap primitive; the primitive formatting data includes at least object index data for identifying the bitmap primitive, data recording the region position and size of the bitmap primitive, data recording the layer overlay display relationship of the bitmap primitive with other bitmap primitives, and data recording the pixel composition command of the bitmap primitive with other bitmap primitives; storing the primitive data and the primitive formatting data in different storage areas of memory or in different memories; and providing the GPU with parallel access to the primitive data and the primitive formatting data.

[0009] Beneficial effects

[0010] This invention divides bitmap primitive data into primitive data and primitive formatting data, and stores them in different SRAMs that can be accessed in parallel. This allows the GPU to quickly obtain primitive data and primitive formatting data, and applies appropriate color processing methods to bitmap primitives of different primitive formats. This achieves the goal of using the smallest area of ​​SRAM and better display effect, reducing hardware costs and system power consumption, and eliminating the need for DRAM display cache. Attached Figure Description

[0011] Figure 1 This is an example of bitmap primitive layering for an automotive instrument UI interface according to some embodiments of the present invention.

[0012] Figure 2 This is a block diagram of a graphics processing system based on a single-core GPU, one embodiment of which is shown.

[0013] Figure 3 This is a block diagram of a graphics processing system based on a multi-core GPU, one embodiment of which is shown.

[0014] Figure 4 This is a simplified flowchart of a bitmap primitive-based graphics processing method according to one embodiment.

[0015] Figure 5 This is an example of data in SRAM2 according to some embodiments of the present invention.

[0016] Figure 6 This is another example of data in SRAM2 according to some embodiments of the present invention.

[0017] Figure 7 This is an example of data in SRAM3 according to some embodiments of the present invention.

[0018] Figure 8 This is an example of data in CACHE1 according to some embodiments of the present invention.

[0019] Figure 9 This is an example of data in CACHE2 according to some embodiments of the present invention.

[0020] Figure 10 This is a structural block diagram of a solid color primitive processor according to one embodiment.

[0021] Figure 11 This is a structural block diagram of one embodiment of the ARGB primitive processor.

[0022] Figure 12 This is a block diagram of the linear gradient primitive processor of one embodiment.

[0023] Figure 13 This is a structural block diagram of a radial gradient gradient primitive processor according to one embodiment.

[0024] Figure 14 This is a structural block diagram of a general primitive processor in one embodiment.

[0025] Figure 15 This is a structural block diagram of a color processor according to one embodiment.

[0026] Figure 16 This is a schematic diagram of a ColorReady connection node based on a CrossBar dynamically reconfigurable matrix circuit, one embodiment of which.

[0027] Figure 17 This is a block diagram of the pixel shader in one embodiment.

[0028] Figure 18 This is a structural block diagram of a primitive filter in one embodiment.

[0029] Figure 19 This is a block diagram of the structure of a depth processor in one embodiment.

[0030] Figure 20 This is a flowchart of a command parser obtaining pixel composition commands in one embodiment.

[0031] Figure 21 This is a flowchart of a primitive filter for filtering bitmap primitives in one embodiment.

[0032] The best embodiment of the present invention

[0033] The present invention will now be described in further detail with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are for illustrative and explanatory purposes only and are not intended to limit the scope of the invention.

[0034] In computer graphics, there are two main types of graphics: bitmap and vector graphics. Bitmap graphics are composed of pixels; they become distorted when enlarged and have larger file sizes, but they offer more realistic and richer color display effects. Vector graphics are composed of lines and curves; they do not become distorted when enlarged and have smaller file sizes, and are commonly used for drawing icons.

[0035] A graphics processing system typically includes a CPU, a GPU, and memory. Memory stores the application program (APP), graphics APIs, GPU drivers, and graphics data. The CPU runs the graphics APIs and the application program, and calls the GPU driver to start the GPU. The GPU reads the graphics data from memory to create a user interface (UI) and outputs it to the display. To achieve better display results, the application UI is often designed entirely with bitmaps as its primitives, which often results in larger program files and higher hardware requirements.

[0036] It should be noted that, in this application, "graphic primitive" refers to graphic elements, such as text of various glyphs, symbols and icons of various shapes, and background images with rich or simple colors. "Bitmap" in this application refers to a bitmap-based graphics encoding format. "Layer" in this application includes three meanings: the hierarchical attribute of graphic primitives, the overlay display level of graphic primitives, and bitmap graphic primitives displayed in overlay.

[0037] The bitmap-based graphics processing system of the present invention includes a CPU, static random access memories (SRAM1, SRAM2, and SRAM3) encapsulated in an MCU and connected to the CPU via a system communication bus, and a graphics processing unit (GPU) connected to the CPU and SRAM1, SRAM2, and SRAM3 via the system communication bus. SRAM1 is configured with three buffers for storing application programs (APP), graphics APIs (APIs), and GPU drivers, respectively. The GPU can be a single-core GPU with only one subprocessor or a multi-core GPU including multiple subprocessors operating in parallel. Figure 2 A block diagram illustrating the architecture of a graphics processing system based on a single-core GPU, as exemplified in one embodiment, is shown. Figure 3An example block diagram of a graphics processing system architecture based on a multi-core GPU is shown. In addition to subprocessors, the GPU includes a first cache (CACHE1) and a second cache (CACHE2) connected to one or more subprocessors via an internal GPU communication bus (GPU bus). The first cache (CACHE1) and the second cache (CACHE2) can also be high-speed static random access memory (SRAM). Compared to dynamic random access memory (DRAM), SRAM has the advantages of faster read speed and lower power consumption, but it is also more expensive. Each pixel of a bitmap primitive in bitmap format is assigned specific coordinates (x, y) and transparency and color (ARGB) values. The color information of each pixel is represented by RGB, and the transparency is represented by A. Based on the information depth, bitmaps can be divided into 1, 4, 8, 16, 24, and 32-bit, etc. The more bits of information used per pixel, the more colors are available, the more realistic the color representation, and the larger the data volume, thus requiring more storage space.

[0038] Existing embedded systems typically use frame buffers to process bitmap primitives. Each storage unit in the frame buffer corresponds to a pixel on the screen, and the entire frame buffer corresponds to a frame of image, which is a direct mapping of the image displayed on the screen. Therefore, achieving a good display effect requires a large storage space, and considering that SRAM is relatively expensive, current technologies typically use cheaper DRAM memory. However, DRAM memory consumes more power, which also increases the complexity of the device.

[0039] Figure 4 A simplified flowchart illustrating a bitmap primitive-based graphics processing method according to some embodiments of the present invention is provided. The method includes blocks 70-72. In block 70, the data information of the bitmap primitive is divided into at least primitive data and primitive formatting data. The primitive data includes at least data recording the primitive format of the bitmap primitive, data recording the ARGB values ​​of the bitmap primitive, and data recording the storage address and size of the primitive data. The primitive formatting data includes at least object index data for identifying the bitmap primitive, data recording the region position and size of the bitmap primitive, data recording the layer overlay display relationship between the bitmap primitive and other bitmap primitives, and data recording pixel composition commands between the bitmap primitive and other bitmap primitives.

[0040] In block 71, the map data and primitive formatting data are stored in different storage areas or different memories in the memory. In some embodiments, SRAM2 and SRAM3 are configured to store map data and primitive formatting data respectively, and the first cache CACHE1 and the second cache CACHE2 are configured to read data provided by SRAM2 and SRAM3 respectively.

[0041] In box 72, the GPU is provided with parallel access to primitive data and primitive formatting data. The GPU's subprocessors access SRAM2 and SRAM3 in parallel and apply appropriate processing methods for bitmap primitives of different primitive formats, achieving the goal of using the smallest SRAM area, faster processing speed, and better display effect, thereby reducing hardware costs.

[0042] In some embodiments, blocks 70-72 discussed above may be executed in different orders as needed.

[0043] In some embodiments, the bitmap-based graphics processing method further includes dividing the primitives into at least three layer levels: window layer primitives as the basic layer, control layer primitives belonging to the window layer primitives, and bitmap layer primitives belonging to the control layer primitives. A two-dimensional UI graphical interface contains one or more window layer primitives, each window layer primitive contains one or more control layer primitives, and each control layer primitive contains one or more bitmap layer primitives. Bitmap layer primitives are the smallest nodes, and window layer primitives are the largest nodes. Window layer primitives (window) correspond to ordinary graphical windows, pop-up windows, dialog windows, floating windows, etc. Control layer primitives (widget) correspond to buttons, scroll bars, status lists, edit boxes, picture boxes, etc., and bitmap layer primitives (bitmap) correspond to static or dynamic images, text, numbers, icons, etc.

[0044] In some embodiments, the graphics processing method based on bitmap primitives further includes classifying the bitmap primitives into at least three different primitive formats: solid color bitmap primitives containing the same color and the same transparency, ARGB bitmap primitives containing different colors and the same or different transparency, and glyph bitmap primitives containing the same or different colors and the same or different transparency.

[0045] like Figure 5 , Figure 6 As illustrated in the example, SRAM2 is configured with a bitmap metadata buffer 30 for storing metadata of bitmap primitives.

[0046] like Figure 5For example, the metadata 301 of a solid color bitmap primitive includes data (BitmapFormat) for recording the primitive format of the solid color bitmap primitive, data for recording the ARGB fill color value of the solid color bitmap primitive, and data for recording the storage address and size of the metadata of the solid color bitmap primitive. The metadata 302 of an ARGB bitmap primitive includes data (BitmapFormat) for recording the primitive format of the ARGB bitmap primitive, data 310 for recording multiple pixel ARGB values ​​of the ARGB bitmap primitive, and data for recording the storage address and size of the metadata of the ARGB bitmap primitive. ARGB bitmap primitives can be categorized by size and format into 32-bit ARGB bitmap primitives, ARGB-C bitmap primitives, 24-bit ARGB bitmap primitives with the same transparency, 24-bit ARGB bitmap primitives with different transparency, 16-bit ARGB bitmap primitives, mono bitmap primitives, palette bitmap primitives, linear gradient bitmap primitives, radial gradient bitmap primitives, JPEG bitmap primitives, PNG bitmap primitives, etc.

[0047] In this system, for 32-bit ARGB bitmap primitives, each pixel's transparency (A) and color components (R, G, B) are recorded using 8 bits. For 24-bit ARGB bitmap primitives with the same transparency, each pixel's color components (R, G, B) are recorded using 8 bits, with transparency A defaulting to 0xFF. For 24-bit ARGB bitmap primitives with varying transparency, each pixel's transparency (A) is recorded using 8 bits, color components (R and B) are recorded using 5 bits, and color component (G) is recorded using 6 bits. For 16-bit ARGB bitmap primitives, each pixel's color components (R and B) are recorded using 5 bits, and color component (G) is recorded using 6 bits, with transparency A defaulting to 0xFF. For mono bitmap primitives, each pixel uses 1 bit to record color, with transparency defaulting to 0xFF. For palette bitmap primitives, each pixel uses an 8-bit index to record its ARGB value; the index table has 256 entries, allowing for the definition of 256 colors. Each pixel of a JPEG bitmap primitive has the same transparency, and its color values ​​come from the JPEG image decoder; the color and saturation values ​​of each pixel of a PNG bitmap primitive come from the PNG image decoder. An ARGB-C bitmap primitive refers to a bitmap primitive with only a few valid pixels (non-zero transparency values) and most of it being transparent areas (zero transparency values). The metadata 304 of an ARGB-C bitmap primitive includes data recording the primitive format (BitmapFormat), data recording the valid pixels of the ARGB-C bitmap primitive, and data recording the storage address and size of the metadata of the ARGB-C bitmap primitive.

[0048] The data used to record the effective pixels of ARGB-C bitmap primitives is recorded row by row, including one or more row data blocks 320. Each row data block includes the position coordinates of the first effective pixel in the effective pixel row, the number of effective pixels in the effective pixel row, and the ARGB values ​​of the effective pixels in the effective pixel row arranged by column.

[0049] The first row of data block 321 records the coordinates of the first valid pixel in the first row of the ARGB-C bitmap primitives, the number of valid pixels in the first row, and the ARGB values ​​of the valid pixels [1…m] arranged in columns in the first row.

[0050] Linear gradient bitmap primitives refer to bitmap primitives that have a linear gradient effect. For example... Figure 6 As explained in the example, the metadata 305 of the linear gradient bitmap primitive includes data (BitmapFormat) for recording the primitive format of the linear gradient bitmap primitive, data for recording the coordinates of the starting point of the linear gradient, data for recording the coordinates of the ending point of the linear gradient, data for recording the ARGB data of the starting point of the linear gradient, data for recording the ARGB data of the ending point of the linear gradient, data for recording the formula for calculating the gradient of the linear gradient, and data for recording the storage address and size of the metadata of the linear gradient bitmap primitive.

[0051] Radial gradient bitmap primitives refer to bitmap primitives that have a radial gradient effect. For example... Figure 6 As illustrated in the example, the data 306 of the radial gradient bitmap primitive includes data (BitmapFormat) for recording the primitive format of the radial gradient bitmap primitive, data for recording the coordinates of the center point of the gradient region circle, data for recording the inner radius of the gradient region circle, data for recording the outer radius of the gradient region circle, data for recording the radial gradient calculation formula, and data for recording the storage address and size of the data 306 of the radial gradient bitmap primitive. The data 307 of the JPEG bitmap primitive includes data (BitmapFormat) for recording the primitive format of the JPEG bitmap, the storage address of the JPEG encoded data, and the bitstream length in bytes. The data 308 of the PNG bitmap primitive includes data (BitmapFormat) for recording the primitive format of the PNG bitmap, the storage address of the PNG encoded data, and the bitstream length in bytes.

[0052] The metadata 303 of the glyph bitmap primitive includes data for recording the primitive format of the glyph bitmap primitive, data for recording the glyph ARGB values ​​of the glyph bitmap primitive, data for recording the glyph outline of the glyph bitmap primitive, and data for recording the storage address and size of the metadata of the glyph bitmap primitive. The glyph bitmap primitive can be an 8-bit glyph bitmap primitive. Each pixel of an 8-bit glyph bitmap primitive uses 8 bits to record the pixel's transparency A, and the color of the text is specified by the glyph ARGB values.

[0053] Storing the ARGB value of a 32-bit solid color bitmap primitive in SRAM2 requires only 4 bytes, regardless of the image size. For icon graphics where only a few areas have valid pixels and most areas are transparent, 32-bit ARGB-C bitmap primitives using a position-based compressed encoding format can be used, requiring even less storage space. For example, a 10×10 icon graphic with 30 valid pixels and the remaining 70 pixels being transparent requires only 120 bytes to store the ARGB values ​​of the valid pixels using 32-bit ARGB-C bitmap primitives, with no storage space required for the transparent areas. For control layers in the UI interface with linear or radial gradient effects, linear gradient bitmap primitives and radial gradient bitmap primitives can be used. Only the starting point, coordinates of the starting point, ARGB values, and calculation formula need to be stored, without needing to store the ARGB value of each pixel, saving considerable storage space.

[0054] Using the above-mentioned bitmap primitives in different formats to adapt to different types of graphic elements in applications can effectively reduce SRAM storage space and GPU read time, while achieving a more realistic and richer color display effect.

[0055] like Figure 8 As explained in the example, the first cache CACHE1 has a bitmap metadata cache area 50 allocated to read and cache the data in the bitmap metadata buffer 30 in SRAM2.

[0056] The bitmap metadata cache 50 includes multiple data blocks, each storing the metadata of a bitmap primitive. If the pixel to be drawn involves bitmap primitives from 6 different layers, the metadata of the bitmap primitives from the 6 different layers can be stored in 6 data blocks 501, 502, 503, 504, 505, and 506 respectively.

[0057] like Figure 7As illustrated in the example, SRAM3 is configured with a window layer buffer 40 for storing primitive formatting data of multiple window layer primitives, a control layer buffer 41 for storing primitive formatting data of multiple control layer primitives, and a bit layer buffer 42 for storing primitive formatting data of multiple bit layer primitives.

[0058] The window layer buffer 40 is divided into multiple window layer primitive formatting data blocks 401. A window layer bitmap primitive formatting data block 409 stores primitive formatting data for a window layer primitive, including object index data (window index window_index) to identify the window layer primitive (such as a dialog window, floating window, message window, regular window, etc.), data to record the primitive format of the window layer primitive (BitmapFormat), data to record the position and size of the window layer primitive area (window area window_rect(x,y,w,h)), and data to record the number of control layer primitives belonging to the window layer primitive (control). The system includes: a list of window layer primitives (number of primitives), object index data (widget_index) to identify the control layer primitives belonging to the window layer primitives, layer number (window_layer) to mark the layer overlay display relationship between window layer primitives and other window layer primitives, pixel composition command (window_pixel_cmd) to record the pixel composition commands between window layer primitives and other window layer primitives, and object index data (sibling_window_index) to identify other window layer primitives. The GPU can traverse all window layer primitives using the sibling_window_index.

[0059] The control layer buffer 41 is divided into multiple control layer primitive formatting data blocks 411. A control layer primitive formatting data block 419 stores primitive formatting data for a control layer primitive, including object index data (widget_index) to identify the control layer primitive (such as a button, scroll bar, status list, edit box, picture box, etc.), data to record the primitive format of the control layer primitive (BitmapFormat), data to record the position and size of the control layer primitive area (widget_rect(x,y,w,h)), object index data to identify the bitmap primitive belonging to the control layer primitive (bitmap_index), and data to record the position and size of the control layer primitive area. The GPU uses several data sets: the number of bit-layer primitives (bit-layer primitive count), the layer number (widget_layer) to indicate the overlay relationship between control layer primitives and other control layer primitives belonging to the same window layer primitive, the pixel composition command (widget_pixel_cmd) to record the pixel composition command between control layer primitives and other control layer primitives, the object index (window_index) to identify the window layer primitive to which the control layer primitive belongs, and the object index (sibling_widget_index) to identify other control layer primitives belonging to the same window layer primitive. Using the sibling_widget_index, the GPU can traverse all control layer primitives under the same window layer primitive.

[0060] The bitmap buffer 42 is divided into multiple bitmap primitive formatting data blocks 421. Each bitmap primitive formatting data block 429 stores primitive formatting data for a bitmap primitive, including: data recording the primitive format of the bitmap primitive (BitmapFormat); object index data identifying the control layer primitive to which the bitmap primitive belongs (widget_index); data recording the position and size of the bitmap primitive's envelope rectangle (DispRect(x,y,w,h)); and data recording the position and size of the bitmap primitive's clipping rectangle (ClipRect(x,y,w,h)). The `bitmap_layer` property (`y, w, h`) is used to record the location of the metadata storage for bitmap primitives, the layer number (`bitmap_layer`) used to mark the layer overlay display relationship between a bitmap primitive and other bitmap primitives belonging to the same control layer, the pixel composition command (`bitmap_pixel_cmd`) used to record the pixel composition command between a bitmap primitive and other bitmap primitives, and the object index data (`sibling_Bitmap_index`) used to identify other bitmap primitives belonging to the same control layer. Through the `sibling_Bitmap_index`, the GPU can traverse all bitmap primitives under the same control layer.

[0061] like Figure 9 As explained in the example, the second cache CACHE2 is configured with a primitive cache area 60 to read and cache primitive formatted data from the window layer buffer 40, control layer buffer 41 and bit layer buffer 42 in SRAM3.

[0062] The primitive cache 60 includes multiple data blocks, each storing primitive formatting data for different bitmap primitives. If the pixels to be drawn involve 6 different bitmap primitives, the primitive formatting data for the 6 bitmap primitives can be stored in 6 data blocks 601, 602, 603, 604, 605, and 606 respectively.

[0063] When multiple bitmap elements are overlaid in the same area on the screen, the initial layer number of each bitmap element is defined according to the layer overlay display relationship: the bitmap element is placed on top of the control element, and the control element is placed on top of the window element. The layer number of the bitmap element displayed on top is larger, and the layer number of the bitmap element displayed on the bottom is smaller.

[0064] When different bit-layer graphics belonging to the same control layer are overlaid, the layer number of the upper bit-layer graphics is larger, and the layer number of the lower bit-layer graphics is smaller. When different control layers belonging to the same window layer are overlaid, the layer number of the upper control layer graphics is larger, and the layer number of the lower control layer graphics is smaller.

[0065] When bitmap elements belonging to different control layers are overlaid, they are displayed according to the principle that the control layer element with the larger layer number is displayed on top, and the control layer element with the smaller layer number is displayed on the bottom. When control layer elements belonging to different window layers are overlaid, they are displayed according to the principle that the window layer element with the larger layer number is displayed on top, and the window layer element with the smaller layer number is displayed on the bottom.

[0066] When an event occurs that causes the application to generate a new event, and the GPU needs to add a new layer on top of the existing layer to display the new event, the GPU sets the layer number of the new layer to be greater than that of the existing layer, according to the display rules for the new layer being superimposed on the original layer.

[0067] like Figure 1 An example of an automotive LCD instrument display screen 100. In the display screen 100, the initially displayed two-dimensional UI interface is divided into window layer primitive 1 and window layer primitive 2. Window layer primitive 1 includes control layer primitive 11, control layer primitive 12, and control layer primitive 13. Control layer primitive 11 further includes bit layer primitive 111. Control layer primitive 12 further includes bit layer primitive 121, bit layer primitive 122, bit layer primitive 123, and bit layer primitive 124. Control layer primitive 13 further includes bit layer primitive 131. Window layer primitive 2 includes control layer primitive 21 and control layer primitive 22. Control layer primitive 21 further includes bit layer primitive 211, bit layer primitive 212, and bit layer primitive 213. Control layer primitive 22 further includes bit layer primitive 221 and bit layer primitive 222.

[0068] Following the display rule of layering window, control, and bit layers, control layer elements 11, 12, and 13, which belong to window layer element 1, are displayed above window layer element 1. Bit layer element 111 is superimposed on control layer element 11. Bit layer elements 121, 122, 123, and 124, which belong to control layer element 12, are superimposed on control layer element 12. Bit layer element 131 is superimposed on control layer element 13. Window layer element 1 is displayed at the bottom.

[0069] Similarly, control layer elements 21 and 22, which belong to window layer element 2, are in the middle, with bit layer elements 211, 212, 213, 221, and 222 on top, and window layer element 2 at the bottom. Then, based on the layer number of the bit layer elements belonging to control layer element 21, bit layer elements 212 and 213, which have larger layer numbers, are superimposed on bit layer 211 for display.

[0070] When a new alarm event "Accident-prone area ahead, beware!" occurs, bitmap primitives 223 and 224 need to be added to the existing control layer primitive 22. Bitmap primitive 223 needs to be overlaid on the existing bitmap primitive 222, and bitmap primitive 224 needs to be overlaid on the existing control layer primitive 22. The GPU then iterates through the area containing the currently displayed bitmap primitives 223 and 224 to check if there are any existing bitmap primitives belonging to the same control layer primitive 22. If so, the layer index (bitmap_layer) of the existing bitmap primitive is incremented by 1 to become the bitmap layer index of the new bitmap primitive; otherwise, the bitmap layer index of the new bitmap primitive is 0.

[0071] Assuming the current pixel to be displayed is Figure 1 When P(200, 100) is shown, the bitmap primitives containing that pixel, from top to bottom, include bitmap primitive 223, bitmap primitive 222, control primitive 22, and window primitive 2. The GPU calculates the depth value Z for these bitmap primitives based on the layer numbers that record the layer overlay display relationship of window layer, control layer, bitmap layer, and newly added bitmap primitives overlaid on existing bitmap primitives. The GPU sorts these bitmap primitives by depth value Z from smallest to largest, assigns corresponding color channels in sequence, and assigns corresponding primitive processors according to the primitive format for processing. Finally, based on the corresponding pixel composition command for each bitmap primitive, it generates pixel composite ARGB values ​​with overlay display effect and outputs them to the display.

[0072] In some embodiments, the pixel compositing command may be set according to PORTER-DUFF image compositing rules or other image compositing rules. Bitmap primitives with the largest depth value Z are superimposed on bitmap primitives with the smallest depth value Z for display.

[0073] like Figure 2 The example illustrates that a single-core GPU encapsulates a subprocessor that generates and outputs composite ARGB values ​​for pixels, and a first cache (CACHE1) and a second cache (CACHE2) connected to the subprocessor via the GPU bus, as well as a timing generator connected to the subprocessor and the first and second caches via the GPU bus. Figure 3The example illustrates that a multi-core GPU encapsulates multiple sub-processors that generate and output composite ARGB values ​​from pixels, along with a first cache (CACHE1) and a second cache (CACHE2) connected to these sub-processors via a GPU bus, and a timing generator connecting the sub-processors and the first and second caches via the GPU bus. Each sub-processor operates on the same principle but processes different pixels. If a multi-core GPU containing 200 sub-processors is used... Figure 1 For example, a multi-core GPU can allocate subprocessor 1 to process pixel P(200,100), subprocessor 2 to process pixel P(200,101), subprocessor 3 to process pixel P(200,102), ..., 200 subprocessors can process 200 pixels simultaneously.

[0074] During initialization, the CPU calls the application's program data stored in SRAM1 to launch the application, calls the program data of the graphics API and GPU driver, and launches the GPU driver. The GPU driver initializes the GPU, decomposes the application's UI elements into primitive formatting data for window layer primitives, primitive formatting data for control layer primitives, and primitive formatting data for bit layer primitives, and saves them to the window layer buffer 40, control layer buffer 41, and bit layer buffer 42 in SRAM3 respectively. It also starts the GPU and stores the application's primitive data in the bitmap primitive data buffer 30 in SRAM2.

[0075] The second cache, CACHE2, reads primitive formatting data from the window layer buffer 40, control layer buffer 41, and bit layer buffer 42 of SRAM3 via the system communication bus, according to the subprocessor's requirement for primitive formatting data to draw the current pixel, and sends it to the subprocessor. The first cache, CACHE1, reads bitmap metadata from the bitmap metadata buffer 30 of SRAM2 via the system communication bus, according to the subprocessor's requirement for bitmap metadata to draw the current pixel, and sends it to the subprocessor. The first cache and the second cache read data in parallel.

[0076] In some embodiments, the GPU's subprocessor includes a primitive filter that reads a second cache (CACHE2) and filters out all bitmap primitives containing the pixel to be drawn within the region of the bitmap primitive, a layer data register array (BitmapList) that stores the layer data of the filtered bitmap primitives, a depth processor that calculates the depth value Z of all filtered bitmap primitives and sorts the primitive parameter information of all filtered bitmap primitives according to the depth value Z, and a depth sort register array (ZSortList) that stores the primitive parameter information of all sorted bitmap primitives, and reads the pixel composition command of the corresponding bitmap primitive from the second cache (CACHE2) according to the sorted primitive parameter information. The command parser stores the primitive command register array of the sorted bitmap primitive pixel composition commands. It reads the data of the first cache CACHE1 and divides it into multiple primitive processors that can generate pixel ARGB values ​​according to the primitive format BitmapFormat. It reads the data of the first cache CACHE1 and sequentially schedules the color channels according to the sorted bitmap primitives and schedules the corresponding primitive processors according to the primitive format BitmapFormat to generate the color processors of the pixel to be drawn in one or more bitmap primitives. It generates and outputs the pixel composition ARGB value of the pixel to be drawn based on the ARGB value of the pixel to be drawn in one or more bitmap primitives and the pixel composition command.

[0077] Layer data may include bitmap index (bitmap_index), primitive format (bitmapformat), window index (window_index), widget index (widget_index), bitmap layer number (bitmap_layer), widget layer number (widget_layer), and window layer number (window_layer). A GPU includes multiple primitive processors, and each primitive format (BitmapFormat) must be configured with at least one primitive processor. The number of primitive processors will affect the speed of graphics refresh and display.

[0078] Figure 10 An example block diagram of a solid color primitive processor for processing solid color bitmap primitives is shown. The solid color primitive processor may include a primitive parameter register P1 that receives and stores configuration parameters sent by a color processor, and an addressing / calculation unit S1 connected to the primitive parameter register P1.

[0079] The primitive parameter register P1 may include a command register R0a for storing various working commands (such as primitive processor parameter settings, starting primitive processor operation, stopping primitive processor operation, pausing primitive processor operation, etc.), a primitive format register R1a for storing the primitive format BitmapFormat, a primitive region coordinate register R2a for storing primitive region coordinates, a pixel coordinate register R3a for storing the coordinates of the pixel to be drawn, a pixel color register R4a for storing the ARGB value of the pixel to be drawn, and a primitive color register F1a for storing the ARGB value of the fill color.

[0080] Since all pixels of a solid color bitmap primitive have the same ARGB value, the ARGB value of the pixel to be drawn in the pixel color register R4a is equal to the ARGB value of the fill color in the primitive color register F1a. The addressing / calculation unit S1 directly writes the ARGB value of the fill color in the primitive color register F1a into the pixel color register R4a without calculation, and then outputs a ColorReady signal to the color processor indicating that the color is complete.

[0081] Figure 11 An example block diagram of an ARGB primitive processor structure for processing ARGB bitmap primitives is shown. The ARGB primitive processor may include an ARGB cache A2 that obtains and stores ARGB bitmap primitive data from a first cache CACHE1 via the GPU bus; a primitive parameter register P2 that receives and stores configuration parameters sent by a color processor; an addressing / calculation unit S2 connecting the primitive parameter register P2 and the ARGB cache A2; and a pixel color cache C2 connecting the primitive parameter register P2 and the addressing / calculation unit S2. The addressing / calculation unit obtains data from the ARGB cache A2 and the primitive parameter register P2 and calculates the ARGB value of the pixel to be drawn according to a preset calculation formula.

[0082] The primitive parameter register P2 may include a command register R0b, a primitive format register R1b, a primitive region coordinate register R2b, a pixel coordinate register R3b, a pixel color register R4b for storing the ARGB value of the pixel to be drawn, a data storage address register F1b for storing the primitive data storage address of the first pixel of the ARGB bitmap primitive, and a data row byte length register F2b for storing the row byte length of the ARGB bitmap primitive.

[0083] Among them, the command register R0b, primitive format register R1b, primitive region coordinate register R2b, pixel coordinate register R3b, and pixel color register R4b are the same as those mentioned above. Figure 10The example solid color primitive processor has the same functions for command register R0a, primitive format register R1a, primitive region coordinate register R2a, pixel coordinate register R3a, and pixel color register R4a.

[0084] The addressing / calculation unit S2 reads data from the primitive region coordinate register R2b, pixel coordinate register R3b, data storage address register F1b, and data row byte length register F2b. Based on a preset calculation formula, it calculates the storage address in the ARGB cache of the ARGB value of the current ARGB bitmap primitive at the coordinates of the pixel to be drawn. Then, it reads the ARGB value from the ARGB cache based on this address and sends it to the pixel color register R4b. If necessary, it sends the ARGB value of the pixel to be drawn, along with its coordinates, to the pixel color cache C2. Finally, it outputs a ColorReady signal to the color processor, indicating that the color drawing is complete. The preset calculation formula includes the steps of calculating the coordinates of the pixel to be drawn and calculating the storage address in the ARGB cache of the ARGB value of the pixel to be drawn based on its coordinates.

[0085] The pixel color cache C2 stores the XY coordinates and ARGB values ​​of one or more pixels.

[0086] Figure 12 An example block diagram of a primitive processor structure for a linear gradient bitmap primitive is provided. The linear gradient primitive processor includes a primitive parameter register P3 that receives and stores configuration parameters sent by a color processor, an addressing / calculation unit S3 connected to the primitive parameter register P3, and a pixel color buffer C3 connected to the primitive parameter register P3 and the addressing / calculation unit S3. The addressing / calculation unit S3 obtains data from the primitive parameter register P3 and calculates the ARGB value of the pixel to be drawn according to a preset calculation formula.

[0087] The primitive parameter register P3 may include a command register R0c, a primitive format register R1c, a primitive region coordinate register R2c, a pixel coordinate register R3c, a pixel color register R4c for storing the ARGB values ​​of the pixels to be drawn sent by the pixel color buffer, a start color register F1c for storing the ARGB values ​​of the linear gradient start color of the current linear gradient bitmap primitive, an end color register F2c for storing the ARGB values ​​of the linear gradient end color of the current linear gradient bitmap primitive, a start coordinate register F3c for storing the coordinates of the start point of the linear gradient of the current linear gradient bitmap primitive, and an end coordinate register F4c for storing the coordinates of the end point of the linear gradient of the current linear gradient bitmap primitive.

[0088] Among them, the command register R0c, primitive format register R1c, primitive region coordinate register R2c, pixel coordinate register R3c, and pixel color register R4c are the same as those mentioned above. Figure 10 The example solid color primitive processor has the same functions for command register R0a, primitive format register R1a, primitive region coordinate register R2a, pixel coordinate register R3a, and pixel color register R4a.

[0089] The addressing / calculation unit S3 reads the data from the primitive parameter register P3 and calculates the ARGB value of the pixel to be drawn according to a preset calculation formula. This value is then sent to the pixel color register R4c. If necessary, the ARGB value and coordinates of the pixel to be drawn are sent to the pixel color buffer C3. Finally, a ColorReady signal indicating that the color drawing is complete is output to the color processor. The preset calculation formula is the linear gradient calculation formula contained in the primitive data of this linear gradient bitmap.

[0090] The pixel color cache C3 stores the XY coordinates and ARGB values ​​of one or more pixels.

[0091] Figure 13 An example block diagram of a primitive processor structure for a radial gradient bitmap primitive is provided. The radial gradient primitive processor may include a primitive parameter register P4 that receives and stores configuration parameters sent by a color processor, an addressing / computation unit S4 connected to the primitive parameter register P4, and a pixel color buffer C4 that connects the primitive parameter register P4 and the addressing / computation unit S4.

[0092] The primitive parameter register may include a command register R0d, a primitive format register R1d, a primitive region coordinate register R2d, a pixel coordinate register R3d, a pixel color register R4d, a start color register F1d for storing the ARGB value of the radial gradient start color, an end color register F2d for storing the ARGB value of the radial gradient end color, a circle center coordinate register F3d for storing the coordinates of the center point of the gradient region circle, a circle inner radius register F4d for storing the inner radius of the gradient region circle, and a circle outer radius register F5d for storing the outer radius of the gradient region circle.

[0093] Among them, the command register R0d, the primitive format register R1d, the primitive region coordinate register R2d, the pixel coordinate register R3d, and the pixel color register R4d are the same as those mentioned above. Figure 10 The example solid color primitive processor has the same functions for command register R0a, primitive format register R1a, primitive region coordinate register R2a, pixel coordinate register R3a, and pixel color register R4a.

[0094] The addressing / calculation unit S4 reads the data from the primitive parameter register P4 and calculates the ARGB value of the pixel to be drawn according to a preset calculation formula. This value is then sent to the pixel color register R4d. If necessary, the ARGB value and coordinates of the pixel to be drawn are sent to the pixel color buffer C4. Finally, a ColorReady signal indicating that the color drawing is complete is output to the color processor. The preset calculation formula is the radial gradient calculation formula contained in the primitive data of the radial gradient bitmap.

[0095] The pixel color cache C4 stores the XY coordinates and ARGB values ​​of one or more pixels.

[0096] Figure 14 An example block diagram of one type of general-purpose primitive processor is shown. This general-purpose primitive processor can handle bitmap primitives of various formats, executing the corresponding processing procedure according to the BitmapFormat primitive format sent by the color processor.

[0097] The general-purpose primitive processor may include an ARGB cache A5 that obtains and stores the primitive data of the bitmap primitives to be drawn from the first cache CACHE1 via the GPU bus, a primitive parameter register P5 that receives and stores the configuration parameters sent by the color processor, an addressing / computation unit S5 that connects the primitive parameter register and the ARGB cache, and a pixel color cache C5 that connects the primitive parameter register and the addressing / computation unit.

[0098] The primitive parameter register includes a command register R0e, a primitive format register R1e, a primitive region coordinate register R2e, a pixel coordinate register R3e, a pixel color register R4e, and format-specific registers F1e, F2e, ... Fne, which store the calculation parameters required for calculating the ARGB values ​​of the pixels to be drawn for various primitive formats.

[0099] According to some embodiments, the format-specific registers may include a register for storing ARGB fill color values, a data storage address register for storing the data storage address of the first pixel of an ARGB bitmap primitive, a data row byte length register for storing the row byte length of an ARGB bitmap primitive, a start color register for storing the ARGB start color of a linear gradient, an end color register for storing the ARGB end color of a linear gradient, a start coordinate register for storing the coordinates of the start point of a linear gradient, an end coordinate register for storing the coordinates of the end point of a linear gradient, a start color register for storing the ARGB start color of a radial gradient, an end color register for storing the ARGB end color of a radial gradient, a start coordinate register for storing the coordinates of the start point of a radial gradient, an end coordinate register for storing the coordinates of the end point of a radial gradient, a circle center coordinate register for storing the coordinates of the center point of the gradient area circle, an inner radius register for storing the inner radius of the gradient area circle, and an outer radius register for storing the outer radius of the gradient area circle.

[0100] The primitive parameter register P5 receives configuration parameters (including primitive format BitmapFormat, command parameters, primitive data, etc.) sent by the color processor. The addressing / calculation unit S5 reads the corresponding calculation parameters from the format-specific registers F1e, F2e, ... Fne according to the primitive format, and reads the data from the ARGB cache A5 as needed for calculation. Then, according to the preset calculation formula, it calculates the ARGB value of the pixel to be drawn and sends it to the pixel color register R4e. As needed, it sends the ARGB value of the pixel to be drawn along with the coordinates of the pixel to be drawn to the pixel color cache C5, and then outputs a ColorReady signal to the color processor indicating that the color is complete.

[0101] In some embodiments, the GPU may include both general-purpose primitive processors and different types of primitive processors such as solid color primitive processors, ARGB primitive processors, glyph primitive processors, linear gradient primitive processors, and radial gradient primitive processors.

[0102] For efficiency, the first cache (CACHE1) and the second cache (CACHE2) can be configured as SRAM memories for parallel processing, allowing subprocessors to simultaneously access primitive data and primitive formatting data. Alternatively, multiple primitive processors can be configured in parallel processing to further improve processing speed.

[0103] Figure 15 A block diagram of one type of color processor is shown. The color processor includes primitive pixel color processing circuitry and dynamically reconfigurable matrix circuitry.

[0104] Based on the primitive format and object index data of one or more bitmap primitives containing the pixel to be drawn, the primitive pixel color processing circuit reads the primitive data of the bitmap primitive with the primitive format from the primitive data cache 50 of the first cache CACHE1, reads the primitive format data of the bitmap primitive with the object index data from the primitive cache 60 of the second cache CACHE2, sends the configuration parameters required to start working to the primitive parameter register of one or more currently idle primitive processors, and sends a command to start the primitive processor to work so that the primitive processor generates pixel ARGB values.

[0105] The dynamically reconfigurable matrix circuit, according to the superposition display relationship of one or more bitmap primitives where the pixel to be drawn is located, sequentially matches one or more color channels with the one or more primitive processors from bottom to top to establish a connection, obtains the signal from the primitive processor indicating that the color has been completed, then reads the pixel color register of the primitive processor to obtain the pixel ARGB value, and outputs it.

[0106] The primitive pixel color processing circuit can retrieve the corresponding bitmap primitive data and primitive formatting data from the bitmap primitive data cache 50 of the first cache CACHE1 and the primitive cache 60 of the second cache CACHE2, based on the primitive parameter information (including but not limited to: bitmap_index, primitive format) of all pixels to be drawn stored in the depth sorting register array and the ZSortList sorted by depth value Z. It then starts the corresponding primitive processor and simultaneously controls the dynamically reconfigurable matrix circuit to establish connections between color channel 1, color channel 2...color channel n and primitive processor 1 (processing bitmap_index1 bitmap), primitive processor 2 (processing bitmap_index2 bitmap),...primitive processor k (processing bitmap_indexn bitmap), according to the ZSortList sorting list from bottom to top. Since the ZSortList sorting list of the pixels to be drawn is different each time, the connection between the color channels and the primitive processors is dynamically reconfigured.

[0107] Figure 16 A schematic diagram of a ColorReady connection node based on a CrossBar dynamically reconfigurable matrix circuit is shown as an example of one embodiment. The GPU includes 13 primitive processors (Unit1 to Unit13) for processing 13 different primitive formats, and 9 color channels (ch1 to ch9) for processing 9 overlay display bitmap primitives.

[0108] Assuming the current ZSortList sorting list records bitmap primitive parameter information for 6 layers (i.e., 6 bits of bitmap primitive parameter information), the dynamically reconfigurable matrix circuit establishes a ColorReady connection between color channel ch1 and primitive processor Unit1, which processes the first-layer bitmap primitive bitmap_index1; color channel ch2 and primitive processor Unit3, which processes the second-layer bitmap primitive bitmap_index2; color channel ch3 and primitive processor Unit12, which processes the third-layer bitmap primitive bitmap_index3; color channel ch4 and primitive processor Unit9, which processes the fourth-layer bitmap primitive bitmap_index4; color channel ch5 and primitive processor Unit6, which processes the fifth-layer bitmap primitive bitmap_index5; and color channel ch6 and primitive processor Unit5, which processes the sixth-layer bitmap primitive bitmap_index6.

[0109] Specifically, based on the primitive format bitmapformat1 of the first-level bitmap primitive bitmap_index1, the color processor configures primitive processor Unit1 to process the first-level bitmap primitive bitmap_index1; based on the primitive format bitmapformat2 of the second-level bitmap primitive bitmap_index2, the color processor configures primitive processor Unit3 to process the second-level bitmap primitive bitmap_index2; based on the primitive format bitmapformat3 of the third-level bitmap primitive bitmap_index3, the color processor configures primitive processor Unit12 to process the third-level bitmap primitive bitmap_index3. x3; Based on the primitive format bitmapformat4 of the fourth-layer bitmap primitive bitmap_index4, the color processor configures primitive processor Unit9 to process the fourth-layer bitmap primitive bitmap_index4; Based on the primitive format bitmapformat5 of the fifth-layer bitmap primitive bitmap_index5, the color processor configures primitive processor Unit6 to process the fifth-layer bitmap primitive bitmap_index5; Based on the primitive format bitmapformat6 of the sixth-layer bitmap primitive bitmap_index6, the color processor configures primitive processor Unit5 to process the sixth-layer bitmap primitive bitmap_index6.

[0110] After primitive processors Unit1, Unit3, Unit12, Unit9, Unit6, and Unit5 finish processing, they send out a ColorReady signal. Upon receiving this signal, color channels ch1-6 obtain ARGB values ​​from primitive processors Unit1, Unit3, Unit12, Unit9, Unit6, and Unit5, and then send them to the pixel color register. The pixel color register stores the ARGB values ​​sent by color channels ch1-6, forming an ARGB color array ChannelColor[123456].

[0111] Then, the pixel shader reads the ChannelColor[123456] stored in the pixel color register and the pixel composition command BitmapCmd[123456] stored in the primitive command register array, calculates the final superimposed pixel composition ARGB value, and sends it to the row pixel color buffer for storage.

[0112] A pixel shader may include multiple pixel calculation units connected in series, and an initial color register connected to the first pixel calculation unit. The initial color register stores the initial color ARGB value; the first pixel calculation unit reads the initial color ARGB value and the pixel ARGB value of the pixel to be drawn in the first layer bitmap primitive provided by the color processor, and calculates the first pixel composite ARGB value by combining the two according to the pixel composite command defined in the first layer bitmap primitive of the pixel to be drawn.

[0113] The nth pixel calculation unit reads the pixel composite ARGB value calculated by the previous pixel calculation unit and the pixel ARGB value of the pixel to be drawn in the nth layer bitmap provided by the color processor. It then calculates the nth pixel composite ARGB value according to the pixel composite command defined for the pixel in the nth layer bitmap primitives; where n is a natural number greater than 1. The maximum value of n is the number of bitmap primitives involved in the pixel to be drawn. If the pixel to be drawn involves 6 bitmap primitives, then the maximum value of n is 6.

[0114] In some embodiments, the pixel ARGB value of the pixel to be drawn in the first layer bitmap primitive is obtained through color channel 1 of the color processor. The pixel ARGB value of the pixel to be drawn in the nth layer bitmap primitive is obtained through color channel n of the color processor.

[0115] Figure 17A block diagram of the pixel shader in one embodiment is shown. The initial color register stores the initial color PixelColor0 and the ARGB value (0,0,0,0). The first pixel calculation unit F (bitmapCmd1) calculates the pixel composite ARGB value PixelColor1 by taking PixelColor0 and the pixel ARGB value ChannelColor[1] of color channel 1 according to the calculation formula of the pixel composite command BitmapCmd[1] of the bitmap primitive. Pixel calculation unit 2 calculates PixelColor2 by taking PixelColor1 and the ChannelColor[2] of color channel 2 according to the calculation formula of the pixel composite command BitmapCmd[2] of the bitmap primitive, and so on, until the pixel composite of all color channels of the pixel to be drawn is completed, and the final composite pixel ARGB value is output to the row pixel buffer.

[0116] The timing generator reads the ARGB value of each pixel from the row pixel buffer point by point and outputs it to the display. Then, when the next row field synchronization signal arrives, it starts the next row scan and the processing of the next frame image, and sends the coordinate values ​​of the next pixel to be drawn to the subprocessor.

[0117] like Figure 9 For example, for efficiency, the second cache CACHE2 includes an index register 61 (mini_window) to store the window index window_index1611 of the first window layer primitive. The primitive filter responds to the current line and field synchronization signal, obtains the pixel coordinates to be drawn, then reads index register 61 (mini_window) to obtain the window index window_index1 of the first window layer primitive. Starting from the first window layer primitive, it traverses the primitive formatting data of window layer primitives, control layer primitives, and bitmap layer primitives one by one. It then sends the layer data of the bitmap primitives within the bitmap primitive region that contains the pixel coordinates to be drawn to the layer data register array BitmapList for storage. The layer data includes at least object index data, primitive format, and layer number.

[0118] Figure 18A block diagram illustrating the structure of a primitive filter in one embodiment is provided. The primitive filter may include a window index (window_index1) for accessing the second cache (CACHE2) via the GPU bus to obtain the first window layer primitive, a filter for primitive formatting data and filtering out the layer data of the bitmap primitive containing the pixel to be drawn, a pixel register (cur_p) connected to the filter for storing the coordinates of the pixel to be drawn, a window index register (cur_window) connected to the filter for storing the window index (window_index), a control index register (cur_widget) for storing the control index (widget_index), and a bitmap index register (cur_bitmap) for storing the bitmap index (bitmap_index).

[0119] Figure 21 This example illustrates the process of a primitive filter filtering bitmap primitives in one embodiment. The primitive filter initializes by reading the index register mini_window61 and storing the window index window_index1 of the first window layer primitive in the window index register cur_window. The filter first reads the window index register cur_window and checks if the region window_rect1(x,y,w,h) of the first window layer primitive contains the pixel coordinates P(x,y) to be drawn. If not, it continues reading the window index register cur_window to traverse other window layer primitives. If so, it uses the window index register cur_window to read the control index widget_index of the control layer primitives belonging to the current window layer primitive and stores it in the control index register cur_widget. Then, it uses the control index register cur_widget to read the control regions widget_rect(x,y,w,h) of all control layer primitives belonging to the current window layer primitive, checking each widget_rect(x,y,w,h) to see if it contains the pixel coordinates P(x,y). If the pixel coordinates P(x,y) are not found, continue traversing other control layer primitives. If they are found, use the control index register cur_widget to read the bitmap index bitmap_index of the bit layer primitive belonging to the current control layer primitive from the control primitive buffer and save it in the bitmap index register cur_bitmap. Use the bitmap index register cur_bitmap to read the clipping rectangles ClipRect of all bit layer primitives belonging to the current control layer primitive from the bitmap primitive buffer. Check one by one whether the clipping rectangle ClipRect of the current bit layer primitive contains the pixel coordinates P(x,y) to be drawn. If not, traverse other bit layer primitives again. If they are found, push the required layer data into the layer data register array BitmapList. Continue in this way until all bit layer primitives, control layer primitives, and window layer primitives have been filtered.

[0120] Figure 19 A structural block diagram of a depth processor according to one embodiment is illustrated. The depth processor may include a plurality of depth value Z calculation units, a depth value Z comparator connected to the depth value Z calculation units, and a depth sorting list generator connected to the depth value Z comparator.

[0121] The depth value Z calculation unit obtains the filtered layer data stored in the layer data register array Bitmaplist, and calculates the depth value Z of each filtered bitmap primitive according to a preset calculation formula; where the calculation formula is: Depth value Z = layer index bitmap_layer of the bitmap primitive + layer index widget_layer of the control layer primitive to which the bitmap primitive belongs × (maximum number of stackable layers + 1) + layer index window_layer of the control layer primitive to which the control layer primitive belongs × (maximum number of stackable layers + 1)^ 2 .

[0122] Then, the depth value Z comparator compares the size of the depth values ​​Z of different bitmap primitives. Then, the depth sorting list generator sorts the primitive parameter information of the bitmap primitives in ascending order of depth value Z, generates a depth sorting list, and sends it to the depth sorting register array ZSortlist for storage.

[0123] Following the principle that bitmap primitives with the largest depth value Z are superimposed on bitmap primitives with the smallest depth value Z, the sorted depth sort list ZSortlist represents the layer superposition display order of the pixels to be drawn from bottom to top.

[0124] The formula for calculating the depth value Z ensures that all bitmap primitives are displayed according to the layer overlay relationship between different bitmap layers belonging to the same control layer primitive, where the bitmap layer primitive with the larger bitmap_layer number is superimposed on the bitmap layer primitive with the smaller bitmap_layer number, and between different control layers belonging to the same window layer primitive, the control layer primitive with the larger control_layer number is superimposed on the control layer primitive with the smaller control_layer number.

[0125] The command parser retrieves pixel composition commands for one or more different bitmap primitives containing the pixel to be drawn from the primitive cache area 60 of the second cache (CACHE2), and sends the pixel composition commands to the primitive command register array for storage in a bottom-to-top stacked display order. The pixel shader retrieves the pixel composition command from the primitive command register array.

[0126] Figure 20A flowchart illustrating one embodiment of the command parser obtaining pixel composition commands is provided. The command parser obtains the bitmap index BitmapIndex[1…m] of each bitmap primitive from the depth sort register array ZSortList, and then obtains the pixel composition command PixelCommand[1…m] of each bitmap primitive from the primitive cache area 60 of the second cache CACHE2 according to the bitmap index BitmapIndex[1…m], and sends it to the primitive command register array BitmapCommandList for storage.

[0127] The primitive command register array BitmapCommandList also stores the pixel composition command BitmapCmd[1…m] for each bitmap primitive in the order of ZSortList.

[0128] The above-described preferred embodiments have further detailed the objectives, technical solutions, and advantages of the present invention. It should be understood that these embodiments are merely disclosures to enable those skilled in the art to make or implement them, and are not intended to limit the scope of protection of the present invention. Any obvious modifications, equivalent substitutions, and improvements made based on the principles defined in this invention should be included within the scope of protection of this invention. The scope of rights claimed by this invention should not be limited to the above-described embodiments, but should be the broadest possible scope consistent with the principles and technical features defined in the claims of this invention.

Claims

1. A bitmap primitive-based GPU, comprising: It includes one or more sub-processors, a first cache and a second cache connected to the sub-processors via a GPU bus, and a timing generator connecting the sub-processors, the first cache and the second cache; The subprocessor includes at least one primitive filter, at least one depth processor, at least one command parser, multiple primitive processors, at least one color processor controlling the operation of the multiple primitive processors, and at least one pixel shader; wherein, the color processor, based on the primitive data and primitive formatting data of one or more bitmap primitives containing the pixel to be drawn, starts one or more primitive processors capable of processing the primitive format of the bitmap primitives containing the pixel to be drawn, obtains the pixel ARGB value generated by the one or more primitive processors, and provides the pixel ARGB value to the pixel shader; the pixel shader, based on the pixel composition command of one or more bitmap primitives containing the pixel to be drawn and the pixel ARGB value, calculates the pixel composite ARGB value of the pixel to be drawn, and provides the pixel composite ARGB value to the timing generator; The first cache is configured with a bitmap metadata cache area for caching the metadata of the bitmap primitives; the second cache is configured with a primitive cache area for caching the primitive formatting data of the bitmap primitives; wherein, the metadata of the bitmap primitives includes at least data recording the primitive format of the bitmap primitives, data recording the ARGB values ​​of the bitmap primitives, and data recording the metadata storage address and size of the bitmap primitives; the primitive formatting data includes at least object index data for identifying the bitmap primitives, data recording the region position and size of the bitmap primitives, data recording the layer overlay display relationship between the bitmap primitives and other bitmap primitives, and data recording the pixel composition commands of the bitmap primitives and other bitmap primitives.

2. The GPU based on bitmap primitives as described in claim 1, characterized in that, The bitmap primitives are classified into at least three different primitive formats: solid color bitmap primitives containing the same color and the same transparency; ARGB bitmap primitives containing different colors and the same or different transparency; and glyph bitmap primitives containing the same or different colors and the same or different transparency. The metadata of the solid color bitmap primitive includes data for recording the primitive format of the solid color bitmap primitive, data for recording the ARGB value of the fill color of the solid color bitmap primitive, and data for recording the storage address and size of the metadata of the solid color bitmap primitive. The image data of the ARGB bitmap primitive includes data for recording the primitive format of the ARGB bitmap primitive, data for recording the pixel ARGB values ​​of the ARGB bitmap primitive, and data for recording the image data storage address and size of the ARGB bitmap primitive. The image data of the character bitmap element includes data for recording the element format of the character bitmap element, data for recording the character ARGB value of the character bitmap element, data for recording the character outline of the character bitmap element, and data for recording the storage address and size of the image data of the character bitmap element.

3. The GPU based on bitmap primitives as described in claim 1, characterized in that, The bitmap primitives are divided into at least three different layer levels: window layer primitives as the basic layer, control layer primitives belonging to the window layer primitives, and bitmap layer primitives belonging to the control layer primitives. The primitive formatting data of the window layer primitive includes object index data for identifying the window layer primitive, data for recording the primitive format of the window layer primitive, data for recording the position and size of the window layer primitive area, data for recording the number of control layer primitives belonging to the window layer primitive, object index data for identifying the control layer primitives belonging to the window layer primitive, layer number for marking the layer overlay display relationship between the window layer primitive and other window layer primitives, data for recording the pixel composition command of the window layer primitive and other window layer primitives, and object index data for identifying the other window layer primitives; The primitive formatting data of the control layer primitive includes object index data for identifying the control layer primitive, data for recording the primitive format of the control layer primitive, data for recording the position and size of the control layer primitive area, object index data for identifying the bit layer primitive belonging to the control layer primitive, data for recording the number of bit layer primitives belonging to the control layer primitive, layer number for marking the layer overlay display relationship between the control layer primitive and other control layer primitives belonging to the same window layer primitive, data for recording the pixel composition command of the control layer primitive and other control layer primitives, object index data for identifying the window layer primitive to which the control layer primitive belongs, and object index data for identifying the other control layer primitives; The primitive formatting data of the bitlayer primitive includes object index data for identifying the bitlayer primitive, data for recording the primitive format of the bitlayer primitive, object index data for identifying the control layer primitive to which the bitlayer primitive belongs, data for recording the position and size of the envelope rectangle of the bitlayer primitive, data for recording the position and size of the clipping rectangle of the bitlayer primitive, data for recording the storage location of the primitive data, layer number for marking the layer overlay display relationship between the bitlayer primitive and other bitlayer primitives belonging to the same control layer primitive, data for recording the pixel compositing command between the bitlayer primitive and other bitlayer primitives, and object index data for identifying the other bitlayer primitives.

4. The GPU based on bitmap primitives as described in claim 2, characterized in that, According to the primitive format, the ARGB bitmap primitive includes ARGB-C bitmap primitives containing only a few valid pixels; the primitive data of the ARGB-C bitmap primitive includes data for recording the primitive format of the ARGB-C bitmap primitive, data for recording the valid pixels of the ARGB-C bitmap primitive, and data for recording the primitive data storage address and size of the ARGB-C bitmap primitive; The data used to record the effective pixels of ARGB-C bitmap primitives is recorded row by row, including one or more row data blocks. Each row data block includes the position coordinates of the first effective pixel in the effective pixel row, the number of effective pixels in the effective pixel row, and the ARGB values ​​of the effective pixels in the effective pixel row arranged in columns.

5. The GPU based on bitmap primitives as described in claim 2, characterized in that, According to the primitive format, the ARGB bitmap primitive may further include a linear gradient bitmap primitive with a linear gradient gradient effect; the primitive data of the linear gradient bitmap primitive includes data for recording the primitive format of the linear gradient bitmap primitive, data for recording the coordinates of the starting point of the linear gradient, data for recording the coordinates of the ending point of the linear gradient, data for recording the ARGB value of the starting point of the linear gradient, data for recording the ARGB value of the ending point of the linear gradient, data for recording the calculation formula of the linear gradient, and data for recording the storage address and size of the primitive data of the linear gradient bitmap primitive.

6. The GPU based on bitmap primitives as described in claim 2, characterized in that, According to the primitive format, the ARGB bitmap primitive may further include a radial gradient bitmap primitive with a radial gradient gradient effect; the primitive data of the radial gradient bitmap primitive includes data for recording the primitive format of the radial gradient bitmap primitive, data for recording the coordinates of the center point of the gradient region circle, data for recording the inner radius of the gradient region circle, data for recording the outer radius of the gradient region circle, data for recording the radial gradient gradient calculation formula, and data for recording the storage address and size of the primitive data of the radial gradient bitmap primitive.

7. The GPU based on bitmap primitives as described in claim 1, characterized in that, The first cache and the second cache are SRAM static random access memory.

8. The GPU based on bitmap primitives as described in claim 1, characterized in that, The color processor includes a primitive pixel color processing circuit and a dynamically reconfigurable matrix circuit; based on the primitive format and object index data of one or more bitmap primitives where the pixel to be drawn is located, the primitive pixel color processing circuit reads the primitive data of the bitmap primitive with the primitive format from the first cache, reads the primitive formatting data of the bitmap primitive with the object index data from the second cache, and sends the configuration parameters required to start working to one or more primitive processors, so that the primitive processors generate pixel ARGB values; The dynamically reconfigurable matrix circuit, according to the layer overlay display relationship of one or more bitmap primitives where the pixel to be drawn is located, sequentially matches one or more color channels from bottom to top and establishes connections with one or more primitive processors, obtains the state of the primitive processor and the pixel ARGB value it generates, and outputs the pixel ARGB value.

9. The GPU based on bitmap primitives as described in claim 2, characterized in that, The primitive processor includes a solid color primitive processor for processing the solid color bitmap primitives; the solid color primitive processor includes a primitive parameter register for receiving and storing configuration parameters sent by the color processor and an addressing / calculation unit connected to the primitive parameter register; The primitive parameter register includes a command register for storing various working commands, a primitive format register for storing primitive formats, a primitive region coordinate register for storing primitive region coordinates, a pixel coordinate register for storing the coordinates of the pixel to be drawn, a pixel color register for storing the ARGB values ​​of the pixel to be drawn, and a primitive color register for storing the ARGB values ​​of the fill color. The addressing / calculation unit writes the fill color ARGB value into the pixel color register, and then outputs a signal to the color processor to indicate that the color has been completed.

10. The GPU based on bitmap primitives as described in claim 2, characterized in that, The primitive processor includes an ARGB primitive processor for processing the ARGB bitmap primitives; the ARGB primitive processor includes a primitive parameter register that receives and stores configuration parameters sent by the color processor, an ARGB cache that obtains and stores primitive data from the first cache, an addressing / computing unit that connects the primitive parameter register and the ARGB cache, and a pixel color cache that connects the primitive parameter register and the addressing / computing unit. The primitive parameter register includes a command register for storing various working commands, a primitive format register for storing primitive formats, a primitive region coordinate register for storing primitive region coordinates, a pixel coordinate register for storing the coordinates of the pixel to be drawn, a pixel color register for storing the ARGB value of the pixel to be drawn, a data storage address register for storing the primitive data storage address of the first pixel of the ARGB bitmap primitive, and a data row byte length register for storing the row byte length of the ARGB bitmap primitive. The addressing / calculation unit obtains data from the ARGB cache and the primitive parameter register, calculates the ARGB value of the pixel to be drawn according to the preset calculation formula, sends it to the pixel color register and the pixel color cache, and then outputs a signal to the color processor to indicate that the color has been completed.

11. The GPU based on bitmap primitives as described in claim 5, characterized in that, The primitive processor includes a linear gradient primitive processor for processing the linear gradient bitmap primitives; the linear gradient primitive processor includes a primitive parameter register for receiving and storing configuration parameters sent by the color processor, an addressing / computation unit connected to the primitive parameter register, and a pixel color cache connected to the primitive parameter register and the addressing / computation unit. The primitive parameter register includes a command register for storing various working commands, a primitive format register for storing primitive formats, a primitive region coordinate register for storing primitive region coordinates, a pixel coordinate register for storing the coordinates of the pixel to be drawn, a pixel color register for storing the ARGB values ​​of the pixel to be drawn, a start color register for storing the ARGB values ​​of the start color of the linear gradient, an end color register for storing the ARGB values ​​of the end color of the linear gradient, a start coordinate register for storing the coordinates of the start point of the linear gradient, and an end coordinate register for storing the coordinates of the end point of the linear gradient. The addressing / calculation unit reads the data from the primitive parameter register, calculates the ARGB value of the pixel to be drawn according to the preset calculation formula, sends it to the pixel color cache and the pixel color register, and then outputs a signal to the color processor to indicate that the color has been completed.

12. The GPU based on bitmap primitives as described in claim 6, characterized in that, The primitive processor includes a radial gradient primitive processor for processing the radial gradient gradient bitmap primitives; the radial gradient gradient primitive processor includes a primitive parameter register for receiving and storing configuration parameters sent by the color processor, an addressing / calculation unit connected to the primitive parameter register, and a pixel color cache connected to the primitive parameter register and the addressing / calculation unit. The primitive parameter register includes a command register for storing various working commands, a primitive format register for storing primitive formats, a primitive region coordinate register for storing primitive region coordinates, a pixel coordinate register for storing the coordinates of the pixel to be drawn, a pixel color register for storing the ARGB values ​​of the pixel to be drawn, a start color register for storing the start radial gradient color ARGB values, an end color register for storing the end radial gradient color ARGB values, a circle center coordinate register for storing the coordinates of the center point of the gradient region circle, a circle inner radius register for storing the inner radius of the gradient region circle, and a circle outer radius register for storing the outer radius of the gradient region circle. The addressing / calculation unit reads the data from the primitive parameter register, calculates the ARGB value of the pixel to be drawn according to the preset calculation formula, sends it to the pixel color cache and the pixel color register, and then outputs a signal to the color processor to indicate that the color has been completed.

13. The GPU based on bitmap primitives as described in claim 1, characterized in that, The primitive processor includes a general-purpose primitive processor capable of processing multiple primitive formats; the general-purpose primitive processor includes a primitive parameter register that receives and saves configuration parameters sent by the color processor, an ARGB cache that obtains and saves primitive data from the first cache, an addressing / computing unit that connects the primitive parameter register and the ARGB cache, and a pixel color cache that connects the primitive parameter register and the addressing / computing unit. The primitive parameter register includes a command register for storing various working commands, a primitive format register for storing primitive formats, a primitive region coordinate register for storing primitive region coordinates, a pixel coordinate register for storing the coordinates of the pixel to be drawn, a pixel color register for storing the ARGB value of the pixel to be drawn, and a format-specific register for storing the calculation parameters required for calculating the ARGB value of the pixel to be drawn for various primitive formats. The addressing / calculation unit reads the corresponding calculation parameters in the format dedicated register according to the primitive format, reads the data in the ARGB cache according to the calculation needs, calculates the ARGB value of the pixel to be drawn according to the preset calculation formula, sends it to the pixel color register, and sends the ARGB value of the pixel to be drawn and the coordinates of the pixel to be drawn together to the pixel color cache as needed, and then outputs a signal to the color processor to indicate that the color has been completed.

14. The GPU based on bitmap primitives as described in claim 1, characterized in that, The pixel shader includes multiple pixel calculation units connected in sequence, and an initial color register connected to the first pixel calculation unit; the initial color register stores the initial color ARGB value; the first pixel calculation unit reads the initial color ARGB value and the pixel ARGB value of the pixel to be drawn in the first layer bitmap primitive provided by the color processor, and calculates the first pixel composite ARGB value according to the pixel composite command of the pixel to be drawn in the first layer bitmap primitive; The nth pixel calculation unit reads the pixel composite ARGB value calculated by the previous pixel calculation unit and the pixel ARGB value of the pixel to be drawn in the nth layer bitmap primitive provided by the color processor. It calculates the nth pixel composite ARGB value according to the pixel composite command of the pixel to be drawn in the nth layer bitmap primitive and outputs it as the pixel composite ARGB value of the pixel to be drawn; where n is a natural number greater than 1.

15. The GPU based on bitmap primitives as described in claim 1, characterized in that, The subprocessor further includes a layer data register array connected to the primitive filter; the second cache is configured with an index register storing object index data for identifying the first window layer primitive; the primitive filter receives the coordinate values ​​of the pixel to be drawn sent by the timing generator, and reads the index register, and sequentially traverses the primitive formatting data of the window layer primitives, control layer primitives, and bit layer primitives provided by the second cache, starting from the first window layer primitive, to filter out the layer data of bitmap primitives containing the coordinates of the pixel to be drawn within all primitive regions; the layer data includes at least object index data, primitive format, and layer number; The layer data register array stores the layer data.

16. The GPU based on bitmap primitives as described in claim 15, characterized in that, The subprocessor further includes a depth sorting register array connected to the depth processor; the depth processor includes multiple depth value Z calculation units, depth value Z comparators connected to the depth value Z calculation units, and a depth sorting list generator connected to the depth value Z comparators; The depth value Z calculation unit reads the layer data from the layer data register array and calculates the depth value Z of each filtered bitmap primitive according to a preset calculation formula. The depth value Z comparator compares the magnitude of the depth value Z; The depth sorting list generator sorts the primitive parameter information in ascending order of the depth value Z to generate a depth sorting list, which is then sent to the depth sorting register array for storage. The primitive parameter information includes the object index data and the primitive format.

17. The GPU based on bitmap primitives as described in claim 16, characterized in that, The color processor reads the depth sorting list from the depth sorting register array, reads the primitive data of bitmap primitives with the primitive format from the first cache according to the primitive parameter information recorded in the depth sorting list, reads the primitive formatting data of bitmap primitives with the object index data from the second cache, starts one or more primitive processors capable of processing the primitive format, and establishes a connection with the primitive processor by matching the color channels in the order of the depth sorting list, obtains the pixel ARGB value generated by the primitive processor, and outputs the pixel ARGB value through the color channel.

18. The GPU based on bitmap primitives as described in claim 1, characterized in that, The subprocessor also includes a primitive command register array connected to the command parser; The command parser obtains the pixel composition command of one or more bitmap primitives containing the pixel to be drawn from the second cache, and sends the pixel composition command to the primitive command register array for storage in the order of the layer overlay display relationship from bottom to top; The pixel shader obtains the pixel composition command from the primitive command register array.

19. A graphics processing system based on bitmap primitives, characterized in that, Includes a CPU, and a first static random access memory, a second static random access memory, a third static random access memory, and a GPU as described in any one of claims 1 to 3, connected to the CPU and the first static random access memory, the second static random access memory, and the third static random access memory; The second static random access memory is configured with a bitmap metadata buffer for storing metadata of the bitmap primitives; the third static random access memory is configured with a buffer for storing primitive formatting data of the bitmap primitives.

20. A graphics processing method based on bitmap primitives, characterized in that, include: The data information of the bitmap primitives is divided into at least primitive data and primitive formatting data; The image data includes at least data recording the image format of the bitmap image, data recording the ARGB value of the bitmap image, and data recording the image data storage address and size of the bitmap image; the image formatting data of the bitmap image includes at least object index data to identify the bitmap image, data recording the region position and size of the bitmap image, data recording the layer overlay display relationship between the bitmap image and other bitmap image, and data recording the pixel composition command between the bitmap image and other bitmap image. The image data and the image formatting data are stored in different storage areas or different memories in the memory. Provide the GPU with parallel access to the primitive data and the primitive formatting data.

21. The graphics processing method based on bitmap primitives as described in claim 20, characterized in that, Also includes: The bitmap primitives are classified into at least three different primitive formats: solid color bitmap primitives containing the same color and the same transparency; ARGB bitmap primitives containing different colors and the same or different transparency; and glyph bitmap primitives containing the same or different colors and the same or different transparency. The metadata of the solid color bitmap primitive includes data for recording the primitive format of the solid color bitmap primitive, data for recording the ARGB value of the fill color of the solid color bitmap primitive, and data for recording the storage address and size of the metadata of the solid color bitmap primitive. The image data of the ARGB bitmap primitive includes data for recording the primitive format of the ARGB bitmap primitive, data for recording the pixel ARGB values ​​of the ARGB bitmap primitive, and data for recording the image data storage address and size of the ARGB bitmap primitive. The image data of the character bitmap element includes data for recording the element format of the character bitmap element, data for recording the character ARGB value of the character bitmap element, data for recording the character outline of the character bitmap element, and data for recording the storage address and size of the image data of the character bitmap element.

22. The graphics processing method based on bitmap primitives as described in claim 21, characterized in that, According to the primitive format, the ARGB bitmap primitive includes ARGB-C bitmap primitives containing only a few valid pixels; the primitive data of the ARGB-C bitmap primitive includes data for recording the primitive format of the ARGB-C bitmap primitive, data for recording the valid pixels of the ARGB-C bitmap primitive, and data for recording the primitive data storage address and size of the ARGB-C bitmap primitive; The data of the effective pixels of the ARGB-C bitmap primitive are recorded row by row, including multiple row data blocks. Each row data block includes the position coordinates of the first effective pixel in the row, the number of effective pixels in the row, and the ARGB values ​​of the effective pixels arranged in columns in the row.

23. The graphics processing method based on bitmap primitives as described in claim 21, characterized in that, According to the primitive format, the ARGB bitmap primitive includes a linear gradient bitmap primitive with a linear gradient gradient effect; the primitive data of the linear gradient bitmap primitive includes data for recording the primitive format of the linear gradient bitmap primitive, data for recording the starting coordinates, data for recording the ending coordinates, data for recording the starting ARGB value, data for recording the ending ARGB value, data for recording the linear gradient gradient calculation formula, and data for recording the primitive data storage address and size of the linear gradient bitmap primitive.

24. The graphics processing method based on bitmap primitives as described in claim 20, characterized in that, Also includes: The bitmap primitives are divided into at least three different layer levels: window layer primitives as the basic layer, control layer primitives belonging to the window layer primitives, and bitmap layer primitives belonging to the control layer primitives. The primitive formatting data of the window layer primitive includes object index data for identifying the window layer primitive, data for recording the primitive format of the window layer primitive, data for recording the location and size of the window layer primitive area, data for recording the number of control layer primitives belonging to the window layer primitive, object index data for identifying the control layer primitives belonging to the window layer primitive, layer number for marking the layer overlay display relationship between the window layer primitive and other window layer primitives, data for recording the pixel composition command of the window layer primitive and other window layer primitives, and object index data for identifying the other window layer primitives; The primitive formatting data of the control layer primitive includes object index data to identify the control layer primitive, data to record the primitive format of the control layer primitive, data to record the region position and size of the control layer primitive, object index data to identify the bit layer primitive belonging to the control layer primitive, data to record the number of bit layer primitives belonging to the control layer primitive, layer number to mark the layer overlay display relationship between the control layer primitive and other control layer primitives belonging to the same window layer primitive, data to record the pixel composition command of the control layer primitive and other control layer primitives, object index data to identify the window layer primitive to which the control layer primitive belongs, and object index data to identify the other control layer primitives. The primitive formatting data of the bitlayer primitive includes object index data for identifying the bitlayer primitive, data for recording the primitive format of the bitlayer primitive, object index data for identifying the control layer primitive to which the bitlayer primitive belongs, data for recording the position and size of the envelope rectangle of the bitlayer primitive, data for recording the position and size of the clipping rectangle of the bitlayer primitive, data for recording the storage location of the primitive data, layer number for marking the layer overlay display relationship between the bitlayer primitive and other bitlayer primitives belonging to the same control layer primitive, data for recording the pixel composition command of the bitlayer primitive and other bitlayer primitives, and object index data for identifying the other bitlayer primitives.

25. The graphics processing method based on bitmap primitives as described in claim 20, characterized in that, The memory is a static random access memory (SRAM).

Images