WO2023245494A1

WO2023245494A1 - Method and apparatus for acquiring texture data from rendering engine, and electronic device

Info

Publication number: WO2023245494A1
Application number: PCT/CN2022/100445
Authority: WO
Inventors: 张峰; 陈帅雷; 刘宁
Original assignee: 云智联网络科技(北京)有限公司
Priority date: 2022-06-22
Filing date: 2022-06-22
Publication date: 2023-12-28

Abstract

Provided in the present application are a method and apparatus for acquiring texture data from a rendering engine, and an electronic device and a computer program. The method for acquiring texture data from a rendering engine is applied to a livestreaming terminal. The livestreaming terminal comprises a first OpenGL thread and a second OpenGL thread, wherein the first OpenGL thread is an OpenGL thread of a rendering engine. The method comprises: monitoring, in a first OpenGL thread, whether the initialization of a rendering engine is completed; in response to the initialization of the rendering engine being completed, acquiring a texture ID from the first OpenGL thread; and from a second OpenGL thread, acquiring the texture ID by using a callback function. According to some embodiments, the problem of it being impossible to acquire a texture ID when a rendering engine executes rendering by using an OpenGL thread is solved, such that a livestreaming terminal can play rendered data of the rendering engine by means of a video.

Description

Method, device and electronic device for obtaining texture data from rendering engine

Technical field

The present application relates to the field of virtual live broadcast, specifically, to a method and device, electronic equipment and computer program for obtaining texture data from a rendering engine.

Background technique

During the virtual live broadcast process, when the anchor terminal uses a rendering engine to render, it often requires a large amount of memory and GPU computing. This consumption of memory and GPU computing will cause Android terminals with lower configurations (for example, terminals with an Android operating system version lower than 8.0 or a terminal with less than 2G of memory) to become severely overheated, and even cause the live broadcast to freeze or crash.

Currently, the rendered data of the rendering engine is converted into a video stream through the anchor terminal (that is, a video stream is pushed on the anchor end), so that terminals with lower configurations (for example, terminals with Android operating system versions lower than 8.0) can use playback Video streaming can achieve better playback effects.

The inventor found that when the rendering engine uses the OpenGL thread to perform rendering, there is no application interface for providing texture data to the outside. Therefore, it is impossible to convert the data of the rendering engine into a video stream on some platforms (such as the Android platform).

Contents of the invention

This application provides a method and device, electronic equipment and computer program for obtaining texture data from a rendering engine.

According to one aspect of the present application, a method for obtaining texture data from a rendering engine is proposed. The method is applied to a host terminal. The host terminal includes a first OpenGL thread and a second OpenGL thread, and the first OpenGL thread is the The OpenGL thread of the rendering engine, the method includes monitoring whether the initialization of the rendering engine is completed in the first OpenGL thread; in response to the completion of the initialization of the rendering engine, obtaining the texture ID in the first OpenGL thread; In the second OpenGL thread, a callback function is used to obtain the texture ID.

According to some embodiments, obtaining the texture ID in the first OpenGL thread further includes obtaining, in the first OpenGL thread, attribute data of the image data corresponding to the texture ID.

According to some embodiments, the attribute data includes the width and height of the image data.

According to some embodiments, the method further includes obtaining a first drawing context in the first OpenGL thread in response to completion of initialization of the rendering engine.

According to some embodiments, after obtaining the drawing context in the first OpenGL thread, the method further includes obtaining the drawing context of the first OpenGL thread in a second OpenGL thread.

According to some embodiments, after obtaining the first OpenGL thread drawing context in the second OpenGL thread, the method further includes using the first OpenGL thread drawing context to create a second OpenGL thread in the second OpenGL thread. The drawing context.

According to some embodiments, in the second OpenGL thread, the texture ID, the drawing context of the second OpenGL thread, and the attribute data of the image data are sent to the streaming unit.

According to some embodiments, the method is applied to Android systems.

According to one aspect of the present application, a device for obtaining texture data from a rendering engine is proposed. The device is applied to a host terminal. The host terminal includes a first OpenGL thread and a second OpenGL thread, and the first OpenGL thread is the The OpenGL thread of the rendering engine, the device includes a monitoring unit for monitoring whether the initialization of the rendering engine is completed in the first OpenGL thread; a texture ID acquisition unit for responding to the completion of the initialization of the rendering engine. Obtain the texture ID in the first OpenGL thread; a callback unit is used to obtain the texture ID in the second OpenGL thread using a callback function.

