WO2023093076A1

WO2023093076A1 - Method and apparatus for suppressing display jitter, electronic device, and storage medium

Info

Publication number: WO2023093076A1
Application number: PCT/CN2022/105422
Authority: WO
Inventors: 邓宝安
Original assignee: 北京字节跳动网络技术有限公司
Priority date: 2021-11-23
Filing date: 2022-07-13
Publication date: 2023-06-01
Also published as: CN114115688A; CN114115688B

Abstract

The present disclosure provides a method and apparatus for suppressing display jitter, an electronic device, and a storage medium. The method comprises: in response to an update rendering request from a synthesizer, a client determining whether the update rendering request is the same as the previous update rendering request; on the basis of a determination result that the update rendering request is the same as the previous update rendering request, the client obtaining a touch event received by its own input thread, and determining whether the touch event in the update rendering request is the same as the latest touch event received by the input thread; on the basis of a determination result that the touch event in the update rendering request is the same as the latest touch event received by the input thread, determining not to respond to the update rendering request; and on the basis of a determination result that the touch event in the update rendering request is not the same as the latest touch event received by the input thread, performing update rendering of a corresponding scene graph according to the latest touch event received by the input thread, and outputting the rendered scene graph to the synthesizer.

Description

Method and device for suppressing display jitter, electronic equipment, storage medium

This disclosure claims priority to a Chinese patent application with application number 202111392446.X filed with the China Patent Office on November 23, 2021, the entire contents of which are incorporated by reference into this disclosure.

technical field

Embodiments of the present disclosure relate to electronic device display processing technologies, for example, to a method and device for suppressing display jitter, electronic devices, and storage media.

Background technique

In the display framework based on the wayland protocol, the kernel events generated in the operating system are generally sent to the compositor (wayland compositor) first, and the compositor checks the scene graph (scenegraph) of kernel events to determine which window the corresponding client should receive The kernel event. After the client receives the kernel event, it starts to update the rendering interface. After the rendering is completed, the composition request is sent to the compositor (wayland compositor) through the wayland socket. The compositor (wayland compositor) synthesizes multiple interface graphics and outputs them through the display screen. Implement screen pattern refresh. However, since the compositor (wayland compositor) has other tasks to process besides receiving kernel events, sometimes it may cause thread blocking, so that kernel events cannot be responded in time, resulting in frame loss, resulting in screen pattern jitter.

Contents of the invention

Embodiments of the present disclosure provide a method and device for suppressing display jitter, electronic equipment, and a storage medium, so as to suppress the problem of screen pattern jitter existing in the related art.

In a first aspect, the present disclosure provides a method for suppressing display jitter, including:

In response to the updated rendering request from the compositor, the client determines whether the updated rendering request is the same as the previous updated rendering request;

Based on the judgment result that the updated rendering request is the same as the previous updated rendering request, the client obtains the touch event received by its own input thread; judges that the touch event in the updated rendering request is the latest touch event received by the input thread Whether they are the same; based on the judgment result that the touch event in the update rendering request is the same as the latest touch event received by the input thread, it is determined not to respond to the update rendering request, based on the touch event in the update rendering request and the If the judgment result of the latest touch event received by the input thread is different, update and render the corresponding scene graph according to the latest touch event received by the input thread, and output the rendered scene graph to the compositor.

In a second aspect, the present disclosure provides a method for suppressing display jitter, including:

When the trigger period arrives, the compositor detects its own touch event queue. If the touch event queue is empty, the touch event in the previous trigger period generates an update rendering request, and sends the generated update rendering request to The client sends.

In a third aspect, the present disclosure provides a device for suppressing display jitter, including:

The first judging unit is configured to, in response to an updated rendering request from the compositor, judge whether the updated rendering request is the same as the previous updated rendering request;

The acquisition unit is configured to trigger the client to acquire the touch event received by its own input thread based on the judgment result that the updated rendering request is the same as the previous updated rendering request;

The second judging unit is configured to judge whether the touch event in the update rendering request is the same as the latest touch event received by the input thread, based on the touch event in the update rendering request and the latest touch event received by the input thread Triggering the first processing unit if the event is the same; triggering the second processing unit based on the judgment result that the touch event in the update rendering request is different from the latest touch event received by the input thread;

a first processing unit configured to determine not to respond to the update rendering request;

The second processing unit is configured to update and render the corresponding scene graph based on the latest touch event received by the input thread, and output the rendered scene graph to the compositor.

