OpusOhos：为 HarmonyOS 打造高性能音频编解码库

发表于 分类于 阅读次数：

引言

随着 HarmonyOS 生态的快速发展，移动应用对高质量音频处理的需求日益增长。无论是实时语音通话、音频录制还是流媒体传输，都需要一个高效、可靠的音频编解码解决方案。Opus 作为一种开放、免版税的音频编解码标准，以其卓越的音质和灵活性在业界广受认可。然而，HarmonyOS 平台缺乏成熟的 Opus 编解码库支持。本文将详细介绍 OpusOhos 库的设计与实现过程，探讨如何将 C/C++ 原生库高效集成到 HarmonyOS 应用开发生态中。

目前该库已发布到OpenHarmony三方库中心仓，点击前往

开发背景

技术需求分析

在开发 HarmonyOS 音频应用时，我们面临以下核心需求：

  1. 高压缩比与高音质：需要在有限的带宽条件下传输高质量音频
  2. 低延迟：实时通话场景要求端到端延迟控制在毫秒级
  3. 多场景适配：支持从窄带语音（8kHz）到全频带音乐（48kHz）的各种应用场景
  4. 跨平台兼容：与主流平台的 Opus 实现保持兼容

为什么选择 Opus

Opus 编解码器由 IETF（互联网工程任务组）标准化（RFC 6716），具有以下显著优势：

  • 优异的音频质量：在各种比特率下都能提供出色的音质
  • 超低延迟：算法延迟仅 5-66.5ms，适合实时通信
  • 宽泛的比特率范围：支持 6 kbps 到 510 kbps
  • 自适应性强：可动态调整比特率以适应网络状况
  • 开源免费：无需支付版税，降低开发成本

HarmonyOS 集成挑战

HarmonyOS 应用主要使用 ArkTS 进行开发，而 Opus 库是用 C 语言实现的。如何在两者之间搭建高效、稳定的桥梁成为关键挑战：

  1. 语言互操作：ArkTS 与 C/C++ 之间的数据传递和类型转换
  2. 内存管理：跨语言边界的内存安全问题
  3. 性能优化：最小化跨层调用开销
  4. API 设计：为 ArkTS 开发者提供符合习惯的接口

技术方案设计

整体架构

OpusOhos 采用三层架构设计，实现了从底层编解码算法到上层应用接口的完整封装：

1
2
3
4
5
6
7
8
9
10
┌─────────────────────────────────────────┐
│         ArkTS Application Layer         │
│   (OpusEncoder / OpusDecoder Class)     │
├─────────────────────────────────────────┤
│          N-API Bridge Layer             │
│      (napi_init.cpp - 接口适配)         │
├─────────────────────────────────────────┤
│        Native Library Layer             │
│    (libopus.so - Opus 1.5.2 核心)      │
└─────────────────────────────────────────┘

各层职责划分：

  • ArkTS 应用层：提供面向对象的 API，处理业务逻辑和数据格式转换
  • N-API 桥接层：实现 JavaScript/ArkTS 与 C++ 的互操作，负责类型转换和错误处理
  • 原生库层：基于 libopus 1.5.2 实现高性能的编解码算法

技术选型

1. Opus 库版本

OpusOhos 1.0.1 基于 libopus 1.5.2 实现，提供了：

  • 优化的 ARM NEON 指令集支持
  • 改进的低比特率性能
  • 更好的音频质量评估算法

2. N-API 接口技术

N-API（Native API）是 HarmonyOS 提供的用于构建原生插件的接口层，具有以下特点：

  • ABI 稳定性：跨版本兼容，减少维护成本
  • 上下文隔离：安全地管理 JavaScript 和 C++ 对象生命周期
  • 异常安全：提供完善的错误处理机制

3. 构建系统

采用 CMake 作为构建工具，配合 HarmonyOS SDK 提供的工具链：

1
2
3
4
5
6
7
8
9
cmake_minimum_required(VERSION 3.5.0)
project(myNpmLib)

