Game image update processing method, device, storage medium and electronic device

Abstract

The present disclosure relates to a method, device, storage medium and electronic device for updating a game image. The method includes: a cloud game server receives multiple game update images from a master server, wherein the game update image is obtained by the master server in response to a game update operation by splitting a basic image composed of multiple game programs, and each game update image corresponds to a game program; the cloud game server merges the multiple game update images into a local initial image file layer to obtain a merged image file layer; the cloud game server sends the merged image file layer to the game server, wherein the game server is used to display the game update image to the user based on the merged image file layer. The present disclosure solves the technical problems of reduced flexibility of game images, decreased game performance and excessively high maintenance costs caused by the increasing number of image layers after game updates and the presence of a large amount of duplicate information between the image layers.

Description

Technical Field

[0001] The present disclosure relates to the field of cloud gaming, and more specifically, to a method, device, storage medium, and electronic device for updating a game image. Background Art

[0002] In cloud gaming scenarios, users need to be able to play a variety of games while also meeting the gaming needs of users in different regions. In cloud PC scenarios, users need to be able to play our games without downloading them. To meet user demands for low latency and high image quality, cloud gaming systems, including cloud game storage devices, need to be deployed in various locations. This requires maintaining game storage in multiple locations simultaneously, making real-time game updates and configuration changes a challenge.

[0003] like Figure 1 The update method shown in the figure, the existing technical solution is mainly to use Qcow2 image to save the game data. The above method mounts the game data to the cloud game system. The Qcow2 image of each area is consistent, and it is impossible to configure the game image of each area separately. Figure 2 As shown, a traditional way of merging images is to merge the image of the previous layer. When multiple layers of images need to be merged, the remaining images of the previous merger will be merged each time. There will be a lot of duplicate content in the merged image, which will reduce the flexibility of the game image, reduce the game performance, and increase the maintenance cost.

[0004] To address the above-mentioned problems, no effective solutions have been proposed so far. Summary of the Invention

[0005] The embodiments of the present disclosure provide a method, device, storage medium, and electronic device for processing game image updates to at least address the technical issues of reduced flexibility in game image updates, decreased game performance, and excessively high maintenance costs caused by the increasing number of image layers after a game update and the presence of a large amount of duplicate information between the image layers.

[0006] According to one aspect of an embodiment of the present disclosure, a method for processing game image updates is provided, which is applied to a cloud gaming system, wherein the cloud gaming system includes a master control server and at least one cloud gaming server, the cloud gaming server communicates with the game server, and different cloud gaming servers install and run corresponding game programs, including: the cloud gaming server receives multiple game update images from the master control server, wherein the game update images are obtained by the master control server in response to a game update operation, by splitting a basic image composed of multiple game programs, and each of the game update images corresponds to a game program; the cloud gaming server merges the multiple game update images into a local initial image file layer to obtain a merged image file layer; the cloud gaming server sends the merged image file layer to the game server, wherein the game server is used to display the game update image to the user based on the merged image file layer.

[0007] Optionally, the above method also includes: in the case that there are multiple cloud game servers, the multiple cloud game servers respectively receive one or more of the above game update images from the above master control server, and merge the one or more of the above game update images into the local initial image file layer on the multiple cloud game servers to obtain multiple merged image file layers.

[0008] Optionally, each of the above-mentioned cloud gaming servers locally includes: a first image and a second image, the above-mentioned first image is used to be mounted to the initial front-end disk through the daemon process of the virtualization management software, the above-mentioned initial front-end disk is used to generate the above-mentioned initial image file layer, the above-mentioned second image is used to be mounted to the initial back-end disk through the above-mentioned daemon process, and the above-mentioned initial back-end disk is used to merge multiple of the above-mentioned game update images.

[0009] Optionally, the cloud gaming server merges multiple game update images into a local initial image file layer to obtain a merged image file layer, including: the cloud gaming server merges multiple game update images to obtain a basic service image; the cloud gaming server controls the initial back-end disk to merge the basic service image and the underlying sub-image of the initial image file layer with the basic image to obtain a merged image file layer; wherein, after performing the merge operation, the pointer direction of the parent image of the upper layer of the underlying sub-image is pointed to the merged image file.

[0010] Optionally, before the cloud gaming server controls the initial back-end disk to merge the basic service image with the underlying sub-image of the initial image file layer, the method further includes: the cloud gaming server obtains the number of disk layers of the initial back-end disk within a preset idle period; if the number of disk layers is greater than a preset layer threshold, the step of controlling the initial back-end disk to merge the basic service image with the underlying sub-image of the initial image file layer is executed.

