We use essential cookies for the website to function, as well as analytics cookies for analyzing and creating statistics of the website performance. To agree to the use of analytics cookies, click "Accept All". You can manage your preferences at any time by clicking "Cookie Settings" on the footer. More Information.

Cookie Settings
Only Essential Cookies
Accept All
MaterialsConsole

HarmonyOS

输入关键字搜索
HMS Core
AppGallery Connect
HUAWEI HiAI
CTRL+K
GuidesMediaAVCodec KitAudio and Video CodecsAudio Decoding

Audio Decoding

Last updated: 2026-09-08 08:15
Content overview

You can call the Native APIs of this module to perform audio decoding, that is, to decode media data into a PCM stream.

For supported decoding capabilities, see AVCodec Supported Formats.

When to Use

  • Audio playback

    Before playing audio, you need to decode the audio first and then send the data to the hardware speaker for playback.

  • Audio rendering

Before applying audio effects to an audio file, you need to decode it first and then render it through the audio processing module.

  • Audio editing

Audio editing (such as adjusting the playback speed of a single channel) must be performed based on PCM streams, so you need to decode the audio file first.

NOTE

A stream generated through the MP3 audio encoding process cannot be directly decoded through the MP3 audio decoding process. It is recommended to use the following process: PCM stream -> MP3 audio encoding -> muxing -> demuxing -> MP3 audio decoding.

Development Guidelines

For detailed API descriptions, see native_avcodec_audiocodec.h.

Refer to the following sample code to complete the full audio decoding process, including: creating a decoder, setting decoding parameters (sample rate/bitrate/number of channels, etc.), starting, flushing, resetting, and destroying resources.

During app development, you must call methods in a specific order to perform corresponding operations. Otherwise, the system may throw exceptions or produce other undefined behaviors. For the specific sequence, refer to the following development steps and their descriptions.

The following figure shows the audio decoding call relationship:

  • Dashed lines indicate optional operations.

  • Solid lines indicate mandatory operations.

Linking the Dynamic Libraries in the CMake Script

Collapse
Word wrap
Dark theme
Copy code
  1. target_link_libraries(sample PUBLIC libnative_media_codecbase.so)
  2. target_link_libraries(sample PUBLIC libnative_media_core.so)
  3. target_link_libraries(sample PUBLIC libnative_media_acodec.so)
NOTE

The word sample above is only an example. Replace it with the actual project directory name as needed.

How to Develop

  1. Add the required header files.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. #include <multimedia/player_framework/native_avcodec_audiocodec.h>
    2. #include <multimedia/native_audio_channel_layout.h>
    3. #include <multimedia/player_framework/native_avcapability.h>
    4. #include <multimedia/player_framework/native_avcodec_base.h>
    5. #include <multimedia/player_framework/native_avformat.h>
    6. #include <multimedia/player_framework/native_avbuffer.h>

  2. Create a decoder instance object. OH_AVCodec * is the pointer to the decoder instance.

    An app can create a decoder by media type or codec name.

    Method 1: Create a decoder by MIME type.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. // Set the encoding flag; false indicates decoding.
    2. bool isEncoder = false;
    3. // Create a decoder by MIME type.
    4. OH_AVCodec *audioDec_ = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC, isEncoder);

Method 2: Create a decoder by codec name.

Collapse
Word wrap
Dark theme
Copy code
  1. // Create a decoder by codec name.
  2. OH_AVCapability *capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_AAC, false);
  3. const char *name = OH_AVCapability_GetName(capability);
  4. OH_AVCodec *audioDec_ = OH_AudioCodec_CreateByName(name);

Add the header file and namespace:

Collapse
Word wrap
Dark theme
Copy code
  1. #include <mutex>
  2. #include <queue>
  3. // C++ standard library namespace.
  4. using namespace std;

Example:

Collapse
Word wrap
Dark theme
Copy code
  1. // Initialize the queue.
  2. class ADecBufferSignal {
  3. public:
  4.     std::mutex inMutex_;
  5.     std::mutex outMutex_;
  6.     std::mutex startMutex_;
  7.     std::condition_variable inCond_;
  8.     std::condition_variable outCond_;
  9.     std::condition_variable startCond_;
  10.     std::queue<uint32_t> inQueue_;
  11.     std::queue<uint32_t> outQueue_;
  12.     std::queue<OH_AVBuffer *> inBufferQueue_;
  13.     std::queue<OH_AVBuffer *> outBufferQueue_;
  14. };
  15. ADecBufferSignal *signal_;

  1. Call OH_AudioCodec_RegisterCallback() to register callback functions.

    Register the callback function pointer set OH_AVCodecCallback, including:

    • OH_AVCodecOnError: decoder error.

    • OH_AVCodecOnStreamChanged: callback for stream information changes, including sample rate change, channel count change, and audio sample format change. The decoding formats that support detecting these changes are: Audio Vivid, AAC, FLAC, MP3, VORBIS. (Supported since API version 15)

    • OH_AVCodecOnNeedInputBuffer: callback indicating that new input data is needed during operation, meaning the decoder is ready and can accept data input.

    • OH_AVCodecOnNewOutputBuffer: callback indicating that new output data has been generated during operation, meaning decoding is complete.

    You can handle the information reported by this callback to ensure the decoder operates properly.

    NOTE

    Do not call decoder-related APIs or perform time-consuming operations in the callback.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. // Implementation of the OH_AVCodecOnError callback function.
    2. static void OnError(OH_AVCodec *codec, int32_t errorCode, void *userData)
    3. {
    4.     (void)codec;
    5.     (void)errorCode;
    6.     (void)userData;
    7. }
    8. // Implementation of the OH_AVCodecOnStreamChanged callback function.
    9. static void OnOutputFormatChanged(OH_AVCodec *codec, OH_AVFormat *format, void *userData)
    10. {
    11.     (void)codec;
    12.     (void)userData;
    13.     // Callback handling after decoding output parameter changes. Process based on the actual situation.
    14.     int32_t sampleRate;
    15.     int32_t channelCount;
    16.     int32_t sampleFormat;
    17.     if (OH_AVFormat_GetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, &sampleRate)) {
    18.         // Check whether the sample rate has changed and handle accordingly.
    19.     }
    20.     if (OH_AVFormat_GetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, &channelCount)) {
    21.         // Check whether the channel count has changed and handle accordingly.
    22.     }
    23.     if (OH_AVFormat_GetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, &sampleFormat)) {
    24.         // Determine whether the audio sample format has changed and handle accordingly.
    25.     }
    26. }
    27. // Implementation of the OH_AVCodecOnNeedInputBuffer callback function.
    28. static void OnInputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *data, void *userData)
    29. {
    30.     (void)codec;
    31.     ADecBufferSignal *signal = static_cast<ADecBufferSignal *>(userData);
    32.     unique_lock<mutex> lock(signal->inMutex_);
    33.     signal->inQueue_.push(index);
    34.     signal->inBufferQueue_.push(data);
    35.     signal->inCond_.notify_all();
    36.     // Send the decoded input stream to the inBufferQueue_ queue.
    37. }
    38. // Implementation of the OH_AVCodecOnNewOutputBuffer callback function.
    39. static void OnOutputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *data, void *userData)
    40. {
    41.     (void)codec;
    42.     ADecBufferSignal *signal = static_cast<ADecBufferSignal *>(userData);
    43.     unique_lock<mutex> lock(signal->outMutex_);
    44.     signal->outQueue_.push(index);
    45.     signal->outBufferQueue_.push(data);
    46.     signal->outCond_.notify_all();
    47.     // Send the index of the corresponding output buffer to the outQueue_ queue.
    48.     // Send the decoded data to the outBufferQueue_ queue.
    49. }

    Configure the callbacks:

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. signal_ = new ADecBufferSignal();
    2. OH_AVCodecCallback cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
    3. // Configure the asynchronous callback.
    4. int32_t ret = OH_AudioCodec_RegisterCallback(audioDec_, cb_, signal_);
    5. if (ret != AV_ERR_OK) {
    6.     // Handle the exception.
    7. }

  2. (Optional) Call OH_AudioCodec_SetDecryptionConfig to set the decryption configuration.

    After obtaining DRM information (see step 4 in Media Data Demultiplexing), configure decryption through this API.

    For details about DRM-related APIs, see DRM API Reference.

    This API must be called before Prepare.

    Add the header files:

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. #include <multimedia/drm_framework/native_mediakeysystem.h>
    2. #include <multimedia/drm_framework/native_mediakeysession.h>
    3. #include <multimedia/drm_framework/native_drm_err.h>
    4. #include <multimedia/drm_framework/native_drm_common.h>

    Link the dynamic library in the CMake script:

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. target_link_libraries(sample PUBLIC libnative_drm.so)

    Usage example:

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. // Create the specified DRM system based on DRM information. Here, "com.wiseplay.drm" is used as an example.
    2. MediaKeySystem *system = nullptr;
    3. int32_t ret = OH_MediaKeySystem_Create("com.wiseplay.drm", &system);
    4. if (system == nullptr) {
    5.     printf("create media key system failed");
    6.     return;
    7. }
    8. 

    9. // Create a decryption session.
    10. MediaKeySession *session = nullptr;
    11. DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
    12. ret = OH_MediaKeySystem_CreateMediaKeySession(system, &contentProtectionLevel, &session);
    13. if (ret != DRM_ERR_OK) {
    14.     // If creation fails, check the DRM API documentation and log information.
    15.     printf("create media key session failed.");
    16.     return;
    17. }
    18. if (session == nullptr) {
    19.     printf("media key session is nullptr.");
    20.     return;
    21. }
    22. // Obtain the license request, set the license response, and so on.
    23. // Set the decryption configuration, that is, set the decryption session and the secure channel flag (currently audio decryption does not support secure channels, so set it to false) in the decoder.
    24. bool secureAudio = false;
    25. ret = OH_AudioCodec_SetDecryptionConfig(audioDec_, session, secureAudio);

  3. Call OH_AudioCodec_Configure() to configure the decoder.

