CN114237532A - Multi-window implementation method, device and medium based on Linux embedded system - Google Patents

Multi-window implementation method, device and medium based on Linux embedded system Download PDF

Info

Publication number
CN114237532A
CN114237532A CN202111448378.4A CN202111448378A CN114237532A CN 114237532 A CN114237532 A CN 114237532A CN 202111448378 A CN202111448378 A CN 202111448378A CN 114237532 A CN114237532 A CN 114237532A
Authority
CN
China
Prior art keywords
thread
window
variable
display
rendering
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Pending
Application number
CN202111448378.4A
Other languages
Chinese (zh)
Inventor
崔运涛
邓博
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Allwinner Technology Co Ltd
Original Assignee
Allwinner Technology Co Ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Allwinner Technology Co Ltd filed Critical Allwinner Technology Co Ltd
Priority to CN202111448378.4A priority Critical patent/CN114237532A/en
Publication of CN114237532A publication Critical patent/CN114237532A/en
Pending legal-status Critical Current

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
    • G06F3/14—Digital output to display device ; Cooperation and interconnection of the display device with other functional units
    • G06F3/1407—General aspects irrespective of display type, e.g. determination of decimal point position, display with fixed or driving decimal point, suppression of non-significant zeros
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
    • G06T1/00—General purpose image data processing
    • G06T1/20—Processor architectures; Processor configuration, e.g. pipelining

Abstract

The invention relates to a technical scheme of a multi-window implementation method, a device and a medium based on a Linux embedded system, which comprises the following steps: reconstructing, namely reconstructing a display standard structural body of the Linux embedded system; initializing, loading a reconstructed OpenGL program function library, and executing initialization; multi-window realization, namely, executing multi-window creation, frame cache object exchange, window display and window display position adjustment through a plurality of functions in the reconstructed OpenGL program function library; the synchronous thread processing, the rendering thread synchronization processing by the Vsync processing thread, and the synchronization signal management and the management of the frame buffer object by the rendering thread. The invention has the beneficial effects that: on the basis of not changing an OpenGLES library and an OpenGLES application provided by a GPU manufacturer, a set of method for realizing multi-window/multi-process/multi-thread rendering is designed, and the rendering experience and flexibility of OpenGLES under fbdev are improved.

Description