add_library(opusohos SHARED napi_init.cpp opus)
target_link_libraries(opusohos PUBLIC 
    libace_napi.z.so 
    libhilog_ndk.z.so
    ${NATIVERENDER_ROOT_PATH}/../../../libs/${OHOS_ARCH}/libopus.so
)

数据流设计

编码流程

1
2
3
4
5
6
7
8
9
PCM Audio (Int16Array)
    ↓
ArkTS Layer: 准备单个音频帧
    ↓
N-API Layer: ArrayBuffer 传递
    ↓
Native Layer: opus_encode() 编码单帧
    ↓
ArkTS Layer: 返回裸 Opus 帧数据

解码流程

1
2
3
4
5
6
7
8
9
Opus Frame (Uint8Array / ArrayBuffer)
    ↓
ArkTS Layer: 接收单个 Opus 帧
    ↓
N-API Layer: 帧数据传递
    ↓
Native Layer: opus_decode() 解码单帧
    ↓
ArkTS Layer: 返回 Int16Array PCM 样本

内存管理策略

跨语言边界的内存管理是整个方案的核心难点之一。我们采用以下策略：

  1. 零拷贝传递：使用 ArrayBuffer 在 ArkTS 和 C++ 之间共享内存
  2. 明确的生命周期：通过 init() 和 destroy() 方法明确资源管理
  3. RAII 原则：在 C++ 层使用智能指针和自动析构
  4. 错误恢复：任何异常都要确保资源正确释放

核心实现详解

1. N-API 编码器实现

N-API 层的编码器实现是整个系统的核心，处理数据转换、单帧编码、内存管理等环节。

初始化过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
static napi_value InitEncoder(napi_env env, napi_callback_info info) {
    // 1. 参数解析
    size_t argc = 4;
    napi_value args[4];
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

    int32_t sampleRate, channels, bitRate, frameDurationMs;
    napi_get_value_int32(env, args[0], &sampleRate);
    napi_get_value_int32(env, args[1], &channels);
    napi_get_value_int32(env, args[2], &bitRate);
    napi_get_value_int32(env, args[3], &frameDurationMs);

    // 2. 创建 Opus 编码器
    int err;
    encoder_ = opus_encoder_create(sampleRate, channels, 
                                    OPUS_APPLICATION_AUDIO, &err);

    // 3. 根据帧时长动态计算帧大小
    gFrameDurationMs = frameDurationMs;
    gFrameSize = static_cast<opus_int32>(sampleRate * frameDurationMs / 1000);

    // 4. 验证帧时长合法性
    const int validDurations[] = {
        sampleRate / 400,      // 2.5ms
        sampleRate / 200,      // 5ms
        sampleRate / 100,      // 10ms
        sampleRate / 50,       // 20ms
        sampleRate / 50 * 2,   // 40ms
        sampleRate / 50 * 3,   // 60ms
        sampleRate / 50 * 4,   // 80ms
        sampleRate / 50 * 5,   // 100ms
        sampleRate / 50 * 6    // 120ms
    };

    bool isValidFrame = false;
    for (int validSize : validDurations) {
        if (gFrameSize == validSize) {
            isValidFrame = true;
            break;
        }
    }

    if (!isValidFrame) {
        OH_LOG_ERROR(LOG_APP, "Invalid frame duration: %d ms for sample rate %d",
                     frameDurationMs, sampleRate);
        return nullptr;
    }

    // 5. 配置比特率
    opus_encoder_ctl(encoder_, OPUS_SET_BITRATE(bitRate));

    return nullptr;
}

设计要点：

  • 动态帧大小计算：根据采样率和帧时长灵活计算，不再固定为20ms
  • 帧时长验证：支持2.5/5/10/20/40/60/80/100/120ms多种配置
  • 采样率适配：根据不同采样率正确计算对应的帧样本数
  • 错误检查：验证帧时长合法性，确保初始化成功

编码过程

