视频解码
====

视频解码是多媒体处理的核心环节，功能是将压缩的视频码流解码为原始像素数据。视频解码支持同步模式与异步模式两种运行机制，两者主要区别为buffer获取方式的同异步之分，开发者可根据自身业务选择适合的接口调用模式。

本文档主要介绍异步模式视频解码的实现流程，同步模式视频解码请参考[视频解码同步模式](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/synchronous-video-decoding)。根据解码后数据处理方式的不同，视频解码支持Surface模式和Buffer模式两种输出模式，适用于不同的应用场景。

*   Surface模式。
    
    解码后的图像帧通过[NativeWindow](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-nativewindow-nativewindow)来传递输出数据，可以与其他模块对接（如显示模块[自定义渲染(XComponent)](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/napi-xcomponent-guidelines)）。适用于视频播放、实时预览等需要将画面渲染到屏幕的解码场景。
    
*   Buffer模式。
    
    解码后的原始YUV数据通过共享内存输出，开发者可直接访问和处理每一帧图像数据。适用于视频编辑、YUV原始数据保存等需要获取并处理原始数据的解码场景。
    

| 差异 | surface模式 | buffer模式 |
| :-- | :-- | :-- |
| 配置 | 在调用OH\_VideoDecoder\_Prepare接口前，必须调用OH\_VideoDecoder\_SetSurface接口设置OHNativeWindow。 | \- |
| 输出处理 | 
不送显：调用OH\_VideoDecoder\_FreeOutputBuffer接口丢弃解码帧。

送显：调用OH\_VideoDecoder\_RenderOutputBuffer接口显示并释放解码帧，或调用OH\_VideoDecoder\_RenderOutputBufferAtTime接口在指定时间点显示并释放解码帧。如需实现音画同步或者控制显示速度，建议优先调用OH\_VideoDecoder\_RenderOutputBufferAtTime接口送显。

 | 输出数据处理后，必须调用OH\_VideoDecoder\_FreeOutputBuffer接口释放数据。 |
| 回调数据 | 在Surface模式下，只能获取到输出回调buffer的数据信息。 | 在Buffer模式下，可以获取到输出回调buffer的共享内存的地址和数据信息。 |