According to one aspect of the present application, an electronic device is proposed, including one or more processing units; a storage unit for storing one or more programs; when the one or more programs are processed by the one or more processing units Execution causes one or more processing units to implement the method as described in any of the previous embodiments.

According to one aspect of the present application, a computer program is proposed, including a computer program or an instruction. When the computer program or the instruction is executed by a processor, the method as described above is implemented.

According to example embodiments of the present application, by obtaining the texture ID in the OpenGL thread of the rendering engine, and using the callback function to send the texture ID in the OpenGL thread of the rendering engine to another OpenGL thread, the problem that the rendering engine is executing using the OpenGL thread is solved. When rendering, the problem of being unable to obtain the texture ID allows the anchor terminal to play the rendered data of the rendering engine in the form of a video.

Description of the drawings

In order to explain the technical solutions in the embodiments of the present application more clearly, the drawings needed to be used in the description of the embodiments will be briefly introduced below.

FIG. 1 shows a flowchart 1000 of a method for obtaining texture data from a rendering engine according to an example embodiment of the present application.

FIG. 2 shows a flowchart 2000 of yet another method of obtaining texture data from a rendering engine according to an example embodiment of the present application.

Figure 3 shows a block diagram of a device for obtaining texture data from a rendering engine according to an example embodiment of the present application.

FIG. 4 shows an electronic device according to an example embodiment of the present application.

Detailed ways

Example embodiments will now be described more fully with reference to the accompanying drawings. Example embodiments may, however, be embodied in various forms and should not be construed as limited to the embodiments set forth herein; rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the concepts of the example embodiments. To those skilled in the art. The same reference numerals in the drawings represent the same or similar parts, and thus their repeated description will be omitted.

The described features, structures or characteristics may be combined in any suitable manner in one or more embodiments. In the following description, numerous specific details are provided to provide a thorough understanding of embodiments of the present disclosure. However, those skilled in the art will appreciate that the technical solutions of the present disclosure may be practiced without one or more of these specific details, or other manners, components, materials, devices, operations, etc. may be employed. In these cases, well-known structures, methods, devices, implementations, materials or operations will not be shown or described in detail.

The flowcharts shown in the drawings are only illustrative, and do not necessarily include all contents and operations/steps, nor must they be performed in the order described. For example, some operations/steps can be decomposed, and some operations/steps can be merged or partially merged, so the actual order of execution may change according to the actual situation.

The terms "first", "second", etc. in the description and claims of this application and the above-mentioned drawings are used to distinguish different objects, rather than describing a specific sequence. Furthermore, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusion. For example, a process, method, system, product or device that includes a series of steps or units is not limited to the listed steps or units, but optionally also includes steps or units that are not listed, or optionally also includes Other steps or units inherent to such processes, methods, products or devices.

The rendering engine is a game development engine that can be used to create real-time, visual 2D and 3D animations, games and other content. It is widely used in game development, virtual simulation, animation, education, architecture, movies and other industries.

OpenGL (Open Graphics Library, referred to as Open Graphics Programming Interface), includes some functions for operating graphics and images, and standardizes the application programming interface for rendering 2D and 3D vector images.

When the rendering engine uses OpenGL to perform rendering, it needs to use a drawing context, also called a state machine, to record the information and status required for OpenGL rendering. For example, the information that needs to be recorded includes the color currently used for drawing, whether there is lighting calculation, and the light source that is turned on.

A set of OpenGL state machines corresponds to a drawing context. If two windows correspond to two different drawing contexts, the two windows are in independent states and the drawing states will not affect each other. OpenGL is a single-threaded working mode, and the drawing context of each OpenGL thread is a private variable of the OpenGL thread. The drawing commands of each OpenGL thread can only act on its drawing context and cannot access the texture resources of other OpenGL threads.

According to example embodiments of the present application, by obtaining the texture ID in the OpenGL thread of the rendering engine, and using the callback function to send the texture ID in the OpenGL thread of the rendering engine to another OpenGL thread, the problem that the rendering engine is executing using the OpenGL thread is solved. During rendering, the problem of being unable to obtain the texture ID allows the anchor terminal to play the rendered data of the rendering engine in the form of video.