The following describes the configuration option keys:

The following describes the parameter ranges for each audio decoding type:

Starting from API version 20, you can query the sample rate range capability through the OH_AVCapability_GetAudioSupportedSampleRateRanges API. The following audio decoding types support decoding at any sample rate within the range:

Expand
Audio Decoding Type Sample Rate (Hz)
Flac 8000 ~ 384000
Vorbis 8000 ~ 192000
APE 1 ~ 2147483647
Collapse
Word wrap
Dark theme
Copy code
  1. // The following configuration values are examples only. Set them based on the actual decoding capabilities.
  2. // Configure the audio sample rate (mandatory).
  3. constexpr uint32_t DEFAULT_SAMPLERATE = 44100;
  4. // Configure the audio bitrate (optional).
  5. constexpr uint32_t DEFAULT_BITRATE = 32000;
  6. // Configure the number of audio channels (required).
  7. constexpr uint32_t DEFAULT_CHANNEL_COUNT = 2;
  8. // Configure the maximum input length (optional).
  9. constexpr uint32_t DEFAULT_MAX_INPUT_SIZE = 1152;
  10. // Configure whether it is ADTS decoding (optional for AAC decoding).
  11. constexpr uint32_t DEFAULT_AAC_TYPE = 1;
  12. // Configure the block alignment in bytes for audio data. Supported since API version 22. Required only for WMAV1, WMAV2, and WMA PRO decoding.
  13. constexpr int32_t DEFAULT_BLOCK_ALIGN = 1;
  14. OH_AVFormat *format = OH_AVFormat_Create();
  15. // Write the format.
  16. OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, DEFAULT_SAMPLERATE);
  17. OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
  18. OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, DEFAULT_CHANNEL_COUNT);
  19. OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, DEFAULT_MAX_INPUT_SIZE);
  20. OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
  21. OH_AVFormat_SetIntValue(format, OH_MD_KEY_BLOCK_ALIGN, DEFAULT_BLOCK_ALIGN);
  22. // Configure the decoder.
  23. int32_t ret = OH_AudioCodec_Configure(audioDec_, format);
  24. if (ret != AV_ERR_OK) {
  25.     // Handle the exception.
  26. }

  1. Call OH_AudioCodec_Prepare() to prepare the decoder.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. int32_t ret = OH_AudioCodec_Prepare(audioDec_);
    2. if (ret != AV_ERR_OK) {
    3.     // Handle the exception.
    4. }

  2. Call OH_AudioCodec_Start() to start the decoder and enter the running state.

    Add the header file:

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. #include <fstream>

    Usage example:

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. ifstream inputFile_;
    2. ofstream outFile_;
    3. 

    4. // Enter the input file path based on actual usage.
    5. const char* inputFilePath = "/";
    6. // Enter the output file path based on actual usage.
    7. const char* outputFilePath = "/";
    8. // Open the binary file to be decoded.
    9. inputFile_.open(inputFilePath, ios::in | ios::binary);
    10. // Configure the output path for the decoded file.
    11. outFile_.open(outputFilePath, ios::out | ios::binary);
    12. // Start decoding.
    13. int32_t ret = OH_AudioCodec_Start(audioDec_);
    14. if (ret != AV_ERR_OK) {
    15.     // Handle the exception.
    16. }

  3. (Optional) Call OH_AVCencInfo_SetAVBuffer() to set cencInfo.

    If the currently playing program is a DRM-encrypted program and the upper-layer app performs media demuxing, you must call OH_AVCencInfo_SetAVBuffer() to set cencInfo to the AVBuffer for decrypting the media data in the AVBuffer.

    Add the header file:

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. #include <multimedia/player_framework/native_cencinfo.h>

    Link the dynamic library in the CMake script:

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. target_link_libraries(sample PUBLIC libnative_media_avcencinfo.so)

    Usage example:

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. auto buffer = signal_->inBufferQueue_.front();
    2. uint32_t keyIdLen = DRM_KEY_ID_SIZE;
    3. uint8_t keyId[] = {
    4.     0xd4, 0xb2, 0x01, 0xe4, 0x61, 0xc8, 0x98, 0x96,
    5.     0xcf, 0x05, 0x22, 0x39, 0x8d, 0x09, 0xe6, 0x28};
    6. uint32_t ivLen = DRM_KEY_IV_SIZE;
    7. uint8_t iv[] = {
    8.     0xbf, 0x77, 0xed, 0x51, 0x81, 0xde, 0x36, 0x3e,
    9.     0x52, 0xf7, 0x20, 0x4f, 0x72, 0x14, 0xa3, 0x95};
    10. uint32_t encryptedBlockCount = 0;
    11. uint32_t skippedBlockCount = 0;
    12. uint32_t firstEncryptedOffset = 0;
    13. uint32_t subsampleCount = 1;
    14. DrmSubsample subsamples[1] = { {0x10, 0x16} };
    15. // Create a CencInfo instance.
    16. OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
    17. if (cencInfo == nullptr) {
    18.     // Handle the exception.
    19. }
    20. // Set the decryption algorithm.
    21. OH_AVErrCode errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_AES_CTR);
    22. if (errNo != AV_ERR_OK) {
    23.     // Handle the exception.
    24. }
    25. // Set the KeyId and Iv.
    26. errNo = OH_AVCencInfo_SetKeyIdAndIv(cencInfo, keyId, keyIdLen, iv, ivLen);
    27. if (errNo != AV_ERR_OK) {
    28.     // Handle the exception.
    29. }
    30. // Set the sample information.
    31. errNo = OH_AVCencInfo_SetSubsampleInfo(cencInfo, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset,
    32.     subsampleCount, subsamples);
    33. if (errNo != AV_ERR_OK) {
    34.     // Handle the exception.
    35. }
    36. // Set the mode: KeyId, Iv, and SubSamples have been set.
    37. errNo = OH_AVCencInfo_SetMode(cencInfo, DRM_CENC_INFO_KEY_IV_SUBSAMPLES_SET);
    38. if (errNo != AV_ERR_OK) {
    39.     // Handle the exception.
    40. }
    41. // Set CencInfo to the AVBuffer.
    42. errNo = OH_AVCencInfo_SetAVBuffer(cencInfo, buffer);
    43. if (errNo != AV_ERR_OK) {
    44.     // Handle the exception.
    45. }
    46. // Destroy the CencInfo instance.
    47. errNo = OH_AVCencInfo_Destroy(cencInfo);
    48. if (errNo != AV_ERR_OK) {
    49.     // Handle the exception.
    50. }

  4. Call OH_AudioCodec_PushInputBuffer() to write the data to be decoded.

    Call this API after filling in the complete input data.

