播放与推流外部输入音频（包括音效、伴奏）

实现原理

该功能适用于需要播放或推流音乐文件的多种场景。

• 伴奏 API：用于播放比较长的音乐文件，例如伴奏音乐、背景音乐等。同时只能播放一个音乐文件。

• 音效 API：用于播放较短的音效文件，例如掌声、笑声等音效。可以同时播放多个音乐文件。

相关功能如下：

实现播放伴奏

调用伴奏相关 API 时，一次只能播放一个音频文件。

1. 加入频道并推送音频流，SDK 默认是推送的。

   Android

   // 播放伴奏或音效需要推送音频流，SDK默认是开启的
   mAliRtcEngine.publishLocalAudioStream(true);

   iOS

   // 播放伴奏或音效需要推送音频流，SDK默认是开启的
   engine.publishLocalVideoStream(true)

2. 播放控制

加入频道并推音频流后，调用 startAudioAccompany 播放伴奏。成功调用该方法后，本地会触发 onAudioAccompanyStateChanged 回调，远端会触发 onRemoteAudioAccompanyStarted 回调。

除此之外，你还可以通过下面的接口实现播放控制：

• stopAudioAccompany：停止播放。

• pauseAudioAccompany：暂停播放。

• resumeAudioAccompany：恢复播放。

• getAudioAccompanyDuration、getAudioAccompanyCurrentPosition、setAudioAccompanyPosition：文件时长获取与播放进度控制。

• setAudioAccompanyVolume：同时设置伴奏本地播放和远端推流的音量。

• getAudioAccompanyPublishVolume、setAudioAccompanyPublishVolume：获取或调节伴奏在远端的播放音量。

• getAudioAccompanyPlayoutVolume、setAudioAccompanyPlayoutVolume：获取或调节伴奏在本地播放的音量

// 伴奏文件路径
private String mMixingMusicFilepath = "/assets/music.wav";

// 伴奏播放配置
AliRtcEngine.AliRtcAudioAccompanyConfig config = new AliRtcEngine.AliRtcAudioAccompanyConfig();
config.loopCycles = -1; // 循环次数， -1表示无限循环
config.publishVolume = publishVolume; // 推流音量,[0-100]
config.playoutVolume = playbackVolume; // 本地播放音量,[0-100]
config.startPosMs = 0; // 起始播放位置
// 开始播放
mAliRtcEngine.startAudioAccompany(mMixingMusicFilepath, config);

// 暂停/恢复伴奏
mAliRtcEngine.pauseAudioAccompany();
mAliRtcEngine.resumeAudioAccompany();

// 停止播放
mAliRtcEngine.stopAudioAccompany();

// 获取伴奏文件的时长（单位为ms），需要在startAudioAccompany之后调用,否则会返回-1
int duration = mAliRtcEngine.getAudioAccompanyDuration();
// 如果需要获取指定文件的时长，可以通过getAudioFileInfo接口，该接口在创建引擎后即可调用，结果通过onAudioFileInfo回调返回
mAliRtcEngine.getAudioFileInfo(filePath);
@Override
public void onAudioFileInfo(AliRtcEngine.AliRtcAudioFileInfo info, AliRtcEngine.AliRtcAudioAccompanyErrorCode errorCode) {

    handler.post(() -> {
        String msg = "onAudioFileInfo.file:" + info.filePath + "duration:" + info.durationMs + "audioPlayingErrorCode=" + errorCode;
        ToastHelper.showToast(PlayAudioFilesActivity.this, msg, Toast.LENGTH_SHORT);
    });
}

// 获取/设置音量
mAliRtcEngine.setAudioAccompanyVolume(50); // [0-100]
int publishVolume = mAliRtcEngine.getAudioAccompanyPublishVolume();
mAliRtcEngine.setAudioAccompanyPublishVolume(50);
int playoutVolume = mAliRtcEngine.getAudioAccompanyPlayoutVolume();
mAliRtcEngine.setAudioAccompanyPlayoutVolume(50);

// 获取/设置播放进度
int currPosition = mAliRtcEngine.getAudioAccompanyCurrentPosition(); // 单位为ms
int targetPosition = 1000; // 以1000ms处开始播放为例
mAliRtcEngine.setAudioAccompanyPosition(targetPosition);

// 伴奏文件路径
let filePath = Bundle.main.path(forResource: "music", ofType: "wav")

// 伴奏播放配置
let config = AliRtcAudioAccompanyConfig()
config.loopCycles = loopCount
config.publishVolume = publishVolume
config.playoutVolume = playoutVolume
config.startPosMs = 0
// 开始播放
let result = rtcEngine.startAudioAccompany(withFile: filePath, config: config)

