custom audio playback - ApsaraVideo Live: Central de Documentação do Alibaba Cloud

O ARTC permite ignorar o módulo de reprodução de áudio integrado e gerencie a renderização de áudio com seu próprio player, oferecendo controle total sobre o processamento e a reprodução dos dados de áudio recebidos.

Visão geral

Por padrão, o ARTC inclui um módulo de reprodução de áudio testado em campo que atende à maioria dos requisitos. No entanto, se você já possui um módulo personalizado ou precisa pós-processar os dados antes da reprodução, utilize o recurso de reprodução de áudio personalizada para desativar a lógica interna e assumir a renderização do áudio.

Em seguida, transmita os dados ao dispositivo de reprodução para processamento e execução.

Código de exemplo

Android: Android/ARTCExample/AdvancedUsage/src/main/java/com/aliyun/artc/api/advancedusage/CustomAudioCaptureAndRender/CustomAudioRenderActivity.java.

iOS: iOS/ARTCExample/AdvancedUsage/CustomAudioRender/CustomAudioRenderVC.swift.

Pré-requisitos

Antes de usar a reprodução de áudio personalizada, certifique-se de atender aos seguintes requisitos:

Você consegue desenvolver um módulo completo de reprodução de áudio ou já possui um player interno ou de terceiros.
Você conhece conceitos básicos de processamento de áudio, como formato de dados PCM, taxa de amostragem e número de canais.
Você integrou o SDK do ARTC e implementou os recursos básicos de chamada de áudio e vídeo.
Seu caso de uso exige ignorar o módulo de reprodução interno do ARTC. Caso contrário, use a solução padrão para garantir estabilidade e compatibilidade.

Implementação

1. Desative a reprodução interna

Para usar a reprodução de áudio personalizada, desative a reprodução interna do SDK. Recomendamos fazer isso ao crie a instância do mecanismo chamando getInstance e passando o parâmetro extras. O parâmetro relevante é:

user_specified_use_external_audio_player: especifica se o sistema deve usar um player externo.

"TRUE": usa um player externo e desativa a reprodução interna.
"FALSE": usa a reprodução interna padrão.

Android

String extras = "{\"user_specified_use_external_audio_player\":\"TRUE\"}";
mAliRtcEngine = AliRtcEngine.getInstance(this, extras);

iOS

// Create and initialize the engine.
var customAudioPlayConfig: [String: String] = [:]
// Use an external player, which disables the SDK's internal playback.
customAudioPlayConfig["user_specified_use_external_audio_player"] = "TRUE"
// Serialize to JSON.
guard let jsonData = try? JSONSerialization.data(withJSONObject: customAudioPlayConfig, options: []),
let extras = String(data: jsonData, encoding: .utf8) else {
    print("JSON serialization failed")
    return
}
let engine = AliRtcEngine.sharedInstance(self, extras:extras)

Mac

NSString * extras = @"{\"user_specified_use_external_audio_player\":\"TRUE\"}";
self.engine = [AliRtcEngine sharedInstance:self extras:extras];

Windows

std::string extras = "{\"user_specified_use_external_audio_player\":\"TRUE\"}";
mAliRtcEngine = AliRtcEngine.getInstance(this, extras.c_str());

2. Registre o callback de quadro de áudio

Chame enableAudioFrameObserver para registrar o callback de quadro de áudio com os seguintes parâmetros:

enable: valor booleano que ativa ou desativa o callback de dados.
audioSource: tipo de source de dados do callback. Para reprodução de áudio personalizada, defina este valor como AliRtcAudioSourcePlayback para receber dados do estágio de reprodução pelo callback onPlaybackAudioFrame.
config: parâmetros de áudio desejados para o callback, incluindo taxa de amostragem e número de canais.

Android

// Set the callback configuration.
AliRtcEngine.AliRtcAudioFrameObserverConfig config = new AliRtcEngine.AliRtcAudioFrameObserverConfig();
config.sampleRate = AliRtcAudioSampleRate_48000;
config.channels = 1;
// Register to enable the playback data callback.
mAliRtcEngine.enableAudioFrameObserver(true, AliRtcAudioSourcePlayback, config);

iOS