编码过程现在专注于单个帧的高效编码，返回裸Opus数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
static napi_value Encode(napi_env env, napi_callback_info info) {
    // 1. 获取单个 PCM 帧数据
    napi_value args[1];
    size_t argc = 1;
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

    void *pcm = nullptr;
    size_t len = 0;
    napi_get_arraybuffer_info(env, args[0], &pcm, &len);

    // 2. 数据验证 - 确保输入的样本数与帧大小一致
    size_t numSamples = len / sizeof(int16_t);
    if (numSamples != gFrameSize) {
        OH_LOG_ERROR(LOG_APP, 
                     "PCM frame size mismatch: expected %d samples, got %zu",
                     gFrameSize, numSamples);
        return nullptr;
    }

    // 3. 分配输出缓冲区 - 裸 Opus 帧数据
    const size_t maxEncodedSize = 4000;
    unsigned char* outputBuffer = 
        static_cast<unsigned char*>(malloc(maxEncodedSize));

    // 4. 编码单个帧
    int16_t* pcmSamples = static_cast<int16_t*>(pcm);
    int encodedBytes = opus_encode(encoder_,
                                   pcmSamples,
                                   gFrameSize,
                                   outputBuffer,
                                   maxEncodedSize);

    if (encodedBytes < 0) {
        OH_LOG_ERROR(LOG_APP, "opus_encode failed with error: %d", 
                     encodedBytes);
        free(outputBuffer);
        return nullptr;
    }

    // 5. 创建返回的 ArrayBuffer - 直接返回裸 Opus 帧
    napi_value result;
    void* resultData = nullptr;
    napi_create_arraybuffer(env, encodedBytes, &resultData, &result);
    memcpy(resultData, outputBuffer, encodedBytes);
    free(outputBuffer);

    OH_LOG_INFO(LOG_APP, "Encoding completed: %d bytes", encodedBytes);

    return result;
}

关键特点：

  1. 单帧处理：一次编码调用处理一个音频帧
  2. 裸数据输出：直接返回 Opus 编码数据，无额外打包开销
  3. 实时流传输：编码后的数据可直接通过 WebSocket/RTC 发送
  4. 高效内存使用：预分配固定大小缓冲区，避免频繁分配

2. N-API 解码器实现

解码器处理裸 Opus 帧数据，直接转换为 PCM 样本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
static napi_value Decode(napi_env env, napi_callback_info info) {
    // 1. 获取单个 Opus 帧数据
    napi_value args[1];
    size_t argc = 1;
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

    void *opusData = nullptr;
    size_t len = 0;
    napi_get_arraybuffer_info(env, args[0], &opusData, &len);

    // 2. 分配 PCM 输出缓冲区
    const size_t maxFrameSize = 5760;  // 48kHz 时的最大帧（120ms）
    int16_t *pcmOutput = static_cast<int16_t*>(
        malloc(maxFrameSize * sizeof(int16_t))
    );

    // 3. 解码单个 Opus 帧
    int decodedSamples = opus_decode(
        decoder_,
        static_cast<const unsigned char*>(opusData),
        static_cast<opus_int32>(len),
        pcmOutput,
        maxFrameSize,
        0  // FEC disabled（前向纠错关闭）
    );

    if (decodedSamples < 0) {
        OH_LOG_ERROR(LOG_APP, "opus_decode failed with error: %d", 
                     decodedSamples);
        free(pcmOutput);
        return nullptr;
    }

    // 4. 创建返回的 ArrayBuffer - 直接返回 PCM 数据
    const size_t resultSize = decodedSamples * sizeof(int16_t);
    napi_value result;
    void* resultData = nullptr;
    napi_create_arraybuffer(env, resultSize, &resultData, &result);
    memcpy(resultData, pcmOutput, resultSize);
    free(pcmOutput);

    OH_LOG_INFO(LOG_APP, "Decoding completed: %d samples", decodedSamples);

    return result;
}

关键特点：

  1. 单帧解码：处理单个裸 Opus 帧，返回对应的 PCM 样本
  2. 直接数据传递：解码结果直接作为 ArrayBuffer 返回，可立即播放
  3. 动态采样数：返回实际解码出的样本数，支持可变帧长
  4. 内存高效：使用预分配的最大缓冲区，一次分配完成

3. ArkTS 封装层设计

ArkTS 层提供面向对象的 API，简化使用流程：