FIG. 1 shows a flowchart 1000 of a method for obtaining rendering data from a rendering engine according to an example embodiment of the present application.

A method of obtaining rendering data from a rendering engine according to an exemplary embodiment of the present application will be described in detail below based on FIG. 1 .

OpenGL is a single-threaded working mode. The texture data of each OpenGL thread is a private variable of the OpenGL thread, and the texture resources of other OpenGL threads cannot be accessed. The embodiment shown in Figure 1 is used to obtain the OpenGL thread of the rendering engine in the second OpenGL thread when the anchor terminal performs virtual live broadcast, that is, the rendering data in the first OpenGL thread, so that the anchor terminal can obtain the rendering data in the second OpenGL thread. Send the obtained rendering data to the streaming unit. In order to obtain the texture data in the first OpenGL thread of the rendering engine, according to an embodiment of the present application, the second OpenGL thread is started in the anchor terminal, and the texture ID obtained in the first OpenGL thread is called back to The second OpenGL thread implements texture ID sharing.

As shown in Figure 1, in step S101, the anchor terminal monitors whether the rendering engine initialization is completed in the first OpenGL thread.

For example, in step S101, the anchor terminal obtains the first OpenGL thread of the rendering engine. After the anchor terminal obtains the first OpenGL thread of the rendering engine, it uses the listening function in the first OpenGL thread of the rendering engine to monitor whether the initialization of the rendering engine is completed.

In step S103, in response to completion of initialization of the rendering engine, the texture ID is obtained in the first OpenGL thread.

According to an embodiment of the present application, the texture ID is obtained using the drawing context. For example, obtain the drawing context in the first OpenGL thread, and use the drawing context to call the interface provided by the rendering engine to obtain the texture ID.

In step S105, in the second OpenGL thread, a callback function is used to obtain the texture ID.

As mentioned before, OpenGL is a single-threaded working mode, and the drawing context of each OpenGL thread is a private variable of the OpenGL thread. The drawing commands of each OpenGL thread can only act on its drawing context and cannot access the texture resources of other OpenGL threads. In order to use the OpenGL thread of the rendering engine, that is, the texture ID in the first OpenGL thread, in step S105, in the second OpenGL thread, use the callback function to obtain the texture ID in the first OpenGL thread, thereby realizing the texture ID in different OpenGL threads. Data sharing of texture IDs.

As an option, according to example embodiments of the present application, the method shown in Figure 1 can be applied to the Android system.

According to the embodiment shown in Figure 1, by obtaining the texture ID in the OpenGL thread of the rendering engine, and using the callback function to send the texture ID in the OpenGL thread of the rendering engine to another OpenGL thread, the problem that the rendering engine uses the OpenGL thread is solved. When performing rendering, the problem of being unable to obtain the texture ID allows the anchor terminal to play the rendered data of the rendering engine in a virtual live broadcast.

FIG. 2 shows a flowchart 2000 of yet another method of obtaining rendering data from a rendering engine according to an example embodiment of the present application.

As mentioned before, OpenGL operates in a single-threaded mode. The texture data of each OpenGL thread is a private variable of the OpenGL thread, and the texture resources of other OpenGL threads cannot be accessed.

In order to obtain the texture data in the first OpenGL thread of the rendering engine, in the embodiment shown in Figure 2, the second OpenGL thread is started in the anchor terminal, and by executing steps S201 to S211, not only the textures of the two OpenGL threads are realized Data is shared, and the rendered data of the rendering engine is converted into a video stream through the anchor terminal, so that terminals with lower configurations can realize virtual live broadcast by playing the video stream.

As shown in Figure 2, in step S201, the anchor terminal monitors whether the rendering engine initialization is completed in the first OpenGL thread.

For example, in step S201, the anchor terminal obtains the first OpenGL thread of the rendering engine. After the anchor terminal obtains the first OpenGL thread of the rendering engine, it uses the listening function in the first OpenGL thread of the rendering engine to monitor whether the initialization of the rendering engine is completed.

In step S203, after the rendering engine initialization is completed, the texture ID, attribute data of the image data, and drawing context are obtained in the first OpenGL thread.

Texture is often used to describe the details of a picture. According to the embodiment of the present application, the texture ID is a pointer to the graphics data that needs to be rendered, and the texture ID is obtained from the pixels of the graphics data.