Multi-window implementation method, device and medium based on Linux embedded system
Technical Field
The invention relates to the field of computers, in particular to a multi-window implementation method, a device and a medium based on a Linux embedded system.
Background
In an actual GPU window system, FBDEV is a basic Linux window system, but the disadvantage of a single window thereof causes that an operating system can only operate one visual window, which means that rendering on a screen can not be operated simultaneously to multiple applications such as Android and Wayland, FBDEV does not have a multi-window system implementation, generally, the implementation requires that FBO is copied to a cache of FBDEV for display, and synchronization in the multi-process system is very tedious.
The prior art is the buffer rendering to the frame buffer under the FBDEV, and if a plurality of processes use GPU rendering or other image producers (such as VE) need to display, the problem of competition with the frame buffer exists.
The implementation of OpenGLES under the Linux frame buffer device can only support single-window output rendering to be output to the frame buffer of the frame buffer device, cannot be multi-window rendering like Android and Wayland, and cannot well support the design of an operating system with multiple processes/threads and with window management or screen synthesis processes.
Disclosure of Invention
The technical scheme of the invention realizes a multi-thread and multi-process multi-window system scheme under OpenGLES FBDEV by combining the characteristics of a packaging library and an IC display driver without changing the codes of the original GPU manufacturer.
The technical scheme of the invention comprises a multi-window implementation method based on a Linux embedded system, which is characterized by comprising the following steps: reconstructing, namely reconstructing a display standard structure body of the Linux embedded system, wherein the reconstructed standard structure body is used for describing an EGL interface variable, a thread variable and a GPU thread management variable; initializing, loading the reconstructed OpenGL program function library and the external API function library, and executing initialization; multi-window realization, namely, executing multi-window creation, frame cache object exchange, window display and window display position adjustment through a plurality of functions in the reconstructed OpenGL program function library; the synchronous thread processing, the rendering thread synchronization processing by the Vsync processing thread, and the synchronization signal management and the management of the frame buffer object by the rendering thread.
According to the multi-window implementation method based on the Linux embedded system, the reconstruction comprises the following steps: reconstructing an API function of OpenGLES/EGL, wherein the EGL interface variables comprise an off-screen buffer area variable and a display resource variable, the off-screen buffer area variable and the display resource variable are respectively used for representing data types of external EGLSurface and EGLDisplay, the thread variable is used for representing a variable owned by each thread, and the GPU thread management variable is used for representing an OpenGLES/EGL native variable of a native GPU manufacturer.
According to the multi-window implementation method based on the Linux embedded system, initialization comprises the following steps: starting a rendering program to perform data loading, wherein the data loading comprises library loading of the native OpenGLES/EGL, and function reconstruction is performed on a standard OpenGLES/EGL API function through reconstruction; the Vsync processing thread is started to synchronize the producer and consumer of the window.
According to the multi-window implementation method based on the Linux embedded system, the multi-window implementation comprises the following steps: the window creation creates an off-screen rendering object through an eglCreateWindowSurface function, initializes the off-screen buffer variable and a consumer hardware layer, and creates at least one window in the same process or multiple processes without mutual influence among the multiple windows; the frame buffer objects are established through eglMakeCurrent function application and frame buffer object quantity buffer, corresponding frame buffer objects are established, corresponding off-screen buffer area variables are initialized, and thread variables are established for storing necessary thread variable data; the frame buffer objects in the off-screen buffer area variables are exchanged through eglSwapBuffers, rendering operation is drawn into the frame buffer objects, a sync signal is created and submitted to a display sending thread, and a new frame buffer object is obtained and bound; the window display sequentially executes the acquisition of postamble variables before the thread, the acquisition of an off-screen buffer window, the acquisition of a frame buffer object written in the function and the execution of binding to the application program binding frame buffer object through a glBindFramebuffer function; the window display position adjustment places different windows into different channels and layers of the consumer via the eglsetfaceext function.
According to the multi-window implementation method based on the Linux embedded system, the multi-window implementation further comprises the following steps: and displaying the eglGetDisplay appointed window on the corresponding consumer, and if the consumer acquires the eglGetDisplay appointed window for the first time, creating a display sending thread of the corresponding consumer.
According to the multi-window implementation method based on the Linux embedded system, the Vsync processing thread comprises: controlling a display sending thread to execute smooth frame sending; returning the buffer used for the cyclic use of the synchronization window; and issuing rendering beats to applications requiring vsync signals.
According to the multi-window implementation method based on the Linux embedded system, the display thread comprises: limiting to display a frame of picture in the same vsync period; sync signal management of synchronous rendering threads; multi-cache consumption of frame cache objects is coordinated based on consumer perspective.
According to the multi-window implementation method based on the Linux embedded system, the method further comprises the step of carrying out side effect elimination processing on the affected API function.
The technical scheme of the invention also comprises a multi-window implementation device based on the Linux embedded system, which comprises a memory, a processor and a computer program which is stored in the memory and can run on the processor, and is characterized in that the processor implements any one of the method steps when executing the computer program.
The present invention also includes a computer-readable storage medium, in which a computer program is stored, wherein the computer program, when executed by a processor, implements any of the method steps.
The invention has the beneficial effects that: on the basis of not changing an OpenGLES library and an OpenGLES application provided by a GPU manufacturer, a set of method for realizing multi-window/multi-process/multi-thread rendering is designed, and the rendering experience and flexibility of OpenGLES under fbdev are improved.
Drawings
The invention is further described below with reference to the accompanying drawings and examples;
FIG. 1 shows a general flow diagram according to an embodiment of the invention.
FIG. 2 is a flow diagram illustrating library initialization according to an embodiment of the present invention.
Fig. 3 is a flow diagram illustrating a switch buffering process according to an embodiment of the present invention.
Fig. 4 is a flow chart illustrating binding of a frame buffer object according to an embodiment of the present invention.
Fig. 5 is a flowchart illustrating a Vsync processing thread work according to an embodiment of the present invention.
FIG. 6 is a flowchart illustrating the operation of a rendering thread according to an embodiment of the present invention.
Fig. 7 shows a diagram of an apparatus according to an embodiment of the invention.
Detailed Description
Reference will now be made in detail to the present preferred embodiments of the present invention, examples of which are illustrated in the accompanying drawings, wherein like reference numerals refer to like elements throughout.
In the description of the present invention, the meaning of a plurality of means is one or more, the meaning of a plurality of means is two or more, and larger, smaller, larger, etc. are understood as excluding the number, and larger, smaller, inner, etc. are understood as including the number.
In the description of the present invention, the consecutive reference numbers of the method steps are for convenience of examination and understanding, and the implementation order between the steps is adjusted without affecting the technical effect achieved by the technical solution of the present invention by combining the whole technical solution of the present invention and the logical relationship between the steps.
In the description of the present invention, unless otherwise explicitly defined, terms such as set, etc. should be broadly construed, and those skilled in the art can reasonably determine the specific meanings of the above terms in the present invention in combination with the detailed contents of the technical solutions.
FIG. 1 shows a general flow diagram according to an embodiment of the invention. The flow of this example is as follows: reconstructing, namely reconstructing a display standard structure body of the Linux embedded system, wherein the reconstructed standard structure body is used for describing an EGL interface variable, a thread variable and a GPU thread management variable; initializing, loading a reconstructed OpenGL program function library, and executing initialization; multi-window realization, namely, executing multi-window creation, frame cache object exchange, window display and window display position adjustment through a plurality of functions in a reconstructed OpenGL program function library; the synchronous thread processing, the rendering thread synchronization processing by the Vsync processing thread, and the synchronization signal management and the management of the frame buffer object by the rendering thread.
The embodiment of the invention newly defines part of the Kronos standard structure for recording some information needed to be used by the embodiment of the invention, and the main structure is defined as follows:
a) aw _ surface _ t: external to the library is an EGLSurface (EGL allocated off-screen buffer) type
Figure BDA0003382535520000051
TABLE 1 aw _ surface _ t Member variables
FBO _ NUM in table 1
b) aw _ display _ resource: corresponding to the exterior being EGLDisplay type
Variables of Type (B) Function of
s_list Two-way linked list For saving the surface variable under the display
id EGLDisplay Native Kronos display structure
R_mCond Conditional wait New render buffer generation for notifying display threads
V_mCond Conditional wait For vsync thread notification vsync events
Table 2 variable composition of aw _ display _ resource
c) A thread variable structure thread _ context, which is a thread variable owned by each thread and used for realizing the rendering of multiple threads and multiple contexts, wherein the important data is as the following table;
variables of Type (B) Function of
r_surface aw_surface_t The read surface is used for recording the setting under the thread;
w_surface aw_surface_t for recording write surface set under the thread
Ctx EGLContext EGLContext variable for recording Kronos standard
Table 3 thread variable structure thread _ context variable
d)gpu_context_t
Variables of Type (B) Function of
egl EGL API function pointer array API implementation function for saving native concrete GPU vendors
gl GL API function pointer array API implementation function for saving native concrete GPU vendors
TABLE 4 gpu _ context _ t function variables
FIG. 2 is a flow diagram illustrating library initialization according to an embodiment of the present invention. In connection with fig. 2, it is summarized as:
after the normal rendering program loads aw _ opengl.so, some special events need to be processed, including library loading of native OpenGLES/EGLs, and reconstructing standard OpenGLES/EGL API functions therein; and starting a Vsync processing thread, and performing API emphasis reconstruction on OpenGLES/EGL which generates side effects.
The partial reconstruction function based on the technical scheme of the invention is as follows:
(1) the eglCreateWindowSurface function is mainly used for creating PbufferSurface, initializing a partial aw _ surface _ t variable and a partial initialization of a display hardware layer, and the PbufferSurface mechanism is utilized to realize the effect of a plurality of surfaces.
(2) The eglMakeCurrent is mainly used for applying for FBO _ NUM buffers and creating FBO, partially initializing an aw _ surface _ t variable and creating a thread variable for storing necessary thread variable data.
(3) eglsepampbuffers, configured to exchange FBOs in aw _ surface _ t, draw a previous drawcall into the FBO, create a sync signal, submit the sync signal to a display sending thread, acquire and bind a new FBO, and perform necessary waiting in the process, where a main flow refers to fig. 3:
(4) glBindFramebuffer, because the Surface is implemented using FBO, since Kronos specifies FBO named 0 as the Surface currently bound, which is actually based on the FBO created (named as the FBO specified by write _ FBO), some processing is required for this function, and the processing flow refers to the flow of fig. 4.
(5) eglSetSurfaceExt, which is a function for supporting the display problem of multiple surfaces in a display, places different surfaces into different channels and layers of the display, thus realizing the effect of a window manager.
(6) eglGetDisplay, reconstructs the function, acts to specify on which display screen the surface is displayed, and if the display is acquired for the first time, creates a rendering thread for the display.
Fig. 5 is a flowchart illustrating a Vsync processing thread work according to an embodiment of the present invention. The process is as follows:
detecting whether a vsync thread has an event or not, traversing the configuration of the display if the vsync thread has the event, updating the c _ read _ fbo thread of the temporary linked list to the read _ fbo, waking up the corresponding rendering thread (eglSwapBuffers) to perform cache exchange and rendering, and notifying the display thread of a vsync event after the cache exchange and the rendering are performed.
The roles of the Vsync processing thread include: the method has the advantages that the function of smoothly sending frames is achieved for the display sending thread, and the fact that only one frame of picture can be sent and displayed in the same vsync period is guaranteed; the interior of the display screen has the buffer function of synchronizing the cyclic use of the surface, and the situation that the rendering thread takes the buffer which is being displayed to cause screen blooming is avoided; rendering beats are issued for applications that are concerned about the vsync signal so that smooth rendering is applied.
FIG. 6 is a flowchart illustrating the operation of a rendering thread according to an embodiment of the present invention. The process comprises the following steps:
detecting that a new display surface appears in the display linked list, updating the surface to be displayed to the temporary linked list, taking the surface in the temporary linked list, waiting for a signal of the sync, submitting the sync signal to display, judging whether data exists in the display list after reading _ fbo + +, and if so, circulating the process until all data are sent and displayed.
The display sending thread is mainly used for sending displays and has the following main functions: smooth display sending, which ensures that each frame can be smoothly displayed on a screen; sync signal management for synchronous rendering threads; managing the consumption of FBO's multiple buffers from a consumer perspective.
Fig. 7 shows a diagram of an apparatus according to an embodiment of the invention. The apparatus comprises a memory 100 and a processor 200, wherein the processor 200 stores a computer program for performing: reconstructing, namely reconstructing a display standard structure body of the Linux embedded system, wherein the reconstructed standard structure body is used for describing an EGL interface variable, a thread variable and a GPU thread management variable; initializing, loading a reconstructed OpenGL program function library, and executing initialization; multi-window realization, namely, executing multi-window creation, frame cache object exchange, window display and window display position adjustment through a plurality of functions in the reconstructed OpenGL program function library; the synchronous thread processing, the rendering thread synchronization processing by the Vsync processing thread, and the synchronization signal management and the management of the frame buffer object by the rendering thread. Wherein the memory 100 is used for storing data.
It should be recognized that the method steps in embodiments of the present invention may be embodied or carried out by computer hardware, a combination of hardware and software, or by computer instructions stored in a non-transitory computer readable memory. The method may use standard programming techniques. Each program may be implemented in a high level procedural or object oriented programming language to communicate with a computer system. However, the program(s) can be implemented in assembly or machine language, if desired. In any case, the language may be a compiled or interpreted language. Furthermore, the program can be run on a programmed application specific integrated circuit for this purpose.
Further, the operations of processes described herein can be performed in any suitable order unless otherwise indicated herein or otherwise clearly contradicted by context. The processes described herein (or variations and/or combinations thereof) may be performed under the control of one or more computer systems configured with executable instructions, and may be implemented as code (e.g., executable instructions, one or more computer programs, or one or more applications) collectively executed on one or more processors, by hardware, or combinations thereof. The computer program includes a plurality of instructions executable by one or more processors.
Further, the method may be implemented in any type of computing platform operatively connected to a suitable interface, including but not limited to a personal computer, mini computer, mainframe, workstation, networked or distributed computing environment, separate or integrated computer platform, or in communication with a charged particle tool or other imaging device, and the like. Aspects of the invention may be embodied in machine-readable code stored on a non-transitory storage medium or device, whether removable or integrated into a computing platform, such as a hard disk, optically read and/or write storage medium, RAM, ROM, or the like, such that it may be read by a programmable computer, which when read by the storage medium or device, is operative to configure and operate the computer to perform the procedures described herein. Further, the machine-readable code, or portions thereof, may be transmitted over a wired or wireless network. The invention described herein includes these and other different types of non-transitory computer-readable storage media when such media include instructions or programs that implement the steps described above in conjunction with a microprocessor or other data processor. The invention also includes the computer itself when programmed according to the methods and techniques described herein.
A computer program can be applied to input data to perform the functions described herein to transform the input data to generate output data that is stored to non-volatile memory. The output information may also be applied to one or more output devices, such as consumers. In a preferred embodiment of the present invention, the transformed data represents physical and tangible objects, including particular visual depictions of physical and tangible objects produced on the consumer.
The embodiments of the present invention have been described in detail with reference to the accompanying drawings, but the present invention is not limited to the above embodiments, and various changes can be made within the knowledge of those skilled in the art without departing from the gist of the present invention.