In a fourth aspect, the present disclosure provides a device for suppressing display jitter, including:

The detection unit is configured to detect whether the touch event queue is empty when the trigger period arrives, and trigger the generation unit based on the detection result that the touch event queue is empty;

a generating unit configured to generate an update rendering request for a touch event in a previous trigger cycle;

A sending unit configured to send the update rendering request to the client.

In a fifth aspect, the present disclosure provides an electronic device, including a processor, a memory, and an executable program stored on the memory and capable of being run by the processor. When the processor runs the executable program, the aforementioned first The steps of the method for suppressing display jitter described in the aspect or the second aspect.

In a sixth aspect, the present disclosure provides a storage medium on which an executable program is stored, and when the executable program is executed by a processor, the steps of the method for suppressing display jitter described in the aforementioned first or second aspect are implemented.

Description of drawings

The following will briefly introduce the drawings that need to be used in the description of the embodiments or related technologies.

FIG. 1 is a schematic flowchart of a method for suppressing display jitter according to an embodiment of the present disclosure;

FIG. 2 is a schematic flowchart of a method for suppressing display jitter according to an embodiment of the present disclosure;

FIG. 3 is a schematic diagram of an implementation framework for suppressing display jitter according to an embodiment of the present disclosure;

FIG. 4 is a schematic diagram of implementation signaling for suppressing display jitter according to an embodiment of the present disclosure;

FIG. 5 is a schematic diagram of the composition and structure of a device for suppressing display jitter according to an embodiment of the present disclosure;

FIG. 6 is a schematic diagram of the composition and structure of a device for suppressing display jitter according to an embodiment of the present disclosure;

FIG. 7 is a schematic diagram of the composition and structure of a device for suppressing display jitter according to an embodiment of the present disclosure;

FIG. 8 is a structural diagram of an electronic device according to an embodiment of the present disclosure.

Detailed ways

Embodiments of the present disclosure will be described in detail below in conjunction with the accompanying drawings.

FIG. 1 is a schematic flow chart of a method for suppressing display jitter in an embodiment of the present disclosure. The method for suppressing display jitter in an embodiment of the present disclosure can be executed by a client. As shown in FIG. 1 , the method for suppressing display jitter in an embodiment of the present disclosure includes The following processing steps:

Step 101, in response to an updated rendering request from the compositor, the client determines whether the updated rendering request is the same as the previous updated rendering request.

After receiving the update rendering request from the compositor, the client first obtains the touch event in the update rendering request, and determines whether the touch event is the same as the touch event in the previously received update rendering request, based on the touch event and If the touch event in the previously received update rendering request is the same as the judgment result, it is determined that the current update rendering request is the same as the previous update rendering request, based on the fact that the touch event is different from the touch event in the previously received update rendering request As a result of the judgment, it is determined that the current update rendering request is different from the previous update rendering request. Wherein, the same touch events refer to the same position information in the touch events.

Here, the client judges the update rendering request sent by the compositor, so as to perform corresponding processing. If the updated rendering request is different from the previous updated rendering request, the client uses the touch event in the updated rendering request to perform updated rendering of the corresponding scene graph. In this case, it is considered that the synthesizer handles the touch event in a timely manner, and no thread blocking occurs.

In the embodiments of the present disclosure, the client refers to an application corresponding to multiple display windows in the display framework of the wayland protocol, and may also be a window currently displayed by a related application or its corresponding process.

In the embodiment of the present disclosure, by setting the input thread for the client, the input thread can detect the touch event input by the input driver, set a time stamp for the detected touch event, and add the touch event with the time stamp to in the touch event queue. In the touch event queue, the detected touch events can be sorted in order of time stamps, so that the client can obtain the latest touch event from the touch event queue.

As an implementation manner, in the embodiment of the present disclosure, corresponding input threads are respectively set for more than one process in the client, and each input thread detects a touch event of its corresponding process. That is, an input thread is set for each client to detect the touch event of the client and add it to a corresponding touch event queue.

Alternatively, only a set number of input threads are set in the operating system, the client detects the current display window, assigns at least one of the set number of input threads to the current display window, and Touch events are detected by the assigned input thread. The number of settings here can be 3, 4, 5, 6, 7, 8, or 9, etc., that is, set a shared input thread for the current display window to dynamically call the corresponding client after the current display window is determined. The input thread detects touch events.