According to some embodiments, the attribute data of the image data obtained in step S203 is the characteristic data of the image data, for example, the width and height of the image data.

When the rendering engine uses OpenGL to perform rendering, it needs to use the drawing context to record the information and status required for OpenGL rendering. For example, the information that needs to be recorded includes the color currently used for drawing, whether there is lighting calculation, and the light source that is turned on.

Since the rendering process of the rendering engine is completed in the OpenGL thread, in step S203, the anchor terminal monitors whether the rendering engine has completed initialization in the first OpenGL thread to obtain the drawing context after the rendering engine is initialized. The drawing mechanism of OpenGL uses the OpenGL drawing context to determine the drawing results and sends the drawing results to the drawing context of the local window system. OpenGL provides an application interface for operating the GPU. OpenGL controls the running status of the graphics rendering pipeline state machine by sending relevant instructions to the GPU. EGL (Embedded Graphics Library, referred to as embedded graphics library) provides an interface for communication between OpenGL and the local window system.

Taking EGL14 as an example, when OpenGL needs to interact with the local window system, EGL14 can be used to communicate with the local window system. The main function of EGL14 is to create a drawing context for OpenGL instructions, draw the target surface, configure frame buffer properties and submit drawing results, etc.

In step S203, the anchor terminal obtains the drawing context EGLContext by calling the system function EGL14.eglGetCurrentContext() in the OpenGL thread of the rendering engine.

In step S205, in the second OpenGL thread, the callback function is used to obtain the texture ID and attribute data of the image data.

As mentioned before, OpenGL is a single-threaded working mode, and the drawing context of each OpenGL thread is a private variable of the OpenGL thread. The drawing commands of each OpenGL thread can only act on its drawing context and cannot access the texture resources of other OpenGL threads. In order to use the OpenGL thread of the rendering engine, that is, the texture ID in the first OpenGL thread, in step S105, in the second OpenGL thread, use the callback function to obtain the texture ID and attribute data of the image data in the first OpenGL thread, and implement Sharing of texture data among different OpenGL threads.

In step S207, in the second OpenGL thread, the drawing context of the first OpenGL thread is obtained.

As mentioned earlier, the drawing context records the information and status required for OpenGL rendering. Therefore, in the second OpenGL, in order to send the rendering data in the first OpenGL to the push unit in the form of a push stream, it is necessary to obtain the drawing context in the first OpenGL thread. According to some embodiments, a post of EGL14 is used to obtain the drawing context in the first OpenGL thread.

In step S209, in the second OpenGL thread, the drawing context of the second OpenGL thread is created using the drawing context of the first OpenGL thread. As mentioned before, the rendering data of different OpenGLs cannot be shared, so the drawing context in the first OpenGL thread cannot be used directly in the second OpenGL thread. Therefore, in step S209, by reading the drawing context information in the first OpenGL thread, the drawing context in the second OpenGL thread is created.

For example, in the first OpenGL thread, create an OpenGL display window of the second OpenGL thread, use the OpenGL display window to obtain the configuration information of the second OpenGL thread, and use the obtained drawing context of the first OpenGL thread and the OpenGL of the second OpenGL thread. The display window and the configuration information of the second OpenGL thread create a drawing context for the second OpenGL thread.

In step S211, in the second OpenGL thread, the texture ID, the drawing context of the second OpenGL thread, and the attribute data of the image data are sent to the streaming unit. The streaming unit of the anchor terminal sends the rendering data and rendered image data to the stream pusher.

According to some embodiments, the stream pusher includes Tencent's TRTC, Zego, Agora, etc. The streamer is used to encode image data into video and send it to the viewing end.

As an option, according to example embodiments of the present application, the method shown in Figure 2 can be applied to the Android system.

In the embodiment shown in Figure 2, not only texture data sharing between two OpenGL threads is realized, but also the rendered data of the rendering engine is converted into a video stream through the anchor terminal, so that terminals with lower configurations can normally watch the anchor terminal A video that plays the rendered data of the rendering engine in a virtual live broadcast.

Figure 3 shows a block diagram of a device for obtaining rendering data from a rendering engine according to an example embodiment of the present application.

According to an embodiment of the present application, the device shown in Figure 3 is applied to the anchor terminal. Wherein, the anchor terminal includes a first OpenGL thread and a second OpenGL thread, and the first OpenGL thread is an OpenGL thread of the rendering engine.

