时域AI超分
======

从6.0.0(20) 版本开始，新增支持OpenGL ES协议。

XEngine Kit提供时域AI超分能力，利用相机的抖动获取不同位置的采样信息，融合时域实现超采样率和超分辨率功能，并利用神经网络达到抗锯齿效果，建议超分倍率为\[1.25, 2.0\]。

#### 约束与限制

*   支持的设备类型：Phone，从5.1.0(18)版本开始新增支持Tablet、PC/2in1设备，从5.1.1(19)版本开始新增支持TV设备。
    
*   可通过以下方式查询相关扩展特性是否支持：
    
    *   对于OpenGL ES，使用[HMS\_XEG\_GetString](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine#hms_xeg_getstring)扩展特性查询接口进行查询。
        
    *   对于Vulkan，使用[HMS\_XEG\_EnumerateDeviceExtensionProperties](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine#hms_xeg_enumeratedeviceextensionproperties)扩展特性查询接口进行查询。
        
    
    如查询结果包含[XEG\_TEMPORAL\_UPSCALE\_EXTENSION\_NAME](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine#xeg_temporal_upscale_extension_name)，则表示支持该特性，若查询结果未包含，则表示不支持该特性。
    

#### 接口说明

以下接口为OpenGL ES和Vulkan时域AI超分设置接口，如需使用更丰富的设置和查询接口，具体API说明详见[接口文档](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine)。

| 接口名 | 描述 |
| :-- | :-- |
| const GLubyte \* HMS\_XEG\_GetString (GLenum name) | XEngine OpenGL ES扩展特性查询接口。 |
| GL\_APICALL void GL\_APIENTRY HMS\_XEG\_TemporalUpscaleParameter(GLenum pname, const GLvoid \*param) | 设置时域AI超分输入参数。 |
| 
GL\_APICALL void GL\_APIENTRY HMS\_XEG\_RenderTemporalUpscale(

GLuint inputTexture,

GLuint depthTexture,

GLuint motionVectorTexture,

GLuint dynamicMaskTexture,

GLfloat jitterX,

GLfloat jitterY

)

 | 录制时域AI超分渲染命令。 |
| VKAPI\_ATTR VkResult VKAPI\_CALL HMS\_XEG\_EnumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, uint32\_t \* pPropertyCount, XEG\_ExtensionProperties \* pProperties) | XEngine Vulkan扩展特性查询接口。 |
| VKAPI\_ATTR VkResult VKAPI\_CALL HMS\_XEG\_CreateTemporalUpscale (VkDevice device, XEG\_TemporalUpscaleCreateInfo \* pTemporalUpscaleInfo, XEG\_TemporalUpscale \* pTemporalUpscale) | 创建XEG\_TemporalUpscale对象。 |
| VKAPI\_ATTR void VKAPI\_CALL HMS\_XEG\_CmdRenderTemporalUpscale (VkCommandBuffer commandBuffer, XEG\_TemporalUpscale temporalUpscale, XEG\_TemporalUpscaleDescription \* pDescription) | 录制时域AI超分渲染命令。 |
| VKAPI\_ATTR void VKAPI\_CALL HMS\_XEG\_DestroyTemporalUpscale (XEG\_TemporalUpscale temporalUpscale) | 销毁XEG\_TemporalUpscale对象。 |

#### 业务流程

*   下面是基于GLES图形API平台集成时域AI超分的主要业务流程
    
    ![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/c5/v3/7itD1VWsSXiyLKuzGJWWKQ/zh-cn_image_0000002664328685.jpg?HW-CC-KV=V1&HW-CC-Date=20260709T132555Z&HW-CC-Expire=86400&HW-CC-Sign=DC3E58BEA262430005AF36BC13B66C213EFA54D4B61926732894A45C715C07FD)
    

1.  用户在进入游戏初始化场景时调用HMS\_XEG\_GetString接口查询XEngine支持的特性，当查询接口返回支持的特性列表中包含[XEG\_TEMPORAL\_UPSCALE\_EXTENSION\_NAME](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine#xeg_temporal_upscale_extension_name)时代表可以使用此特性。
2.  此时调用HMS\_XEG\_TemporalUpscaleParameter接口配置超分参数。
3.  当游戏运行时，游戏渲染待超分的当前帧纹理。
4.  当待超分纹理渲染完成时，即已经做完了带jitter的主pass渲染，准备好了depth、motion vector、color等输入纹理，此时调用HMS\_XEG\_RenderTemporalUpscale接口对待超分的纹理超分。
5.  当超分渲染完成时，游戏渲染剩下的纹理，如UI等。
6.  当前帧已全部渲染完成，进行送显。
7.  当游戏退出时，超分资源会自行释放。

*   下面是基于Vulkan图形API平台集成时域AI超分的主要业务流程
    
    ![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/d9/v3/pBGWjk2YTk-UaszK_UnAMQ/zh-cn_image_0000002633849574.jpg?HW-CC-KV=V1&HW-CC-Date=20260709T132555Z&HW-CC-Expire=86400&HW-CC-Sign=FAB2ABB815D366A917090D07FE99F1DB9DA14DD46B55BB6BCFC86F3F7682FB6A)
    

1.  用户在进入游戏初始化场景时调用HMS\_XEG\_EnumerateDeviceExtensionProperties接口查询XEngine支持的特性，当查询接口返回支持的特性列表中包含时域AI超分时代表可以使用此特性。
2.  此时调用HMS\_XEG\_CreateTemporalUpscale接口创建超分实例。
3.  当游戏运行时，游戏渲染待超分的当前帧纹理。
4.  当待超分纹理渲染完成时，即已经做完了带jitter的主pass渲染，准备好了depth、motion vector、color等输入纹理，此时调用HMS\_XEG\_CmdRenderTemporalUpscale接口对待超分的纹理超分。
5.  当超分渲染完成时，游戏渲染剩下的纹理，如UI等。
6.  当前帧已全部渲染完成，进行送显。
7.  当游戏退出时，调用HMS\_XEG\_DestroyTemporalUpscale接口销毁超分实例。

#### 开发步骤

本章以OpenGL ES和Vulkan图像API集成为例，说明XEngine集成操作过程。

#### \[h2\]配置项目

编译HAP时，Native层so编译需要依赖NDK中的libxengine.so。

*   头文件引用
    
    按需引用XEngine的头文件，如使用OpenGL ES时域AI超分。
    
    #include <cstring>
    #include <cstdlib>
    #include <xengine/xeg\_gles\_extension.h>
    #include <xengine/xeg\_gles\_temporal\_upscale.h>
    
    按需引用XEngine的头文件，如使用Vulkan时域AI超分。
    
    #include <algorithm>
    #include <string>
    #include <vector>
    #include "xengine/xeg\_vulkan\_temporal\_upscale.h"
    #include "xengine/xeg\_vulkan\_extension.h"
    
*   编写CMakeLists.txt
    
    按需引用XEngine的CMakeLists，如使用OpenGL ES时域AI超分功能，CMakeLists.txt部分示例代码如下：
    
    find\_library(
        # 设置路径变量的名称。
        xengine-lib
        # 指定希望CMake定位的NDK库的名称。
        xengine
    )
    find\_library(
        # 设置路径变量的名称。
        EGL-lib
        # 指定希望CMake定位的NDK库的名称。
        EGL
    )
    find\_library(
        # 设置路径变量的名称。
        GLES-lib
        # 指定希望CMake定位的NDK库的名称。
        GLESv3
    )
    
    target\_link\_libraries(nativerender PUBLIC
    ${EGL-lib} ${GLES-lib} ${xengine-lib})
    
    按需引用XEngine的CMakeLists，如使用Vulkan时域AI超分功能，CMakeLists.txt部分示例代码如下，完整示例代码请参见[Demo（GPU加速引擎-Vulkan）](https://gitcode.com/harmonyos_samples/xengine-samplecode-vulkan-temporal-upscale-demo-cpp)。
    
    find\_library(
        # 设置路径变量的名称。
        hilog-lib
        # 指定希望CMake定位的NDK库的名称。
        hilog\_ndk.z
    )
    find\_library(
        # 设置路径变量的名称。
        libace-lib
        # 指定希望CMake定位的NDK库的名称。
        ace\_ndk.z
    )
    find\_library(
        # 设置路径变量的名称。
        libnapi-lib
        # 指定希望CMake定位的NDK库的名称。
        ace\_napi.z
    )
    find\_library(
        # 设置路径变量的名称。
        libuv-lib
        # 指定希望CMake定位的NDK库的名称。
        uv
    )
    add\_library(libassimp SHARED IMPORTED)
    set\_target\_properties(
            libassimp
            PROPERTIES
            IMPORTED\_LOCATION
            ${CMAKE\_CURRENT\_SOURCE\_DIR}/libs/arm64-v8a/libassimp.so
    )
    find\_library(
    # 设置路径变量的名称。
    xengine-lib
    # 指定希望CMake定位的NDK库的名称。
    xengine
    )
    target\_link\_libraries(nativerender PUBLIC
        ${hilog-lib} ${libace-lib} ${libnapi-lib} ${libuv-lib} libnative\_window.so libc++.a libktx librawfile.z.so libassimp ${xengine-lib})
    

#### \[h2\]集成XEngine时域AI超分（OpenGL ES）

使用EGL和OpenGL ES图形API搭建图像渲染管线并集成时域AI超分在Native层实现，渲染结果通过[XComponent](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/ts-basic-components-xcomponent)组件显示到屏幕。

本节阐述OpenGL ES图形API的时域AI超分的使用。

在调用XEngine Kit能力前，需要先通过[Syscap](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/syscap#什么是systemcapabilitysyscap)查询您的目标设备是否支持SystemCapability.Graphic.XEngine系统能力。

1.  调用[HMS\_XEG\_GetString](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine#hms_xeg_getstring)接口，获取XEngine支持的扩展信息，只有在支持[XEG\_TEMPORAL\_UPSCALE\_EXTENSION\_NAME](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine#xeg_temporal_upscale_extension_name)扩展时才可以使用时域AI超分的相关接口。
    
    // 查询XEngine支持的GLES扩展信息
    const char\* extensions = (const char\*)HMS\_XEG\_GetString(XEG\_EXTENSIONS);
    // 检查是否支持时域AI超分
    if (!strstr(extensions, XEG\_TEMPORAL\_UPSCALE\_EXTENSION\_NAME)) {
        exit(1); // 异常退出
    }
    
2.  调用[HMS\_XEG\_TemporalUpscaleParameter](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine#hms_xeg_temporalupscaleparameter)接口，对时域AI超分的参数赋值。
    
    // m\_lowResWidth与m\_lowResHeight分别为用户自定义的渲染宽度与渲染高度，此处以800\*600分辨率为例
    uint32\_t m\_lowResWidth = 800;
    uint32\_t m\_lowResHeight = 600;
    // 设置相机抖动的周期数，此处以8为例
    GLuint jitterNum = 8;
    
    GLsizei inputSize\[2\] = {static\_cast<GLsizei>(m\_lowResWidth), static\_cast<GLsizei>(m\_lowResHeight)};
    // 设置超分输入纹理的真实宽高
    HMS\_XEG\_TemporalUpscaleParameter(XEG\_TEMPORAL\_UPSCALE\_INPUT\_SIZE, inputSize);
    
    HMS\_XEG\_TemporalUpscaleParameter(XEG\_TEMPORAL\_UPSCALE\_JITTER\_NUM, &jitterNum);
    
    // 设置是否存在深度反转，此处为不存在深度反转
    GLboolean isDepthReversed = GL\_FALSE;
    HMS\_XEG\_TemporalUpscaleParameter(XEG\_TEMPORAL\_UPSCALE\_DEPTH\_REVERSED, &isDepthReversed);
    
    // 设置是否重置历史帧数据，true表示重置，false表示不重置。在历史帧未使用超分，并且当前帧开始使用超分的情况下建议设置为true
    GLboolean resetHistory = GL\_TRUE;
    HMS\_XEG\_TemporalUpscaleParameter(XEG\_TEMPORAL\_UPSCALE\_RESET\_HISTORY, &resetHistory);
    
    // 设置画面偏向当前帧（鬼影少但可能存在闪烁）还是历史帧（鬼影多但是更稳定）的平衡程度。此处以0.5为例
    GLfloat steadyLevel = 0.5;
    HMS\_XEG\_TemporalUpscaleParameter(XEG\_TEMPORAL\_UPSCALE\_STEADY\_LEVEL, &steadyLevel);
    
3.  调用[HMS\_XEG\_RenderTemporalUpscale](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine#hms_xeg_rendertemporalupscale)接口进行超分，每帧都需要调用。
    
    其中，参数jitterX和jitterY分别为相机在X方向和Y方向的抖动，是一个类似Halton的低差异序列。
    
    本例使用Halton算法计算Jitter值：使用Halton算法生成一个\[0.0, 1.0\]的序列，再减去0.5使序列范围保持在\[-0.5, 0.5\]，最后除以输入图像的分辨率，得到UV坐标下的Jitter值。
    
    1.  根据Halton算法生成每帧需要的相机抖动（Jitter）。
        
        // Halton算法示例
        float GetHaltonSequence(uint32\_t index, uint32\_t base) {
            float result = 0.0;
            float fraction = 1.0 / base;
            while (index > 0) {
                result += fraction \* (index % base);
                index /= base;
                fraction /= base;
            }
            return result;
        }
        // 当前帧数，需要每帧+1，用于确定当前帧使用的Jitter值，使Jitter值在JitterNum范围内轮转
        uint64\_t frameNum = 0;
        // jitterX与jitterY分别为相机在X和Y方向上的抖动
        float jitterX = 0.0;
        float jitterY = 0.0;
        
        // 此处需要保证生成的低差异序列长度与jitterNum保持一致，且在\[-0.5, 0.5\]的范围内
        jitterX = GetHaltonSequence((frameNum % jitterNum) + 1, 2) - 0.5;
        jitterY = GetHaltonSequence((frameNum % jitterNum) + 1, 3) - 0.5;
        // m\_lowResWidth与m\_lowResHeight为步骤2中的输入图像的宽度和高度
        jitterX = jitterX / m\_lowResWidth;
        jitterY = jitterY / m\_lowResHeight;
        
    2.  调用时域AI超分渲染接口。
        
        // 这里表示第一帧使用超分的情况下设置resetHistory为true，否则设置为false
        resetHistory = frameNum == 0 ? GL\_TRUE : GL\_FALSE;
        HMS\_XEG\_TemporalUpscaleParameter(XEG\_TEMPORAL\_UPSCALE\_RESET\_HISTORY, &resetHistory);
        
        // m\_upscaleFBO为用户自定义创建的超分后的framebuffer
        unsigned int m\_upscaleFBO;
        unsigned int m\_highResWidth;
        unsigned int m\_highResHeight;
        unsigned int m\_lowLightColorTexture;
        unsigned int m\_lowGboDepth;
        unsigned int m\_motionVectorTexture, m\_dynamicMaskTexture;
        
        glBindFramebuffer(GL\_FRAMEBUFFER, m\_upscaleFBO);
        glViewport(0, 0, m\_highResWidth, m\_highResHeight);
        glScissor(0, 0, m\_highResWidth, m\_highResHeight);
        
        // m\_lowLightColorTexture为超分输入纹理。
        // m\_lowGboDepth为深度纹理。
        // m\_motionVectorTexture为运动矢量图像。运动矢量的计算方式为当前渲染像素的NDC坐标的XY值减去上一帧的NDC坐标的XY值。
        // m\_dynamicMaskTexture为物体的动态遮罩图像，格式需要是GL\_RED或其兼容格式。R通道的合法值为0.0、0.2或1.0，其中0.0表示静态物体，0.2表示运动物体如人物，1.0表示特效或半透明物体。
        // jitterX 相机在X方向上的抖动，通常为超分依赖的前序渲染过程中应用的亚像素抖动，包含在相机的投影矩阵中；在ndc坐标系下，其取值范围是 \[-1/width, 1/width\], width是输入inputTexture纹理的宽度（像素数）。
        // jitterY 相机在Y方向上的抖动，通常为超分依赖的前序渲染过程中应用的亚像素抖动，包含在相机的投影矩阵中；在ndc坐标系下，其取值范围是 \[-1/height, 1/height\], height是输入inputTexture纹理的高度（像素数）。
        HMS\_XEG\_RenderTemporalUpscale(m\_lowLightColorTexture, m\_lowGboDepth, m\_motionVectorTexture, m\_dynamicMaskTexture,
                                      -0.5\*jitterX, -0.5\*jitterY);
        

#### \[h2\]集成XEngine时域AI超分（Vulkan）

使用Vulkan图形API搭建图像渲染管线，并集成时域AI超分在Native层实现，渲染结果通过[XComponent](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/ts-basic-components-xcomponent)组件显示到屏幕。

本节阐述Vulkan图形API的时域AI超分使用，详细代码请参见[Samplecode](https://gitcode.com/harmonyos_samples/xengine-samplecode-vulkan-temporal-upscale-demo-cpp)。

在调用XEngine Kit能力前，需要先通过[Syscap](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/syscap#什么是systemcapabilitysyscap)查询您的目标设备是否支持SystemCapability.Graphic.XEngine系统能力。

1.  调用[HMS\_XEG\_EnumerateDeviceExtensionProperties](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine#hms_xeg_enumeratedeviceextensionproperties)接口，获取XEngine支持的扩展信息，只有在支持[XEG\_TEMPORAL\_UPSCALE\_EXTENSION\_NAME](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine#xeg_temporal_upscale_extension_name)扩展时才可以使用时域AI超分的相关接口。
    
    // physicalDevice为Vulkan物理设备，用户需进行初始化
    VkPhysicalDevice physicalDevice;
    // 查询XEngine支持的Vulkan扩展列表
    std::vector<std::string> supportedExtensions;
    uint32\_t pPropertyCount;
    HMS\_XEG\_EnumerateDeviceExtensionProperties(physicalDevice, &pPropertyCount, nullptr);
    if (pPropertyCount > 0) {
        std::vector<XEG\_ExtensionProperties> pProperties(pPropertyCount);
        if (HMS\_XEG\_EnumerateDeviceExtensionProperties(physicalDevice, &pPropertyCount,
            &pProperties.front()) == VK\_SUCCESS) {
            for (auto ext : pProperties) {
                supportedExtensions.push\_back(ext.extensionName);
            }
        }
    }
    // 查询是否支持时域AI超分
    if (std::find(supportedExtensions.begin(), supportedExtensions.end(), XEG\_TEMPORAL\_UPSCALE\_EXTENSION\_NAME) ==
        supportedExtensions.end()) {
        exit(1); // 异常退出
    }
    
2.  声明实例句柄。
    
    XEG\_TemporalUpscale xegTemporalUpscale;
    
3.  调用[HMS\_XEG\_CreateTemporalUpscale](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine#hms_xeg_createtemporalupscale)接口，创建时域AI超分实例。
    
    // 渲染宽高和超分后宽高均为用户自定义参数，这里将以800\*600的分辨率进行1.5倍超分到1200\*900的分辨率为例
    uint32\_t lowResWidth = 800;
    uint32\_t lowResHeight = 600;
    uint32\_t highResWidth = 1200;
    uint32\_t highResHeight = 900;
    VkRect2D dstRect2D;
    dstRect2D.offset.x = 0;
    dstRect2D.offset.y = 0;
    dstRect2D.extent.width = highResWidth;
    dstRect2D.extent.height = highResHeight;
    const uint32\_t jitterNum = 8;
    // Vulkan逻辑设备，用户需进行初始化
    VkDevice device;
    // XEG\_TemporalUpscaleCreateInfo为创建XEG\_TemporalUpscale对象所需信息
    XEG\_TemporalUpscaleCreateInfo createInfo;
    // 指定输入图像的大小，即低分辨率图像的尺寸
    createInfo.inputSize = {lowResWidth, lowResHeight};
    // 指定输出图像的大小，即高分辨率图像的尺寸
    createInfo.outputSize = {highResWidth, highResHeight};
    createInfo.outputRegion = dstRect2D;
    // 指定输出图像的颜色格式
    createInfo.outputFormat = VK\_FORMAT\_R8G8B8A8\_UNORM;
    // jitterNum为相机抖动的周期数
    createInfo.jitterNum = jitterNum;
    // 指定了深度值是否反转
    createInfo.isDepthReversed = true;
    VkResult res = HMS\_XEG\_CreateTemporalUpscale(device, &createInfo, &xegTemporalUpscale);
    if (res != VK\_SUCCESS) {
        exit(1); // 异常退出
    }
    
4.  调用[HMS\_XEG\_CmdRenderTemporalUpscale](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine#hms_xeg_cmdrendertemporalupscale)接口下发超分，每帧都需要调用。
    
    其中，参数jitterX和jitterY分别为相机在X方向和Y方向的抖动，是一个类似Halton的低差异序列。
    
    本例使用Halton算法计算Jitter值：使用Halton算法生成一个\[0.0, 1.0\]的序列，再减去0.5使序列范围保持在\[-0.5, 0.5\]，最后除以输入图像的分辨率，得到UV坐标下的Jitter值。
    
    1.  根据Halton算法生成每帧需要的相机抖动（Jitter）。
        
        // Halton算法示例
        float GetHaltonSequence(uint32\_t index, uint32\_t base) {
            float result = 0.0;
            float fraction = 1.0 / base;
            while (index > 0) {
                result += fraction \* (index % base);
                index /= base;
                fraction /= base;
            }
            return result;
        }
        
    2.  调用时域AI超分渲染接口。
        
        // 当前帧数，需要每帧+1，用于确定当前帧使用的Jitter值，使Jitter值在JitterNum范围内轮转
        uint64\_t frameNum = 0;
        // jitterX与jitterY分别为相机在X和Y方向上的抖动
        float jitterX = 0.0;
        float jitterY = 0.0;
        // 定义XEG\_TemporalUpscaleDescription对象xegDescription
        XEG\_TemporalUpscaleDescription xegDescription;
        // inputImageView为用户创建的超分输入图像的VkImageView
        VkImageView inputImageView = VK\_NULL\_HANDLE;
        // motionVectorImageView为用户创建的运动矢量图像的VkImageView
        VkImageView motionVectorImageView = VK\_NULL\_HANDLE;
        // depthImageView为用户创建的深度图像的VkImageView
        VkImageView depthImageView = VK\_NULL\_HANDLE;
        // dynamicMaskImageView为用户创建的物体动态遮罩图像的VkImageView
        VkImageView dynamicMaskImageView = VK\_NULL\_HANDLE;
        // outputImageView为用户创建的超分输出图像的VkImageView
        VkImageView outputImageView = VK\_NULL\_HANDLE;
        // commandBuffer为命令缓冲区，用户需进行初始化
        VkCommandBuffer commandBuffer = VK\_NULL\_HANDLE;
        xegDescription.inputImage = inputImageView;
        xegDescription.depthImage = depthImageView;
        xegDescription.motionVectorImage = motionVectorImageView;
        xegDescription.dynamicMaskImage = dynamicMaskImageView;
        xegDescription.outputImage = outputImageView;
        // 此处需要保证生成的低差异序列长度与jitterNum保持一致，且在\[-0.5, 0.5\]的范围内
        jitterX = GetHaltonSequence((frameNum % jitterNum) + 1, 2) - 0.5;
        jitterY = GetHaltonSequence((frameNum % jitterNum) + 1, 3) - 0.5;
        // lowResWidth与lowResHeight为步骤3中的输入图像的宽度和高度
        jitterX = jitterX / lowResWidth;
        jitterY = jitterY / lowResHeight;
        xegDescription.jitterX = -jitterX;
        xegDescription.jitterY = -jitterY;
        // resetHistory为选择是否重置历史帧数据，true表示重置，false则表示不重置，此处以true为例
        xegDescription.resetHistory = (frameNum == 0) ? true : false;
        // steadyLevel为画面偏向当前帧还是历史帧的平衡程度，取值范围为\[0.0, 1.0\]，此处以平衡程度为0.5为例
        xegDescription.steadyLevel = 0.5;
        HMS\_XEG\_CmdRenderTemporalUpscale(commandBuffer, xegTemporalUpscale, &xegDescription);
        
5.  调用[HMS\_XEG\_DestroyTemporalUpscale](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/xengine-kit-xengine#hms_xeg_destroytemporalupscale)接口销毁实例。
    
    if (xegTemporalUpscale) {
        HMS\_XEG\_DestroyTemporalUpscale(xegTemporalUpscale);
    }