Step 102: Based on the judgment result that the updated rendering request is the same as the previous updated rendering request, the client obtains the touch event received by its own input thread, and judges that the touch event in the updated rendering request is consistent with the touch event received by the input thread. Is the latest touch event the same.

In the embodiment of the present disclosure, in order to avoid that the screen pattern refreshing is out of sync due to the failure of the synthesizer to respond to the touch event in time, thus causing the screen pattern of the display screen to shake. When the compositor detects that the local touch event queue is empty, it still sends an update rendering request to the client, so that the client can update and render the pattern based on the touch event detected by itself.

After the client receives the update rendering request sent by the compositor, it judges whether the touch event in the update rendering request is the same as the latest touch event received by the local input thread, so as to determine whether the compositor has discarded the touch event, so that when the compositor discards When a touch event is received, the screen pattern is refreshed and rendered with the latest touch position in the touch event received by the local receiving thread to ensure that the display pattern does not shake and improve the display quality of the display.

Step 103, based on the judgment result that the touch event in the update rendering request is the same as the latest touch event received by the input thread, determine not to respond to the update rendering request.

In the embodiment of the present disclosure, if it is determined that the touch event in the currently received update rendering request is the same as the latest touch event in the client's touch event queue, it means that the compositor can respond to the touch event in time, and no compositor failure occurs. When the thread is blocked and the touch event is discarded, at this time, the client refreshes and renders the screen pattern based on the touch position of the touch event in the update rendering request to ensure normal screen pattern refresh.

Step 104: Based on the judging result that the touch event in the update rendering request is different from the latest touch event received by the input thread, update and render the corresponding scene graph according to the latest touch event received by the input thread, and send to the composite The renderer outputs the rendered scene graph.

In the embodiment of the present disclosure, if it is determined that the touch event in the currently received update rendering request is different from the latest touch event in the client's touch event queue, it may mean that the compositor failed to respond to the touch event in time, and the compositor side A touch event is discarded due to thread blocking. At this time, in order to confirm whether the touch event is discarded on the compositor side, the compositor continues to send an update rendering request to the client, triggering the client to receive based on the local receiving thread. Refresh the screen pattern according to the received touch event to ensure that the display pattern can still be updated with the latest touch event, avoiding the jitter of the display pattern caused by the blockage of the thread on the synthesizer side.

In the embodiment of the present disclosure, by setting an input thread (libinput) for the client to detect the touch event (touch), the client can detect the touch event independently of the compositor, and store the acquired touch event in Local touch event queue. For the compositor side, after the trigger cycle arrives, if no new touch event is detected, an update rendering request is generated with the old touch event and continues to be sent to the client; when the client receives the old touch event After the updated rendering request, the client searches for the latest touch event in the local touch event, updates the corresponding scene graph with the touch position in the latest touch event and renders it, and outputs the rendered scene graph to the compositor . In the embodiments of the present disclosure, by setting a thread for receiving touch events on the client side, even if a compositor (compositor) does not process the touch events in time, it will not cause the shaking of the screen pattern. The embodiment of the present disclosure ensures the continuity of screen pattern update, greatly improves the display effect of the display screen, and improves user experience.

FIG. 2 is a schematic flowchart of a method for suppressing display jitter in an embodiment of the present disclosure. The method for suppressing display jitter in an embodiment of the present disclosure can be executed by a synthesizer. As shown in FIG. 2 , the method for suppressing display jitter in an embodiment of the present disclosure includes The following processing steps:

Step 201, when the trigger period arrives, the synthesizer detects its own touch event queue.

In the embodiment of the present disclosure, when the trigger period arrives, the compositor detects whether a corresponding touch event is received in its own touch event queue, and if it is determined that a touch event is received, generates a corresponding update rendering request based on the touch event, The update rendering request is sent to the client, so that the client performs update rendering of the screen image based on the touch event in the update rendering request.

Step 202, when the touch event queue is empty, a touch event in a previous trigger cycle generates an update rendering request, and sends the generated update rendering request to the client.