// 暂停/恢复播放
rtcEngine.pauseAudioAccompany()
rtcEngine.resumeAudioAccompany()

// 停止播放
rtcEngine.stopAudioAccompany()

// 获取伴奏文件的时长（单位为ms），需要在startAudioAccompany之后调用,否则会返回-1
let duration = rtcEngine.getAudioAccompanyDuration()
// 如果需要获取指定文件的时长，可以通过getAudioFileInfo接口，该接口在创建引擎后即可调用，结果通过onAudioFileInfo回调返回
rtcEngine.getAudioFileInfo(filePath)
func onAudioFileInfo(_ info: AliRtcAudioFileInfo, errorCode: AliRtcAudioAccompanyErrorCode) {
    "onAudioFileInfo, filePath: \(info.filePath), durationMs: \(info.durationMs), errorCode: \(errorCode)".printLog()
}

// 获取/设置音量
rtcEngine.setAudioAccompanyVolume(50) // 同时设置伴奏推流和播放音量，范围[0-100]
let audioPublishVolume = rtcEngine.getAudioAccompanyPublishVolume() // 获取当前伴奏的推流音量
rtcEngine.setAudioAccompanyPublishVolume(50) // 设置伴奏推流音量,范围[0-100]
let audioPlayoutVolume = rtcEngine.getAudioAccompanyPlayoutVolume() // 获取当前伴奏的本地播放音量
rtcEngine.setAudioAccompanyPlayoutVolume(50) // 设置伴奏的本地播放音,范围[0-100]

// 获取/设置播放进度
let currentPosition = rtcEngine.getAudioAccompanyCurrentPosition() // 单位为ms
let targetPosition:Int32 = 1000; // 以1000ms处开始播放为例
rtcEngine.setAudioAccompanyPosition(targetPosition)

实现播放音效

如需同时播放多个音效文件（例如掌声、笑声），可调用 preloadAudioEffect 和 playAudioEffect 等 API。

1. 加入频道并推送音频流，SDK 默认是推送的。

   Android

   // 播放伴奏或音效需要推送音频流，SDK默认是开启的
   mAliRtcEngine.publishLocalAudioStream(true);

   iOS

   // 播放伴奏或音效需要推送音频流，SDK默认是开启的
   engine.publishLocalVideoStream(true)

2. （可选）预加载资源

如果需要重复播放同一音效，建议调用 preloadAudioEffect 将音频文件预加载到内存，以优化性能。

• preloadAudioEffect：加载指定的音效文件，支持本地文件和网络文件 url，推荐使用本地文件。

• unloadAudioEffect：当加载的音效文件使用完毕后，可以调用此接口卸载以释放相关资源。

// 加载指定ID和filePath的音效文件，ID请自行定义
mAliRtcEngine.preloadAudioEffect(mCurrSoundID, filePath);
// 卸载指定ID的音效文件
mAliRtcEngine.unloadAudioEffect(mCurrSoundID);

// 加载指定ID和filePath的音效文件，ID请自行定义
rtcEngine.preloadAudioEffect(withSoundId: self.soundId, filePath: filePath)
// 卸载指定ID的音效文件
rtcEngine.unloadAudioEffect(withSoundId: self.currentEffectIndex)

3. 播放控制

加入频道并推音频流后，调用 playAudioEffect 播放音效文件。播放完成后，本地会触发 onAudioEffectFinished 回调。

除此之外，你还可以通过下面的接口实现播放控制：

• stopAudioEffect/stopAllAudioEffects：停止播放。

• pauseAudioEffect/pauseAllAudioEffects：暂停播放。

• resumeAudioEffect/resumeAllAudioEffects：恢复播放。

• getAudioEffectPublishVolume、setAudioEffectPublishVolume、setAllAudioEffectsPublishVolume：获取或调节音效在远端的播放音量。

• getAudioEffectPlayoutVolume、setAudioEffectPlayoutVolume、setAllAudioEffectsPlayoutVolume：获取或调节音效在本地播放的音量

// 播放伴奏
AliRtcEngine.AliRtcAudioEffectConfig config = new AliRtcEngine.AliRtcAudioEffectConfig();
config.loopCycles = -1;			// 循环播放次数，-1表示无限循环
config.startPosMs = 0;			// 开始播放位置
config.publishVolume = 50;		// 推流音量，[0-100]
config.playoutVolume = 50;		// 本地播放音量，[0-100]
mAliRtcEngine.playAudioEffect(mCurrSoundID, filePath, config);

// 停止播放
mAliRtcEngine.stopAudioEffect(soundId);
mAliRtcEngine.stopAllAudioEffects();

// 暂停播放
mAliRtcEngine.pauseAudioEffect(soundId);
mAliRtcEngine.pauseAllAudioEffects();