At the end, set the flags to AVCODEC_BUFFER_FLAGS_EOS.

Collapse
Word wrap
Dark theme
Copy code
  1. uint32_t index = signal_->inQueue_.front();
  2. auto buffer = signal_->inBufferQueue_.front();
  3. int32_t size;
  4. int64_t pts;
  5. // size is the frame length of each frame of data to be decoded. pts is the timestamp of each frame, used to indicate when the audio should be played.
  6. // Sources for obtaining size and pts: audio/video resource files or the data stream to be decoded.
  7. // If decoding an audio/video resource file, obtain them from the buffer of OH_AVDemuxer_ReadSampleBuffer.
  8. // If decoding a data stream, obtain them from the data stream provider.
  9. // For demonstration purposes, the size and pts saved in the test file are used as an example.
  10. inputFile_.read(reinterpret_cast<char *>(&size), sizeof(size));
  11. inputFile_.read(reinterpret_cast<char *>(&pts), sizeof(pts));
  12. inputFile_.read((char *)OH_AVBuffer_GetAddr(buffer), size);
  13. OH_AVCodecBufferAttr attr = {0};
  14. if (inputFile_.eof()) {
  15.     attr.size = 0;
  16.     attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
  17. } else {
  18.     attr.size = size;
  19.     attr.flags = AVCODEC_BUFFER_FLAGS_NONE;
  20. }
  21. attr.pts = pts;
  22. OH_AVBuffer_SetBufferAttr(buffer, &attr);
  23. int32_t ret = OH_AudioCodec_PushInputBuffer(audioDec_, index);
  24. if (ret != AV_ERR_OK) {
  25.     // Exception handling.
  26. }

  1. Call OH_AudioCodec_FreeOutputBuffer() to release the decoded data.

    After obtaining the decoded PCM stream, call OH_AudioCodec_FreeOutputBuffer() to release it in a timely manner.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. uint32_t index = signal_->outQueue_.front();
    2. OH_AVBuffer *data = signal_->outBufferQueue_.front();
    3. if (data == nullptr) {
    4.     // Exception handling
    5. }
    6. // Obtain the buffer attributes.
    7. OH_AVCodecBufferAttr attr = {0};
    8. int32_t ret = OH_AVBuffer_GetBufferAttr(data, &attr);
    9. if (ret != AV_ERR_OK) {
    10.     // Handle the exception.
    11. }
    12. // Write the decoded data to the corresponding output file.
    13. outFile_.write(reinterpret_cast<char *>(OH_AVBuffer_GetAddr(data)), attr.size);
    14. ret = OH_AudioCodec_FreeOutputBuffer(audioDec_, index);
    15. if (ret != AV_ERR_OK) {
    16.     // Handle the exception.
    17. }
    18. if (attr.flags == AVCODEC_BUFFER_FLAGS_EOS) {
    19.     // End.
    20. }

    Since API version 11, the API for obtaining Audio Vivid metadata is added.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. uint32_t index = signal_->outQueue_.front();
    2. OH_AVBuffer *data = signal_->outBufferQueue_.front();
    3. // Obtain buffer attributes.
    4. OH_AVCodecBufferAttr attr = {0};
    5. int32_t ret = OH_AVBuffer_GetBufferAttr(data, &attr);
    6. if (ret != AV_ERR_OK) {
    7.     // Handle exceptions.
    8. }
    9. // Write the decoded data to the output file.
    10. outFile_.write(reinterpret_cast<char *>(OH_AVBuffer_GetAddr(data)), attr.size);
    11. // API version 11 and later provide the API for obtaining Audio Vivid metadata.
    12. OH_AVFormat *format = OH_AVBuffer_GetParameter(data);
    13. uint8_t *metadata = nullptr;
    14. size_t metaSize;
    15. OH_AVFormat_GetBuffer(format, OH_MD_KEY_AUDIO_VIVID_METADATA, &metadata, &metaSize);
    16. ret = OH_AudioCodec_FreeOutputBuffer(audioDec_, index);
    17. if (ret != AV_ERR_OK) {
    18.     // Handle exceptions.
    19. }
    20. if (attr.flags == AVCODEC_BUFFER_FLAGS_EOS) {
    21.     // End.
    22. }

  2. (Optional) Call OH_AudioCodec_Flush() to flush the decoder.

    After calling OH_AudioCodec_Flush(), the decoder remains in the running state, but the current queue is cleared and decoded data is released.

    In this case, you need to call OH_AudioCodec_Start() to restart decoding.

    When to use:

    • After the decoding output buffer property is AVCODEC_BUFFER_FLAGS_EOS, if you want to resume decoding with the same configuration, you need to call flush.

    • If a recoverable error occurs during execution (that is, OH_AudioCodec_IsValid() returns true), you can call flush and then call OH_AudioCodec_Start() to restart decoding.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. // Flush the decoder audioDec_.
    2. int32_t ret = OH_AudioCodec_Flush(audioDec_);
    3. if (ret != AV_ERR_OK) {
    4.     // Handle the exception.
    5. }
    6. // Restart decoding.
    7. ret = OH_AudioCodec_Start(audioDec_);
    8. if (ret != AV_ERR_OK) {
    9.     // Handle the exception.
    10. }

  3. (Optional) Call OH_AudioCodec_Reset() to reset the decoder.

    After calling OH_AudioCodec_Reset(), the decoder returns to the initialized state. All input/output buffers obtained before the reset become invalid. You must call OH_AudioCodec_Configure() to reconfigure the decoder, and then call OH_AudioCodec_Start() to restart decoding. After the decoder starts, obtain new input/output buffers.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. // Reset the decoder audioDec_.
    2. int32_t ret = OH_AudioCodec_Reset(audioDec_);
    3. if (ret != AV_ERR_OK) {
    4.     // Handle the exception.
    5. }
    6. // Reconfigure the decoder parameters.
    7. ret = OH_AudioCodec_Configure(audioDec_, format);
    8. if (ret != AV_ERR_OK) {
    9.     // Handle the exception.
    10. }

  4. Call OH_AudioCodec_Stop() to stop the decoder.