Claims (10)

1. A multi-window implementation method based on a Linux embedded system is characterized by comprising the following steps:
reconstructing, namely reconstructing a display standard structure body of the Linux embedded system, wherein the reconstructed standard structure body is used for describing an EGL interface variable, a thread variable and a GPU thread management variable;
initializing, loading the reconstructed OpenGL program function library and the external API function library, and executing initialization;
multi-window realization, namely, executing multi-window creation, frame cache object exchange, window display and window display position adjustment through a plurality of functions in the reconstructed OpenGL program function library;
the synchronous thread processing, the rendering thread synchronization processing by the Vsync processing thread, and the synchronization signal management and the management of the frame buffer object by the rendering thread.
2. The method according to claim 1, wherein the reconstructing comprises:
reconstructing an API function of OpenGLES/EGL, wherein the EGL interface variables comprise an off-screen buffer area variable and a display resource variable, the off-screen buffer area variable and the display resource variable are respectively used for representing data types of external EGLSurface and EGLDisplay, the thread variable is used for representing a variable owned by each thread, and the GPU thread management variable is used for representing an OpenGLES/EGL native variable of a native GPU manufacturer.
3. The method according to claim 2, wherein the initializing comprises:
starting a rendering program to perform data loading, wherein the data loading comprises library loading of the native OpenGLES/EGL, and function reconstruction is performed on a standard OpenGLES/EGL API function through reconstruction;
the Vsync processing thread is started to synchronize the producer and consumer of the window.
4. The method for implementing multiple windows based on the Linux embedded system of claim 1, wherein the implementing multiple windows comprises:
the window creation creates an off-screen rendering object through an eglCreateWindowSurface function, initializes the off-screen buffer variable and a consumer hardware layer, and creates at least one window in the same process or multiple processes without mutual influence among the multiple windows;
the frame buffer objects are established through eglMakeCurrent function application and frame buffer object quantity buffer, corresponding frame buffer objects are established, corresponding off-screen buffer area variables are initialized, and thread variables are established for storing necessary thread variable data;
the frame buffer objects in the off-screen buffer area variables are exchanged through eglSwapBuffers, rendering operation is drawn into the frame buffer objects, a sync signal is created and submitted to a display sending thread, and a new frame buffer object is obtained and bound;
the window display sequentially executes the acquisition of postamble variables before the thread, the acquisition of an off-screen buffer window, the acquisition of a frame buffer object written in the function and the execution of binding to the application program binding frame buffer object through a glBindFramebuffer function;
the window display position adjustment places different windows into different channels and layers of the consumer via the eglsetfaceext function.
5. The Linux embedded system-based multi-window implementation method of claim 4, wherein the multi-window implementation further comprises:
and displaying the screen on the corresponding screen through the eglGetDisplay appointed window, and if the screen is acquired for the first time, creating a display sending thread corresponding to the screen.
6. The Linux embedded system-based multi-window implementation method of claim 1, wherein the Vsync processing thread comprises:
executing smooth frame sending on the display sending thread, and limiting to send and display a frame of picture for the same vsync period;
returning the buffer used for the cyclic use of the synchronization window; and issuing rendering beats to applications requiring vsync signals.
7. The method for implementing multiple windows based on the Linux embedded system according to claim 1, wherein the rendering thread comprises: limiting to display a frame of picture in the same vsync period; sync signal management of synchronous rendering threads; multi-cache consumption of frame cache objects is coordinated based on consumer perspective.
8. The method for implementing multiple windows based on the Linux embedded system of claim 1, further comprising performing an elimination side effect process on the affected API functions.
9. A multi-window implementation device based on a Linux embedded system, comprising a memory, a processor and a computer program stored in said memory and executable on said processor, characterized in that said processor implements the method steps of any one of claims 1 to 8 when executing said computer program.
10. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the method steps of any one of claims 1 to 8.
CN202111448378.4A 2021-11-30 2021-11-30 Multi-window implementation method, device and medium based on Linux embedded system Pending CN114237532A (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN202111448378.4A CN114237532A (en) 2021-11-30 2021-11-30 Multi-window implementation method, device and medium based on Linux embedded system

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN202111448378.4A CN114237532A (en) 2021-11-30 2021-11-30 Multi-window implementation method, device and medium based on Linux embedded system

Publications (1)

Publication Number Publication Date
CN114237532A true CN114237532A (en) 2022-03-25

Family

ID=80752367

Family Applications (1)

Application Number Title Priority Date Filing Date
CN202111448378.4A Pending CN114237532A (en) 2021-11-30 2021-11-30 Multi-window implementation method, device and medium based on Linux embedded system

Country Status (1)

Country Link
CN (1) CN114237532A (en)

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN115131488A (en) * 2022-08-31 2022-09-30 麒麟软件有限公司 Method and system for managing display cache in wayland graphic display environment
CN116302579A (en) * 2023-05-25 2023-06-23 智成时空(西安)创新科技有限公司 Space-time big data efficient loading rendering method and system for Web end

Cited By (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN115131488A (en) * 2022-08-31 2022-09-30 麒麟软件有限公司 Method and system for managing display cache in wayland graphic display environment
CN115131488B (en) * 2022-08-31 2022-11-29 麒麟软件有限公司 Method and system for managing display cache in wayland graphic display environment
CN116302579A (en) * 2023-05-25 2023-06-23 智成时空(西安)创新科技有限公司 Space-time big data efficient loading rendering method and system for Web end
CN116302579B (en) * 2023-05-25 2023-08-04 智成时空(西安)创新科技有限公司 Space-time big data efficient loading rendering method and system for Web end

Similar Documents

Publication Publication Date Title
US11487644B2 (en) Graphics processing unit application execution control
US10949944B2 (en) System and method for unified application programming interface and model
CN113791667B (en) Backward compatibility by using spoofed clocks and fine-grained frequency control
TWI406185B (en) Real-time display post-processing using programmable hardware
US9292414B2 (en) System, method, and computer program product for debugging graphics programs locally utilizing a system with a single GPU
US8878833B2 (en) Systems, methods, and apparatus for recording of graphical display
EP3111318B1 (en) Cross-platform rendering engine
CN107515759B (en) Screen capture method and device, electronic equipment and readable storage medium
CN114237532A (en) Multi-window implementation method, device and medium based on Linux embedded system
US20070091097A1 (en) Method and system for synchronizing parallel engines in a graphics processing unit
US20140354664A1 (en) Method of and apparatus for controlling frame buffer operations
US11467717B2 (en) Optimizing window resize actions for remoted applications
US10803547B2 (en) Graphics processing systems using a subset of pipeline stages
US20160148359A1 (en) Fast Computation of a Laplacian Pyramid in a Parallel Computing Environment
CN111651079A (en) Handwriting display method, device, equipment and computer storage medium
CN116185743B (en) Dual graphics card contrast debugging method, device and medium of OpenGL interface
US6952217B1 (en) Graphics processing unit self-programming
CN111542872A (en) Arbitrary block rendering and display frame reconstruction
US8237725B1 (en) Vertex cache map mode for per-vertex state changes
KR101399473B1 (en) Method and apparatus for rendering processing by using multiple processings
CN110730976B (en) Method and system for a transaction-based display pipeline interfacing with a graphics processing unit
US20230096035A1 (en) Parallelization of gpu composition with dpu topology selection
US9159160B1 (en) Texture sharing between application modules
JP2009301473A (en) Window display unit, window display process, window display program, recording medium recording window display program, and window display integrated circuit
CN112581575A (en) Texture system is done to outer video

Legal Events

Date Code Title Description
PB01 Publication
PB01 Publication
SE01 Entry into force of request for substantive examination
SE01 Entry into force of request for substantive examination