HarmonyOS 鸿蒙Next中关于 AudioRenderer 写入数据方法 writeData 的疑问

感谢回答，原理我看明白了，但还是不太行，我这边是生成了一个0.1s的很短的音频，然后每秒调用一次，即使我现在去除定时方法，而且执行完第一次set之后后续全部返回 return audio.AudioDataCallbackResult.INVALID，也还是有急促的声音，大致生成方法如下

// ========== 音频初始化与预生成 ==========
async createAudioBuffer(frequency: number, duration: number, amplitude: number): Promise<ArrayBuffer> {
  const samples = Math.floor(SAMPLE_RATE * duration);
  const buffer = new ArrayBuffer(samples * 2);
  const view = new Int16Array(buffer);
  const S = 2 * Math.PI * frequency / SAMPLE_RATE;
  const R = 100 / SAMPLE_RATE; // 快速衰减
  const P = 200 / SAMPLE_RATE;
  const O = 500 / SAMPLE_RATE;

  for (let i = 0; i < samples; i++) {
    view[i] = amplitude * (
      0.09 * Math.exp(-i * R) * Math.sin(S * i) +
        0.34 * Math.exp(-i * P) * Math.sin(2 * S * i) +
        0.57 * Math.exp(-i * O) * Math.sin(6 * S * i)
    ) * 0x7FFF;
  }
  return buffer;
}

this.createAudioBuffer(440, BEAT_DURATION, 0.7)

1. 播放音频时会出现部分杂音、卡顿，有时甚至会大段出现。

   • 分析原因：
     AudioRenderer会调用AudioRendererWriteDataCallback方法来写入音频数据，如果数据未能填满回调buffer的长度就放入队列里播放，则会导致杂音、卡顿等现象。因为部分buffer未填满导致存在脏数据影响播放。

   • 解决方案：
     在无法填满回调所需长度数据的情况下，需要返回audio.AudioDataCallbackResult.INVALID，此时系统不会处理该段音频数据，然后会再次向应用请求数据，在确认数据填满后再返回audio.AudioDataCallbackResult.VALID进行播放，参考如下代码，可以判断写入数据是否已填满buffer，如果未填满就可以返回INVALID：

     // 获取音频数据长度readLen，判断能否填满buffer
     if (readLen < buffer.byteLength) {
       return audio.AudioDataCallbackResult.INVALID;
     }
     

2. 停止写入音频数据后，播放没有停止，还会一直输出杂音。

   • 分析原因：
     在没有写入新的音频数据也没有停止AudioRenderer的情况下，则会循环播放缓冲区的历史数据，导致不断输出杂音，影响播放效果。

   • 解决方案：
     对于最后一帧，如果数据不够填满缓冲长度，开发者需要使用剩余数据拼接空数据的方式，将缓冲填满，不够的时候可以用0将数据填满，没有音频数据写入时返回INVALID，或停止AudioRenderer。参考示例代码如下：

     if (chunkSize < rendererBuffer.byteLength) {
       const view = new DataView(rendererBuffer);
       for (let i = chunkSize; i < rendererBuffer.byteLength; i++) {
         view.setUint8(i, 0); 
       }
     }
     

【解决方案】

主要在于音频的回调处理中，下面是AudioRenderere使用writeData写入生成正弦波脉冲音频的Demo代码，具体可参考使用AudioRenderer渲染音频文件的示例代码。

import { BusinessError } from '@ohos.base';
import { audio } from '@kit.AudioKit';


// 常量定义
const SAMPLE_RATE = 48000;
const BEAT_DURATION = 0.1; // 0.1秒音频
const PLAY_INTERVAL = 1000; // 每秒播放一次

@Entry
@Component
struct AudioPlayerPage {
  // 音频渲染器
  private audioRenderer: audio.AudioRenderer | null = null;
  private isRendererInitialized: boolean = false;

  // 音频数据
  private audioBuffer: ArrayBuffer | null = null;
  private bufferSize: number = 0;
  private totalSize: number = 0;

  // 定时器
  private playTimer: number | null = null;

  // 播放状态
  @State isPlaying: boolean = false;
  @State statusText: string = "准备中";
  @State playCount: number = 0;