[0011] Optionally, before the cloud gaming server controls the initial back-end disk to merge the basic service image with the underlying sub-image of the initial image file layer, the method further includes: the cloud gaming server detects whether the second image is in use; if the second image is in use, waits until the use ends, and then executes the step of controlling the initial back-end disk to merge the basic service image with the underlying sub-image of the initial image file layer; if the second image is not in use, directly executes the step of controlling the initial back-end disk to merge the basic service image with the underlying sub-image of the initial image file layer.

[0012] Optionally, after the cloud gaming server controls the initial back-end disk to merge the basic service image with the underlying sub-image of the initial image file layer, the method further includes: the cloud gaming server switches the initial back-end disk to a new front-end disk, and switches the initial front-end disk to a new back-end disk.

[0013] Optionally, the above method also includes: in response to the game update end operation, the above cloud game server searches for and closes the process that is occupying the above initial front-end disk and / or the above initial back-end disk; the above cloud game server uninstalls the above initial front-end disk and the above initial back-end disk to uninstall the target game update image on the above initial front-end disk and the above initial back-end disk.

[0014] According to another aspect of an embodiment of the present disclosure, a game image update processing device is also provided, which is applied to a cloud gaming system. The cloud gaming system includes a master control server and at least one cloud gaming server. The cloud gaming server communicates with the game server, and different cloud gaming servers install and run corresponding game programs. The device includes: a receiving module for receiving multiple game update images from the master control server, wherein the game update images are obtained by the master control server in response to a game update operation, by splitting a basic image composed of multiple game programs, and each of the game update images corresponds to a game program; a merging module for merging the multiple game update images into a local initial image file layer to obtain a merged image file layer; a sending module for sending the merged image file layer to the game server, wherein the game server is used to display the game update image to the user based on the merged image file layer.

[0015] According to another aspect of an embodiment of the present disclosure, a computer-readable storage medium is further provided, wherein the computer-readable storage medium includes a stored program, wherein when the program is running, the device where the computer-readable storage medium is located is controlled to execute any one of the above-mentioned game image update processing methods.

[0016] According to another aspect of an embodiment of the present disclosure, an electronic device is also provided, including a memory and a processor, characterized in that a computer program is stored in the above-mentioned memory, and the above-mentioned processor is configured to run the above-mentioned computer program to execute any one of the above-mentioned game image update processing methods.

[0017] In the embodiment of the present disclosure, a game update image processing method is adopted, and multiple game update images are received from a master server through a cloud game server, wherein the above-mentioned game update images are obtained by the above-mentioned master server in response to the game update operation, by splitting the basic image composed of multiple game programs, and each of the above-mentioned game update images corresponds to a game program; the above-mentioned cloud game server merges the multiple above-mentioned game update images into a local initial image file layer to obtain a merged image file layer; the above-mentioned cloud game server sends the above-mentioned merged image file layer to the game server, wherein the above-mentioned game server is used to display the above-mentioned game update image to the user based on the above-mentioned merged image file layer, thereby achieving the purpose of real-time merging of the image file layers generated locally by each game storage device, thereby realizing the technical effect of improving the flexibility and game performance of the game update image and reducing the maintenance cost, and further solving the technical problems of reduced flexibility of the game update image, decreased game performance and excessively high maintenance cost caused by the continuous increase in the number of image layers after the game update and the existence of a large amount of duplicate information between the image layers. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] The drawings described herein are used to provide a further understanding of the present disclosure and constitute a part of the present disclosure. The exemplary embodiments of the present disclosure and their descriptions are used to explain the present disclosure and do not constitute an improper limitation of the present disclosure. In the drawings:

[0019] Figure 1 This is a schematic diagram of a game image update process according to the prior art;

[0020] Figure 2 This is a schematic diagram of a game image merging process according to the prior art;

[0021] Figure 3 This is a flowchart of the steps of a method for updating a game image according to an embodiment of the present disclosure;

[0022] Figure 4 This is a flowchart of steps of an optional game image update processing method according to an embodiment of the present disclosure;

[0023] Figure 5 This is a schematic flow chart of steps of an optional method for merging game images according to an embodiment of the present disclosure;

[0024] Figure 6 is a schematic diagram of an optional game image merging process according to an embodiment of the present disclosure;

[0025] Figure 7 1 is a flowchart of another optional method for updating a game image according to an embodiment of the present disclosure;

[0026] Figure 8 It is a structural diagram of a game image update processing device according to an embodiment of the present disclosure. DETAILED DESCRIPTION

[0027] In order to enable those skilled in the art to better understand the solutions of the present disclosure, the technical solutions in the embodiments of the present disclosure will be clearly and completely described below in conjunction with the drawings in the embodiments of the present disclosure. Obviously, the embodiments described are only part of the embodiments of the present disclosure, not all of the embodiments. Based on the embodiments of the present disclosure, all other embodiments obtained by ordinary technicians in this field without making creative efforts should fall within the scope of protection of the present disclosure.

