HarmonyOS 鸿蒙Next系统如何进行pcm流式播放

一、先搞懂两个接口的本质区别

1. AudioRenderer（ArkTS侧的API）
   这个是鸿蒙给应用层（ArkTS/ArkUI）封装好的音频渲染接口，你在Stage模型里直接调用就行，不用碰C/C++代码。它的回调模式，就是系统音频线程会定期“喊你”，让你喂PCM数据进去，刚好适合你这种边下载边喂数据的流式场景。

2. OHAudio（Native层的API）
   这个是给Native（C/C++）代码用的接口，属于NAPI开发范畴，比AudioRenderer更底层，性能上限更高，但门槛也高，得自己处理线程、内存这些。

简单说：想省事、快速实现，选AudioRenderer；追求极致低延迟、高性能，才考虑OHAudio。

二、AudioRenderer 回调模式的核心注意点（直接用的话重点看这个）

1. 数据喂得够不够快，别断流
   回调是系统定时触发的，比如每10ms喊你一次要数据，你必须在回调里把足够的PCM数据塞进去，不然就会出现卡顿、爆音。
   流式场景下，你下载的线程要和回调线程做好缓冲，比如搞个环形队列，下载的数据先扔队列里，回调里直接从队列取，别让回调里直接等网络下载，不然必超时。

2. 格式参数必须和PCM数据严格对齐
   创建AudioRenderer的时候，配置的采样率、位深（比如16bit）、声道数、数据格式，必须和你服务端下的PCM数据完全一致，不然声音会变调、杂音甚至完全没声。
   举个例子：你服务端是44100Hz、16bit、单声道的PCM，创建的时候就必须配一样的参数，不能瞎写。

3. 回调里别做耗时操作
   回调函数是跑在系统的音频线程里的，这里面只能做“取数据、塞数据”这种轻量操作，别在里面做IO、网络、复杂计算，不然会阻塞音频线程，直接爆音。

4. 线程安全问题
   你下载数据的线程和AudioRenderer的回调线程，都要访问同一个数据缓冲区，必须做好加锁，不然会出现数据错乱、崩溃。

主要一个napi开发(也就是Native层)，一个直接arkts开发；

如果仅仅是为了播放pcm格式的音频, 用AVPlayer也可以

使用AudioRenderer渲染音频文件的示例代码

import { audio } from '@kit.AudioKit';
import { BusinessError } from '@kit.BasicServicesKit';
import { fileIo as fs } from '@kit.CoreFileKit';
import { common } from '@kit.AbilityKit';
// ...
const TAG = 'AudioRendererDemo';
class Options {
  public offset?: number;
  public length?: number;
}
// ...

let audioRenderer: audio.AudioRenderer | undefined = undefined;
let audioStreamInfo: audio.AudioStreamInfo = {
  samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_48000, // 采样率。
  channels: audio.AudioChannel.CHANNEL_2, // 通道。
  sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE, // 采样格式。
  encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW // 编码格式。
};
let audioRendererInfo: audio.AudioRendererInfo = {
  usage: audio.StreamUsage.STREAM_USAGE_MUSIC, // 音频流使用类型：音乐。根据业务场景配置，参考StreamUsage。
  rendererFlags: 0 // 音频渲染器标志。
};
let audioRendererOptions: audio.AudioRendererOptions = {
  streamInfo: audioStreamInfo,
  rendererInfo: audioRendererInfo
};
let writeDataCallback: audio.AudioRendererWriteDataCallback;