  aboutToAppear() {
    this.initAudioRenderer();
    this.prepareAudioBuffer();
  }

  aboutToDisappear() {
    this.stopPlayback();
    this.releaseRenderer();
    this.clearTimer();
  }

  // 初始化音频渲染器
  async initAudioRenderer() {
    try {
      // 释放已有的渲染器
      if (this.audioRenderer) {
        this.audioRenderer.release();
      }

      // 配置音频参数
      let audioParams: audio.AudioRendererOptions = {
        streamInfo: {
          samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_48000,
          channels: audio.AudioChannel.CHANNEL_1,
          sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
          encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
        },
        rendererInfo: {
          usage: audio.StreamUsage.STREAM_USAGE_MUSIC,
          rendererFlags: 0
        }
      };

      // 创建音频渲染器
      this.audioRenderer = await audio.createAudioRenderer(audioParams);
      this.isRendererInitialized = true;
      this.statusText = "准备就绪";
      console.info("音频渲染器初始化成功");
    } catch (err) {
      const businessError = err as BusinessError;
      console.error(`音频渲染器初始化失败: ${businessError.message}`);
      this.statusText = "初始化失败";
    }
  }

  // 预生成音频缓冲区
  async prepareAudioBuffer() {
    try {
      this.audioBuffer = await this.createAudioBuffer(440, BEAT_DURATION, 0.7);
      this.totalSize = this.audioBuffer.byteLength;
      this.statusText = "音频就绪，点击开始";
      console.info("音频缓冲区生成成功");
    } catch (err) {
      const businessError = err as BusinessError;
      console.error(`音频缓冲区生成失败: ${businessError.message}`);
      this.statusText = "音频生成失败";
    }
  }

  // 生成音频数据
  async createAudioBuffer(frequency: number, duration: number, amplitude: number): Promise<ArrayBuffer> {
    const samples = Math.floor(SAMPLE_RATE * duration);
    const buffer = new ArrayBuffer(samples * 2);
    const view = new Int16Array(buffer);
    const S = 2 * Math.PI * frequency / SAMPLE_RATE;
    const R = 100 / SAMPLE_RATE; 
    const P = 200 / SAMPLE_RATE;
    const O = 500 / SAMPLE_RATE;

    for (let i = 0; i < samples; i++) {
      view[i] = amplitude * (
        0.09 * Math.exp(-i * R) * Math.sin(S * i) +
          0.34 * Math.exp(-i * P) * Math.sin(2 * S * i) +
          0.57 * Math.exp(-i * O) * Math.sin(6 * S * i)
      ) * 0x7FFF;
    }
    return buffer;
  }

  // 音频数据写入回调
  writeDataCallback = (rendererBuffer: ArrayBuffer): audio.AudioDataCallbackResult => {
    if (!this.audioBuffer || this.bufferSize >= this.totalSize) {
      // 数据已全部写入或没有数据，返回INVALID停止请求
      return audio.AudioDataCallbackResult.INVALID;
    }

    const remaining = this.totalSize - this.bufferSize;
    const chunkSize = Math.min(remaining, rendererBuffer.byteLength);

    console.info(`写入数据: 剩余=${remaining}, 块大小=${chunkSize}, 缓冲区大小=${rendererBuffer.byteLength}`);

    // 复制音频数据到渲染缓冲区
    if (chunkSize > 0) {
      const srcBuffer = new Uint8Array(this.audioBuffer, this.bufferSize, chunkSize);
      const dstBuffer = new Uint8Array(rendererBuffer);
      dstBuffer.set(srcBuffer);
      this.bufferSize += chunkSize;
    }

    // 如果数据不足填满缓冲区，使用DataView填充静音
    if (chunkSize < rendererBuffer.byteLength) {
      const view = new DataView(rendererBuffer);
      for (let i = chunkSize; i < rendererBuffer.byteLength; i++) {
        view.setUint8(i, 0);
      }
      console.info(`填充静音: 从位置 ${chunkSize} 到 ${rendererBuffer.byteLength}`);
    }
    return audio.AudioDataCallbackResult.VALID;
  }