[0028] It should be noted that the terms "first", "second", etc. in the specification and claims of the present disclosure and the above-mentioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that the numbers used in this way can be interchanged where appropriate, so that the embodiments of the present disclosure described herein can be implemented in an order other than those illustrated or described herein. In addition, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusions, for example, a process, method, system, product or device that includes a series of steps or units is not necessarily limited to those steps or units clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0029] First, to facilitate understanding of the embodiments of the present disclosure, some of the terms or nouns involved in the present disclosure are explained below:

[0030] Daemon: A special process that runs in the background and is used to perform specific tasks on the system.

[0031] Cloud gaming: A gaming method based on cloud computing. In the cloud gaming mode, all games are run on the server side, and the rendered game screen is compressed and transmitted to users through the network.

[0032] Cloud PC: Similar to cloud gaming, this is a cloud-based gaming method. However, this method provides users with a completely open environment, rather than restricting them to just playing games. Users can use cloud PCs for a range of tasks, including video editing and machine learning.

[0033] Qcow2: This is the file format for disk image files used by QEMU (QEMU Emulated Processor). It stands for "QEMU Emulated Processor Copy-On-Write" and uses a disk storage optimization strategy that delays storage allocation until it is actually needed.

[0034] Libvit virtualization management software: The primary goal is to provide a way to manage multiple different virtualization vendors / hypervisors. The Libvit daemon can be called by local / remote virsh, and Libvirtd calls qemu-kvm to operate virtual machines.

[0035] PCI device: peripheral device, a device plugged into a PCI slot.

[0036] According to an embodiment of the present disclosure, an embodiment of a method for updating a game image is provided. It should be noted that the steps shown in the flowchart of the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions, and although a logical order is shown in the flowchart, in some cases, the steps shown or described can be executed in an order different from that shown here.

[0037] The technical solution of the embodiment of the method can be executed in a mobile terminal, a computer terminal, or a similar computing device. Taking running on a mobile terminal as an example, the mobile terminal can be a smartphone (such as an Android phone, an iOS phone, etc.), a tablet computer, a PDA, a mobile Internet device (MID), a PAD, and other terminal devices. The mobile terminal may include one or more processors (the processor may include but is not limited to a central processing unit (CPU), a graphics processing unit (GPU), a digital signal processing (DSP) chip, a microprocessor (MCU), a programmable logic device (FPGA), a neural network processor (NPU), a tensor processing unit (TPU), an artificial intelligence (AI) type processor, etc.) and a memory for storing data. Optionally, the mobile terminal may also include a transmission device, input and output devices, and a display device for communication functions. It will be understood by those skilled in the art that the above structural description is only illustrative and does not limit the structure of the mobile terminal. For example, the mobile terminal may also include more or fewer components than those described in the above structural description, or have a configuration different from that described in the above structural description.

[0038] The memory can be used to store computer programs, for example, software programs and modules of application software, such as the computer program corresponding to the update processing method of the game image in the embodiment of the present disclosure. The processor executes various functional applications and data processing by running the computer program stored in the memory, that is, realizes the update processing method of the game image mentioned above. The memory may include a high-speed random access memory, and may also include a non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory may further include a memory remotely arranged relative to the processor, and these remote memories can be connected to the mobile terminal via a network. Examples of the above-mentioned network include but are not limited to the Internet, corporate intranet, local area network, mobile communication network and combinations thereof.

[0039] The transmission device is used to receive or send data via a network. Specific examples of the aforementioned network may include a wireless network provided by the mobile terminal's communications provider. In one embodiment, the transmission device includes a network interface controller (NIC), which can be connected to other network devices via a base station to enable communication with the Internet. In another embodiment, the transmission device may be a radio frequency (RF) module, which is used to communicate with the Internet wirelessly. The technical solution of the embodiment of the method can be applied to various communication systems, such as: Global System of Mobile communication (GSM) system, Code Division Multiple Access (CDMA) system, Wideband Code Division Multiple Access (WCDMA) system, General Packet Radio Service (GPRS), Long Term Evolution (LTE) system, LTE Frequency Division Duplex (FDD) system, LTE Time Division Duplex (TDD), Universal Mobile Telecommunication System (UMTS), Worldwide Interoperability for Microwave Access (WiMAX) communication system or 5G system. Optionally, device to device (D2D) communication can be carried out between multiple mobile terminals. Optionally, the 5G system or 5G network is also called a New Radio (NR) system or NR network.

[0040] The display device can be, for example, a touch-screen liquid crystal display (LCD) and a touch display (also referred to as a "touch screen" or "touch display screen"). The liquid crystal display can enable a user to interact with the user interface of the mobile terminal. In some embodiments, the mobile terminal has a graphical user interface (GUI), and the user can interact with the GUI by finger contacts and / or gestures on the touch-sensitive surface. The human-computer interaction functions here optionally include the following interactions: creating web pages, drawing, word processing, making electronic documents, games, video conferencing, instant messaging, sending and receiving emails, call interfaces, playing digital videos, playing digital music and / or web browsing, etc. The executable instructions for performing the above-mentioned human-computer interaction functions are configured / stored in a computer program product executable by one or more processors or a readable computer-readable storage medium.