In the embodiment of the present disclosure, in order to avoid that the screen pattern refreshing is out of sync due to the failure of the synthesizer to respond to the touch event in time, thus causing the screen pattern of the display screen to shake. When the compositor detects that the local touch event queue is empty, it still sends an update rendering request to the client, so that the client can update and render the pattern based on the touch event detected by itself. When the touch event queue is empty, the touch event in the last trigger cycle is used to generate an update rendering request, that is, the update rendering request sent currently carries the same content as the update rendering request sent in the last trigger cycle. This situation of repeatedly sending update rendering requests for the same content means that no new touch events are detected on the compositor side, as a reminder to the client, and the client determines whether it has not detected new touch events. If the client does not detect a new touch event, it means that the user has stopped related operations on the display window; if the client does not detect a new touch event, it means that the compositor side causes thread delay Processing. At this time, the user has relevant operations but the synthesizer does not detect the touch event. At this time, the client needs to actively update and render the screen image based on the latest touch event in its own touch event queue to avoid display jitter.

In the embodiment of the present disclosure, when the trigger period arrives and the compositor detects that its own touch event queue is still empty, it continues to send the previously generated update rendering request to the client, and when the number of sending times reaches the set threshold or when a new touch event is detected, stops sending of previously generated update rendering requests.

In one embodiment, when the user stops the relevant operations on the display window, in order to prevent the compositor from continuously sending update rendering requests to the client, resulting in unnecessary occupation of processing resources and unnecessary consumption of electric energy of electronic devices, When the compositor detects that the touch event queue continues to be empty and the number of times the update rendering request is continuously sent reaches the set threshold, it actively stops sending the same update rendering request continuously. The set threshold here can be 5 times, 10 times, 15 times, 20 times, etc., and can be dynamically set according to the processing resources and power consumption of the operating system. When the compositor detects that the touch event queue remains empty and continues to send update rendering requests, and the compositor detects new touch events, it generates a new update rendering request and sends it to the client, ending the continuous sending of the same update rendering request Mechanisms.

In the embodiment of the present disclosure, when the synthesizer detects that there are more than two touch events, the update rendering request is generated with the touch event whose time is closest to the current moment. In the case that the synthesizer cannot detect the touch event in time due to thread blocking, it will inevitably lead to the blockage of the touch event and receive more than two touch events at a certain moment. At this time, for the touch event with an earlier time stamp As far as it is concerned, it is already the user's previous operation, and it does not need to be processed accordingly, it can be discarded directly, and only the latest received touch event triggers the client to update the image.

The embodiments of the present disclosure will be described in detail below with reference to examples.

In the embodiment of the present disclosure, the window manager Kwin architecture is used as an example to illustrate the window image. Kwin is generally written based on QT. Although the touch event reception in Kwin is completed in a separate thread, the touch event is sent to the client. , needs to go through the QT event loop, that is, the touch event needs to be sent to the client on the main thread. For example, if the refresh rate is 60 frames, the interval between each vsync is 16ms. In the case of each vsync update, the current Whether the touch queue is updated, under normal circumstances, the sampling rate of touch will be higher than the frequency of vsync. If there is no blocking, each vsync will receive at least one touch event, and if the main thread is slightly blocked, it will cause a certain vsync If the touch is not updated within the cycle, there will be a situation where the client end draws less and causes frame loss; in the actual display image, the user triggers the touch behavior, but the application window does not show the corresponding response.

The window manager examines the corresponding Scenegraph to determine which display windows should receive touch events. Among them, Scenegraph refers to the display content on the screen. After receiving the touch event, the client starts to update the rendering interface. After the rendering is completed, the composition request is sent to the compositor through the wayland socket. The compositor performs image synthesis and displays it on the screen at an appropriate time. Makes the user observe that the screen pattern is being refreshed. However, in general, the wayland compositor has other tasks to process besides receiving kernel events, which may cause thread blocking at certain times, so that kernel events cannot be responded in time, resulting in frame loss.

FIG. 3 is a schematic diagram of an implementation framework for suppressing display jitter in an embodiment of the present disclosure. As shown in FIG. 3 , in order to avoid the above problems, a receiving thread (touchThread or inputThread) is opened at the client end to receive touch events, that is, the client end also has a touch event. The ability to receive events. The client side receives the user's touch behavior from the wayland compositor and its own libinput. In the embodiment of the present disclosure, although the touch event is used as an example for description, the embodiment of the present disclosure is still suitable for other events, such as input events such as mouse and stylus, that is, input events such as mouse and stylus can also be implemented as the present disclosure Example touch event.