// 恢复播放
mAliRtcEngine.resumeAudioEffect(soundId);
mAliRtcEngine.resumeAllAudioEffects();

// 获取或者设置音量
// 推流音量
mAliRtcEngine.getAudioEffectPublishVolume(soundId);
mAliRtcEngine.setAudioEffectPublishVolume(soundId, 50);
mAliRtcEngine.setAllAudioEffectsPublishVolume(50);
// 播放音量
mAliRtcEngine.getAudioEffectPlayoutVolume(soundId);
mAliRtcEngine.setAudioEffectPlayoutVolume(soundId, 50);
mAliRtcEngine.setAllAudioEffectsPlayoutVolume(50);

// 播放
let config = AliRtcAudioEffectConfig()
config.loopCycles = -1
config.startPosMs = 0
config.publishVolume = 50
config.playoutVolume = 50
let result = rtcEngine.playAudioEffect(withSoundId: self.soundId, filePath: filePath, config: config)
if result != 0 {
    UIAlertController.showAlertWithMainThread(msg: "播放音效失败，错误码: \(result)", vc: self)
}

// 停止播放
rtcEngine.stopAudioEffect(withSoundId: soundId)
rtcEngine.stopAllAudioEffects()

// 暂停播放
rtcEngine.pauseAudioEffect(withSoundId: soundId)
rtcEngine.pauseAllAudioEffects()

// 恢复播放
rtcEngine.resumeAudioEffect(withSoundId: soundId)
rtcEngine.resumeAllAudioEffects()

// 获取或设置音量
rtcEngine.getAudioEffectPublishVolume(withSoundId: soundId)
rtcEngine.setAudioEffectPublishVolumeWithSoundId(soundId, volume: 50)
rtcEngine.setAllAudioEffectsPublishVolume(50)
rtcEngine.resumeAudioEffect(withSoundId: soundId)    
rtcEngine.getAudioEffectPlayoutVolume(withSoundId: soundId)
rtcEngine.setAudioEffectPlayoutVolumeWithSoundId(soundId, volume: 50)

实现原理

示例代码

/* 根据自己的业务设置对应的参数 */
AliRtcEngine.AliRtcExternalAudioStreamConfig config = new AliRtcEngine.AliRtcExternalAudioStreamConfig();
/* 设置播放音量为0 ，意味着不进行本地播放 */
config.playoutVolume = currentAudioPlayoutVolume;
/* 设置推流音量为0， 意味着不进行推流 */
config.publishVolume = currentAudioPublishVolume;
config.channels = 1;
config.sampleRate = 48000;
// 返回值为外部输入流ID,后续通过该ID将数据送入SDK
audioStreamID = mAliRtcEngine.addExternalAudioStream(config);

/* 根据自己的业务设置对应的参数 */
AliRtcExternalAudioStreamConfig *config = [AliRtcExternalAudioStreamConfig new];
config.channels = _pcmChannels;
config.sampleRate = _pcmSampleRate;
/* 设置播放音量为0 ，意味着不进行本地播放 */
config.playoutVolume = 0;
/* 设置推流音量为0， 意味着不进行推流 */
config.publishVolume = 100;
// 返回值为外部输入流ID,后续通过该ID将数据送入SDK
_externalPlayoutStreamId = [self.engine addExternalAudioStream:config];

AliRtcEngine.AliRtcAudioFrame rawData = new AliRtcEngine.AliRtcAudioFrame();
rawData.data = frameInfo.audio_data[0];
rawData.numSamples = (int) (frameInfo.audio_data[0].length / (2 * frameInfo.audio_channels));
rawData.bytesPerSample = 2;
rawData.numChannels = frameInfo.audio_channels;
rawData.samplesPerSec = frameInfo.audio_sample_rate;

int ret = mAliRtcEngine.pushExternalAudioStreamRawData(audioStreamID, rawData);
if(ret == 0x01070101) {
    // 缓冲区满
    sleep(20);
} else if(ret < 0) {
    /* 异常， 检查参数和推流状态 */
}

AliRtcAudioFrame *sample = [AliRtcAudioFrame new];
sample.dataPtr = _pcmLocalData;
sample.samplesPerSec = _pcmLocalSampleRate;
sample.bytesPerSample = sizeof(int16_t);
sample.numOfChannels = _pcmLocalChannels;
sample.numOfSamples = numOfSamples;
int rc = [self.engine pushExternalAudioStream:_externalPlayoutStreamId rawData:sample];

if(rc == 0x01070101) {
    // 缓冲区满
    sleep(20);
} else if(ret < 0) {
    /* 异常， 检查参数和推流状态 */
}

mAliRtcEngine.removeExternalAudioStream(audioStreamID);

[self.engine removeExternalAudioStream:_externalPublishStreamId];