[0041] Figure 3 This is a flowchart of a method for updating a game image according to an embodiment of the present disclosure. Figure 3 As shown, the method is applied to a cloud gaming system, which includes a master control server and at least one cloud gaming server. The cloud gaming server communicates with the game server, and different cloud gaming servers install and run corresponding game programs, including the following steps:

[0042] Step S102: The cloud gaming server receives multiple game update images from the master control server, wherein the game update images are obtained by the master control server in response to a game update operation by splitting a base image composed of multiple game programs, and each game update image corresponds to a game program;

[0043] Step S104: The cloud gaming server merges the multiple game update images into a local initial image file layer to obtain a merged image file layer.

[0044] In step S106, the cloud game server sends the merged image file layer to the game server, wherein the game server is used to display the game update image to the user based on the merged image file layer.

[0045] Optionally, in the disclosed embodiment, the game server can respond to a game update operation and split the base image in the game scene according to the game content to obtain multiple game update images; each game update image corresponds to a pre-set game directory and game data, and the game server can automatically query the game directory and save the game data to the multiple game update images. Optionally, the location of the game storage device (e.g., a computer room) can be determined based on a pre-configured game area (e.g., a geographical area or an area divided according to the game), and the local information of the game storage device can be recorded in a database.

[0046] In the embodiment of the present disclosure, a game update image processing method is adopted, and multiple game update images are received from a master server through a cloud game server, wherein the above-mentioned game update images are obtained by the above-mentioned master server in response to the game update operation, by splitting the basic image composed of multiple game programs, and each of the above-mentioned game update images corresponds to a game program; the above-mentioned cloud game server merges the multiple above-mentioned game update images into a local initial image file layer to obtain a merged image file layer; the above-mentioned cloud game server sends the above-mentioned merged image file layer to the game server, wherein the above-mentioned game server is used to display the above-mentioned game update image to the user based on the above-mentioned merged image file layer, thereby achieving the purpose of real-time merging of the image file layers generated locally by each game storage device, thereby realizing the technical effect of improving the flexibility and game performance of the game update image and reducing the maintenance cost, and further solving the technical problems of reduced flexibility of the game update image, decreased game performance and excessively high maintenance cost caused by the continuous increase in the number of image layers after the game update and the existence of a large amount of duplicate information between the image layers.

[0047] Optionally, when there are multiple cloud gaming servers, the multiple cloud gaming servers respectively receive one or more of the game update images from the master control server, and the multiple cloud gaming servers respectively merge the one or more of the game update images into the local initial image file layer to obtain multiple merged image file layers.

[0048] As an optional embodiment, Figure 4 FIG. 1 is a flowchart of an optional method for updating a game image according to an embodiment of the present disclosure. Figure 4As shown, the update processing method of the above-mentioned game image includes the following method steps: after the game update is completed, the basic image of the above-mentioned game is divided into multiple game update images, wherein the above-mentioned multiple game update images correspond to pre-set game directories and game data, the system automatically finds the above-mentioned game directories, and saves the above-mentioned game data to the above-mentioned multiple game update images; the above-mentioned multiple game update images are transmitted to the local game storage device, and the multiple above-mentioned game update images are restored to the above-mentioned basic image locally on the above-mentioned game storage device. The above-mentioned initial back-end disk merges the underlying sub-image of the above-mentioned image file layer with the above-mentioned basic image to obtain a merged image file layer, and the above-mentioned merged image file layer is used as a new image for the user, and the update is completed.

[0049] In an optional embodiment, each of the above-mentioned cloud gaming servers locally includes: a first image and a second image, the above-mentioned first image is used to be mounted to the initial front-end disk through the daemon process of the virtualization management software, the above-mentioned initial front-end disk is used to generate the above-mentioned initial image file layer, the above-mentioned second image is used to be mounted to the initial back-end disk through the above-mentioned daemon process, and the above-mentioned initial back-end disk is used to merge multiple of the above-mentioned game update images.

[0050] As an optional embodiment, Figure 5 This is a flowchart of an optional game update image merging method according to an embodiment of the present disclosure. Figure 5 As shown, the above-mentioned game update image merging includes the following method steps: within a preset idle period, obtaining the disk layer number of the initial back-end disk of the above-mentioned basic image; judging whether the above-mentioned disk layer number is greater than the preset layer threshold, if the above-mentioned disk layer number is less than the preset layer threshold, entering a waiting state until the above-mentioned disk layer number is greater than the preset layer threshold, otherwise detecting whether the above-mentioned second image is in use; if the above-mentioned second image is in use, entering a waiting state until the use of the above-mentioned second image ends; if the above-mentioned second image is in an idle state, executing a basic image merging operation, using the above-mentioned merged basic image as the foreground image, and executing a refresh operation.