The touch event received from the wayland compositor end, according to the timestamp carried by the touch event, discards the expired touch event in the touch event queue, and when the main thread of the wayland compositor completes the previous frame each time, if there is no new touch event Update, the touch event of the previous frame is sent to the client again. At this time, the client side will receive a touch event that is repeated from the previous frame. The client side compares its own touch event queue. If there is no updated touch event, it believes that the user no longer has touch behavior. If there is an updated touch event In the case of an event, the touch event received by the client at this time is a touch event that needs to be updated, but for some reason, the wayland compositor failed to inform the client of the updated touch event. The data of the touch event received by the compositor is replaced with the latest touch event received by the client itself, and the updated rendering of a new frame is completed, thus solving the problem of frame loss caused by a touch event on the wayland compositor, and still ensuring the normal operation of the client The updated rendering of the display image avoids display jitter.

In the embodiment of the present disclosure, when the time stamp of the touch event obtained by the wayland client from its own libinput is the same as the time stamp of the touch event sent by the wayland compositor of the server, the touch event sent by the wayland compositor of the server is discarded. At this time, it means that the wayland compositor can detect the touch event in time, and no frame loss occurs. When the timestamp of the latest touch event obtained by the wayland client from its own libinput is different from the timestamp of the touch event sent by the server's wayland compositor, the latest touch event received by the wayland client replaces the touch event sent by the wayland compositor. Performs an updated rendering of the displayed image.

Through the framework structure for suppressing display jitter shown in Figure 3, it is possible to avoid the refresh jitter of the display image caused by the frame loss of the wayland compositor, and improve the display effect.

The embodiment of the present disclosure does not need to modify the third-party program, but only needs to add the corresponding transmission protocol in the corresponding file library at the operating system level. When the third-party application calls the bottom file layer library, the corresponding suppression can be realized. Display dithering function.

FIG. 4 is a schematic diagram of signaling for suppressing display jitter in an embodiment of the present disclosure. As shown in FIG. 4 , in the embodiment of the present disclosure, the working mechanism of the Kwin architecture is modified. On the wayland compositor side, through Connection::processEvents Add the corresponding code logic, after judging eventQueue.isEmpty, re-emit the touch event received in the previous trigger cycle to the wayland client, so as to avoid the display image not being refreshed in time due to frame loss. On the wayland client side, it is necessary to create an input thread for the process corresponding to each client, and maintain a position queue (position information corresponding to the touch event).

The wayland compositor terminal and client terminal receive the user's operation on the display window through their own libinput, and detect the corresponding touch event. Among them, when the trigger cycle (display frame update cycle) arrives at the wayland compositor side, it is judged whether the touch event queue is empty, and based on the judgment result that the touch event queue is empty, the previous trigger cycle can be sent to the client. touch event, and when the wayland compositor main thread completes the previous frame each time, if there is no new touch event update, the previous frame touch event will be sent to the client again.

At this time, the client side will receive a touch event that is repeated from the previous frame. The client side compares its own touch event queue. If there is no updated touch event, it believes that the user no longer has touch behavior. If there is an updated touch event In the event of an event, that is, the position of the touch event changes, the touch event received by the client needs to be updated at this time, and the wayland compositor failed to notify the client of the updated touch event. At this time, the client needs to be based on its own Received the latest touch event to complete the updated rendering of a new frame.

In one embodiment, after the wayland client receives PositionChanged, it will trigger Compositor::triggerRender to call QWaylandWindow::requestUpdate. In the case of requestUpdate execution, compare the position information in the touch event, based on the updated comparison result of the position, complete the updated rendering of a new frame with the updated position, based on the comparison result of the unupdated position in the touch event, from the wayland client Get the latest position from the position queue at the end, and complete the updated rendering of a new frame with the latest position.

The embodiment of the present disclosure solves the problem of frame loss caused by a touch event at the wayland compositor end, and can still ensure that the client end performs normal update and rendering of the display image, avoiding the phenomenon of display jitter.

FIG. 5 is a schematic diagram of the composition and structure of the device for suppressing display jitter in the embodiment of the present disclosure. The device for suppressing display jitter in the embodiment of the present disclosure can be a client. As shown in FIG. 5 , the device for suppressing display jitter in the embodiment of the present disclosure includes :

The first judging unit 50 is configured to, in response to the updated rendering request from the compositor, judge whether the updated rendering request is the same as the previous updated rendering request;

The acquisition unit 51 is configured to trigger the client to acquire the touch event received by its own input thread based on the judgment result that the updated rendering request is the same as the previous updated rendering request;