// Set the callback configuration.
var observerConfig: AliRtcAudioFrameObserverConfig = AliRtcAudioFrameObserverConfig()
observerConfig.sampleRate = ._Unknown
observerConfig.channels = .monoAudio
// Register to enable the playback data callback.
let audioSource: AliRtcAudioSource = .playback
engine.enableAudioFrameObserver(true, audioSource: audioSource, config: observerConfig)

Mac

AliRtcAudioFrameObserverConfig* config = [[AliRtcAudioFrameObserverConfig alloc] init];
config.channels = audioNumChannel;
config.sampleRate = AliRtcAudioSampleRate_48000;
config.mode = AliRtcAudioFrameObserverOperationModeReadOnly;
[self.engine enableAudioFrameObserver:TRUE audioSource:AliRtcAudioSourcePlayback config:config];

Windows

// Set the callback configuration.
AliEngineAudioFrameObserverConfig config ;
config.sampleRate = AliRtcAudioSampleRate_48000;
config.channels = AliEngineMonoAudio;
// Register to enable the playback data callback.
mAliRtcEngine->EnableAudioFrameObserver(true, AliEngineAudioSourcePlayback, config);

3. Processe os dados PCM no callback

No callback, processe os dados PCM recebidos e transmita-os ao dispositivo de reprodução.

Android

@Override
public boolean onPlaybackAudioFrame(AliRtcEngine.AliRtcAudioFrame frame) {
    // Implement your custom logic to play the audio data received in the callback.

    return true;
}

iOS

func onPlaybackAudioFrame(_ frame: AliRtcAudioFrame) -> Bool {
    // Implement your custom logic to play the audio data received in the callback.
    
    return true
}

Mac

- (BOOL)onPlaybackAudioFrame:(AliRtcAudioFrame* _Nonnull)frame {
    // Implement your custom logic to play the audio data received in the callback.
    return true;
}

Windows

bool CTutorialDlg::OnPlaybackAudioFrame(AliEngineAudioRawData audioRawData) {
	// Implement your custom logic to play the audio data received in the callback.
	return true;
}

4. Desative o observer

Android

mAliRtcEngine.enableAudioFrameObserver(false, AliRtcAudioSourcePlayback, config)

iOS

engine.enableAudioFrameObserver(false, audioSource: audioSource, config: observerConfig)

Mac

[self.engine enableAudioFrameObserver:false audioSource:AliRtcAudioSourcePlayback config:config];

Windows

mAliRtcEngine->EnableAudioFrameObserver(false, AliEngineAudioSourcePlayback, config);

5. (Opcional) Ative ou desative dinamicamente a reprodução interna

Para ativar ou desativar dinamicamente a reprodução interna do SDK durante uma chamada, use o método setParameter.

Android

/* Dynamically disable internal playback. */
String parameter = "{\"audio\":{\"enable_system_audio_device_play\":\"FALSE\"}}";
mAliRtcEngine.setParameter(parameter);

/* Dynamically enable internal playback. */
String parameter = "{\"audio\":{\"enable_system_audio_device_play\":\"TRUE\"}}"; 
mAliRtcEngine.setParameter(parameter);

iOS

// Dynamically disable internal playback.
engine.setParameter("{\"audio\":{\"enable_system_audio_device_play\":\"FALSE\"}}")
// Dynamically enable internal playback.
engine.setParameter("{\"audio\":{\"enable_system_audio_device_play\":\"TRUE\"}}")

Mac

// Dynamically disable internal playback.
[self.engine setParameter:"{\"audio\":{\"enable_system_audio_device_play\":\"FALSE\"}}"];
// Dynamically enable internal playback.
[self.engine setParameter:"{\"audio\":{\"enable_system_audio_device_play\":\"TRUE\"}}"];

Windows

/* Dynamically disable internal playback. */
std::string parameter = "{\"audio\":{\"enable_system_audio_device_play\":\"FALSE\"}}";
mAliRtcEngine->SetParameter(parameter.c_str());

/* Dynamically enable internal playback. */
std::string parameter = "{\"audio\":{\"enable_system_audio_device_play\":\"TRUE\"}}"; 
mAliRtcEngine->SetParameter(parameter.c_str());