OpusEncoder 类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
export class OpusEncoder {
  private sampleRate: number = 0;
  private channels: number = 0;
  private bitRate: number = 0;
  private frameSize: number = 0;
  private frameDurationMs: number = 20;

  /**
   * 初始化编码器
   * @param sampleRate 采样率（8000/12000/16000/24000/48000）
   * @param channels 声道数（1 或 2）
   * @param bitRate 比特率（bps）
   * @param frameDurationMs 帧时长（ms），可选，默认 20ms
   *        支持值：2.5 | 5 | 10 | 20 | 40 | 60 | 80 | 100 | 120
   *        推荐值：20ms（低延迟）、60ms（与 iOS opus_dart 兼容）
   */
  init(sampleRate: number, channels: number, bitRate: number, 
       frameDurationMs?: number) {
    const actualFrameDuration = frameDurationMs ?? 20;

    // 验证帧时长
    this.frameSize = OpusEncoder.getFrameSize(sampleRate, actualFrameDuration);

    // 初始化编码器
    opusOhos.initEncoder(sampleRate, channels, bitRate, actualFrameDuration);

    this.sampleRate = sampleRate;
    this.channels = channels;
    this.bitRate = bitRate;
    this.frameDurationMs = actualFrameDuration;
  }

  /**
   * 编码单个 PCM 帧为裸 Opus 数据
   * 
   * @param pcmData Int16Array 格式的 PCM 样本
   * @returns ArrayBuffer 格式的裸 Opus 帧数据
   */
  encode(pcmData: Int16Array): ArrayBuffer {
    if (pcmData.length !== this.frameSize) {
      throw new Error(`PCM frame size mismatch: expected ${this.frameSize}, ` +
                      `got ${pcmData.length}`);
    }

    const cleanBuffer = this.ensureAlignedBuffer(pcmData);
    return opusOhos.encode(cleanBuffer);
  }

  /**
   * 根据采样率和帧时长计算帧大小
   * @param sampleRate 采样率
   * @param frameDurationMs 帧时长（ms），可选，默认 20ms
   * @returns 每帧样本数
   */
  static getFrameSize(sampleRate: number, frameDurationMs?: number): number {
    const duration = frameDurationMs ?? 20;
    const frameSize = Math.floor(sampleRate * duration / 1000);

    // 验证帧时长支持
    const validDurations = [2.5, 5, 10, 20, 40, 60, 80, 100, 120];
    if (!validDurations.includes(duration)) {
      throw new Error(`Unsupported frame duration ${duration}ms. ` +
                      `Supported: 2.5, 5, 10, 20, 40, 60, 80, 100, 120`);
    }

    return frameSize;
  }

  /**
   * 工具方法：Uint8Array 转 Int16Array
   */
  static bytesToInt16(bytes: Uint8Array): Int16Array {
    if (bytes.byteOffset % 2 === 0) {
      return new Int16Array(bytes.buffer, bytes.byteOffset, 
                           Math.floor(bytes.length / 2));
    }

    const int16Length = Math.floor(bytes.length / 2);
    const int16List = new Int16Array(int16Length);
    const dataView = new DataView(bytes.buffer, bytes.byteOffset);
    for (let i = 0; i < int16Length; i++) {
      int16List[i] = dataView.getInt16(i * 2, true);
    }
    return int16List;
  }

  private ensureAlignedBuffer(pcmData: Int16Array): ArrayBuffer {
    if (pcmData.byteOffset === 0 && 
        pcmData.buffer.byteLength === pcmData.byteLength) {
      return pcmData.buffer;
    }

    const cleanBuffer = new ArrayBuffer(pcmData.byteLength);
    new Uint8Array(cleanBuffer).set(
      new Uint8Array(pcmData.buffer, pcmData.byteOffset, pcmData.byteLength)
    );
    return cleanBuffer;
  }

  destroy() {
    opusOhos.destroyEncoder();
  }
}

API 特点：

  1. 灵活的帧时长：支持2.5-120ms多种配置
  2. 单帧编码：一次处理一个音频帧，直接返回裸Opus数据
  3. 流传输优化：编码结果可直接通过网络发送
  4. 输入验证：自动检查帧大小，提前发现错误