The second judging unit 52 is configured to judge whether the touch event in the update rendering request is the same as the latest touch event received by the input thread, based on the touch event in the update rendering request and the latest touch event received by the input thread Triggering the first processing unit if the touch event is the same; triggering the second processing unit based on the judgment result that the touch event in the update rendering request is different from the latest touch event received by the input thread;

The first processing unit 53 is configured to determine not to respond to the update rendering request;

The second processing unit 54 is configured to update and render the corresponding scene graph based on the latest touch event received by the input thread, and output the rendered scene graph to the compositor.

In one embodiment, based on the device for suppressing display jitter shown in FIG. 5 , the device for suppressing display jitter of the embodiment of the present disclosure, as shown in FIG. 6 , further includes:

The adding unit 55 is configured to set a time stamp for the touch event after the input thread detects the touch event driven by the input, and add the touch event with the time stamp to the touch event queue.

The first setting unit 56 is configured to respectively set corresponding input threads for more than one process in the client, and each input thread detects a touch event of its corresponding process.

The second setting unit 57 is configured to set a set number of input threads;

The assignment unit 58 is configured to trigger the client to detect the current display window, assign at least one of the set number of input threads to the current display window, and use the assigned input thread Detect touch events.

In one embodiment, the second processing unit 54 is further configured to:

Based on the judgment result that the updated rendering request is different from the previous updated rendering request, the touch event in the updated rendering request is used to perform updated rendering of the corresponding scene graph, and the touch events in the touch event queue are ignored.

In an exemplary embodiment, the first judging unit 50, the acquiring unit 51, the second judging unit 52, the first processing unit 53, the second processing unit 54, the adding unit 55, the first setting unit 56, the second setting unit 57 And distribution unit 58 etc. can be used by one or more central processing unit (Central Processing Unit, CPU), application specific integrated circuit (Application Specific Integrated Circuit, ASIC), digital signal processor (Digital Signal Processor, DSP), programmable logic device (Programmable Logic Device, PLD), complex programmable logic device (Complex Programmable Logic Device, CPLD), field-programmable gate array (Field-Programmable Gate Array, FPGA), general-purpose processor, controller, microcontroller (Micro ControllerUnit , MCU), microprocessor (Microprocessor), or other electronic components to implement the steps of the method for suppressing display jitter in the foregoing embodiments.

In the embodiment of the present disclosure, the operation manner of each unit in the apparatus for suppressing display jitter shown in FIG. 5 has been described in detail in the embodiment of the method, and will not be described in detail here.

The device for suppressing display jitter shown in FIG. 5 is applicable to the client side in the display framework of the wayland protocol.

FIG. 7 is a schematic diagram of the composition and structure of the device for suppressing display jitter in the embodiment of the present disclosure. The device for suppressing display jitter in the embodiment of the present disclosure may be a synthesizer. As shown in FIG. 7 , the device for suppressing display jitter in the embodiment of the present disclosure includes :

The detection unit 60 is configured to detect whether the touch event queue is empty when the trigger period arrives, and trigger the generation unit based on the detection result that the touch event queue is empty;

The generating unit 61 is configured to generate an update rendering request for a touch event in a previous trigger cycle;

The sending unit 62 is configured to send the update rendering request to the client.

In one embodiment, after the sending unit 62 sends the update rendering request to the client, the detection unit 60 is further configured to detect that the touch event queue is still empty when the trigger period arrives Next, the sending unit 62 continues to send the previously generated update rendering request to the client; when the number of sending times reaches the set threshold or a new touch event is detected, the sending of the previously generated update rendering request is stopped .

In one embodiment, the generating unit 61 is further configured to:

When the detection unit 60 detects that there are more than two touch events, the update rendering request is generated with the touch event whose time is closest to the current moment.

In an exemplary embodiment, the detecting unit 60, the generating unit 61 and the sending unit 62 etc. may be controlled by one or more CPUs, ASICs, DSPs, PLDs, CPLDs, FPGAs, general purpose processors, controllers, MCUs, microprocessors, or other electronic components for implementing the steps of the method for suppressing display jitter in the foregoing embodiments.

In the embodiment of the present disclosure, the operation manner of each unit in the apparatus for suppressing display jitter shown in FIG. 7 has been described in detail in the embodiment of the method, and will not be described in detail here.

