由于工作需要，开始研究WebRTC源码，现将如何把本地音频回调出来分享一下。
如果要使用Native WebRTC封装SDK，就要把RTC的一些基础能力暴露出来，本地视频、远端音视频都可以在相应的track里添加Sink就能拿到，但本地音频回调就没那么容易了，需要修改RTC的源码才可以。
首先来看一下AudioDeviceModule这个音频设备模块，它把录音和播放封装在一块，其中与录音相关的API有
//获取音频采集设备个数
virtual int16_t RecordingDevices() = 0;
//跟据设备索引获取设备名称和GUID(有的设备名称可能是一样，但GUID唯一)
virtual int32_t RecordingDeviceName(uint16_t index,
char name[kAdmMaxDeviceNameSize],
char guid[kAdmMaxGuidSize]) = 0;
//更换音频采集设备
virtual int32_t SetRecordingDevice(uint16_t index) = 0;
//初始化采集设备
virtual int32_t InitRecording() = 0;
//开始采集音频
virtual int32_t StartRecording() = 0;
//停止采集音频
virtual int32_t StopRecording() = 0;
这个模块会在创建webrtc::PeerConnectionFactoryInterface会用到
rtc::scoped_refptr<PeerConnectionFactoryInterface>
CreatePeerConnectionFactory(
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
rtc::Thread* signaling_thread,
rtc::scoped_refptr<AudioDeviceModule> default_adm,
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
std::unique_ptr<VideoEncoderFactory> video_encoder_factory,
std::unique_ptr<VideoDecoderFactory> video_decoder_factory,
rtc::scoped_refptr<AudioMixer> audio_mixer,
rtc::scoped_refptr<AudioProcessing> audio_processing);
如果传入参数default_adm为nullptr，WebRTC会用AudioDeviceModuleImpl创建它，来看一下AudioDeviceModuleImpl的主要成员
//当前平台
PlatformType platform_type_ = kPlatformNotSupported;
//用于处理从audio_device_采集出来的音频，交由AudioTransport做一些合法性检查然后传输出去
AudioDeviceBuffer audio_device_buffer_;
//音频设备类，不同的平台有不同的实现 ，windows上用会AudioDeviceWindowsCore实现
std::unique_ptr<AudioDeviceGeneric> audio_device_;
audio_device_采集的音频会交由audio_device_buffer_处理，在由AudioTransport传输，来看一下AudioTransport
class AudioTransport {
public:
virtual int32_t RecordedDataIsAvailable(const void* audioSamples,
const size_t nSamples,
const size_t nBytesPerSample,
const size_t nChannels,
const uint32_t samplesPerSec,
const uint32_t totalDelayMS,
const int32_t clockDrift,
const uint32_t currentMicLevel,
const bool keyPressed,
uint32_t& newMicLevel) = 0; // NOLINT
// Implementation has to setup safe values for all specified out parameters.
virtual int32_t NeedMorePlayData(const size_t nSamples,
const size_t nBytesPerSample,
const size_t nChannels,
const uint32_t samplesPerSec,
void* audioSamples,
size_t& nSamplesOut, // NOLINT
int64_t* elapsed_time_ms,
int64_t* ntp_time_ms) = 0; // NOLINT
// Method to pull mixed render audio data from all active VoE channels.
// The data will not be passed as reference for audio processing internally.
virtual void PullRenderData(int bits_per_sample,
int sample_rate,
size_t number_of_channels,
size_t number_of_frames,
void* audio_data,
int64_t* elapsed_time_ms,
int64_t* ntp_time_ms) = 0;
protected:
virtual ~AudioTransport() {}
};
在WebRTC的默认实现中会用AudioTransportImpl实例化AudioTransport 。
以上分析可以看出如果想把设备控制权从WebRTC里拿出来可以自定义类继承至AudioDeviceModuleImpl，如果要把采集到的音频回调出来可以自定类继承至AudioTransportImpl。那么如何让音频回调是从我们自定义的类里创建的呢？再来看看默认的AudioTransportImpl是如何创建的。
通过源码可以看到在AudioState里有AudioTransportImpl对象，它是类对象，如果想让它从子类中创建必须为类对象指针，所以将它改为AudioTransportImpl*类型，将AudioState的构造改为
AudioState::AudioState(const AudioState::Config& config)
: config_(config),audio_transport_(nullptr) {
process_thread_checker_.Detach();
RTC_DCHECK(config_.audio_mixer);
RTC_DCHECK(config_.audio_device_module);
audio_transport_ = audio_device_module()->CreateAudioTransPort(
config_.audio_mixer, config_.audio_processing.get());
needDelete_ = audio_transport_ == nullptr;
if (needDelete_) {
audio_transport_ = new AudioTransportImpl(config_.audio_mixer,
config_.audio_processing.get());
}
RTC_DCHECK(audio_transport_);
}
上面的代码audio_device_module()是得到adm_对象，CreateAudioTransPort就是我们要增加的纯虚函数所以在AudioDeviceModule类中增加
virtual AudioTransportImpl* CreateAudioTransPort(
AudioMixer* mixer,
AudioProcessing* audio_processing) = 0;
这个在AudioDeviceModuleImpl的实现为返回nullptr，这样如果没有子类实现它，结果就和原来的没有区别。
另外如果想要实现自定义输入，必须把WebRTC的采集停止掉，在AudioDeviceModule增加纯虚函数：
virtual int32_t SendRecordedBuffer(const uint8_t* audio_data,
uint32_t data_len,
int bits_per_sample,
int sample_rate,
size_t number_of_channels) = 0;
在AudioDeviceModuleImpl实现：
int32_t AudioDeviceModuleImpl::SendRecordedBuffer(const uint8_t* audio_data,
uint32_t data_len,
int bits_per_sample,
int sample_rate,
size_t number_of_channels) {
//if in external mode,shoudle control at subclass
audio_device_buffer_.SetRecordingChannels(number_of_channels);
audio_device_buffer_.SetRecordingSampleRate(sample_rate);
audio_device_buffer_.SetRecordedBuffer(audio_data, (data_len >> 1) / number_of_channels);
audio_device_buffer_.SetVQEData(0, 0);
audio_device_buffer_.DeliverRecordedData();
return 0;
}
整个的一个继承代码类似这样
//本地音频回调
class RecordedDataObserver {
public:
virtual void onRecodedData(
const void* audioSamples,
const size_t nSamples,
const size_t nBytesPerSample,
const size_t nChannels,
const uint32_t samplesRate) = 0;
virtual ~RecordedDataObserver() {}
};
namespace base {
using namespace webrtc;
class TaskQueueFactory;
class AudioMixer;
class AudioProcessing;
class CustomizedAudioDeviceModule : public webrtc::AudioDeviceModuleImpl{
public:
static rtc::scoped_refptr<webrtc::AudioDeviceModule> CreateADM();
CustomizedAudioDeviceModule(AudioLayer audio_layer,
webrtc::TaskQueueFactory* task_queue_factory);
virtual ~CustomizedAudioDeviceModule();
class AudioRecordCallBack : public AudioTransportImpl {
public:
AudioRecordCallBack(webrtc::AudioMixer* mixer, webrtc::AudioProcessing* audio_processing);
virtual ~AudioRecordCallBack();
int32_t RecordedDataIsAvailable(const void* audioSamples,
const size_t nSamples,
const size_t nBytesPerSample,
const size_t nChannels,
const uint32_t samplesPerSec,
const uint32_t totalDelayMS,
const int32_t clockDrift,
const uint32_t currentMicLevel,
const bool keyPressed,
uint32_t& newMicLevel) override;
void RegisterObserver(RecordedDataObserver* dataObserver);
private:
RecordedDataObserver* recorderDataOb;
};
AudioTransportImpl* CreateAudioTransPort(
webrtc::AudioMixer* mixer,
webrtc::AudioProcessing* audio_processing) override;
bool IsExternalAudioInput() const override;
void SetExternalAudioMode(bool bExternal);
void RegisterObserver(RecordedDataObserver* dataObserver);
private:
std::unique_ptr<AudioRecordCallBack> audioRecordCb_;
bool externalAudio_;
RecordedDataObserver* dataObserver_;
};
}
实现文件
rtc::scoped_refptr<webrtc::AudioDeviceModule> base::CustomizedAudioDeviceModule::CreateADM()
{
// Create the generic reference counted (platform independent) implementation.
rtc::scoped_refptr<base::CustomizedAudioDeviceModule> audioDevice(
new rtc::RefCountedObject<base::CustomizedAudioDeviceModule>(webrtc::AudioDeviceModule::kPlatformDefaultAudio,
&webrtc::GlobalTaskQueueFactory()));
// Ensure that the current platform is supported.
if (audioDevice->CheckPlatform() == -1) {
return nullptr;
}
// Ensure that the generic audio buffer can communicate with the platform
// specific parts.
if (audioDevice->AttachAudioBuffer() == -1) {
return nullptr;
}
return audioDevice;
}
base::CustomizedAudioDeviceModule::~CustomizedAudioDeviceModule() {
}
webrtc::AudioTransportImpl* base::CustomizedAudioDeviceModule::CreateAudioTransPort(
webrtc::AudioMixer* mixer,
webrtc::AudioProcessing* audio_processing) {
audioRecordCb_ = std::make_unique<AudioRecordCallBack>(mixer, audio_processing);
if (dataObserver_) {
audioRecordCb_->RegisterObserver(dataObserver_);
}
return audioRecordCb_.get();
}
bool base::CustomizedAudioDeviceModule::IsExternalAudioInput() const {
return externalAudio_;
}
void base::CustomizedAudioDeviceModule::SetExternalAudioMode(bool bExternal) {
externalAudio_ = bExternal;
}
void base::CustomizedAudioDeviceModule::RegisterObserver(RecordedDataObserver* dataObserver) {
//要在CreatePeerConnectionFactory后调用
RTC_CHECK(dataObserver);
RTC_CHECK(audioRecordCb_);
dataObserver_ = dataObserver;
audioRecordCb_->RegisterObserver(dataObserver);
}
base::CustomizedAudioDeviceModule::AudioRecordCallBack::AudioRecordCallBack(
webrtc::AudioMixer* mixer,
webrtc::AudioProcessing* audio_processing) :
AudioTransportImpl(mixer,audio_processing),
recorderDataOb(nullptr) {
}
base::CustomizedAudioDeviceModule::AudioRecordCallBack::~AudioRecordCallBack() {
}
int32_t base::CustomizedAudioDeviceModule::AudioRecordCallBack::RecordedDataIsAvailable( const void* audioSamples,
const size_t nSamples,
const size_t nBytesPerSample,
const size_t nChannels,
const uint32_t samplesPerSec,
const uint32_t totalDelayMS,
const int32_t clockDrift,
const uint32_t currentMicLevel,
const bool keyPressed,
uint32_t& newMicLevel) {
if (recorderDataOb) {
recorderDataOb->onRecodedData(audioSamples, nSamples, nBytesPerSample, nChannels,samplesPerSec);
}
return AudioTransportImpl::RecordedDataIsAvailable(
audioSamples,
nSamples,
nBytesPerSample,
nChannels,
samplesPerSec,
totalDelayMS,
clockDrift,
currentMicLevel,
keyPressed,
newMicLevel);
}
void base::CustomizedAudioDeviceModule::AudioRecordCallBack::RegisterObserver(RecordedDataObserver* dataObserver) {
recorderDataOb = dataObserver;
}
在webrtc::CreatePeerConnectionFactory的时候把adm对象传进去，需要注意的是，adm对象要由worker_thread创建，原因是AudioDeviceModuleImpl中的audio_device_buffer_要在worker_thread中运行，所以adm的StartRecording()、StopRecording()，也要在worker_thread中运行。
adm对象销毁也要由worker_thread销毁。
换音频采集设置调用adm对象的SetRecordingDevice(uint16_t index)，需要StopRecording,SetRecordingDevice,InitRecording,StartRecording。
自定义输入音频要增加接口类似这种：
int32_t AudioDeviceModuleImpl::SendRecordedBuffer(const uint8_t* audio_data,
uint32_t data_len,
int bits_per_sample,
int sample_rate,
size_t number_of_channels) {
if (!external_audio_input_)
return -1;
audio_device_buffer_.SetRecordingChannels(number_of_channels);
audio_device_buffer_.SetRecordingSampleRate(sample_rate);
audio_device_buffer_.SetRecordedBuffer(audio_data, (data_len >> 1) / number_of_channels);
audio_device_buffer_.SetVQEData(0, 0);
audio_device_buffer_.DeliverRecordedData();
return 0;
}
本人刚开始学习WebRTC，难免有不当之处，欢迎指正。
如果有更好的实现，欢迎分享。
扫一扫
1403
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