OpusDecoder 类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
export class OpusDecoder {
  private sampleRate: number = 0;
  private channels: number = 0;
  private frameSize: number = 0;
  private frameDurationMs: number = 20;

  /**
   * 初始化解码器
   * @param sampleRate 采样率（8000/12000/16000/24000/48000）
   * @param channels 声道数（1 或 2）
   * @param frameDurationMs 帧时长（ms），可选，默认 20ms
   *        支持值：2.5 | 5 | 10 | 20 | 40 | 60 | 80 | 100 | 120
   *        推荐值：20ms（低延迟）、60ms
   * @note 解码时的帧时长应与编码时一致
   */
  init(sampleRate: number, channels: number, frameDurationMs?: number) {
    const actualFrameDuration = frameDurationMs ?? 20;

    // 验证帧时长
    this.frameSize = OpusDecoder.getFrameSize(sampleRate, actualFrameDuration);

    // 初始化解码器
    opusOhos.initDecoder(sampleRate, channels, actualFrameDuration);

    this.sampleRate = sampleRate;
    this.channels = channels;
    this.frameDurationMs = actualFrameDuration;
  }

  /**
   * 解码单个裸 Opus 帧为 PCM 数据
   * 
   * 适用于实时流传输场景（WebSocket 接收）：
   * - 输入：单个裸 Opus 帧（从网络接收的原始数据）
   * - 输出：PCM 样本数组（Int16Array）
   * 
   * @param frameData 单个 Opus 帧数据 (Uint8Array 或 ArrayBuffer)
   * @returns 解码后的 PCM 样本 (Int16Array)
   */
  decode(frameData: Uint8Array | ArrayBuffer): Int16Array {
    if (this.sampleRate === 0) {
      throw new Error('Decoder not initialized. Call init() first.');
    }

    // 统一转换为 ArrayBuffer
    const buffer = frameData instanceof Uint8Array ? frameData.buffer : frameData;

    // 调用 native decode 方法
    const pcmBuffer: ArrayBuffer = opusOhos.decode(buffer);

    // 将 ArrayBuffer 转换为 Int16Array
    const int16Length = pcmBuffer.byteLength / 2;
    return new Int16Array(pcmBuffer, 0, int16Length);
  }

  /**
   * 解码单个裸 Opus 帧，直接返回 Uint8Array 格式的 PCM 数据
   * 
   * @param frameData 单个 Opus 帧数据 (Uint8Array 或 ArrayBuffer)
   * @returns Uint8Array 格式的 PCM 数据
   */
  decodeToBytes(frameData: Uint8Array | ArrayBuffer): Uint8Array {
    const samples = this.decode(frameData);
    return new Uint8Array(samples.buffer, samples.byteOffset, samples.byteLength);
  }

  /**
   * 根据采样率和帧时长计算帧大小
   * @param sampleRate 采样率
   * @param frameDurationMs 帧时长（ms），可选，默认 20ms
   * @returns 每帧样本数
   */
  static getFrameSize(sampleRate: number, frameDurationMs?: number): number {
    const duration = frameDurationMs ?? 20;
    const frameSize = Math.floor(sampleRate * duration / 1000);

    const validDurations = [2.5, 5, 10, 20, 40, 60, 80, 100, 120];
    if (!validDurations.includes(duration)) {
      throw new Error(`Unsupported frame duration ${duration}ms. ` +
                      `Supported: 2.5, 5, 10, 20, 40, 60, 80, 100, 120`);
    }

    return frameSize;
  }

  /**
   * 工具方法：Uint8Array 转 Int16Array
   */
  static bytesToInt16(bytes: Uint8Array): Int16Array {
    if (bytes.byteOffset % 2 === 0) {
      return new Int16Array(bytes.buffer, bytes.byteOffset, 
                           Math.floor(bytes.length / 2));
    }

    const int16Length = Math.floor(bytes.length / 2);
    const int16List = new Int16Array(int16Length);
    const dataView = new DataView(bytes.buffer, bytes.byteOffset);
    for (let i = 0; i < int16Length; i++) {
      int16List[i] = dataView.getInt16(i * 2, true);
    }
    return int16List;
  }