As shown in FIG. 3 , a device for obtaining rendering data from a rendering engine includes a listening unit 301 , a texture ID obtaining unit 303 and a callback unit 305 . Among them, the listening unit 301 is used to monitor whether the rendering engine initialization is completed in the first OpenGL thread; the texture ID acquisition unit 303 is used to respond to the completion of the rendering engine initialization and obtain the texture ID in the first OpenGL thread; the callback unit 305 uses In the second OpenGL thread, use the callback function to obtain the texture ID.

According to an embodiment of the present application, the texture ID acquisition unit 303 is also used to acquire attribute data of the image data and the drawing context of the first OpenGL thread. The callback unit 305 is also used to obtain attribute data of the image data in the first OpenG thread.

According to some embodiments, the device shown in Figure 3 further includes a drawing context unit, configured to obtain the drawing context in the first OpenGL thread, and use the obtained drawing context to create a drawing context of the second OpenGL thread.

According to some other embodiments, the device shown in Figure 3 further includes a streaming unit for sending the texture ID, the drawing context of the second OpenGL thread and the attribute data of the image data to the streamer. Among them, stream pushers include Tencent’s TRTC, Zego, and Agora. The streamer is used to encode image data into video and send it to the viewing end.

The device shown in Figure 3 is any electronic device used for the anchor terminal, such as a tablet, a mobile phone, etc.

FIG. 4 shows an electronic device according to an exemplary embodiment of the present application. The electronic device 200 according to this embodiment of the present application is described below with reference to FIG. 4 . The electronic device 200 shown in FIG. 4 is only an example and should not impose any limitations on the functions and usage scope of the embodiments of the present application.

As shown in Figure 4, electronic device 200 is embodied in the form of a general computing device. The components of the electronic device 200 may include, but are not limited to: at least one processing unit 210, at least one storage unit 220, a bus 230 connecting different system components (including the storage unit 220 and the processing unit 210), a display unit 240, and the like.

The storage unit stores program code, and the program code can be executed by the processing unit 210, so that the processing unit 210 executes the methods described in this specification according to various exemplary embodiments of the present application. For example, the processing unit 210 may perform the method as shown in FIG. 1 .

The storage unit 220 may include a readable medium in the form of a volatile storage unit, such as a random access storage unit (RAM) 2201 and/or a cache storage unit 2202, and may further include a read-only storage unit (ROM) 2203.

Storage unit 220 may also include a program/utility 2204 having a set of (at least one) program modules 2205 including, but not limited to: an operating system, one or more application programs, other program modules, and program data, Each of these examples, or some combination, may include the implementation of a network environment.

Bus 230 may be a local area representing one or more of several types of bus structures, including a memory unit bus or memory unit controller, a peripheral bus, a graphics acceleration port, a processing unit, or using any of a variety of bus structures. bus.

Electronic device 200 may also communicate with one or more external devices 300 (e.g., keyboard, pointing device, Bluetooth device, etc.), may also communicate with one or more devices that enable a user to interact with electronic device 200, and/or with Any device that enables the electronic device 200 to communicate with one or more other computing devices (eg, router, modem, etc.). This communication may occur through input/output (I/O) interface 250. Furthermore, the electronic device 200 may also communicate with one or more networks (eg, a local area network (LAN), a wide area network (WAN), and/or a public network, such as the Internet) through the network adapter 260. Network adapter 260 may communicate with other modules of electronic device 200 via bus 230. It should be understood that, although not shown in the figures, other hardware and/or software modules may be used in conjunction with electronic device 200, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives And data backup storage system, etc.

Through the above description of the embodiments, those skilled in the art can easily understand that the example embodiments described here can be implemented by software, or can be implemented by software combined with necessary hardware. The technical solution according to the embodiment of the present application can be embodied in the form of a software product. The software product can be stored in a non-volatile storage medium (which can be a CD-ROM, U disk, mobile hard disk, etc.) or on the network, including A plurality of instructions to cause a computing device (which may be a personal computer, a server, a network device, etc.) to execute the above method according to an embodiment of the present application.

A software product may take the form of one or more readable media in any combination. The readable medium may be a readable signal medium or a readable storage medium. The readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or device, or any combination thereof. More specific examples (non-exhaustive list) of readable storage media include: electrical connection with one or more conductors, portable disk, hard disk, random access memory (RAM), read only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination of the above.