[0051] In an optional embodiment, the cloud gaming server merges the plurality of game update images into a local initial image file layer to obtain a merged image file layer, including:

[0052] Step S202: The cloud gaming server merges the multiple game update images to obtain a basic service image.

[0053] In step S204, the cloud gaming server controls the initial back-end disk to merge the basic service image with the underlying sub-image of the initial image file layer to obtain the merged image file layer; after the merge operation is performed, the pointer direction of the parent image of the upper layer of the underlying sub-image is pointed to the merged image file.

[0054] In the embodiment of the present disclosure, the cloud game server is used to merge multiple game update images to obtain a basic service image; the cloud game server controls the initial back-end disk to merge the basic service image with the underlying sub-image of the initial image file layer to obtain the merged image file layer; wherein, after performing the merge operation, the pointer direction of the parent image of the upper layer of the underlying sub-image is pointed to the merged image file, thereby achieving the purpose of updating and changing the latest image information on the basis of the basic image, thereby realizing the technical effect of improving the efficiency of game update image merging, and further solving the technical problem of low game update image merging efficiency caused by a large amount of duplicate content in different image layers after the game is updated.

[0055] As an optional embodiment, Figure 6 is a schematic diagram of an optional game update image merging process according to an embodiment of the present disclosure, such as Figure 6 As shown, for example, the first-layer image is merged into the base image to obtain a merged image file layer (i.e., base image + first-layer image); the pointer direction of the parent image of the second-layer image is pointed to the above-mentioned merged image file, and the above-mentioned second-layer image is merged with the above-mentioned merged image file layer to obtain a new merged image file layer (i.e., base image + first-layer image + second-layer image), which is also the base merged image. Each time the above-mentioned merge operation is performed, the latest image information is updated and modified based on the base image, and duplicate information between the two image file layers to be merged is automatically eliminated.

[0056] In an optional embodiment, before the cloud gaming server controls the initial backend disk to merge the basic service image with the underlying sub-image of the initial image file layer, the method further includes:

[0057] Step S302: the cloud gaming server obtains the number of disk layers of the initial backend disk within a preset idle period;

[0058] Step S304: If the number of disk layers is greater than a preset layer threshold, the step of controlling the initial backend disk to merge the basic service image with the bottom sub-image of the initial image file layer is executed.

[0059] Optionally, if the number of disk layers is less than or equal to the preset layer threshold, the system enters a waiting state until the number of disk layers is greater than the preset layer threshold, and executes the step of controlling the initial back-end disk to merge the underlying sub-image of the image file layer with the base image.

[0060] As an optional embodiment, Figure 7 is a flowchart of another optional game image update processing method according to an embodiment of the present disclosure, such as Figure 7 As shown, before the cloud gaming server controls the initial backend disk to merge the basic service image with the underlying sub-image of the initial image file layer, the method further includes:

[0061] Step S402: the cloud gaming server detects whether the second image is currently in use.

[0062] Step S404: If the second image is in the used state, wait until the used state ends, and then execute the step of controlling the initial backend disk to merge the basic service image with the underlying sub-image of the initial image file layer;

[0063] Step S406: If the second image is not in the used state, directly executing the step of controlling the initial backend disk to merge the basic service image with the bottom sub-image of the initial image file layer.

[0064] Optionally, the above-mentioned merging of multiple game update images into the image file layer generated locally on the game storage device includes: restoring the multiple game update images to the above-mentioned basic image locally on the above-mentioned game storage device; controlling the above-mentioned initial back-end disk to merge the underlying sub-image of the above-mentioned image file layer with the above-mentioned basic image to obtain a merged image file layer; after performing the merging operation, pointing the pointer direction of the parent image of the upper layer of the above-mentioned underlying sub-image to the above-mentioned merged image file.

[0065] In an optional embodiment, after the above-mentioned cloud gaming server controls the above-mentioned initial back-end disk to merge the above-mentioned basic service image with the underlying sub-image of the above-mentioned initial image file layer, the above-mentioned method also includes: the above-mentioned cloud gaming server switches the above-mentioned initial back-end disk to a new front-end disk, and switches the above-mentioned initial front-end disk to a new back-end disk.

[0066] In an optional embodiment, the above method further includes:

[0067] Step S502: In response to the game update end operation, the cloud game server searches for and closes the process that is occupying the initial front-end disk and / or the initial back-end disk;

[0068] In step S504, the cloud game server uninstalls the target game update image on the initial front-end disk and the initial back-end disk by uninstalling the initial front-end disk and the initial back-end disk.