  destroy() {
    opusOhos.destroyDecoder();
  }
}

API 特点：

  1. 单帧解码：处理单个裸Opus帧，直接返回PCM样本
  2. 多种返回格式：支持Int16Array和Uint8Array两种输出格式
  3. 灵活的帧时长：支持与编码器一致的多种帧时长配置
  4. 流传输优化：接收网络数据后可直接解码播放

4. 多架构支持

OpusOhos 支持 HarmonyOS 的主要架构平台：

预编译库管理

1
2
3
4
5
libs/
├── arm64-v8a/
│   └── libopus.so      # ARM64 平台库
└── x86_64/
    └── libopus.so      # x86_64 模拟器库

CMake 架构选择

1
2
3
target_link_libraries(opusohos PUBLIC 
    ${NATIVERENDER_ROOT_PATH}/../../../libs/${OHOS_ARCH}/libopus.so
)

${OHOS_ARCH} 变量由 HarmonyOS 构建系统自动设置，确保链接正确的库版本。

性能优化策略

1. 单帧流传输优化

直接编解码：

  • 编码：PCM 帧 → 裸 Opus 数据（无打包开销）
  • 解码：裸 Opus 帧 → PCM 样本（无解包开销）
  • 适合实时流传输（WebSocket、RTC）

实测性能指标（48kHz, 单声道）：

  • 单帧编码延迟：~0.3-0.5ms
  • 单帧解码延迟：~0.2-0.4ms
  • 低开销的网络传输

2. 内存优化

零拷贝技术：

  • 使用 ArrayBuffer 共享内存
  • 避免 ArkTS 和 C++ 之间的数据复制
  • 直接在原始 buffer 上操作

高效的帧大小计算：

  • 预计算帧大小，避免重复计算
  • 支持多种帧时长配置（2.5-120ms）

3. 错误处理与日志

快速失败：

  • 参数验证前置（帧大小、帧时长）
  • 早期返回避免无效计算
  • 详细的日志记录（使用 HiLog）
1
2
OH_LOG_INFO(LOG_APP, "Encoding completed: %d bytes", encodedBytes);
OH_LOG_ERROR(LOG_APP, "opus_encode failed with error: %d", encodedBytes);

部署与使用

包管理配置

oh-package.json5:

1
2
3
4
5
6
7
8
9
10
{
  "name": "@lengain/opusohos",
  "version": "1.0.1",
  "description": "Opus audio codec for HarmonyOS",
  "main": "Index.ets",
  "license": "Apache-2.0",
  "dependencies": {
    "libopusohos.so": "file:./src/main/cpp/types/libopusohos"
  }
}

应用集成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import { OpusEncoder, OpusDecoder } from '@lengain/opusohos';

// 编码示例 - 支持灵活的帧时长配置
const encoder = new OpusEncoder();
encoder.init(48000, 1, 64000, 20);  // 48kHz, 单声道, 64kbps, 20ms帧
const pcmFrame = new Int16Array(960);  // 960 samples = 20ms @ 48kHz
const opusFrame = encoder.encode(pcmFrame);  // 返回裸 Opus 帧
encoder.destroy();

// 解码示例 - 接收的裸 Opus 帧可直接解码
const decoder = new OpusDecoder();
decoder.init(48000, 1, 20);  // 参数须与编码端一致
const pcmData = decoder.decode(opusFrame);  // 直接返回 PCM 样本
// 或返回 Uint8Array 格式
const pcmBytes = decoder.decodeToBytes(opusFrame);
decoder.destroy();

关键改进：

  1. 单帧编解码：直接处理单个帧，返回裸Opus数据，无打包开销
  2. 灵活帧时长：支持2.5-120ms的多种帧时长配置
  3. 流传输友好：编码结果可直接通过WebSocket/RTC发送
  4. 简化的API：不再需要复杂的打包/解包逻辑

参考资料

  1. Opus Codec Official Website
  2. RFC 6716 - Definition of the Opus Audio Codec
  3. HarmonyOS N-API Development Guide
  4. libopus API Documentation
  5. CMake Official Documentation