A computer-readable storage medium may include a data signal propagated in baseband or as part of a carrier wave carrying the readable program code therein. Such propagated data signals may take many forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the above. A readable storage medium may also be any readable medium other than a readable storage medium that can transmit, propagate, or transport the program for use by or in connection with an instruction execution system, apparatus, or device. Program code contained on a readable storage medium may be transmitted using any appropriate medium, including but not limited to wireless, wired, optical cable, RF, etc., or any suitable combination of the above.

The program code for performing the operations of the present application can be written in any combination of one or more programming languages, including object-oriented programming languages such as Java, C++, etc., as well as conventional procedural programming. Language—such as "C" or a similar programming language. 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 execute on. In situations involving remote computing devices, the remote computing device may be connected to the user computing device through any kind of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computing device, such as provided by an Internet service. (business comes via Internet connection).

The computer-readable medium carries one or more programs. When the one or more programs are executed by a device, the computer-readable medium implements the aforementioned functions.

Those skilled in the art can understand that the above-mentioned modules can be distributed in devices according to the description of the embodiments, or can be modified accordingly in one or more devices that are only different from this embodiment. The modules of the above embodiments can be combined into one module, or further divided into multiple sub-modules.

According to an embodiment of the present application, a computer program is proposed, including a computer program or instructions. When the computer program or instructions are executed by a processor, the above-described method can be performed.

The embodiments of the present application are introduced in detail above. Specific examples are used in this article to illustrate the principles and implementation methods of the present application. The description of the above embodiments is only used to help understand the method and the core idea of the present application. At the same time, any changes or deformations made by those skilled in the art based on the ideas of the present application and the specific implementation modes and application scope of the present application shall fall within the scope of protection of the present application. In summary, the contents of this specification should not be construed as limiting this application.

Claims

A method of obtaining texture data from a rendering engine. The method is applied to a host terminal. The host terminal includes a first OpenGL thread and a second OpenGL thread, and the first OpenGL thread is the OpenGL thread of the rendering engine. Characteristically, the method includes:

Monitor whether the rendering engine initialization is completed in the first OpenGL thread;

In response to completion of initialization of the rendering engine, obtain a texture ID in the first OpenGL thread;

In the second OpenGL thread, a callback function is used to obtain the texture ID.
The method according to claim 1, wherein obtaining the texture ID in the first OpenGL thread further includes:

Obtain the attribute data of the image data corresponding to the texture ID in the first OpenGL thread.
The method of claim 2, wherein the attribute data includes width and height of the image data.
The method of claim 2, further comprising:

In response to completion of initialization of the rendering engine, a first drawing context is obtained in the first OpenGL thread.
The method according to claim 4, characterized in that, after obtaining the drawing context in the first OpenGL thread, the method further includes:

Obtain the drawing context of the first OpenGL thread in the second OpenGL thread.
The method according to claim 5, characterized in that, after obtaining the first OpenGL thread drawing context in the second OpenGL thread, the method further includes:

In the second OpenGL thread, the drawing context of the second OpenGL thread is created using the first OpenGL thread drawing context.
The method of claim 6, further comprising:

In the second OpenGL thread, the texture ID, the drawing context of the second OpenGL thread, and the attribute data of the image data are sent to the streaming unit.
The method according to claim 1, characterized in that the method is applied to Android system.
A device for obtaining texture data from a rendering engine. The device is applied to a host terminal. The host terminal includes a first OpenGL thread and a second OpenGL thread, and the first OpenGL thread is the OpenGL thread of the rendering engine. Characteristically, the device includes:

A monitoring unit configured to monitor whether the rendering engine initialization is completed in the first OpenGL thread;

A texture ID acquisition unit configured to acquire a texture ID in the first OpenGL thread in response to the completion of initialization of the rendering engine;

A callback unit, configured to use a callback function to obtain the texture ID in the second OpenGL thread.
An electronic device, characterized by including:

one or more processing units;

A storage unit used to store one or more programs;

When the one or more programs are executed by the one or more processing units, the one or more processing units implement the method as described in any one of claims 1-8.
A computer program, including a computer program or instructions, characterized in that when the computer program or instructions are executed by a processor, the method according to any one of claims 1-8 is implemented.