[0069] In the embodiment of the present disclosure, a method of automatically finding and closing the program occupying the disk is adopted, and in response to the end operation of the game update, the process that is occupying the above-mentioned initial front-end disk and / or the above-mentioned initial back-end disk is found and closed; a method of uninstalling the above-mentioned initial front-end disk and the above-mentioned initial back-end disk is adopted to uninstall the target game update image on the above-mentioned initial front-end disk and the above-mentioned initial back-end disk, thereby achieving the purpose of automatically finding and closing the program occupying the disk and thus completing the automatic unloading of the disk, and realizing the technical effect of improving the efficiency of image merging, thereby solving the problem that the game update image is dynamically mounted on the game disk through the Libvit virtualization management software technology, and needs to be uninstalled after the game data update is completed, but the disk mechanism of Windows itself cannot directly uninstall the image in the outer layer, but needs to be performed in Windows by uninstalling the PCI device. When uninstalling the disk, it is encountered that the disk cannot be unloaded due to program occupation, thereby affecting the technical problem of image disk merging efficiency.

[0070] According to an embodiment of the present disclosure, there is also provided an embodiment of a device for implementing the above-mentioned game image update processing method. Figure 8 FIG. 1 is a structural diagram of a game image update processing device according to an embodiment of the present disclosure, such as Figure 8 As shown, the game image update processing device is applied to a cloud gaming system. The cloud gaming system includes a master control server and at least one cloud gaming server. The cloud gaming server communicates with the game server. Different cloud gaming servers install and run corresponding game programs. The device includes a receiving module 60, a merging module 62, and a sending module 64, wherein:

[0071] The above-mentioned receiving module 60 is used to receive multiple game update images from the main control server, wherein the above-mentioned game update images are obtained by the above-mentioned main control server in response to the game update operation, by splitting the basic image composed of multiple game programs, and each of the above-mentioned game update images corresponds to a game program; the above-mentioned merging module 62 is used to merge the multiple above-mentioned game update images into the local initial image file layer to obtain a merged image file layer; the above-mentioned sending module 64 is used to send the above-mentioned merged image file layer to the game server, wherein the above-mentioned game server is used to display the above-mentioned game update image to the user based on the above-mentioned merged image file layer.

[0072] It should be noted that the above modules can be implemented by software or hardware. For example, for the latter, it can be implemented in the following ways: the above modules can be located in the same processor; or the above modules can be located in different processors in any combination.

[0073] It should be noted that the receiving module 60, merging module 62, and sending module 64 correspond to steps S102 to S106 in the method embodiment. The examples and application scenarios implemented by these modules and the corresponding steps are the same, but are not limited to the contents disclosed in the above method embodiment. It should be noted that the above modules, as part of the device, can be run on a computer terminal.

[0074] It should be noted that the optional or preferred implementation of this embodiment can be found in the relevant description in the method embodiment, which will not be repeated here.

[0075] The above-mentioned game image update processing device can also include a processor and a memory. The above-mentioned receiving module 60, merging module 62, sending module 64, etc. are all stored in the memory as program units, and the processor executes the above-mentioned program units stored in the memory to realize the corresponding functions.

[0076] The processor includes a core, which retrieves the corresponding program unit from memory. There can be one or more cores. Memory may include non-permanent memory in a computer-readable medium, random access memory (RAM), and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory includes at least one memory chip.

[0077] According to an embodiment of the present disclosure, a computer-readable storage medium embodiment is also provided. Optionally, in this embodiment, the computer-readable storage medium includes a stored program, wherein when the program is executed, the device containing the computer-readable storage medium is controlled to execute any of the above-mentioned game image update processing methods.

[0078] Optionally, in this embodiment, the computer-readable storage medium may be located in any computer terminal in a computer terminal group in a computer network, or in any mobile terminal in a mobile terminal group, and the computer-readable storage medium includes a stored program.

[0079] Optionally, when the program is running, the device where the computer-readable storage medium is located is controlled to perform the following functions: the cloud game server receives multiple game update images from the master server, wherein the above-mentioned game update images are obtained by the above-mentioned master server in response to the game update operation, by splitting the basic image composed of multiple game programs, and each of the above-mentioned game update images corresponds to a game program; the above-mentioned cloud game server merges the multiple above-mentioned game update images into the local initial image file layer to obtain a merged image file layer; the above-mentioned cloud game server sends the above-mentioned merged image file layer to the game server, wherein the above-mentioned game server is used to display the above-mentioned game update image to the user based on the above-mentioned merged image file layer.

[0080] Optionally, when the program is running, the device that controls the computer-readable storage medium can also perform the following functions: in the case where there are multiple cloud game servers, the multiple cloud game servers respectively receive one or more of the above-mentioned game update images from the above-mentioned master control server, and the multiple cloud game servers respectively merge the one or more of the above-mentioned game update images into the local initial image file layer to obtain multiple merged image file layers.