After stopping, you can call OH_AudioCodec_Start() to re-enter the started state. The input/output buffers obtained before stopping can no longer be used. You must obtain new input/output buffers after restarting.

Collapse
Word wrap
Dark theme
Copy code
  1. ```c++
  2. // Stop the decoder audioDec_.
  3. int32_t ret = OH_AudioCodec_Stop(audioDec_);
  4. if (ret != AV_ERR_OK) {
  5.     // Handle the exception.
  6. }
  7. ```
  1. Call OH_AudioCodec_Destroy() to destroy the decoder instance and release resources.
NOTE

Do not destroy the decoder repeatedly.

Collapse
Word wrap
Dark theme
Copy code
  1. ```c++
  2. // Call OH_AudioCodec_Destroy to destroy the decoder.
  3. int32_t ret = OH_AudioCodec_Destroy(audioDec_);
  4. if (ret != AV_ERR_OK) {
  5.     // Handle the exception.
  6. } else {
  7.     audioDec_ = NULL; // Do not destroy repeatedly.
  8. }
  9. ```
Synchronous Audio Encoding
Synchronous Audio Decoding
English
©2026 HUAWEI Developers. All rights reserved.
Terms of Use
Statement About HUAWEI Developers and Privacy
Cookies
Cookie Settings
Open-Source Software Notice
Search in Guides
Enter a keyword.