AVCodec支持的视频解码格式请参考[视频解码](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/avcodec-support-formats#视频解码)。

具体实现可参考[示例工程](https://gitcode.com/openharmony/applications_app_samples/tree/master/code/BasicFeature/Media/AVCodec)。

#### 状态机调用关系

1.  初始化状态（Initialized）。
    *   初始创建解码器实例时，解码器处于Initialized状态。
    *   任何状态下，调用OH\_VideoDecoder\_Reset接口，可返回Initialized状态。
2.  配置状态（Configured）。
    *   Initialized状态下，调用OH\_VideoDecoder\_Configure接口配置解码器，配置成功后解码器进入Configured状态。
3.  就绪状态（Prepared）。
    *   Configured状态下，调用OH\_VideoDecoder\_Prepare接口进入Prepared状态。
    *   Executing状态下，调用OH\_VideoDecoder\_Stop接口，可返回到Prepared状态。
4.  运行状态（Executing）。
    *   Prepared状态下，调用OH\_VideoDecoder\_Start接口进入Executing状态。
    *   Executing状态包含三个子状态：
        *   Running：调用OH\_VideoDecoder\_Start接口进入Running子状态。
        *   Flushed：调用OH\_VideoDecoder\_Flush接口进入Flushed子状态。
        *   End-of-Stream：解码器接收到输入buffer的flag为[OH\_AVCodecBufferFlags](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-avbuffer-info-h#oh_avcodecbufferflags)中的AVCODEC\_BUFFER\_FLAGS\_EOS时，进入End-of-Stream子状态。在此状态下，解码器不再接受新的输入，但是仍然会继续生成输出，直到输出尾帧。
5.  错误状态（Error）。
    *   极少数情况下，解码器异常时进入Error状态，接口会返回错误码或通过OH\_AVCodecOnError回调抛出异常。
    *   Error状态下，可以调用OH\_VideoDecoder\_Reset接口返回Initialized状态，或者调用OH\_VideoDecoder\_Destroy接口进入最后的Released状态。
6.  释放状态（Released）。
    *   使用完解码器后，必须调用OH\_VideoDecoder\_Destroy接口销毁解码器实例，使解码器进入Released状态。

**图1** 状态机调用关系示意图

![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/72/v3/sNEmyxL6SqK4K-CCUuEnSg/zh-cn_image_0000002594828724.png?HW-CC-KV=V1&HW-CC-Date=20260612T073508Z&HW-CC-Expire=86400&HW-CC-Sign=DEE13173149DBF56D113147DB80A77CBF20A4BAC858BF4A401AD89150AD4B3BA)

#### 开发指导

详细的API说明请参考[native\_avcodec\_videodecoder.h](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-avcodec-videodecoder-h)。

参考以下示例代码，完成视频解码的基础流程，包括：创建解码器、设置解码参数、开始、刷新、重置、停止、销毁资源。

**图2** 视频解码调用关系示意图

*   虚线表示可选。
    
*   实线表示必选。
    

![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/37/v3/hKSiNDaqREam1OofxcuzmA/zh-cn_image_0000002625108321.png?HW-CC-KV=V1&HW-CC-Date=20260612T073508Z&HW-CC-Expire=86400&HW-CC-Sign=A5E520810B1C906624FDA7264E4E6A226CF364A176E834E9FD0A8B6CC84E38FF)

#### \[h2\]在 CMake 脚本中链接动态库

target\_link\_libraries(sample PUBLIC libnative\_media\_codecbase.so)
target\_link\_libraries(sample PUBLIC libnative\_media\_core.so)
target\_link\_libraries(sample PUBLIC libnative\_media\_vdec.so)

![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/58/v3/SqjO4LQ-QbqIZaAyGRvyLw/note_3.0-zh-cn.png?HW-CC-KV=V1&HW-CC-Date=20260612T073508Z&HW-CC-Expire=86400&HW-CC-Sign=432D7609EA0F304D2D0E8DB7F5BD7B00EF7F4E09E3A2E681EC0FB0A2FADB80D0)

上述'sample'字样仅为示例，此处由开发者根据实际工程目录自定义。

#### \[h2\]定义基础结构

本部分示例代码按照C++17标准编写，仅作参考。开发者可以参考此部分，定义自己的buffer对象。

1.  添加头文件。
    
    #include <condition\_variable>
    #include <memory>
    #include <mutex>
    #include <queue>
    #include <shared\_mutex>
    
2.  解码器回调buffer的信息。
    
    struct CodecBufferInfo {
        CodecBufferInfo(uint32\_t index, OH\_AVBuffer \*buffer): index(index), buffer(buffer), isValid(true) {}
        // 回调buffer。
        OH\_AVBuffer \*buffer = nullptr;
        // 回调buffer对应的index。
        uint32\_t index = 0;
        // 判断当前buffer信息是否有效。
        bool isValid = true;
    };
    
3.  解码输入输出队列。
    
    class CodecBufferQueue {
    public:
        // 将回调buffer的信息传入队列。
        void Enqueue(const std::shared\_ptr<CodecBufferInfo> bufferInfo)
        {
            std::unique\_lock<std::mutex> lock(mutex\_);
            bufferQueue\_.push(bufferInfo);
            cond\_.notify\_all();
        }
    
        // 获取回调buffer的信息。
        std::shared\_ptr<CodecBufferInfo> Dequeue(int32\_t timeoutMs = 1000)
        {
            std::unique\_lock<std::mutex> lock(mutex\_);
            (void)cond\_.wait\_for(lock, std::chrono::milliseconds(timeoutMs), \[this\]() { return !bufferQueue\_.empty(); });
            if (bufferQueue\_.empty()) {
                return nullptr;
            }
            std::shared\_ptr<CodecBufferInfo> bufferInfo = bufferQueue\_.front();
            bufferQueue\_.pop();
            return bufferInfo;
        }
    
        // 清空队列，之前的回调buffer设置为不可用。
        void Flush()
        {
            std::unique\_lock<std::mutex> lock(mutex\_);
            while (!bufferQueue\_.empty()) {
                std::shared\_ptr<CodecBufferInfo> bufferInfo = bufferQueue\_.front();
                // Flush、Stop、Reset、Destroy操作之后，之前回调的buffer信息设置为无效。
                bufferInfo->isValid = false;
                bufferQueue\_.pop();
            }
        }
    
    private:
        std::mutex mutex\_;
        std::condition\_variable cond\_;
        std::queue<std::shared\_ptr<CodecBufferInfo>> bufferQueue\_;
    };
    
4.  全局变量。
    
    仅作参考，可以根据实际情况将其封装到对象中。
    
    // 视频帧宽度。
    int32\_t width = 320;
    // 视频帧高度。
    int32\_t height = 240;
    // 视频像素格式。
     OH\_AVPixelFormat pixelFormat = AV\_PIXEL\_FORMAT\_NV12;
    // 视频宽跨距。
    int32\_t widthStride = 0;
    // 视频高跨距。
    int32\_t heightStride = 0;
    // 解码器实例指针。
    OH\_AVCodec \*videoDec = nullptr;
    // 解码器同步锁。
    std::shared\_mutex codecMutex;
    // 解码器输入队列。
    CodecBufferQueue inQueue;
    // 解码器输出队列。
    CodecBufferQueue outQueue;
    

#### \[h2\]Surface模式

参考以下示例代码，可以完成Surface模式下视频解码的全流程，实现异步模式的数据轮转。此处以输入H.264码流文件，解码送显输出为例。

1.  添加头文件。
    
    #include <multimedia/player\_framework/native\_avcodec\_videodecoder.h>
    #include <multimedia/player\_framework/native\_avcapability.h>
    #include <multimedia/player\_framework/native\_avcodec\_base.h>
    #include <multimedia/player\_framework/native\_avformat.h>
    #include <multimedia/player\_framework/native\_avbuffer.h>
    #include <fstream>
    
2.  创建解码器实例。
    
    开发者可以通过名称或媒体类型创建解码器。示例中的变量说明如下：
    
    *   videoDec：视频解码器实例的指针；
    *   capability：解码器能力查询实例的指针；
    *   OH\_AVCODEC\_MIMETYPE\_VIDEO\_AVC：AVC格式视频编解码器。
    
    // 通过codec name创建解码器，应用有特殊需求，比如选择支持某种分辨率规格的解码器，可先查询capability，再根据codec name创建解码器。
    OH\_AVCapability \*capability = OH\_AVCodec\_GetCapability(OH\_AVCODEC\_MIMETYPE\_VIDEO\_AVC, false);
    // 创建硬件解码器实例。
    OH\_AVCapability \*capability= OH\_AVCodec\_GetCapabilityByCategory(OH\_AVCODEC\_MIMETYPE\_VIDEO\_AVC, false, HARDWARE);
    const char \*name = OH\_AVCapability\_GetName(capability);
    OH\_AVCodec \*videoDec = OH\_VideoDecoder\_CreateByName(name);
    
    // 通过MIME TYPE创建解码器，只能创建系统推荐的特定编解码器。
    // 涉及创建多路编解码器时，优先创建硬件解码器实例，硬件资源不够时再创建软件解码器实例。
    // 软/硬解：创建H.264解码器实例。
    OH\_AVCodec \*videoDec = OH\_VideoDecoder\_CreateByMime(OH\_AVCODEC\_MIMETYPE\_VIDEO\_AVC);
    // 软/硬解：创建H.265解码器实例。
    OH\_AVCodec \*videoDec = OH\_VideoDecoder\_CreateByMime(OH\_AVCODEC\_MIMETYPE\_VIDEO\_HEVC);
    
3.  调用OH\_VideoDecoder\_RegisterCallback()设置回调函数。
    
    注册回调函数指针集合OH\_AVCodecCallback，包括：
    
    *   OH\_AVCodecOnError 解码器运行错误，返回的错误码详情请参见：[OH\_AVCodecOnError](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-avcodec-base-h#oh_avcodeconerror)；
    *   OH\_AVCodecOnStreamChanged 码流信息变化，如码流宽、高变化；
    *   OH\_AVCodecOnNeedInputBuffer 运行过程中需要新的输入数据，即解码器已准备好，可以输入数据；
    *   OH\_AVCodecOnNewOutputBuffer 运行过程中产生了新的输出数据，即解码完成。
    
    开发者可以通过处理该回调报告的信息，确保解码器正常运转。
    
    回调函数的具体实现可参考[示例工程](https://gitcode.com/openharmony/applications_app_samples/tree/master/code/BasicFeature/Media/AVCodec)。
    
    // 解码异常回调OH\_AVCodecOnError实现。
    static void OnError(OH\_AVCodec \*codec, int32\_t errorCode, void \*userData)
    {
        // 回调的错误码由开发者判断处理。
        (void)codec;
        (void)errorCode;
        (void)userData;
    }
    
    // 解码数据流变化回调OH\_AVCodecOnStreamChanged实现。
    // 解码输入码流分辨率发生变化时触发此回调函数。
    static void OnStreamChanged(OH\_AVCodec \*codec, OH\_AVFormat \*format, void \*userData)
    {
        // 可通过format获取到变化后的视频宽、高等。
        (void)codec;
        (void)userData;
        bool ret = OH\_AVFormat\_GetIntValue(format, OH\_MD\_KEY\_VIDEO\_PIC\_WIDTH, &width) &&
                   OH\_AVFormat\_GetIntValue(format, OH\_MD\_KEY\_VIDEO\_PIC\_HEIGHT, &height);
        if (!ret) {
            // 异常处理。
        }
    }
    
    // 解码输入回调OH\_AVCodecOnNeedInputBuffer实现。
    static void OnNeedInputBuffer(OH\_AVCodec \*codec, uint32\_t index, OH\_AVBuffer \*buffer, void \*userData)
    {
        // 输入帧的数据buffer和对应的index送入inQueue队列。
        (void)codec;
        (void)userData;
        inQueue.Enqueue(std::make\_shared<CodecBufferInfo>(index, buffer));
    }
    
    // 解码输出回调OH\_AVCodecOnNewOutputBuffer实现。
    static void OnNewOutputBuffer(OH\_AVCodec \*codec, uint32\_t index, OH\_AVBuffer \*buffer, void \*userData)
    {
        // 完成帧的数据buffer和对应的index送入outQueue队列。
        (void)codec;
        (void)userData;
        outQueue.Enqueue(std::make\_shared<CodecBufferInfo>(index, buffer));
    }
    
    // 配置异步回调，调用 OH\_VideoDecoder\_RegisterCallback 接口。
    OH\_AVCodecCallback cb = {&OnError, &OnStreamChanged, &OnNeedInputBuffer, &OnNewOutputBuffer};
    // 配置异步回调。
    OH\_AVErrCode ret = OH\_VideoDecoder\_RegisterCallback(videoDec, cb, nullptr); // nullptr:开发者执行回调所依赖的数据userData为空。
    if (ret != AV\_ERR\_OK) {
        // 异常处理。
    }
    
    ![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/41/v3/OV6jqQs8Rn6ImCSMYuGSmg/note_3.0-zh-cn.png?HW-CC-KV=V1&HW-CC-Date=20260612T073508Z&HW-CC-Expire=86400&HW-CC-Sign=4A30CA99255E816A029A4DF552D8D8D2C7BEAF49A4E989BA8676D4EB31646B34)
    
    1.  在回调函数中，对数据队列进行操作时，需要注意多线程同步的问题。
    2.  播放视频时，若视频码流的SPS（Sequence Parameter Set）中包含颜色信息（如RangeFlag、ColorPrimary、MatrixCoefficient、TransferCharacteristic），解码器会把这些信息通过OH\_AVCodecOnStreamChanged接口中的OH\_AVFormat返回。
    3.  视频解码的Surface模式下，内部数据默认是走HEBC（High Efficiency Bandwidth Compression，高效带宽压缩），无法获取到widthStride和heightStride的值。
    
4.  （可选）OH\_VideoDecoder\_SetDecryptionConfig设置解密配置。在获取到DRM信息（参考[音视频解封装](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/audio-video-demuxer)开发步骤第4步），完成DRM许可证申请后，通过此接口进行解密配置。此接口需在Prepare前调用。在Surface模式下，DRM解密能力既支持安全视频通路，也支持非安全视频通路。DRM相关接口详见[DRM API文档](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-drm)。
    
    添加头文件。
    
    #include <multimedia/drm\_framework/native\_mediakeysystem.h>
    #include <multimedia/drm\_framework/native\_mediakeysession.h>
    #include <multimedia/drm\_framework/native\_drm\_err.h>
    #include <multimedia/drm\_framework/native\_drm\_common.h>
    
    在CMake脚本中链接动态库。
    
    target\_link\_libraries(sample PUBLIC libnative\_drm.so)
    
    根据DRM码流要求的内容保护级别和硬件设备支持的内容保护级别创建对应的通路。
    
    如果DRM码流要求的内容保护级别是硬件级保护，则推荐使用安全视频通路，示例如下：
    
    // 根据DRM信息创建指定的DRM系统, 以创建"com.wiseplay.drm"为例
    MediaKeySystem \*system = nullptr;
    int32\_t ret = OH\_MediaKeySystem\_Create("com.wiseplay.drm", &system);
    if (system == nullptr) {
        printf("create media key system failed");
        return;
    }
    
    // 创建解密会话，如果使用安全视频通路，应创建CONTENT\_PROTECTION\_LEVEL\_HW\_CRYPTO及其以上内容保护级别的MediaKeySession；
    MediaKeySession \*session = nullptr;
    DRM\_ContentProtectionLevel contentProtectionLevel = CONTENT\_PROTECTION\_LEVEL\_HW\_CRYPTO;
    ret = OH\_MediaKeySystem\_CreateMediaKeySession(system, &contentProtectionLevel, &session);
    if (ret != DRM\_OK) {
        // 如创建失败，请查看DRM接口文档及日志信息
        printf("create media key session failed.");
        return;
    }
    if (session == nullptr) {
        printf("media key session is nullptr.");
        return;
    }
    
    // 获取许可证请求、设置许可证响应等
    
    // 设置解密配置, 即将解密会话、安全视频通路标志设置到解码器中
    // 如果DRM解决方案支持安全视频通路，在使用安全视频通路时，需将secureVideoPath设置为true，并在此之前须创建安全解码器
    // 即在步骤3使用OH\_VideoDecoder\_CreateByName函数、参数为解码器名称后拼接.secure（如“\[CodecName\].secure”）创建安全解码器
    bool secureVideoPath = true;
    ret = OH\_VideoDecoder\_SetDecryptionConfig(videoDec, session, secureVideoPath);
    
    如果DRM码流要求的内容保护级别是软件级保护，则推荐使用非安全视频通路，示例如下：
    
    // 根据DRM信息创建指定的DRM系统，以创建"com.wiseplay.drm"为例。
    MediaKeySystem \*system = nullptr;
    int32\_t ret = OH\_MediaKeySystem\_Create("com.wiseplay.drm", &system);
    if (system == nullptr) {
        printf("create media key system failed");
        return;
    }
    
    // 创建解密会话，如果使用安全视频通路，应创建CONTENT\_PROTECTION\_LEVEL\_HW\_CRYPTO及其以上内容保护级别的MediaKeySession。
    // 如果使用非安全视频通路，应创建CONTENT\_PROTECTION\_LEVEL\_SW\_CRYPTO及以上内容保护级别的MediaKeySession。
    MediaKeySession \*session = nullptr;
    DRM\_ContentProtectionLevel contentProtectionLevel = CONTENT\_PROTECTION\_LEVEL\_SW\_CRYPTO;
    ret = OH\_MediaKeySystem\_CreateMediaKeySession(system, &contentProtectionLevel, &session);
    if (ret != DRM\_ERR\_OK) {
        // 如创建失败，请查看DRM接口文档及日志信息。
        printf("create media key session failed.");
        return;
    }
    if (session == nullptr) {
        printf("media key session is nullptr.");
        return;
    }
    
    // 获取许可证请求、设置许可证响应等。
    
    // 设置解密配置，即将解密会话、安全视频通路标志设置到解码器中。
    // 如果DRM解决方案支持安全视频通路，在使用安全视频通路时，需将secureVideoPath设置为true，并在此之前须创建安全解码器。
    // 即在步骤2使用OH\_VideoDecoder\_CreateByName函数、参数为解码器名称后拼接.secure（如“\[CodecName\].secure”）创建安全解码器。
    bool secureVideoPath = false;
    ret = OH\_VideoDecoder\_SetDecryptionConfig(videoDec, session, secureVideoPath);
    
5.  调用OH\_VideoDecoder\_Configure()配置解码器。
    
    详细可配置选项的说明请参考[媒体数据键值对](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-codecbase#媒体数据键值对)中的视频专有键值对。
    
    参数校验规则请参考[OH\_VideoDecoder\_Configure() 参考文档](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-avcodec-videodecoder-h#oh_videodecoder_configure)。
    
    参数取值范围可以通过能力查询接口获取，具体示例请参考[获取支持的编解码能力](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/obtain-supported-codecs)。
    
    目前支持的所有格式都必须配置以下选项：视频帧宽度、视频帧高度。
    
    auto format = std::shared\_ptr<OH\_AVFormat>(OH\_AVFormat\_Create(), OH\_AVFormat\_Destroy);
    if (format == nullptr) {
        // 异常处理。
    }
    // 写入format。
    OH\_AVFormat\_SetIntValue(format.get(), OH\_MD\_KEY\_WIDTH, width); // 必须配置。
    OH\_AVFormat\_SetIntValue(format.get(), OH\_MD\_KEY\_HEIGHT, height); // 必须配置。
    OH\_AVFormat\_SetIntValue(format.get(), OH\_MD\_KEY\_PIXEL\_FORMAT, pixelFormat);
    // 可选，配置低时延解码。
    // 若平台支持，当使能OH\_MD\_KEY\_VIDEO\_ENABLE\_LOW\_LATENCY接口时，视频解码器将按照解码序输出帧。
    OH\_AVFormat\_SetIntValue(format.get(), OH\_MD\_KEY\_VIDEO\_ENABLE\_LOW\_LATENCY, 1);
    // 配置解码器。
    OH\_AVErrCode ret = OH\_VideoDecoder\_Configure(videoDec, format.get());
    if (ret != AV\_ERR\_OK) {
        // 异常处理。
    }
    
6.  设置surface。
    
    本例中的nativeWindow，有两种方式获取：
    
    6.1 如果解码后直接显示，则从XComponent组件获取。
    
    添加头文件。
    
    #include <native\_window/external\_window.h>
    
    在CMake脚本中链接动态库。
    
    target\_link\_libraries(sample PUBLIC libnative\_window.so)
    
    6.1.1 在ArkTS侧，通过xComponentController组件的getXComponentSurfaceId接口获取XComponent对应的surface的ID。详情请参考[自定义渲染 (XComponent)](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/napi-xcomponent-guidelines)。
    
    6.1.2 在Native侧，调用OH\_NativeWindow\_CreateNativeWindowFromSurfaceId接口创建出NativeWindow实例。
    
    OHNativeWindow\* nativeWindow;
    // 基于步骤1.1中获取的surfaceId创建对应的nativeWindow实例。
    OH\_NativeWindow\_CreateNativeWindowFromSurfaceId(surfaceId, &nativeWindow);
    
    6.2 如果解码后接OpenGL后处理，则从NativeImage获取，获取方式请参考 [NativeImage](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/native-image-guidelines)。
    
    Surface模式，开发者可以在解码过程中执行该步骤，即动态切换surface。
    
    // 设置surface。
    // 配置送显窗口参数。
    OH\_AVErrCode ret = OH\_VideoDecoder\_SetSurface(videoDec, nativeWindow);  // nativeWindow通过以上两种方式获取。
    if (ret != AV\_ERR\_OK) {
        // 异常处理。
    }
    // 配置视频与显示屏匹配模式（缓冲区按原比例缩放，使得缓冲区的较小边与窗口匹配，较长边超出窗口的部分被视为透明）。
    OH\_NativeWindow\_NativeWindowSetScalingModeV2(nativeWindow, OH\_SCALING\_MODE\_SCALE\_CROP\_V2);
    
    ![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/6d/v3/9TNURgFTRDKqvKjHCmwsJA/caution_3.0-zh-cn.png?HW-CC-KV=V1&HW-CC-Date=20260612T073508Z&HW-CC-Expire=86400&HW-CC-Sign=773ECF920F658AD00011DE5EC0DC1587462B0DE6D261C94553555B9257E2A730)
    
    若应用对1号和2号解码器均通过调用OH\_VideoDecoder\_SetSurface接口绑定至同一个NativeWindow。在2号解码器处于Running状态时，1号解码器调用OH\_VideoDecoder\_Destroy接口后，会导致2号解码器的视频播放画面卡住。
    
    可以采用以下方案进行更改：
    
    1.  等1号解码器完全释放后，再调用OH\_VideoDecoder\_Start接口启动2号解码器。
    2.  1号解码器用surface1，2号解码器先调用OH\_ConsumerSurface\_Create接口创建临时surface，等1号解码器释放后，再调用OH\_VideoDecoder\_SetSurface接口将2号解码器绑定至surface1上，详情请参见：[创建视频解码器和NativeWindow初始化并行](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/parallel-decoding-nativewindow)。
    
7.  调用OH\_VideoDecoder\_Prepare()解码器就绪。
    
    该接口将在解码器运行前进行一些数据的准备工作。
    
    OH\_AVErrCode ret = OH\_VideoDecoder\_Prepare(videoDec);
    if (ret != AV\_ERR\_OK) {
        // 异常处理。
    }
    
8.  调用OH\_VideoDecoder\_Start()启动解码器。
    
    // 启动解码器，开始解码。
    OH\_AVErrCode ret = OH\_VideoDecoder\_Start(videoDec);
    if (ret != AV\_ERR\_OK) {
        // 异常处理。
    }
    
9.  （可选）OH\_VideoDecoder\_SetParameter()动态配置解码器surface参数。
    
    详细可配置选项的说明请参考[媒体数据键值对](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-codecbase#媒体数据键值对)中的视频专有键值对。
    
    auto format = std::shared\_ptr<OH\_AVFormat>(OH\_AVFormat\_Create(), OH\_AVFormat\_Destroy);
    if (format == nullptr) {
        // 异常处理。
    }
    // 配置显示旋转角度。
    OH\_AVFormat\_SetIntValue(format.get(), OH\_MD\_KEY\_ROTATION, 90);
    OH\_AVErrCode ret = OH\_VideoDecoder\_SetParameter(videoDec, format.get());
    if (ret != AV\_ERR\_OK) {
        // 异常处理。
    }
    
10.  （可选）调用OH\_AVCencInfo\_SetAVBuffer()，设置cencInfo。
     
     若当前播放的节目是DRM加密节目，应用自行实现媒体解封装功能而非使用系统[解封装](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/audio-video-demuxer)功能时，需调用OH\_AVCencInfo\_SetAVBuffer()将cencInfo设置到AVBuffer，这样AVBuffer携带待解密的数据以及cencInfo，以实现AVBuffer中媒体数据的解密。当应用使用系统[解封装](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/audio-video-demuxer)功能时，则无需调用此接口。
     
     添加头文件。
     
     #include <multimedia/player\_framework/native\_cencinfo.h>
     
     在 CMake 脚本中链接动态库。
     
     target\_link\_libraries(sample PUBLIC libnative\_media\_avcencinfo.so)
     
     使用示例：
     
     *   buffer：回调函数OnNeedInputBuffer传入的参数。
     
     uint32\_t keyIdLen = DRM\_KEY\_ID\_SIZE;
     uint8\_t keyId\[\] = {
         0xd4, 0xb2, 0x01, 0xe4, 0x61, 0xc8, 0x98, 0x96,
         0xcf, 0x05, 0x22, 0x39, 0x8d, 0x09, 0xe6, 0x28};
     uint32\_t ivLen = DRM\_KEY\_IV\_SIZE;
     uint8\_t iv\[\] = {
         0xbf, 0x77, 0xed, 0x51, 0x81, 0xde, 0x36, 0x3e,
         0x52, 0xf7, 0x20, 0x4f, 0x72, 0x14, 0xa3, 0x95};
     uint32\_t encryptedBlockCount = 0;
     uint32\_t skippedBlockCount = 0;
     uint32\_t firstEncryptedOffset = 0;
     uint32\_t subsampleCount = 1;
     DrmSubsample subsamples\[1\] = { {0x10, 0x16} };
     // 创建CencInfo实例。
     OH\_AVCencInfo \*cencInfo = OH\_AVCencInfo\_Create();
     if (cencInfo == nullptr) {
         // 异常处理。
     }
     // 设置解密算法。
     OH\_AVErrCode errNo = OH\_AVCencInfo\_SetAlgorithm(cencInfo, DRM\_ALG\_CENC\_AES\_CTR);
     if (errNo != AV\_ERR\_OK) {
         // 异常处理。
     }
     // 设置KeyId和Iv。
     errNo = OH\_AVCencInfo\_SetKeyIdAndIv(cencInfo, keyId, keyIdLen, iv, ivLen);
     if (errNo != AV\_ERR\_OK) {
         // 异常处理。
     }
     // 设置Sample信息。
     errNo = OH\_AVCencInfo\_SetSubsampleInfo(cencInfo, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset,
         subsampleCount, subsamples);
     if (errNo != AV\_ERR\_OK) {
         // 异常处理。
     }
     // 设置模式：KeyId、Iv和SubSamples已被设置。
     errNo = OH\_AVCencInfo\_SetMode(cencInfo, DRM\_CENC\_INFO\_KEY\_IV\_SUBSAMPLES\_SET);
     if (errNo != AV\_ERR\_OK) {
         // 异常处理。
     }
     // 将CencInfo设置到AVBuffer中。
     errNo = OH\_AVCencInfo\_SetAVBuffer(cencInfo, buffer);
     if (errNo != AV\_ERR\_OK) {
         // 异常处理。
     }
     // 销毁CencInfo实例。
     errNo = OH\_AVCencInfo\_Destroy(cencInfo);
     if (errNo != AV\_ERR\_OK) {
         // 异常处理。
     }
     
11.  调用OH\_VideoDecoder\_PushInputBuffer()写入解码码流。
     
     送入输入队列进行解码，以下示例中：
     
     *   size、offset、pts、frameData：输入尺寸、偏移量、时间戳、帧数据等字段信息，获取方式可以参考[音视频解封装](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/audio-video-demuxer)“步骤-9：开始解封装，循环获取sample”。
     *   flags：缓冲区标记的类别，请参考[OH\_AVCodecBufferFlags](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-avbuffer-info-h#oh_avcodecbufferflags)。
     
     bufferInfo的成员变量：
     
     *   buffer：回调函数OnNeedInputBuffer传入的参数，可以通过[OH\_AVBuffer\_GetAddr](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-avbuffer-h#oh_avbuffer_getaddr)接口获取输入码流虚拟地址。
     *   index：回调函数OnNeedInputBuffer传入的参数，与buffer唯一对应的标识。
     *   isValid：bufferInfo中存储的buffer实例是否有效。
     
     std::shared\_ptr<CodecBufferInfo> bufferInfo = inQueue.Dequeue();
     std::shared\_lock<std::shared\_mutex> lock(codecMutex);
     if (bufferInfo == nullptr || !bufferInfo->isValid) {
         // 异常处理。
     }
     // 写入码流数据。
     uint8\_t \*addr = OH\_AVBuffer\_GetAddr(bufferInfo->buffer);
     if (addr == nullptr) {
        // 异常处理。
     }
     int32\_t capacity = OH\_AVBuffer\_GetCapacity(bufferInfo->buffer);
     if (size > capacity) {
         // 异常处理。
     }
     memcpy(addr, frameData, size);
     // 配置帧数据的输入尺寸、偏移量、时间戳等字段信息。
     OH\_AVCodecBufferAttr info;
     info.size = size;
     info.offset = offset;
     info.pts = pts;
     info.flags = flags;
     // info信息写入buffer。
     OH\_AVErrCode setBufferRet = OH\_AVBuffer\_SetBufferAttr(bufferInfo->buffer, &info);
     if (setBufferRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     // 送入解码输入队列进行解码。
     OH\_AVErrCode pushInputRet = OH\_VideoDecoder\_PushInputBuffer(videoDec, bufferInfo->index);
     if (pushInputRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     
12.  调用OH\_VideoDecoder\_RenderOutputBuffer()/OH\_VideoDecoder\_RenderOutputBufferAtTime()显示并释放解码帧，或调用OH\_VideoDecoder\_FreeOutputBuffer()释放解码帧。
     
     以下示例中，bufferInfo的成员变量：
     
     *   index：回调函数OnNewOutputBuffer传入的参数，与buffer唯一对应的标识；
     *   buffer：回调函数OnNewOutputBuffer传入的参数，Surface模式开发者无法通过[OH\_AVBuffer\_GetAddr](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-avbuffer-h#oh_avbuffer_getaddr)接口获取图像虚拟地址；
     *   isValid：bufferInfo中存储的buffer实例是否有效。
     
     std::shared\_ptr<CodecBufferInfo> bufferInfo = outQueue.Dequeue();
     std::shared\_lock<std::shared\_mutex> lock(codecMutex);
     if (bufferInfo == nullptr || !bufferInfo->isValid) {
         // 异常处理。
     }
     // 获取解码后信息。
     OH\_AVCodecBufferAttr info;
     OH\_AVErrCode getBufferRet = OH\_AVBuffer\_GetBufferAttr(bufferInfo->buffer, &info);
     if (getBufferRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     // 值由开发者决定。
     bool isRender;
     bool isNeedRenderAtTime;
     OH\_AVErrCode ret = AV\_ERR\_OK;
     if (isRender) {
         // 显示并释放已完成处理的信息，index为对应buffer队列的下标。
         if (isNeedRenderAtTime){
             // 获取系统绝对时间，renderTimestamp由开发者结合业务指定显示时间。
             int64\_t renderTimestamp =
                 std::chrono::duration\_cast<std::chrono::nanoseconds>(std::chrono::high\_resolution\_clock::now().time\_since\_epoch()).count();
             ret = OH\_VideoDecoder\_RenderOutputBufferAtTime(videoDec, bufferInfo->index, renderTimestamp);
         } else {
             ret = OH\_VideoDecoder\_RenderOutputBuffer(videoDec, bufferInfo->index);
         }
     
     } else {
         // 释放已完成处理的信息。
         ret = OH\_VideoDecoder\_FreeOutputBuffer(videoDec, bufferInfo->index);
     }
     if (ret != AV\_ERR\_OK) {
         // 异常处理。
     }
     
     ![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/1b/v3/vw04rB9mRH24lZxobrvDpg/caution_3.0-zh-cn.png?HW-CC-KV=V1&HW-CC-Date=20260612T073508Z&HW-CC-Expire=86400&HW-CC-Sign=648D5B105A5A7D954DA57616482584F30FB7BBD937354F6D056F842EF59FE57C)
     
     1.  如果要获取buffer的属性，如pixel\_format、stride等可通过调用[OH\_NativeWindow\_NativeWindowHandleOpt](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-external-window-h#oh_nativewindow_nativewindowhandleopt)接口获取。
     2.  显示并释放解码帧时，推荐优先调用[OH\_VideoDecoder\_RenderOutputBufferAtTime](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-avcodec-videodecoder-h#oh_videodecoder_renderoutputbufferattime)接口。
     
13.  （可选）调用OH\_VideoDecoder\_Flush()刷新解码器。
     
     调用OH\_VideoDecoder\_Flush接口后，解码器仍处于运行态，但会清除解码器中缓存的输入和输出数据及参数集如H.264格式的PPS/SPS。此时需要调用OH\_VideoDecoder\_Start接口重新开始解码。
     
     以下示例中：
     
     *   xpsData、xpsSize：PPS/SPS信息，获取方式可以参考[音视频解封装](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/audio-video-demuxer)。
     
     std::unique\_lock<std::shared\_mutex> lock(codecMutex);
     // 刷新解码器videoDec。
     OH\_AVErrCode flushRet = OH\_VideoDecoder\_Flush(videoDec);
     if (flushRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     inQueue.Flush();
     outQueue.Flush();
     // 重新开始解码。
     OH\_AVErrCode startRet = OH\_VideoDecoder\_Start(videoDec);
     if (startRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     
     std::shared\_ptr<CodecBufferInfo> bufferInfo = inQueue.Dequeue();
     if (bufferInfo == nullptr || !bufferInfo->isValid) {
         // 异常处理。
     }
     // 重传PPS/SPS。
     // 配置帧数据PPS/SPS信息。
     uint8\_t \*addr = OH\_AVBuffer\_GetAddr(bufferInfo->buffer);
     if (addr == nullptr) {
        // 异常处理
     }
     int32\_t capacity = OH\_AVBuffer\_GetCapacity(bufferInfo->buffer);
     if (xpsSize > capacity) {
         // 异常处理。
     }
     memcpy(addr, xpsData, xpsSize);
     OH\_AVCodecBufferAttr info;
     info.flags = AVCODEC\_BUFFER\_FLAG\_CODEC\_DATA;
     // info信息写入buffer。
     OH\_AVErrCode setBufferRet = OH\_AVBuffer\_SetBufferAttr(bufferInfo->buffer, &info);
     if (setBufferRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     // 将帧数据推送到解码器中，index为对应buffer队列的下标。
     OH\_AVErrCode pushInputRet = OH\_VideoDecoder\_PushInputBuffer(videoDec, bufferInfo->index);
     if (pushInputRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     
14.  （可选）调用OH\_VideoDecoder\_Reset()重置解码器。
     
     调用OH\_VideoDecoder\_Reset接口后，解码器回到初始化的状态，需要调用OH\_VideoDecoder\_Configure接口、OH\_VideoDecoder\_SetSurface接口和OH\_VideoDecoder\_Prepare接口重新配置。
     
     std::unique\_lock<std::shared\_mutex> lock(codecMutex);
     // 重置解码器videoDec。
     OH\_AVErrCode resetRet = OH\_VideoDecoder\_Reset(videoDec);
     if (resetRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     inQueue.Flush();
     outQueue.Flush();
     // 重新配置解码器参数。
     auto format = std::shared\_ptr<OH\_AVFormat>(OH\_AVFormat\_Create(), OH\_AVFormat\_Destroy);
     if (format == nullptr) {
         // 异常处理。
     }
     OH\_AVErrCode configRet = OH\_VideoDecoder\_Configure(videoDec, format.get());
     if (configRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     // Surface模式重新配置surface，而Buffer模式不需要配置surface。
     OH\_AVErrCode setRet = OH\_VideoDecoder\_SetSurface(videoDec, nativeWindow);
     if (setRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     // 解码器重新就绪。
     OH\_AVErrCode prepareRet = OH\_VideoDecoder\_Prepare(videoDec);
     if (prepareRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     
15.  （可选）调用OH\_VideoDecoder\_Stop()停止解码器。
     
     调用OH\_VideoDecoder\_Stop()后，解码器保留了解码实例，释放输入输出buffer。开发者可以直接调用OH\_VideoDecoder\_Start接口继续解码，输入的第一个buffer需要携带参数集，从IDR帧开始送入。
     
     std::unique\_lock<std::shared\_mutex> lock(codecMutex);
     // 终止解码器videoDec。
     OH\_AVErrCode ret = OH\_VideoDecoder\_Stop(videoDec);
     if (ret != AV\_ERR\_OK) {
         // 异常处理。
     }
     inQueue.Flush();
     outQueue.Flush();
     
16.  调用OH\_VideoDecoder\_Destroy()销毁解码器实例，释放资源。
     
     ![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/b0/v3/mtG6zzT-Q9yF4l6wkTVjKA/note_3.0-zh-cn.png?HW-CC-KV=V1&HW-CC-Date=20260612T073508Z&HW-CC-Expire=86400&HW-CC-Sign=250E67E78E621022487813A172ADE7CBD8FE5D86D90D760F30C24C3CCE62231D)
     
     1.  不能在回调函数中调用；
     2.  执行该步骤之后，需要开发者将videoDec指向nullptr，防止野指针导致程序错误。
     
     std::unique\_lock<std::shared\_mutex> lock(codecMutex);
     // 释放nativeWindow实例。
     if(nativeWindow != nullptr){
         OH\_NativeWindow\_DestroyNativeWindow(nativeWindow);
         nativeWindow = nullptr;
     }
     // 调用OH\_VideoDecoder\_Destroy，注销解码器。
     OH\_AVErrCode ret = AV\_ERR\_OK;
     if (videoDec != nullptr) {
         OH\_VideoDecoder\_Destroy(videoDec);
         videoDec = nullptr;
     }
     inQueue.Flush();
     outQueue.Flush();
     

#### \[h2\]Buffer模式

参考以下示例代码，可以完成Buffer模式下视频解码的全流程，实现异步模式的数据轮转。此处以输入H.264码流文件，解码成YUV文件为例。

1.  添加头文件。
    
    #include <multimedia/player\_framework/native\_avcodec\_videodecoder.h>
    #include <multimedia/player\_framework/native\_avcapability.h>
    #include <multimedia/player\_framework/native\_avcodec\_base.h>
    #include <multimedia/player\_framework/native\_avformat.h>
    #include <multimedia/player\_framework/native\_avbuffer.h>
    #include <native\_buffer/native\_buffer.h>
    #include <fstream>
    
2.  创建解码器实例。
    
    与Surface模式相同，此处不再赘述。
    
    // 通过codecname创建解码器，应用有特殊需求，比如选择支持某种分辨率规格的解码器，可先查询capability，再根据codec name创建解码器。
    OH\_AVCapability \*capability = OH\_AVCodec\_GetCapability(OH\_AVCODEC\_MIMETYPE\_VIDEO\_AVC, false);
    const char \*name = OH\_AVCapability\_GetName(capability);
    OH\_AVCodec \*videoDec = OH\_VideoDecoder\_CreateByName(name);
    
    // 通过MIME TYPE创建解码器，只能创建系统推荐的特定编解码器。
    // 涉及创建多路编解码器时，优先创建硬件解码器实例，硬件资源不够时再创建软件解码器实例。
    // 软/硬解：创建H.264解码器。
    OH\_AVCodec \*videoDec = OH\_VideoDecoder\_CreateByMime(OH\_AVCODEC\_MIMETYPE\_VIDEO\_AVC);
    // 硬解：创建H.265解码器。
    OH\_AVCodec \*videoDec = OH\_VideoDecoder\_CreateByMime(OH\_AVCODEC\_MIMETYPE\_VIDEO\_HEVC);
    
3.  调用OH\_VideoDecoder\_RegisterCallback()设置回调函数。
    
    注册回调函数指针集合OH\_AVCodecCallback，包括：
    
    *   OH\_AVCodecOnError 解码器运行错误，返回的错误码详情请参见：[OH\_AVCodecOnError](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-avcodec-base-h#oh_avcodeconerror)；
    *   OH\_AVCodecOnStreamChanged 码流信息变化，如码流宽、高变化；
    *   OH\_AVCodecOnNeedInputBuffer 运行过程中需要新的输入数据，即解码器已准备好，可以输入数据；
    *   OH\_AVCodecOnNewOutputBuffer 运行过程中产生了新的输出数据，即解码完成。
    
    开发者可以通过处理该回调报告的信息，确保解码器正常运转。
    
    回调函数的具体实现可参考[示例工程](https://gitcode.com/openharmony/applications_app_samples/tree/master/code/BasicFeature/Media/AVCodec)。
    
    int32\_t cropTop = 0;
    int32\_t cropBottom = 0;
    int32\_t cropLeft = 0;
    int32\_t cropRight = 0;
    bool isFirstFrame = true;
    // 解码异常回调OH\_AVCodecOnError实现。
    static void OnError(OH\_AVCodec \*codec, int32\_t errorCode, void \*userData)
    {
        // 回调的错误码由开发者判断处理。
        (void)codec;
        (void)errorCode;
        (void)userData;
    }
    
    // 解码数据流变化回调OH\_AVCodecOnStreamChanged实现。
    // 解码输入码流分辨率发生变化时触发此回调函数。
    static void OnStreamChanged(OH\_AVCodec \*codec, OH\_AVFormat \*format, void \*userData)
    {
        // 可选，开发者需要获取视频宽、高、跨距等时可配置。
        // 可通过format获取到变化后的视频宽、高、跨距等。
        (void)codec;
        (void)userData;
        bool ret = OH\_AVFormat\_GetIntValue(format, OH\_MD\_KEY\_VIDEO\_PIC\_WIDTH, &width) &&
                   OH\_AVFormat\_GetIntValue(format, OH\_MD\_KEY\_VIDEO\_PIC\_HEIGHT, &height) &&
                   OH\_AVFormat\_GetIntValue(format, OH\_MD\_KEY\_VIDEO\_STRIDE, &widthStride) &&
                   OH\_AVFormat\_GetIntValue(format, OH\_MD\_KEY\_VIDEO\_SLICE\_HEIGHT, &heightStride) &&
                   // 获取裁剪矩形信息可选。
                   OH\_AVFormat\_GetIntValue(format, OH\_MD\_KEY\_VIDEO\_CROP\_TOP, &cropTop) &&
                   OH\_AVFormat\_GetIntValue(format, OH\_MD\_KEY\_VIDEO\_CROP\_BOTTOM, &cropBottom) &&
                   OH\_AVFormat\_GetIntValue(format, OH\_MD\_KEY\_VIDEO\_CROP\_LEFT, &cropLeft) &&
                   OH\_AVFormat\_GetIntValue(format, OH\_MD\_KEY\_VIDEO\_CROP\_RIGHT, &cropRight);
        if (!ret) {
            // 异常处理。
        }
    }
    
    // 解码输入回调OH\_AVCodecOnNeedInputBuffer实现。
    static void OnNeedInputBuffer(OH\_AVCodec \*codec, uint32\_t index, OH\_AVBuffer \*buffer, void \*userData)
    {
        // 输入帧的数据buffer和对应的index送入inQueue队列。
        (void)codec;
        (void)userData;
        inQueue.Enqueue(std::make\_shared<CodecBufferInfo>(index, buffer));
    }
    
    // 解码输出回调OH\_AVCodecOnNewOutputBuffer实现。
    static void OnNewOutputBuffer(OH\_AVCodec \*codec, uint32\_t index, OH\_AVBuffer \*buffer, void \*userData)
    {
        // 可选，开发者需要获取视频宽、高、跨距等时可配置。
        // 获取视频宽、高、跨距。
        if (isFirstFrame) {
            auto format = std::shared\_ptr<OH\_AVFormat>(OH\_VideoDecoder\_GetOutputDescription(codec), OH\_AVFormat\_Destroy);
            if (format == nullptr) {
                // 异常处理。
            }
            bool ret = OH\_AVFormat\_GetIntValue(format.get(), OH\_MD\_KEY\_VIDEO\_PIC\_WIDTH, &width) &&
                       OH\_AVFormat\_GetIntValue(format.get(), OH\_MD\_KEY\_VIDEO\_PIC\_HEIGHT, &height) &&
                       OH\_AVFormat\_GetIntValue(format.get(), OH\_MD\_KEY\_VIDEO\_STRIDE, &widthStride) &&
                       OH\_AVFormat\_GetIntValue(format.get(), OH\_MD\_KEY\_VIDEO\_SLICE\_HEIGHT, &heightStride) &&
                       // 获取裁剪矩形信息可选。
                       OH\_AVFormat\_GetIntValue(format.get(), OH\_MD\_KEY\_VIDEO\_CROP\_TOP, &cropTop) &&
                       OH\_AVFormat\_GetIntValue(format.get(), OH\_MD\_KEY\_VIDEO\_CROP\_BOTTOM, &cropBottom) &&
                       OH\_AVFormat\_GetIntValue(format.get(), OH\_MD\_KEY\_VIDEO\_CROP\_LEFT, &cropLeft) &&
                       OH\_AVFormat\_GetIntValue(format.get(), OH\_MD\_KEY\_VIDEO\_CROP\_RIGHT, &cropRight);
            if (!ret) {
                // 异常处理。
            }
            isFirstFrame = false;
        }
        // 完成帧的数据buffer和对应的index送入outQueue队列。
        (void)userData;
        outQueue.Enqueue(std::make\_shared<CodecBufferInfo>(index, buffer));
    }
    // 配置异步回调，调用OH\_VideoDecoder\_RegisterCallback接口。
    OH\_AVCodecCallback cb = {&OnError, &OnStreamChanged, &OnNeedInputBuffer, &OnNewOutputBuffer};
    // 配置异步回调。
    OH\_AVErrCode ret = OH\_VideoDecoder\_RegisterCallback(videoDec, cb, nullptr); // nullptr:开发者执行回调所依赖的数据userData为空。
    if (ret != AV\_ERR\_OK) {
        // 异常处理。
    }
    
    ![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/8d/v3/6hLAjc7TTBW6l2K4blGrrQ/note_3.0-zh-cn.png?HW-CC-KV=V1&HW-CC-Date=20260612T073508Z&HW-CC-Expire=86400&HW-CC-Sign=88D870F1627B88E342F450857FDFBDA76D9CA1D53773AE8189CC6EF95127B18D)
    
    在回调函数中，对数据队列进行操作时，需要注意多线程同步的问题。
    
4.  （可选）OH\_VideoDecoder\_SetDecryptionConfig设置解密配置。在获取到DRM信息（参考[音视频解封装](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/audio-video-demuxer)开发步骤第4步），完成DRM许可证申请后，通过此接口进行解密配置。此接口需在Prepare前调用。在Buffer模式下，DRM解密能力仅支持非安全视频通路。DRM相关接口详见[DRM API文档](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-drm)。
    
    添加头文件。
    
    #include <multimedia/drm\_framework/native\_mediakeysystem.h>
    #include <multimedia/drm\_framework/native\_mediakeysession.h>
    #include <multimedia/drm\_framework/native\_drm\_err.h>
    #include <multimedia/drm\_framework/native\_drm\_common.h>
    
    在CMake脚本中链接动态库。
    
    target\_link\_libraries(sample PUBLIC libnative\_drm.so)
    
    使用示例：
    
    // 根据DRM信息创建指定的DRM系统，以创建"com.wiseplay.drm"为例。
    MediaKeySystem \*system = nullptr;
    int32\_t ret = OH\_MediaKeySystem\_Create("com.wiseplay.drm", &system);
    if (system == nullptr) {
        printf("create media key system failed");
        return;
    }
    
    // 创建解密会话。
    // 使用非安全视频通路，应创建CONTENT\_PROTECTION\_LEVEL\_SW\_CRYPTO及以上内容保护级别的MediaKeySession。
    MediaKeySession \*session = nullptr;
    DRM\_ContentProtectionLevel contentProtectionLevel = CONTENT\_PROTECTION\_LEVEL\_SW\_CRYPTO;
    ret = OH\_MediaKeySystem\_CreateMediaKeySession(system, &contentProtectionLevel, &session);
    if (ret != DRM\_ERR\_OK) {
        // 如创建失败，请查看DRM接口文档及日志信息。
        printf("create media key session failed.");
        return;
    }
    if (session == nullptr) {
        printf("media key session is nullptr.");
        return;
    }
    // 获取许可证请求、设置许可证响应等。
    // 设置解密配置，即将解密会话、安全视频通路标志设置到解码器中。
    bool secureVideoPath = false;
    ret = OH\_VideoDecoder\_SetDecryptionConfig(videoDec, session, secureVideoPath);
    
5.  调用OH\_VideoDecoder\_Configure()配置解码器。
    
    与Surface模式相同，此处不再赘述。
    
    auto format = std::shared\_ptr<OH\_AVFormat>(OH\_AVFormat\_Create(), OH\_AVFormat\_Destroy);
    if (format == nullptr) {
        // 异常处理。
    }
    // 写入format。
    OH\_AVFormat\_SetIntValue(format.get(), OH\_MD\_KEY\_WIDTH, width); // 必须配置。
    OH\_AVFormat\_SetIntValue(format.get(), OH\_MD\_KEY\_HEIGHT, height); // 必须配置。
    OH\_AVFormat\_SetIntValue(format.get(), OH\_MD\_KEY\_PIXEL\_FORMAT, pixelFormat);
    // 配置解码器。
    OH\_AVErrCode ret = OH\_VideoDecoder\_Configure(videoDec, format.get());
    if (ret != AV\_ERR\_OK) {
        // 异常处理。
    }
    
6.  调用OH\_VideoDecoder\_Prepare()解码器就绪。
    
    该接口将在解码器运行前进行一些数据的准备工作。
    
    OH\_AVErrCode ret = OH\_VideoDecoder\_Prepare(videoDec);
    if (ret != AV\_ERR\_OK) {
        // 异常处理。
    }
    
7.  调用OH\_VideoDecoder\_Start()启动解码器。
    
    std::unique\_ptr<std::ofstream> outputFile = std::make\_unique<std::ofstream>();
    if (outputFile != nullptr) {
        outputFile->open("/\*yourpath\*.yuv", std::ios::out | std::ios::binary | std::ios::ate);
    }
    // 启动解码器，开始解码。
    OH\_AVErrCode ret = OH\_VideoDecoder\_Start(videoDec);
    if (ret != AV\_ERR\_OK) {
        // 异常处理。
    }
    
8.  （可选）OH\_VideoDecoder\_SetParameter()动态配置解码器参数。
    
    详细可配置选项的说明请参考[媒体数据键值对](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-codecbase#媒体数据键值对)中的视频专有键值对。
    
    auto format = std::shared\_ptr<OH\_AVFormat>(OH\_AVFormat\_Create(), OH\_AVFormat\_Destroy);
    if (format == nullptr) {
        // 异常处理。
    }
    // 配置帧率。
    OH\_AVFormat\_SetDoubleValue(format.get(), OH\_MD\_KEY\_FRAME\_RATE, 30.0);
    OH\_AVErrCode ret = OH\_VideoDecoder\_SetParameter(videoDec, format.get());
    if (ret != AV\_ERR\_OK) {
        // 异常处理。
    }
    
9.  （可选）调用OH\_AVCencInfo\_SetAVBuffer()，设置cencInfo。
    
    与Surface模式相同，此处不再赘述。
    
    使用示例：
    
    uint32\_t keyIdLen = DRM\_KEY\_ID\_SIZE;
    uint8\_t keyId\[\] = {
        0xd4, 0xb2, 0x01, 0xe4, 0x61, 0xc8, 0x98, 0x96,
        0xcf, 0x05, 0x22, 0x39, 0x8d, 0x09, 0xe6, 0x28};
    uint32\_t ivLen = DRM\_KEY\_IV\_SIZE;
    uint8\_t iv\[\] = {
        0xbf, 0x77, 0xed, 0x51, 0x81, 0xde, 0x36, 0x3e,
        0x52, 0xf7, 0x20, 0x4f, 0x72, 0x14, 0xa3, 0x95};
    uint32\_t encryptedBlockCount = 0;
    uint32\_t skippedBlockCount = 0;
    uint32\_t firstEncryptedOffset = 0;
    uint32\_t subsampleCount = 1;
    DrmSubsample subsamples\[1\] = { {0x10, 0x16} };
    // 创建CencInfo实例。
    OH\_AVCencInfo \*cencInfo = OH\_AVCencInfo\_Create();
    if (cencInfo == nullptr) {
        // 异常处理。
    }
    // 设置解密算法。
    OH\_AVErrCode errNo = OH\_AVCencInfo\_SetAlgorithm(cencInfo, DRM\_ALG\_CENC\_AES\_CTR);
    if (errNo != AV\_ERR\_OK) {
        // 异常处理。
    }
    // 设置KeyId和Iv。
    errNo = OH\_AVCencInfo\_SetKeyIdAndIv(cencInfo, keyId, keyIdLen, iv, ivLen);
    if (errNo != AV\_ERR\_OK) {
        // 异常处理。
    }
    // 设置Sample信息。
    errNo = OH\_AVCencInfo\_SetSubsampleInfo(cencInfo, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset,
        subsampleCount, subsamples);
    if (errNo != AV\_ERR\_OK) {
        // 异常处理。
    }
    // 设置模式：KeyId、Iv和SubSamples已被设置。
    errNo = OH\_AVCencInfo\_SetMode(cencInfo, DRM\_CENC\_INFO\_KEY\_IV\_SUBSAMPLES\_SET);
    if (errNo != AV\_ERR\_OK) {
        // 异常处理。
    }
    // 将CencInfo设置到AVBuffer中。
    errNo = OH\_AVCencInfo\_SetAVBuffer(cencInfo, buffer);
    if (errNo != AV\_ERR\_OK) {
        // 异常处理。
    }
    // 销毁CencInfo实例。
    errNo = OH\_AVCencInfo\_Destroy(cencInfo);
    if (errNo != AV\_ERR\_OK) {
        // 异常处理。
    }
    
10.  调用OH\_VideoDecoder\_PushInputBuffer()写入解码码流。
     
     与Surface模式相同，此处不再赘述。
     
     std::shared\_ptr<CodecBufferInfo> bufferInfo = inQueue.Dequeue();
     std::shared\_lock<std::shared\_mutex> lock(codecMutex);
     if (bufferInfo == nullptr || !bufferInfo->isValid) {
         // 异常处理。
     }
     // 写入码流数据。
     uint8\_t \*addr = OH\_AVBuffer\_GetAddr(bufferInfo->buffer);
     if (addr == nullptr) {
        // 异常处理。
     }
     int32\_t capacity = OH\_AVBuffer\_GetCapacity(bufferInfo->buffer);
     if (size > capacity) {
         // 异常处理。
     }
     memcpy(addr, frameData, size);
     // 配置帧数据的输入尺寸、偏移量、时间戳等字段信息。
     OH\_AVCodecBufferAttr info;
     info.size = size;
     info.offset = offset;
     info.pts = pts;
     info.flags = flags;
     // info信息写入buffer。
     OH\_AVErrCode setBufferRet = OH\_AVBuffer\_SetBufferAttr(bufferInfo->buffer, &info);
     if (setBufferRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     // 送入解码输入队列进行解码，index为对应buffer队列的下标。
     OH\_AVErrCode pushInputRet = OH\_VideoDecoder\_PushInputBuffer(videoDec, bufferInfo->index);
     if (pushInputRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     
11.  调用OH\_VideoDecoder\_FreeOutputBuffer()释放解码帧。
     
     以下示例中，bufferInfo的成员变量：
     
     *   index：回调函数OnNewOutputBuffer传入的参数，与buffer唯一对应的标识；
     *   buffer： 回调函数OnNewOutputBuffer传入的参数，可以通过[OH\_AVBuffer\_GetAddr](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-avbuffer-h#oh_avbuffer_getaddr)接口获取图像虚拟地址；
     *   isValid：bufferInfo中存储的buffer实例是否有效。
     
     std::shared\_ptr<CodecBufferInfo> bufferInfo = outQueue.Dequeue();
     std::shared\_lock<std::shared\_mutex> lock(codecMutex);
     if (bufferInfo == nullptr || !bufferInfo->isValid) {
         // 异常处理。
     }
     // 获取解码后信息。
     OH\_AVCodecBufferAttr info;
     OH\_AVErrCode getBufferRet = OH\_AVBuffer\_GetBufferAttr(bufferInfo->buffer, &info);
     if (getBufferRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     // 将解码完成数据data写入到对应输出文件中。
     uint8\_t \*addr = OH\_AVBuffer\_GetAddr(bufferInfo->buffer);
     if (addr == nullptr) {
        // 异常处理。
     }
     if (outputFile != nullptr && outputFile->is\_open()) {
         outputFile->write(reinterpret\_cast<char \*>(addr), info.size);
     }
     // Buffer模式，释放已完成写入的数据，index为对应buffer队列的下标。
     OH\_AVErrCode freeOutputRet = OH\_VideoDecoder\_FreeOutputBuffer(videoDec, bufferInfo->index);
     if (freeOutputRet != AV\_ERR\_OK) {
         // 异常处理。
     }
     
     NV12/NV21图像如果需要依次将Y、U、V三个分量拷贝至另一块buffer中，以NV12图像为例，按行拷贝示例如下：
     
     以NV12图像为例，width、height、wStride、hStride图像排布参考下图：
     
     *   OH\_MD\_KEY\_VIDEO\_PIC\_WIDTH表示width；
     *   OH\_MD\_KEY\_VIDEO\_PIC\_HEIGHT表示height；
     *   OH\_MD\_KEY\_VIDEO\_STRIDE表示wStride；
     *   OH\_MD\_KEY\_VIDEO\_SLICE\_HEIGHT表示hStride。
     
     ![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/49/v3/QsmnffmATWSDwG0JHoa8aw/zh-cn_image_0000002594668804.png?HW-CC-KV=V1&HW-CC-Date=20260612T073508Z&HW-CC-Expire=86400&HW-CC-Sign=836CC5DFF5F30DFE51998829E2B60CC8FB636B2E845AE49E982F44E9C9A61AA5)
     
     添加头文件。
     
     #include <string.h>
     
     使用示例：
     
     // 源内存区域的宽、高，通过回调函数OnStreamChanged或接口OH\_VideoDecoder\_GetOutputDescription获取。
     struct Rect
     {
         int32\_t width;
         int32\_t height;
     };
     
     struct DstRect // 目标内存区域的宽跨距、高跨距，由开发者自行设置。
     {
         int32\_t wStride;
         int32\_t hStride;
     };
     // 源内存区域的宽跨距、高跨距，通过回调函数OnStreamChanged或接口OH\_VideoDecoder\_GetOutputDescription获取。
     struct SrcRect
     {
         int32\_t wStride;
         int32\_t hStride;
     };
     
     Rect rect = {320, 240};
     DstRect dstRect = {320, 240};
     SrcRect srcRect = {320, 256};
     uint8\_t\* dst = new uint8\_t\[dstRect.hStride \* dstRect.wStride \* 3 / 2\]; // 目标内存区域的指针。
     uint8\_t\* src = new uint8\_t\[srcRect.hStride \* srcRect.wStride \* 3 / 2\]; // 源内存区域的指针。
     uint8\_t\* dstTemp = dst;
     uint8\_t\* srcTemp = src;
     rect.height = ((rect.height + 1) / 2)  \* 2; // 避免height为奇数；
     rect.width = ((rect.width + 1) / 2)  \* 2; // 避免width为奇数；
     
     // Y 将Y区域的源数据复制到另一个区域的目标数据中。
     for (int32\_t i = 0; i < rect.height; ++i) {
         // 将源数据的一行数据复制到目标数据的一行中。
         memcpy(dstTemp, srcTemp, rect.width);
         // 更新源数据和目标数据的指针，进行下一行的复制。每更新一次源数据和目标数据的指针都向下移动一个wStride。
         dstTemp += dstRect.wStride;
         srcTemp += srcRect.wStride;
     }
     // padding。
     // 更新源数据和目标数据的指针，指针都向下移动一个padding。
     dstTemp += (dstRect.hStride - rect.height) \* dstRect.wStride;
     srcTemp += (srcRect.hStride - rect.height) \* srcRect.wStride;
     rect.height >>= 1;
     // UV 将UV区域的源数据复制到另一个区域的目标数据中。
     for (int32\_t i = 0; i < rect.height; ++i) {
         memcpy(dstTemp, srcTemp, rect.width);
         dstTemp += dstRect.wStride;
         srcTemp += srcRect.wStride;
     }
     
     delete\[\] dst;
     dst = nullptr;
     delete\[\] src;
     src = nullptr;
     
     硬件解码在处理buffer数据时（释放数据前），输出回调开发者收到的AVbuffer是宽、高对齐后的图像数据。
     
     一般需要获取数据的宽、高、跨距、像素格式来保证解码输出数据被正确的处理。
     
     具体实现请参考：[Buffer模式](#buffer模式)的步骤3-调用OH\_VideoDecoder\_RegisterCallback()设置回调函数来获取数据的宽、高、跨距、像素格式。
     

后续流程（包括刷新、重置、停止和销毁解码器）与Surface模式基本一致，请参考[Surface模式](#surface模式)的步骤13-16。

#### 注意事项

1.  解码器执行Flush/Reset/Stop操作之后，再次调用OH\_VideoDecoder\_Start接口重新开始解码时，必须重新向解码器发送SPS/PPS码流参数集。具体示例请参考[Surface模式](#surface模式)中的“步骤-13. 调用OH\_VideoDecoder\_Flush()刷新解码器”。
2.  Flush、Reset、Stop、Destroy接口需在非回调线程中调用。接口执行时会阻塞等待所有已触发的回调执行完毕，再将执行结果返回给开发者。
3.  由于硬件解码器资源有限，每个解码器在使用完毕后都必须调用OH\_VideoDecoder\_Destroy接口销毁实例，释放资源。
4.  视频解码输入码流仅支持AnnexB格式，且同一帧的多个slice需一次送入解码器。
5.  一旦调用Flush、Reset、Stop接口，会触发系统回收OH\_AVBuffer，开发者不可对之前回调函数获取到的OH\_AVBuffer继续进行操作。
6.  DRM解密能力在Surface模式下既支持非安全视频通路，也支持安全视频通路。在Buffer模式下仅支持非安全视频通路。
7.  在Buffer模式下，开发者通过输出回调函数OH\_AVCodecOnNewOutputBuffer获取到OH\_AVBuffer后，必须调用OH\_VideoDecoder\_FreeOutputBuffer接口释放，确保系统能够将后续解码的数据写入到相应的位置。如果开发者通过调用OH\_AVBuffer\_GetNativeBuffer接口获取OH\_NativeBuffer指针实例，并且该实例的生命周期超过了当前的OH\_AVBuffer指针实例，那么开发者需手动拷贝数据，并自行管理新生成的OH\_NativeBuffer实例的生命周期，确保其正确使用和释放。
8.  为确保系统服务的持续可用性，系统会实时检测应用对实例的占用行为，当检测到应用存在异常的实例占用行为，系统会自动介入并终止该应用实例。需要注意的是：持续的实例管理不当可能导致进程被终止，开发者可通过查询以下日志来确认应用实例是否被系统终止。
    
    日志匹配规则：HardwareDecoding.\*kill\\s+进程名:进程pid
    
    示例：
    
    HardwareDecoding process background, kill com.test:1887
    
    HardwareDecoding reachLimit and background, kill com.test:1887
    
    HardwareDecoding killPercentage, kill com.test:1887
    

#### 示例代码

*   [基于AVCodec能力的视频编解码](https://gitcode.com/openharmony/applications_app_samples/tree/master/code/BasicFeature/Media/AVCodec)

#### 视频解码支持的能力

| 支持的能力 | 使用简述 |
| :-- | :-- |
| 动态分辨率切换 | 
仅硬件解码器支持输入码流分辨率发生变化，发生变化后会触发OH\_VideoDecoder\_RegisterCallback接口设置的回调函数OnStreamChanged()。

具体可参考上文中：Surface模式步骤-3或Buffer模式步骤-3。

 |
| 动态切换surface | 

通过调用OH\_VideoDecoder\_SetSurface可动态切换OHNativeWindow，仅Surface模式支持。

具体可参考上文中：Surface模式步骤-6。

 |
| 低时延解码 | 

通过调用OH\_VideoDecoder\_Configure接口配置低时延键值。

具体可参考上文中：Surface模式的步骤-5或Buffer模式步骤-5。

 |