[0081] Optionally, when the program is running, the device where the computer-readable storage medium is located can also perform the following functions: the above-mentioned cloud game server merges multiple of the above-mentioned game update images to obtain a basic service image; the above-mentioned cloud game server controls the above-mentioned initial back-end disk to merge the above-mentioned basic service image with the underlying sub-image of the above-mentioned initial image file layer to obtain the above-mentioned merged image file layer; wherein, after performing the merge operation, the pointer direction of the parent image of the upper layer of the above-mentioned underlying sub-image is pointed to the above-mentioned merged image file.

[0082] Optionally, when the program is running, the device that controls the computer-readable storage medium can also perform the following functions: the above-mentioned cloud game server obtains the number of disk layers of the above-mentioned initial back-end disk within a preset idle period; if the above-mentioned number of disk layers is greater than the preset layer threshold, then the above-mentioned step of controlling the above-mentioned initial back-end disk to merge the above-mentioned basic service image with the underlying sub-image of the above-mentioned initial image file layer is executed.

[0083] Optionally, when the program is running, the device where the computer-readable storage medium is located can also perform the following functions: the above-mentioned cloud game server detects whether the above-mentioned second image is in the used state; if the above-mentioned second image is in the used state, wait until the above-mentioned used state ends, and then execute the above-mentioned step of controlling the above-mentioned initial back-end disk to merge the above-mentioned basic service image with the underlying sub-image of the above-mentioned initial image file layer; if the above-mentioned second image is not in the above-mentioned used state, directly execute the above-mentioned step of controlling the above-mentioned initial back-end disk to merge the above-mentioned basic service image with the underlying sub-image of the above-mentioned initial image file layer.

[0084] Optionally, when the program is running, the device controlling the computer-readable storage medium can also perform the following functions: the cloud gaming server switches the initial back-end disk to a new front-end disk, and switches the initial front-end disk to a new back-end disk.

[0085] Optionally, when the program is running, the device where the computer-readable storage medium is located can also perform the following functions: in response to the game update end operation, the above-mentioned cloud game server searches for and closes the process that is occupying the above-mentioned initial front-end disk and / or the above-mentioned initial back-end disk; the above-mentioned cloud game server uninstalls the game update image on the above-mentioned initial front-end disk and the above-mentioned initial back-end disk by uninstalling the above-mentioned initial front-end disk and the above-mentioned initial back-end disk.

[0086] An embodiment of the present disclosure provides an electronic device, including a memory and a processor, wherein the memory stores a computer program, and the processor is configured to run the computer program to execute any one of the above-mentioned game image update processing methods.

[0087] The present disclosure also provides a computer program product, which, when executed on a data processing device, is suitable for executing an initialized program having the following method steps: a cloud game server receives multiple game update images from a master control server, wherein the game update images are obtained by the master control server in response to a game update operation by splitting a basic image composed of multiple game programs, and each of the game update images corresponds to a game program; the cloud game server merges the multiple game update images into a local initial image file layer to obtain a merged image file layer; the cloud game server sends the merged image file layer to the game server, wherein the game server is used to display the game update image to the user based on the merged image file layer.

[0088] The serial numbers of the above-mentioned embodiments of the present disclosure are for description only and do not represent the advantages or disadvantages of the embodiments.

[0089] In the above embodiments of the present disclosure, the description of each embodiment has its own focus. For parts that are not described in detail in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

[0090] In the several embodiments provided in the present disclosure, it should be understood that the disclosed technical content can be implemented in other ways. Among them, the device embodiments described above are only exemplary. For example, the division of the units can be a logical function division. In actual implementation, there may be other division methods, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of units or modules, which can be electrical or other forms.

[0091] The units described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed across multiple units. Some or all of the units may be selected according to actual needs to achieve the purpose of the present embodiment.

[0092] In addition, the functional units in the various embodiments of the present disclosure may be integrated into a single processing unit, or each unit may exist physically separately, or two or more units may be integrated into a single unit. The aforementioned integrated units may be implemented in the form of hardware or software functional units.