async function initArguments(context: common.UIAbilityContext) {
  let bufferSize: number = 0;
  let file = await context.resourceManager.getRawFd('32_xiyouji.pcm');
  writeDataCallback = (buffer: ArrayBuffer) => {
    let options: Options = {
      offset: bufferSize,
      length: buffer.byteLength
    };

    try {
      let bufferLength = fs.readSync(file.fd, buffer, options);
      bufferSize += buffer.byteLength;
      // 如果当前回调传入的数据不足一帧，空白区域需要使用静音数据填充，否则会导致播放出现杂音。
      if (bufferLength < buffer.byteLength) {
        let view = new DataView(buffer);
        for (let i = bufferLength; i < buffer.byteLength; i++) {
          // 空白区域填充静音数据。当使用音频采样格式为SAMPLE_FORMAT_U8时0x7F为静音数据，使用其他采样格式时0为静音数据。
          view.setUint8(i, 0);
        }
      }
      // API version 11不支持返回回调结果，从API version 12开始支持返回回调结果。
      // 如果开发者不希望播放某段buffer，返回audio.AudioDataCallbackResult.INVALID即可。
      return audio.AudioDataCallbackResult.VALID;
    } catch (error) {
      console.error('Error reading file:', error);
      // ...
      // API version 11不支持返回回调结果，从API version 12开始支持返回回调结果。
      return audio.AudioDataCallbackResult.INVALID;
    }
  };
}

// 初始化，创建实例，设置监听事件。
async function init() {
  audio.createAudioRenderer(audioRendererOptions, (err, renderer) => { // 创建AudioRenderer实例。
    if (!err) {
      console.info(`${TAG}: creating AudioRenderer success`);
      // ...
      audioRenderer = renderer;
      if (audioRenderer !== undefined) {
        audioRenderer.on('writeData', writeDataCallback);
        // ...
      }
    } else {
      console.info(`${TAG}: creating AudioRenderer failed, error: ${err.message}`);
      // ...
    }
  });
}

// 开始一次音频渲染。
async function start() {
  if (audioRenderer !== undefined) {
    let stateGroup = [audio.AudioState.STATE_PREPARED, audio.AudioState.STATE_PAUSED, audio.AudioState.STATE_STOPPED];
    if (stateGroup.indexOf(audioRenderer.state.valueOf()) === -1) { // 当且仅当状态为prepared、paused和stopped之一时才能启动渲染。
      console.error(TAG + 'start failed');
      // ...
      return;
    }
    // 启动渲染。
    audioRenderer.start((err: BusinessError) => {
      if (err) {
        console.error('Renderer start failed.');
        // ...
      } else {
        console.info('Renderer start success.');
        // ...
      }
    });
  }
}

async function pause() {
  // 暂停渲染。
  if (audioRenderer !== undefined) {
    // 只有渲染器状态为running的时候才能暂停。
    if (audioRenderer.state.valueOf() !== audio.AudioState.STATE_RUNNING) {
      console.info('Renderer is not running');
      // ...
      return;
    }
    // 暂停渲染。
    audioRenderer.pause((err: BusinessError) => {
      if (err) {
        console.error('Renderer pause failed.');
        // ...
      } else {
        console.info('Renderer pause success.');
        // ...
      }
    });
  }
}

// 停止渲染。
async function stop() {
  if (audioRenderer !== undefined) {
    // 只有渲染器状态为running或paused的时候才可以停止。
    if (audioRenderer.state.valueOf() !== audio.AudioState.STATE_RUNNING &&
      audioRenderer.state.valueOf() !== audio.AudioState.STATE_PAUSED) {
      console.info('Renderer is not running or paused.');
      // ...
      return;
    }
    // 停止渲染。
    audioRenderer.stop((err: BusinessError) => {
      if (err) {
        console.error('Renderer stop failed.');
        // ...
      } else {
        console.info('Renderer stop success.');
        // ...
      }
    });
  }
}

// 销毁实例，释放资源。
async function release() {
  if (audioRenderer !== undefined) {
    // 渲染器状态不是released状态，才能release。
    if (audioRenderer.state.valueOf() === audio.AudioState.STATE_RELEASED) {
      console.info('Renderer already released');
      // ...
      return;
    }

    // ...

    // 释放资源。
    audioRenderer.release((err: BusinessError) => {
      if (err) {
        console.error('Renderer release failed.');
        // ...
      } else {
        // 关闭沙箱文件
        console.info('Renderer release success.');
        // ...
      }
    });
  }
}