  // 播放单次音频
  async playSingleSound(): Promise<boolean> {
    if (!this.audioRenderer || !this.isRendererInitialized || !this.audioBuffer) {
      console.error("音频渲染器或缓冲区未就绪");
      return false;
    }

    try {
      // 重置偏移量
      this.bufferSize = 0;

      // 注册回调
      this.audioRenderer.off('writeData');
      this.audioRenderer.on('writeData', this.writeDataCallback);

      // 启动播放
      await this.audioRenderer.start();

      // 监听播放完成事件
      return new Promise<boolean>((resolve) => {
        const checkComplete = () => {
          if (this.bufferSize >= this.totalSize) {
            this.audioRenderer?.stop();
            resolve(true);
          } else {
            setTimeout(checkComplete, 10);
          }
        };
        setTimeout(checkComplete, 10);
      });
    } catch (err) {
      const businessError = err as BusinessError;
      console.error(`播放失败: ${businessError.message}`);
      return false;
    }
  }

  // 启动定时播放
  async startTimedPlayback() {
    if (this.isPlaying) {
      return;
    }

    if (!this.audioRenderer || !this.isRendererInitialized || !this.audioBuffer) {
      console.error("音频渲染器或缓冲区未就绪");
      this.statusText = "播放器未就绪";
      return;
    }

    this.isPlaying = true;
    this.playCount = 0;
    this.statusText = "定时播放中...";

    // 启动定时器
    this.playTimer = setInterval(async () => {
      const success = await this.playSingleSound();
      if (success) {
        this.playCount++;
        this.statusText = `播放中 (${this.playCount}次)`;
      }
    }, PLAY_INTERVAL);

    // 立即播放第一次
    const success = await this.playSingleSound();
    if (success) {
      this.playCount++;
      this.statusText = `播放中 (${this.playCount}次)`;
    }
  }

  // 停止播放
  async stopPlayback() {
    if (!this.audioRenderer) {
      return;
    }

    try {
      // 停止并移除回调
      await this.audioRenderer.stop();
      this.audioRenderer.off('writeData');

      this.isPlaying = false;
      this.statusText = "已停止";
      this.clearTimer();
      console.info("音频播放停止");
    } catch (err) {
      const businessError = err as BusinessError;
      console.error(`停止播放失败: ${businessError.message}`);
    }
  }

  // 清除定时器
  private clearTimer() {
    if (this.playTimer !== null) {
      clearInterval(this.playTimer);
      this.playTimer = null;
    }
  }

  // 释放渲染器资源
  async releaseRenderer() {
    if (this.audioRenderer) {
      try {
        this.clearTimer();
        this.audioRenderer.off('writeData');
        await this.audioRenderer.stop();
        await this.audioRenderer.release();
        this.isRendererInitialized = false;
        console.info("音频渲染器已释放");
      } catch (err) {
        const businessError = err as BusinessError;
        console.error(`释放渲染器失败: ${businessError.message}`);
      }
    }
  }

  build() {
    Column() {
      Text('定时音频播放器')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .margin({ top: 20, bottom: 40 })

      Text(this.statusText)
        .fontSize(18)
        .margin({ bottom: 20 })

      Text(`播放次数: ${this.playCount}`)
        .fontSize(16)
        .margin({ bottom: 30 })

      Row() {
        Button(this.isPlaying ? '停止定时播放' : '开始定时播放')
          .width(160)
          .height(40)
          .backgroundColor(this.isPlaying ? '#ff0000' : '#007dff')
          .onClick(() => {
            if (this.isPlaying) {
              this.stopPlayback();
            } else {
              this.startTimedPlayback();
            }
          })
          .margin({ right: 20 })

        Button('单次播放')
          .width(120)
          .height(40)
          .backgroundColor('#10a0a0')
          .onClick(async () => {
            if (!this.isPlaying) {
              const success = await this.playSingleSound();
              if (success) {
                this.playCount++;
                this.statusText = `单次播放完成 (${this.playCount}次)`;
              }
            }
          })
      }
      .margin({ bottom: 30 })

    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
    .alignItems(HorizontalAlign.Center)
  }
}