[0093] If the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable computer-readable storage medium. Based on this understanding, the technical solution of the present invention is essentially or the part that contributes to the prior art or all or part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a computer-readable storage medium, including a number of instructions for enabling a computer device (which can be a personal computer, a server or a network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present invention. The aforementioned computer-readable storage medium includes: various media that can store program codes, such as a USB flash drive, a read-only memory (ROM), a random access memory (RAM), a mobile hard disk, a magnetic disk or an optical disk.

[0094] The above is only a preferred embodiment of the present disclosure. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principles of the present disclosure. These improvements and modifications should also be regarded as within the scope of protection of the present disclosure.

Claims

1. A method for updating a game image, characterized in that: Applied to a cloud gaming system, the cloud gaming system includes a master control server and at least one cloud gaming server, the cloud gaming server communicates with the gaming server, and different cloud gaming servers install and run corresponding gaming programs, including: The cloud gaming server receives multiple game update images from a master control server, wherein the game update images are obtained by the master control server in response to a game update operation by splitting a base image composed of multiple game programs, and each game update image corresponds to a game program; The cloud game server merges the multiple game update images into a local initial image file layer to obtain a merged image file layer; The cloud game server sends the merged image file layer to the game server, wherein the game server is used to display the game update image to the user based on the merged image file layer; Among them, the cloud game server merges multiple game update images into the local initial image file layer to obtain a merged image file layer, including: the cloud game server merges multiple game update images to obtain a basic service image; the cloud game server controls the initial back-end disk to merge the basic service image with the underlying sub-image of the initial image file layer to obtain the merged image file layer; wherein, after performing the merge operation, the pointer direction of the upper-layer parent image of the underlying sub-image is pointed to the merged image file, and each time the above merge operation is performed, the latest image information is updated and modified on the basis of the basic service image, and the duplicate information between the two image file layers to be merged is automatically eliminated.

2. The method according to claim 1, characterized in that The method further comprises: In the case where there are multiple cloud game servers, the multiple cloud game servers respectively receive one or more game update images from the master control server, and the multiple cloud game servers respectively merge the one or more game update images into the local initial image file layer to obtain multiple merged image file layers.

3. The method according to claim 1, characterized in that Each of the cloud gaming servers locally includes: a first image and a second image, the first image is used to be mounted to the initial front-end disk through the daemon process of the virtualization management software, the initial front-end disk is used to generate the initial image file layer, the second image is used to be mounted to the initial back-end disk through the daemon process, and the initial back-end disk is used to merge multiple game update images.

4. The method according to claim 1, wherein Before the cloud gaming server controls the initial backend disk to merge the basic service image with the underlying sub-image of the initial image file layer, the method further includes: The cloud gaming server obtains the number of disk layers of the initial backend disk within a preset idle period; If the number of disk layers is greater than a preset layer threshold, the step of controlling the initial back-end disk to merge the basic service image with the bottom sub-image of the initial image file layer is performed.

5. The method according to claim 3, characterized in that Before the cloud gaming server controls the initial backend disk to merge the basic service image with the underlying sub-image of the initial image file layer, the method further includes: The cloud gaming server detects whether the second image is in use; If the second image is in the used state, waiting until the used state ends, and then executing the step of controlling the initial back-end disk to merge the basic service image with the bottom sub-image of the initial image file layer; If the second image is not in the used state, the step of controlling the initial backend disk to merge the basic service image with the bottom sub-image of the initial image file layer is directly performed.

6. The method according to claim 3, characterized in that After the cloud gaming server controls the initial backend disk to merge the basic service image with the underlying sub-image of the initial image file layer, the method further includes: The cloud gaming server switches the initial backend disk to a new frontend disk, and switches the initial frontend disk to a new backend disk.

7. The method according to claim 3, characterized in that The method further comprises: In response to the game update end operation, the cloud game server searches for and closes the process that is occupying the initial front-end disk and / or the initial back-end disk; The cloud game server uninstalls the game update image on the initial front-end disk and the initial back-end disk by uninstalling the initial front-end disk and the initial back-end disk.

8. A game image update processing device, characterized in that: Applied to a cloud gaming system, the cloud gaming system includes a master control server and at least one cloud gaming server, the cloud gaming server communicates with the gaming server, and different cloud gaming servers install and run corresponding gaming programs, including: a receiving module, configured to receive multiple game update images from a master control server, wherein the game update images are obtained by the master control server in response to a game update operation by splitting a base image composed of multiple game programs, and each game update image corresponds to a game program; A merging module, configured to merge the plurality of game update images into a local initial image file layer to obtain a merged image file layer; a sending module, configured to send the merged image file layer to a game server, wherein the game server is configured to display the game update image to a user based on the merged image file layer; Among them, the merging module is also used for: the cloud game server merges multiple game update images to obtain a basic service image; the cloud game server controls the initial back-end disk to merge the basic service image with the underlying sub-image of the initial image file layer to obtain the merged image file layer; wherein, after performing the merge operation, the pointer direction of the parent image of the upper layer of the underlying sub-image is pointed to the merged image file, and each time the above merge operation is performed, the latest image information is updated and modified on the basis of the basic service image, and the duplicate information between the two image file layers to be merged is automatically eliminated.

9. A computer-readable storage medium, characterized in that The computer-readable storage medium includes a stored program, wherein when the program is executed, the device where the computer-readable storage medium is located is controlled to execute the game image update processing method according to any one of claims 1 to 7.

10. An electronic device comprising a memory and a processor, characterized in that: A computer program is stored in the memory, and the processor is configured to run the computer program to execute the game image update processing method according to any one of claims 1 to 7.

Images