The device for suppressing display jitter shown in FIG. 7 is applicable to the synthesizer side in the display frame of the wayland protocol.

Next, an electronic device 11 according to an embodiment of the present disclosure is described with reference to FIG. 8 .

As shown in FIG. 8 , the electronic device 11 includes one or more processors 111 and a memory 112 .

The processor 111 may be a central processing unit (CPU), or other forms of processing units having at least one of data processing capabilities and instruction execution capabilities, and may control other components in the electronic device 11 to perform desired functions. .

Memory 112 may include one or more computer program products, which may include various forms of computer-readable storage media, such as volatile memory and non-volatile memory. The volatile memory may include random access memory (RAM), cache memory (cache), and the like. The non-volatile memory may include read only memory (ROM), hard disk, flash memory, and the like. One or more computer program instructions may be stored on the computer-readable storage medium, and the processor 111 may execute the program instructions to implement the methods for suppressing display jitter and the above-mentioned multiple embodiments of the present disclosure. other desired features. Various contents such as input signal, signal component, noise component, etc. may also be stored in the computer-readable storage medium.

In an example, the electronic device 11 may further include: an input device 113 and an output device 114, and these components may be interconnected through a bus system and other forms of connection mechanisms.

The input device 113 may include, for example, a keyboard, a mouse, and the like.

The output device 114 can output a variety of information to the outside, including the determined distance information, direction information, and the like. The output device 114 may include, for example, a display, a speaker, a printer, and a communication network and its connected remote output devices, and the like.

For simplicity, only some of the components related to the present disclosure in the electronic device 11 are shown in FIG. 8 , and components such as a bus, an input/output interface, etc. are omitted. In addition, according to actual application conditions, the electronic device 11 may also include any other appropriate components.

The embodiments of the present disclosure also describe a storage medium on which an executable program is stored, and the executable program is executed by a processor to perform the steps of the method for suppressing display jitter in the foregoing embodiments.

In addition to the above-mentioned methods and devices, embodiments of the present disclosure may also be computer program products, which include computer program instructions that, when executed by a processor, cause the processor to perform the above-mentioned "exemplary method" of this specification. The steps in the methods according to the embodiments of the present disclosure are described in the section.

The computer program product can be written in any combination of one or more programming languages to execute the program codes for performing the operations of the embodiments of the present disclosure, and the programming languages include object-oriented programming languages, such as Java, C++, etc. , also includes conventional procedural programming languages, such as the "C" language or similar programming languages. The program code may execute entirely on the user's computing device, partly on the user's device, as a stand-alone software package, partly on the user's computing device and partly on a remote computing device, or entirely on the remote computing device or server to execute.

In addition, the embodiments of the present disclosure may also be a computer-readable storage medium, on which computer program instructions are stored, and the computer program instructions, when executed by a processor, cause the processor to execute the above-mentioned "Exemplary Method" section of this specification. The steps in the method according to the embodiments of the present disclosure described in .

The computer readable storage medium may employ any combination of one or more readable media. The readable medium may be a readable signal medium or a readable storage medium. A readable storage medium may include, for example, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device, or device, or any combination thereof. Readable storage media may include: an electrical connection with one or more conductors, a portable disk, a hard disk, random access memory (RAM), read only memory (ROM), erasable programmable read only memory (EPROM or flash memory) , optical fiber, portable compact disc read only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination of the foregoing.

The basic principles of the present disclosure have been described above in conjunction with the embodiments. However, it should be pointed out that the advantages, advantages, effects, etc. mentioned in the present disclosure are only examples, and these advantages, advantages, effects, etc. cannot be considered as the multiple aspects of the present disclosure. An embodiment must have.

Claims

A method for suppressing display jitter, comprising:

In response to the updated rendering request from the compositor, the client determines whether the updated rendering request is the same as the previous updated rendering request;

Based on the judgment result that the updated rendering request is the same as the previous updated rendering request, the client acquires the touch event received by its own input thread;

judging whether the touch event in the update rendering request is the same as the latest touch event received by the input thread;

Based on the judgment result that the touch event in the update rendering request is the same as the latest touch event received by the input thread, it is determined not to respond to the update rendering request, and based on the touch event in the update rendering request and the latest touch event received by the input thread According to the latest touch event received by the input thread, update and render the corresponding scene graph according to the latest touch event received by the input thread, and output the rendered scene graph to the compositor.
The method according to claim 1, further comprising:

The input thread detects an input-driven touch event, sets a time stamp for the touch event, and adds the touch event with the time stamp to the touch event queue.
The method according to claim 1, further comprising:

Corresponding input threads are respectively set for more than one process in the client, and each input thread detects a touch event of its corresponding process.
The method according to claim 1, further comprising:

Setting a set number of input threads, the client detects the current display window, assigns at least one of the set number of input threads to the current display window, and the assigned The input thread detects touch events.
The method of claim 2, further comprising:

Based on the judgment result that the updated rendering request is different from the previous updated rendering request, the client uses the touch event in the updated rendering request to perform updated rendering of the corresponding scene graph, and ignores the touch events in the touch event queue.
A method for suppressing display jitter, comprising:

When the trigger cycle arrives, the synthesizer detects its own touch event queue;

When the touch event queue is empty, an update rendering request is generated by a touch event in a previous trigger cycle, and the generated update rendering request is sent to the client.
According to the method according to claim 6, after the generated update rendering request is sent to the client, the method further includes:

When the trigger period arrives and the compositor detects that its own touch event queue is still empty, it continues to send the previously generated update rendering request to the client. When the number of sending times reaches the set threshold or a new touch is detected In the case of an event, the sending of update rendering requests generated before is stopped.
The method according to claim 6 or 7, further comprising:

When the compositor detects that there are more than two touch events, it uses the touch event whose time is closest to the current moment to generate an update rendering request.
A device for suppressing display jitter, comprising:

The first judging unit is configured to, in response to an updated rendering request from the compositor, judge whether the updated rendering request is the same as the previous updated rendering request;

The acquisition unit is configured to trigger the client to acquire the touch event received by its own input thread based on the judgment result that the updated rendering request is the same as the previous updated rendering request;

The second judging unit is configured to judge whether the touch event in the update rendering request is the same as the latest touch event received by the input thread, based on the touch event in the update rendering request and the latest touch event received by the input thread Triggering the first processing unit if the event is the same; triggering the second processing unit based on the judgment result that the touch event in the update rendering request is different from the latest touch event received by the input thread;

a first processing unit configured to determine not to respond to the update rendering request;

The second processing unit is configured to update and render the corresponding scene graph based on the latest touch event received by the input thread, and output the rendered scene graph to the compositor.
The apparatus of claim 9, further comprising:

The adding unit is configured to set a time stamp for the touch event after the input thread detects the touch event driven by the input, and add the touch event with the time stamp to the touch event queue.
The apparatus of claim 9, further comprising:

The first setting unit is configured to respectively set corresponding input threads for more than one process in the client, and each input thread detects a touch event of its corresponding process.
The apparatus of claim 9, further comprising:

a second setting unit configured to set a set number of said input threads;

An allocation unit configured to trigger the client to detect the current display window, allocate at least one of the set number of input threads to the current display window, and assign the input thread to the current display window. Touch events are detected.
The device according to claim 10, wherein the second processing unit is further configured to:

Based on the judgment result that the updated rendering request is different from the previous updated rendering request, the touch event in the updated rendering request is used to perform updated rendering of the corresponding scene graph, and the touch events in the touch event queue are ignored.
A device for suppressing display jitter, comprising:

The detection unit is configured to detect whether the touch event queue is empty when the trigger period arrives, and trigger the generation unit based on the detection result that the touch event queue is empty;

a generating unit configured to generate an update rendering request for a touch event in a previous trigger cycle;

A sending unit configured to send the update rendering request to the client.
The device according to claim 14, wherein after the sending unit sends the update rendering request to the client, the detection unit is further configured to detect that the touch event queue is still If it is empty, the sending unit continues to send the previously generated update rendering request to the client; when the number of sending times reaches a set threshold or a new touch event is detected, the previously generated update rendering request is stopped sent.
The device according to claim 14 or 15, wherein the generating unit is further configured to:

When the detection unit detects that there are more than two touch events, the update rendering request is generated with the touch event whose time is closest to the current moment.
An electronic device, comprising a processor, a memory, and an executable program stored on the memory and capable of being run by the processor, when the processor runs the executable program, it executes the process described in any one of claims 1 to 8 Steps in the method for suppressing display jitter described above.
A storage medium, on which an executable program is stored, and when the executable program is executed by a processor, the steps of the method for suppressing display jitter according to any one of claims 1 to 8 are implemented.