diff --git a/webrtc/modules/audio_device/android/audio_device_jni_android.cc b/webrtc/modules/audio_device/android/audio_device_jni_android.cc index b24805751f..93932eb253 100644 --- a/webrtc/modules/audio_device/android/audio_device_jni_android.cc +++ b/webrtc/modules/audio_device/android/audio_device_jni_android.cc @@ -43,7 +43,7 @@ jclass AudioDeviceAndroidJni::globalScClass = NULL; // by the same Java application. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetAndroidAudioDeviceObjects( +int32_t AudioDeviceAndroidJni::SetAndroidAudioDeviceObjects( void* javaVM, void* env, void* context) { @@ -114,7 +114,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetAndroidAudioDeviceObjects( // AudioDeviceAndroidJni - ctor // ---------------------------------------------------------------------------- -AudioDeviceAndroidJni::AudioDeviceAndroidJni(const WebRtc_Word32 id) : +AudioDeviceAndroidJni::AudioDeviceAndroidJni(const int32_t id) : _ptrAudioBuffer(NULL), _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _id(id), @@ -201,7 +201,7 @@ void AudioDeviceAndroidJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) // ActiveAudioLayer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::ActiveAudioLayer( +int32_t AudioDeviceAndroidJni::ActiveAudioLayer( AudioDeviceModule::AudioLayer& audioLayer) const { @@ -214,7 +214,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::ActiveAudioLayer( // Init // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::Init() +int32_t AudioDeviceAndroidJni::Init() { CriticalSectionScoped lock(&_critSect); @@ -301,7 +301,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::Init() // Terminate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::Terminate() +int32_t AudioDeviceAndroidJni::Terminate() { CriticalSectionScoped lock(&_critSect); @@ -472,7 +472,7 @@ bool AudioDeviceAndroidJni::Initialized() const // SpeakerIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SpeakerIsAvailable(bool& available) +int32_t AudioDeviceAndroidJni::SpeakerIsAvailable(bool& available) { // We always assume it's available @@ -485,7 +485,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SpeakerIsAvailable(bool& available) // InitSpeaker // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::InitSpeaker() +int32_t AudioDeviceAndroidJni::InitSpeaker() { CriticalSectionScoped lock(&_critSect); @@ -515,7 +515,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::InitSpeaker() // MicrophoneIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneIsAvailable(bool& available) +int32_t AudioDeviceAndroidJni::MicrophoneIsAvailable(bool& available) { // We always assume it's available @@ -528,7 +528,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneIsAvailable(bool& available) // InitMicrophone // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::InitMicrophone() +int32_t AudioDeviceAndroidJni::InitMicrophone() { CriticalSectionScoped lock(&_critSect); @@ -578,7 +578,7 @@ bool AudioDeviceAndroidJni::MicrophoneIsInitialized() const // SpeakerVolumeIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SpeakerVolumeIsAvailable(bool& available) +int32_t AudioDeviceAndroidJni::SpeakerVolumeIsAvailable(bool& available) { available = true; // We assume we are always be able to set/get volume @@ -590,7 +590,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SpeakerVolumeIsAvailable(bool& available) // SetSpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetSpeakerVolume(WebRtc_UWord32 volume) +int32_t AudioDeviceAndroidJni::SetSpeakerVolume(uint32_t volume) { if (!_speakerIsInitialized) @@ -655,7 +655,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetSpeakerVolume(WebRtc_UWord32 volume) // SpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SpeakerVolume(WebRtc_UWord32& volume) const +int32_t AudioDeviceAndroidJni::SpeakerVolume(uint32_t& volume) const { if (!_speakerIsInitialized) @@ -712,7 +712,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SpeakerVolume(WebRtc_UWord32& volume) const } } - volume = static_cast (level); + volume = static_cast (level); return 0; } @@ -721,9 +721,9 @@ WebRtc_Word32 AudioDeviceAndroidJni::SpeakerVolume(WebRtc_UWord32& volume) const // SetWaveOutVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetWaveOutVolume( - WebRtc_UWord16 /*volumeLeft*/, - WebRtc_UWord16 /*volumeRight*/) +int32_t AudioDeviceAndroidJni::SetWaveOutVolume( + uint16_t /*volumeLeft*/, + uint16_t /*volumeRight*/) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -735,9 +735,9 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetWaveOutVolume( // WaveOutVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::WaveOutVolume( - WebRtc_UWord16& /*volumeLeft*/, - WebRtc_UWord16& /*volumeRight*/) const +int32_t AudioDeviceAndroidJni::WaveOutVolume( + uint16_t& /*volumeLeft*/, + uint16_t& /*volumeRight*/) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -749,8 +749,8 @@ WebRtc_Word32 AudioDeviceAndroidJni::WaveOutVolume( // MaxSpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::MaxSpeakerVolume( - WebRtc_UWord32& maxVolume) const +int32_t AudioDeviceAndroidJni::MaxSpeakerVolume( + uint32_t& maxVolume) const { if (!_speakerIsInitialized) @@ -769,8 +769,8 @@ WebRtc_Word32 AudioDeviceAndroidJni::MaxSpeakerVolume( // MinSpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::MinSpeakerVolume( - WebRtc_UWord32& minVolume) const +int32_t AudioDeviceAndroidJni::MinSpeakerVolume( + uint32_t& minVolume) const { if (!_speakerIsInitialized) @@ -789,8 +789,8 @@ WebRtc_Word32 AudioDeviceAndroidJni::MinSpeakerVolume( // SpeakerVolumeStepSize // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SpeakerVolumeStepSize( - WebRtc_UWord16& stepSize) const +int32_t AudioDeviceAndroidJni::SpeakerVolumeStepSize( + uint16_t& stepSize) const { if (!_speakerIsInitialized) @@ -809,7 +809,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SpeakerVolumeStepSize( // SpeakerMuteIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SpeakerMuteIsAvailable(bool& available) +int32_t AudioDeviceAndroidJni::SpeakerMuteIsAvailable(bool& available) { available = false; // Speaker mute not supported on Android @@ -821,7 +821,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SpeakerMuteIsAvailable(bool& available) // SetSpeakerMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetSpeakerMute(bool /*enable*/) +int32_t AudioDeviceAndroidJni::SetSpeakerMute(bool /*enable*/) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -833,7 +833,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetSpeakerMute(bool /*enable*/) // SpeakerMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SpeakerMute(bool& /*enabled*/) const +int32_t AudioDeviceAndroidJni::SpeakerMute(bool& /*enabled*/) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -845,7 +845,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SpeakerMute(bool& /*enabled*/) const // MicrophoneMuteIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneMuteIsAvailable(bool& available) +int32_t AudioDeviceAndroidJni::MicrophoneMuteIsAvailable(bool& available) { available = false; // Mic mute not supported on Android @@ -857,7 +857,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneMuteIsAvailable(bool& available) // SetMicrophoneMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetMicrophoneMute(bool /*enable*/) +int32_t AudioDeviceAndroidJni::SetMicrophoneMute(bool /*enable*/) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -869,7 +869,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetMicrophoneMute(bool /*enable*/) // MicrophoneMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneMute(bool& /*enabled*/) const +int32_t AudioDeviceAndroidJni::MicrophoneMute(bool& /*enabled*/) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -881,7 +881,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneMute(bool& /*enabled*/) const // MicrophoneBoostIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneBoostIsAvailable(bool& available) +int32_t AudioDeviceAndroidJni::MicrophoneBoostIsAvailable(bool& available) { available = false; // Mic boost not supported on Android @@ -893,7 +893,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneBoostIsAvailable(bool& available) // SetMicrophoneBoost // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetMicrophoneBoost(bool enable) +int32_t AudioDeviceAndroidJni::SetMicrophoneBoost(bool enable) { if (!_micIsInitialized) @@ -917,7 +917,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetMicrophoneBoost(bool enable) // MicrophoneBoost // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneBoost(bool& enabled) const +int32_t AudioDeviceAndroidJni::MicrophoneBoost(bool& enabled) const { if (!_micIsInitialized) @@ -936,7 +936,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneBoost(bool& enabled) const // StereoRecordingIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::StereoRecordingIsAvailable(bool& available) +int32_t AudioDeviceAndroidJni::StereoRecordingIsAvailable(bool& available) { available = false; // Stereo recording not supported on Android @@ -950,7 +950,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::StereoRecordingIsAvailable(bool& available) // Specifies the number of input channels. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetStereoRecording(bool enable) +int32_t AudioDeviceAndroidJni::SetStereoRecording(bool enable) { if (enable) @@ -967,7 +967,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetStereoRecording(bool enable) // StereoRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::StereoRecording(bool& enabled) const +int32_t AudioDeviceAndroidJni::StereoRecording(bool& enabled) const { enabled = false; @@ -979,7 +979,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::StereoRecording(bool& enabled) const // StereoPlayoutIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::StereoPlayoutIsAvailable(bool& available) +int32_t AudioDeviceAndroidJni::StereoPlayoutIsAvailable(bool& available) { available = false; // Stereo playout not supported on Android @@ -991,7 +991,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::StereoPlayoutIsAvailable(bool& available) // SetStereoPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetStereoPlayout(bool enable) +int32_t AudioDeviceAndroidJni::SetStereoPlayout(bool enable) { if (enable) @@ -1008,7 +1008,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetStereoPlayout(bool enable) // StereoPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::StereoPlayout(bool& enabled) const +int32_t AudioDeviceAndroidJni::StereoPlayout(bool& enabled) const { enabled = false; @@ -1020,7 +1020,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::StereoPlayout(bool& enabled) const // SetAGC // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetAGC(bool enable) +int32_t AudioDeviceAndroidJni::SetAGC(bool enable) { _AGC = enable; @@ -1042,7 +1042,7 @@ bool AudioDeviceAndroidJni::AGC() const // MicrophoneVolumeIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneVolumeIsAvailable( +int32_t AudioDeviceAndroidJni::MicrophoneVolumeIsAvailable( bool& available) { @@ -1055,8 +1055,8 @@ WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneVolumeIsAvailable( // SetMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetMicrophoneVolume( - WebRtc_UWord32 /*volume*/) +int32_t AudioDeviceAndroidJni::SetMicrophoneVolume( + uint32_t /*volume*/) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -1068,8 +1068,8 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetMicrophoneVolume( // MicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneVolume( - WebRtc_UWord32& /*volume*/) const +int32_t AudioDeviceAndroidJni::MicrophoneVolume( + uint32_t& /*volume*/) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -1081,8 +1081,8 @@ WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneVolume( // MaxMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::MaxMicrophoneVolume( - WebRtc_UWord32& /*maxVolume*/) const +int32_t AudioDeviceAndroidJni::MaxMicrophoneVolume( + uint32_t& /*maxVolume*/) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -1094,8 +1094,8 @@ WebRtc_Word32 AudioDeviceAndroidJni::MaxMicrophoneVolume( // MinMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::MinMicrophoneVolume( - WebRtc_UWord32& /*minVolume*/) const +int32_t AudioDeviceAndroidJni::MinMicrophoneVolume( + uint32_t& /*minVolume*/) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -1107,8 +1107,8 @@ WebRtc_Word32 AudioDeviceAndroidJni::MinMicrophoneVolume( // MicrophoneVolumeStepSize // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneVolumeStepSize( - WebRtc_UWord16& /*stepSize*/) const +int32_t AudioDeviceAndroidJni::MicrophoneVolumeStepSize( + uint16_t& /*stepSize*/) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -1120,7 +1120,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::MicrophoneVolumeStepSize( // PlayoutDevices // ---------------------------------------------------------------------------- -WebRtc_Word16 AudioDeviceAndroidJni::PlayoutDevices() +int16_t AudioDeviceAndroidJni::PlayoutDevices() { // There is one device only @@ -1131,7 +1131,7 @@ WebRtc_Word16 AudioDeviceAndroidJni::PlayoutDevices() // SetPlayoutDevice I (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetPlayoutDevice(WebRtc_UWord16 index) +int32_t AudioDeviceAndroidJni::SetPlayoutDevice(uint16_t index) { if (_playIsInitialized) @@ -1159,7 +1159,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetPlayoutDevice(WebRtc_UWord16 index) // SetPlayoutDevice II (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetPlayoutDevice( +int32_t AudioDeviceAndroidJni::SetPlayoutDevice( AudioDeviceModule::WindowsDeviceType /*device*/) { @@ -1172,8 +1172,8 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetPlayoutDevice( // PlayoutDeviceName // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::PlayoutDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceAndroidJni::PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { @@ -1200,8 +1200,8 @@ WebRtc_Word32 AudioDeviceAndroidJni::PlayoutDeviceName( // RecordingDeviceName // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::RecordingDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceAndroidJni::RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { @@ -1228,7 +1228,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::RecordingDeviceName( // RecordingDevices // ---------------------------------------------------------------------------- -WebRtc_Word16 AudioDeviceAndroidJni::RecordingDevices() +int16_t AudioDeviceAndroidJni::RecordingDevices() { // There is one device only @@ -1239,7 +1239,7 @@ WebRtc_Word16 AudioDeviceAndroidJni::RecordingDevices() // SetRecordingDevice I (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetRecordingDevice(WebRtc_UWord16 index) +int32_t AudioDeviceAndroidJni::SetRecordingDevice(uint16_t index) { if (_recIsInitialized) @@ -1261,7 +1261,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetRecordingDevice(WebRtc_UWord16 index) // SetRecordingDevice II (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetRecordingDevice( +int32_t AudioDeviceAndroidJni::SetRecordingDevice( AudioDeviceModule::WindowsDeviceType /*device*/) { @@ -1274,13 +1274,13 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetRecordingDevice( // PlayoutIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::PlayoutIsAvailable(bool& available) +int32_t AudioDeviceAndroidJni::PlayoutIsAvailable(bool& available) { available = false; // Try to initialize the playout side - WebRtc_Word32 res = InitPlayout(); + int32_t res = InitPlayout(); // Cancel effect of initialization StopPlayout(); @@ -1297,13 +1297,13 @@ WebRtc_Word32 AudioDeviceAndroidJni::PlayoutIsAvailable(bool& available) // RecordingIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::RecordingIsAvailable(bool& available) +int32_t AudioDeviceAndroidJni::RecordingIsAvailable(bool& available) { available = false; // Try to initialize the playout side - WebRtc_Word32 res = InitRecording(); + int32_t res = InitRecording(); // Cancel effect of initialization StopRecording(); @@ -1320,7 +1320,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::RecordingIsAvailable(bool& available) // InitPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::InitPlayout() +int32_t AudioDeviceAndroidJni::InitPlayout() { CriticalSectionScoped lock(&_critSect); @@ -1428,7 +1428,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::InitPlayout() // InitRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::InitRecording() +int32_t AudioDeviceAndroidJni::InitRecording() { CriticalSectionScoped lock(&_critSect); @@ -1536,7 +1536,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::InitRecording() // StartRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::StartRecording() +int32_t AudioDeviceAndroidJni::StartRecording() { CriticalSectionScoped lock(&_critSect); @@ -1620,7 +1620,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::StartRecording() // StopRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::StopRecording() +int32_t AudioDeviceAndroidJni::StopRecording() { @@ -1720,7 +1720,7 @@ bool AudioDeviceAndroidJni::PlayoutIsInitialized() const // StartPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::StartPlayout() +int32_t AudioDeviceAndroidJni::StartPlayout() { CriticalSectionScoped lock(&_critSect); @@ -1804,7 +1804,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::StartPlayout() // StopPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::StopPlayout() +int32_t AudioDeviceAndroidJni::StopPlayout() { CriticalSectionScoped lock(&_critSect); @@ -1871,7 +1871,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::StopPlayout() // Remaining amount of data still in the playout buffer. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::PlayoutDelay(WebRtc_UWord16& delayMS) const +int32_t AudioDeviceAndroidJni::PlayoutDelay(uint16_t& delayMS) const { delayMS = _delayPlayout; @@ -1884,8 +1884,8 @@ WebRtc_Word32 AudioDeviceAndroidJni::PlayoutDelay(WebRtc_UWord16& delayMS) const // Remaining amount of data still in the recording buffer. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::RecordingDelay( - WebRtc_UWord16& delayMS) const +int32_t AudioDeviceAndroidJni::RecordingDelay( + uint16_t& delayMS) const { delayMS = _delayRecording; @@ -1906,9 +1906,9 @@ bool AudioDeviceAndroidJni::Playing() const // SetPlayoutBuffer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetPlayoutBuffer( +int32_t AudioDeviceAndroidJni::SetPlayoutBuffer( const AudioDeviceModule::BufferType /*type*/, - WebRtc_UWord16 /*sizeMS*/) + uint16_t /*sizeMS*/) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -1920,9 +1920,9 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetPlayoutBuffer( // PlayoutBuffer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::PlayoutBuffer( +int32_t AudioDeviceAndroidJni::PlayoutBuffer( AudioDeviceModule::BufferType& type, - WebRtc_UWord16& sizeMS) const + uint16_t& sizeMS) const { type = AudioDeviceModule::kAdaptiveBufferSize; @@ -1935,7 +1935,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::PlayoutBuffer( // CPULoad // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::CPULoad(WebRtc_UWord16& /*load*/) const +int32_t AudioDeviceAndroidJni::CPULoad(uint16_t& /*load*/) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -2019,8 +2019,8 @@ void AudioDeviceAndroidJni::ClearRecordingError() // SetRecordingSampleRate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetRecordingSampleRate( - const WebRtc_UWord32 samplesPerSec) +int32_t AudioDeviceAndroidJni::SetRecordingSampleRate( + const uint32_t samplesPerSec) { if (samplesPerSec > 48000 || samplesPerSec < 8000) @@ -2050,8 +2050,8 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetRecordingSampleRate( // SetPlayoutSampleRate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetPlayoutSampleRate( - const WebRtc_UWord32 samplesPerSec) +int32_t AudioDeviceAndroidJni::SetPlayoutSampleRate( + const uint32_t samplesPerSec) { if (samplesPerSec > 48000 || samplesPerSec < 8000) @@ -2081,7 +2081,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetPlayoutSampleRate( // SetLoudspeakerStatus // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::SetLoudspeakerStatus(bool enable) +int32_t AudioDeviceAndroidJni::SetLoudspeakerStatus(bool enable) { if (!globalContext) @@ -2144,7 +2144,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::SetLoudspeakerStatus(bool enable) // GetLoudspeakerStatus // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::GetLoudspeakerStatus(bool& enabled) const +int32_t AudioDeviceAndroidJni::GetLoudspeakerStatus(bool& enabled) const { enabled = _loudSpeakerOn; @@ -2164,7 +2164,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::GetLoudspeakerStatus(bool& enabled) const // AudioDeviceAndroid.java // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::InitJavaResources() +int32_t AudioDeviceAndroidJni::InitJavaResources() { // todo: Check if we already have created the java object _javaVM = globalJvm; @@ -2395,7 +2395,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::InitJavaResources() // Also stores the max playout volume returned from InitPlayout. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceAndroidJni::InitSampleRate() +int32_t AudioDeviceAndroidJni::InitSampleRate() { int samplingFreq = 44100; jint res = 0; @@ -2548,7 +2548,7 @@ WebRtc_Word32 AudioDeviceAndroidJni::InitSampleRate() } // Store max playout volume - _maxSpeakerVolume = static_cast (res); + _maxSpeakerVolume = static_cast (res); if (_maxSpeakerVolume < 1) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -2677,14 +2677,14 @@ bool AudioDeviceAndroidJni::PlayThreadProcess() if (_playing) { - WebRtc_Word8 playBuffer[2 * 480]; // Max 10 ms @ 48 kHz / 16 bit - WebRtc_UWord32 samplesToPlay = _samplingFreqOut * 10; + int8_t playBuffer[2 * 480]; // Max 10 ms @ 48 kHz / 16 bit + uint32_t samplesToPlay = _samplingFreqOut * 10; // ask for new PCM data to be played out using the AudioDeviceBuffer // ensure that this callback is executed without taking the // audio-thread lock UnLock(); - WebRtc_UWord32 nSamples = + uint32_t nSamples = _ptrAudioBuffer->RequestPlayoutData(samplesToPlay); Lock(); @@ -2821,7 +2821,7 @@ bool AudioDeviceAndroidJni::RecThreadProcess() if (_recording) { - WebRtc_UWord32 samplesToRec = _samplingFreqIn * 10; + uint32_t samplesToRec = _samplingFreqIn * 10; // Call java sc object method to record data to direct buffer // Will block until data has been recorded (see java sc class), diff --git a/webrtc/modules/audio_device/android/audio_device_jni_android.h b/webrtc/modules/audio_device/android/audio_device_jni_android.h index b8186bea54..66318679cd 100644 --- a/webrtc/modules/audio_device/android/audio_device_jni_android.h +++ b/webrtc/modules/audio_device/android/audio_device_jni_android.h @@ -24,121 +24,120 @@ namespace webrtc { class EventWrapper; -const WebRtc_UWord32 N_REC_SAMPLES_PER_SEC = 16000; // Default is 16 kHz -const WebRtc_UWord32 N_PLAY_SAMPLES_PER_SEC = 16000; // Default is 16 kHz +const uint32_t N_REC_SAMPLES_PER_SEC = 16000; // Default is 16 kHz +const uint32_t N_PLAY_SAMPLES_PER_SEC = 16000; // Default is 16 kHz -const WebRtc_UWord32 N_REC_CHANNELS = 1; // default is mono recording -const WebRtc_UWord32 N_PLAY_CHANNELS = 1; // default is mono playout +const uint32_t N_REC_CHANNELS = 1; // default is mono recording +const uint32_t N_PLAY_CHANNELS = 1; // default is mono playout -const WebRtc_UWord32 REC_BUF_SIZE_IN_SAMPLES = 480; // Handle max 10 ms @ 48 kHz +const uint32_t REC_BUF_SIZE_IN_SAMPLES = 480; // Handle max 10 ms @ 48 kHz class ThreadWrapper; class AudioDeviceAndroidJni : public AudioDeviceGeneric { public: - AudioDeviceAndroidJni(const WebRtc_Word32 id); + AudioDeviceAndroidJni(const int32_t id); ~AudioDeviceAndroidJni(); - static WebRtc_Word32 SetAndroidAudioDeviceObjects(void* javaVM, - void* env, - void* context); + static int32_t SetAndroidAudioDeviceObjects(void* javaVM, + void* env, + void* context); - virtual WebRtc_Word32 ActiveAudioLayer( + virtual int32_t ActiveAudioLayer( AudioDeviceModule::AudioLayer& audioLayer) const; - virtual WebRtc_Word32 Init(); - virtual WebRtc_Word32 Terminate(); + virtual int32_t Init(); + virtual int32_t Terminate(); virtual bool Initialized() const; - virtual WebRtc_Word16 PlayoutDevices(); - virtual WebRtc_Word16 RecordingDevices(); - virtual WebRtc_Word32 PlayoutDeviceName(WebRtc_UWord16 index, - char name[kAdmMaxDeviceNameSize], - char guid[kAdmMaxGuidSize]); - virtual WebRtc_Word32 RecordingDeviceName( - WebRtc_UWord16 index, + virtual int16_t PlayoutDevices(); + virtual int16_t RecordingDevices(); + virtual int32_t PlayoutDeviceName(uint16_t index, + char name[kAdmMaxDeviceNameSize], + char guid[kAdmMaxGuidSize]); + virtual int32_t RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); - virtual WebRtc_Word32 SetPlayoutDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetPlayoutDevice( + virtual int32_t SetPlayoutDevice(uint16_t index); + virtual int32_t SetPlayoutDevice( AudioDeviceModule::WindowsDeviceType device); - virtual WebRtc_Word32 SetRecordingDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetRecordingDevice( + virtual int32_t SetRecordingDevice(uint16_t index); + virtual int32_t SetRecordingDevice( AudioDeviceModule::WindowsDeviceType device); - virtual WebRtc_Word32 PlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 InitPlayout(); + virtual int32_t PlayoutIsAvailable(bool& available); + virtual int32_t InitPlayout(); virtual bool PlayoutIsInitialized() const; - virtual WebRtc_Word32 RecordingIsAvailable(bool& available); - virtual WebRtc_Word32 InitRecording(); + virtual int32_t RecordingIsAvailable(bool& available); + virtual int32_t InitRecording(); virtual bool RecordingIsInitialized() const; - virtual WebRtc_Word32 StartPlayout(); - virtual WebRtc_Word32 StopPlayout(); + virtual int32_t StartPlayout(); + virtual int32_t StopPlayout(); virtual bool Playing() const; - virtual WebRtc_Word32 StartRecording(); - virtual WebRtc_Word32 StopRecording(); + virtual int32_t StartRecording(); + virtual int32_t StopRecording(); virtual bool Recording() const; - virtual WebRtc_Word32 SetAGC(bool enable); + virtual int32_t SetAGC(bool enable); virtual bool AGC() const; - virtual WebRtc_Word32 SetWaveOutVolume(WebRtc_UWord16 volumeLeft, - WebRtc_UWord16 volumeRight); - virtual WebRtc_Word32 WaveOutVolume(WebRtc_UWord16& volumeLeft, - WebRtc_UWord16& volumeRight) const; + virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight); + virtual int32_t WaveOutVolume(uint16_t& volumeLeft, + uint16_t& volumeRight) const; - virtual WebRtc_Word32 SpeakerIsAvailable(bool& available); - virtual WebRtc_Word32 InitSpeaker(); + virtual int32_t SpeakerIsAvailable(bool& available); + virtual int32_t InitSpeaker(); virtual bool SpeakerIsInitialized() const; - virtual WebRtc_Word32 MicrophoneIsAvailable(bool& available); - virtual WebRtc_Word32 InitMicrophone(); + virtual int32_t MicrophoneIsAvailable(bool& available); + virtual int32_t InitMicrophone(); virtual bool MicrophoneIsInitialized() const; - virtual WebRtc_Word32 SpeakerVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 SpeakerVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const; + virtual int32_t SpeakerVolumeIsAvailable(bool& available); + virtual int32_t SetSpeakerVolume(uint32_t volume); + virtual int32_t SpeakerVolume(uint32_t& volume) const; + virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const; + virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const; + virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const; - virtual WebRtc_Word32 MicrophoneVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinMicrophoneVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 MicrophoneVolumeStepSize( - WebRtc_UWord16& stepSize) const; + virtual int32_t MicrophoneVolumeIsAvailable(bool& available); + virtual int32_t SetMicrophoneVolume(uint32_t volume); + virtual int32_t MicrophoneVolume(uint32_t& volume) const; + virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const; + virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const; + virtual int32_t MicrophoneVolumeStepSize( + uint16_t& stepSize) const; - virtual WebRtc_Word32 SpeakerMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerMute(bool enable); - virtual WebRtc_Word32 SpeakerMute(bool& enabled) const; + virtual int32_t SpeakerMuteIsAvailable(bool& available); + virtual int32_t SetSpeakerMute(bool enable); + virtual int32_t SpeakerMute(bool& enabled) const; - virtual WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneMute(bool enable); - virtual WebRtc_Word32 MicrophoneMute(bool& enabled) const; + virtual int32_t MicrophoneMuteIsAvailable(bool& available); + virtual int32_t SetMicrophoneMute(bool enable); + virtual int32_t MicrophoneMute(bool& enabled) const; - virtual WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneBoost(bool enable); - virtual WebRtc_Word32 MicrophoneBoost(bool& enabled) const; + virtual int32_t MicrophoneBoostIsAvailable(bool& available); + virtual int32_t SetMicrophoneBoost(bool enable); + virtual int32_t MicrophoneBoost(bool& enabled) const; - virtual WebRtc_Word32 StereoPlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoPlayout(bool enable); - virtual WebRtc_Word32 StereoPlayout(bool& enabled) const; - virtual WebRtc_Word32 StereoRecordingIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoRecording(bool enable); - virtual WebRtc_Word32 StereoRecording(bool& enabled) const; + virtual int32_t StereoPlayoutIsAvailable(bool& available); + virtual int32_t SetStereoPlayout(bool enable); + virtual int32_t StereoPlayout(bool& enabled) const; + virtual int32_t StereoRecordingIsAvailable(bool& available); + virtual int32_t SetStereoRecording(bool enable); + virtual int32_t StereoRecording(bool& enabled) const; - virtual WebRtc_Word32 SetPlayoutBuffer( - const AudioDeviceModule::BufferType type, WebRtc_UWord16 sizeMS); - virtual WebRtc_Word32 PlayoutBuffer( - AudioDeviceModule::BufferType& type, WebRtc_UWord16& sizeMS) const; - virtual WebRtc_Word32 PlayoutDelay(WebRtc_UWord16& delayMS) const; - virtual WebRtc_Word32 RecordingDelay(WebRtc_UWord16& delayMS) const; + virtual int32_t SetPlayoutBuffer( + const AudioDeviceModule::BufferType type, uint16_t sizeMS); + virtual int32_t PlayoutBuffer( + AudioDeviceModule::BufferType& type, uint16_t& sizeMS) const; + virtual int32_t PlayoutDelay(uint16_t& delayMS) const; + virtual int32_t RecordingDelay(uint16_t& delayMS) const; - virtual WebRtc_Word32 CPULoad(WebRtc_UWord16& load) const; + virtual int32_t CPULoad(uint16_t& load) const; virtual bool PlayoutWarning() const; virtual bool PlayoutError() const; @@ -151,13 +150,13 @@ class AudioDeviceAndroidJni : public AudioDeviceGeneric { virtual void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer); - virtual WebRtc_Word32 SetRecordingSampleRate( - const WebRtc_UWord32 samplesPerSec); - virtual WebRtc_Word32 SetPlayoutSampleRate( - const WebRtc_UWord32 samplesPerSec); + virtual int32_t SetRecordingSampleRate( + const uint32_t samplesPerSec); + virtual int32_t SetPlayoutSampleRate( + const uint32_t samplesPerSec); - virtual WebRtc_Word32 SetLoudspeakerStatus(bool enable); - virtual WebRtc_Word32 GetLoudspeakerStatus(bool& enable) const; + virtual int32_t SetLoudspeakerStatus(bool enable); + virtual int32_t GetLoudspeakerStatus(bool& enable) const; private: // Lock @@ -169,8 +168,8 @@ class AudioDeviceAndroidJni : public AudioDeviceGeneric { }; // Init - WebRtc_Word32 InitJavaResources(); - WebRtc_Word32 InitSampleRate(); + int32_t InitJavaResources(); + int32_t InitSampleRate(); // Threads static bool RecThreadFunc(void*); @@ -181,7 +180,7 @@ class AudioDeviceAndroidJni : public AudioDeviceGeneric { // Misc AudioDeviceBuffer* _ptrAudioBuffer; CriticalSectionWrapper& _critSect; - WebRtc_Word32 _id; + int32_t _id; // Events EventWrapper& _timeEventRec; @@ -192,15 +191,15 @@ class AudioDeviceAndroidJni : public AudioDeviceGeneric { // Threads ThreadWrapper* _ptrThreadPlay; ThreadWrapper* _ptrThreadRec; - WebRtc_UWord32 _recThreadID; - WebRtc_UWord32 _playThreadID; + uint32_t _recThreadID; + uint32_t _playThreadID; bool _playThreadIsInitialized; bool _recThreadIsInitialized; bool _shutdownPlayThread; bool _shutdownRecThread; // Rec buffer - WebRtc_Word8 _recBuffer[2 * REC_BUF_SIZE_IN_SAMPLES]; + int8_t _recBuffer[2 * REC_BUF_SIZE_IN_SAMPLES]; // States bool _recordingDeviceIsSpecified; @@ -220,22 +219,22 @@ class AudioDeviceAndroidJni : public AudioDeviceGeneric { bool _stopPlay; // Warnings and errors - WebRtc_UWord16 _playWarning; - WebRtc_UWord16 _playError; - WebRtc_UWord16 _recWarning; - WebRtc_UWord16 _recError; + uint16_t _playWarning; + uint16_t _playError; + uint16_t _recWarning; + uint16_t _recError; // Delay - WebRtc_UWord16 _delayPlayout; - WebRtc_UWord16 _delayRecording; + uint16_t _delayPlayout; + uint16_t _delayRecording; // AGC state bool _AGC; // Stored device properties - WebRtc_UWord16 _samplingFreqIn; // Sampling frequency for Mic - WebRtc_UWord16 _samplingFreqOut; // Sampling frequency for Speaker - WebRtc_UWord32 _maxSpeakerVolume; // The maximum speaker volume value + uint16_t _samplingFreqIn; // Sampling frequency for Mic + uint16_t _samplingFreqOut; // Sampling frequency for Speaker + uint32_t _maxSpeakerVolume; // The maximum speaker volume value bool _loudSpeakerOn; // Stores the desired audio source to use, set in SetRecordingDevice int _recAudioSource; diff --git a/webrtc/modules/audio_device/android/audio_device_opensles_android.cc b/webrtc/modules/audio_device/android/audio_device_opensles_android.cc index e0744d6a93..93271f0ad1 100644 --- a/webrtc/modules/audio_device/android/audio_device_opensles_android.cc +++ b/webrtc/modules/audio_device/android/audio_device_opensles_android.cc @@ -32,7 +32,7 @@ namespace webrtc { -AudioDeviceAndroidOpenSLES::AudioDeviceAndroidOpenSLES(const WebRtc_Word32 id) +AudioDeviceAndroidOpenSLES::AudioDeviceAndroidOpenSLES(const int32_t id) : voe_audio_buffer_(NULL), crit_sect_(*CriticalSectionWrapper::CreateCriticalSection()), id_(id), @@ -100,7 +100,7 @@ void AudioDeviceAndroidOpenSLES::AttachAudioBuffer( voe_audio_buffer_->SetPlayoutChannels(N_PLAY_CHANNELS); } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::ActiveAudioLayer( +int32_t AudioDeviceAndroidOpenSLES::ActiveAudioLayer( AudioDeviceModule::AudioLayer& audioLayer) const { audioLayer = AudioDeviceModule::kPlatformDefaultAudio; @@ -108,7 +108,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::ActiveAudioLayer( return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::Init() { +int32_t AudioDeviceAndroidOpenSLES::Init() { CriticalSectionScoped lock(&crit_sect_); if (is_initialized_) @@ -117,8 +117,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::Init() { SLEngineOption EngineOption[] = { { SL_ENGINEOPTION_THREADSAFE, static_cast(SL_BOOLEAN_TRUE) }, }; - WebRtc_Word32 res = slCreateEngine(&sles_engine_, 1, EngineOption, 0, - NULL, NULL); + int32_t res = slCreateEngine(&sles_engine_, 1, EngineOption, 0, NULL, NULL); if (res != SL_RESULT_SUCCESS) { WEBRTC_OPENSL_TRACE(kTraceError, kTraceAudioDevice, id_, @@ -168,7 +167,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::Init() { return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::Terminate() { +int32_t AudioDeviceAndroidOpenSLES::Terminate() { CriticalSectionScoped lock(&crit_sect_); if (!is_initialized_) @@ -197,7 +196,7 @@ bool AudioDeviceAndroidOpenSLES::Initialized() const { return (is_initialized_); } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SpeakerIsAvailable( +int32_t AudioDeviceAndroidOpenSLES::SpeakerIsAvailable( bool& available) { // We always assume it's available available = true; @@ -205,7 +204,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::SpeakerIsAvailable( return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::InitSpeaker() { +int32_t AudioDeviceAndroidOpenSLES::InitSpeaker() { CriticalSectionScoped lock(&crit_sect_); if (is_playing_) { @@ -227,14 +226,14 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::InitSpeaker() { return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::MicrophoneIsAvailable( +int32_t AudioDeviceAndroidOpenSLES::MicrophoneIsAvailable( bool& available) { // We always assume it's available. available = true; return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::InitMicrophone() { +int32_t AudioDeviceAndroidOpenSLES::InitMicrophone() { CriticalSectionScoped lock(&crit_sect_); if (is_recording_) { WEBRTC_OPENSL_TRACE(kTraceWarning, kTraceAudioDevice, id_, @@ -261,14 +260,14 @@ bool AudioDeviceAndroidOpenSLES::MicrophoneIsInitialized() const { return is_mic_initialized_; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SpeakerVolumeIsAvailable( +int32_t AudioDeviceAndroidOpenSLES::SpeakerVolumeIsAvailable( bool& available) { available = true; // We assume we are always be able to set/get volume. return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetSpeakerVolume( - WebRtc_UWord32 volume) { +int32_t AudioDeviceAndroidOpenSLES::SetSpeakerVolume( + uint32_t volume) { if (!is_speaker_initialized_) { WEBRTC_OPENSL_TRACE(kTraceError, kTraceAudioDevice, id_, " Speaker not initialized"); @@ -294,29 +293,29 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetSpeakerVolume( return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SpeakerVolume( - WebRtc_UWord32& volume) const { +int32_t AudioDeviceAndroidOpenSLES::SpeakerVolume( + uint32_t& volume) const { return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetWaveOutVolume( - WebRtc_UWord16 volumeLeft, - WebRtc_UWord16 volumeRight) { +int32_t AudioDeviceAndroidOpenSLES::SetWaveOutVolume( + uint16_t volumeLeft, + uint16_t volumeRight) { WEBRTC_OPENSL_TRACE(kTraceWarning, kTraceAudioDevice, id_, " API call not supported on this platform"); return -1; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::WaveOutVolume( - WebRtc_UWord16& volumeLeft, - WebRtc_UWord16& volumeRight) const { +int32_t AudioDeviceAndroidOpenSLES::WaveOutVolume( + uint16_t& volumeLeft, + uint16_t& volumeRight) const { WEBRTC_OPENSL_TRACE(kTraceWarning, kTraceAudioDevice, id_, " API call not supported on this platform"); return -1; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::MaxSpeakerVolume( - WebRtc_UWord32& maxVolume) const { +int32_t AudioDeviceAndroidOpenSLES::MaxSpeakerVolume( + uint32_t& maxVolume) const { if (!is_speaker_initialized_) { WEBRTC_OPENSL_TRACE(kTraceError, kTraceAudioDevice, id_, " Speaker not initialized"); @@ -328,8 +327,8 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::MaxSpeakerVolume( return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::MinSpeakerVolume( - WebRtc_UWord32& minVolume) const { +int32_t AudioDeviceAndroidOpenSLES::MinSpeakerVolume( + uint32_t& minVolume) const { if (!is_speaker_initialized_) { WEBRTC_OPENSL_TRACE(kTraceError, kTraceAudioDevice, id_, " Speaker not initialized"); @@ -339,8 +338,8 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::MinSpeakerVolume( return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SpeakerVolumeStepSize( - WebRtc_UWord16& stepSize) const { +int32_t AudioDeviceAndroidOpenSLES::SpeakerVolumeStepSize( + uint16_t& stepSize) const { if (!is_speaker_initialized_) { WEBRTC_OPENSL_TRACE(kTraceError, kTraceAudioDevice, id_, " Speaker not initialized"); @@ -350,51 +349,51 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::SpeakerVolumeStepSize( return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SpeakerMuteIsAvailable( +int32_t AudioDeviceAndroidOpenSLES::SpeakerMuteIsAvailable( bool& available) { available = false; // Speaker mute not supported on Android. return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetSpeakerMute(bool enable) { +int32_t AudioDeviceAndroidOpenSLES::SetSpeakerMute(bool enable) { WEBRTC_OPENSL_TRACE(kTraceWarning, kTraceAudioDevice, id_, " API call not supported on this platform"); return -1; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SpeakerMute( +int32_t AudioDeviceAndroidOpenSLES::SpeakerMute( bool& enabled) const { WEBRTC_OPENSL_TRACE(kTraceWarning, kTraceAudioDevice, id_, " API call not supported on this platform"); return -1; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::MicrophoneMuteIsAvailable( +int32_t AudioDeviceAndroidOpenSLES::MicrophoneMuteIsAvailable( bool& available) { available = false; // Mic mute not supported on Android return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetMicrophoneMute(bool enable) { +int32_t AudioDeviceAndroidOpenSLES::SetMicrophoneMute(bool enable) { WEBRTC_OPENSL_TRACE(kTraceWarning, kTraceAudioDevice, id_, " API call not supported on this platform"); return -1; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::MicrophoneMute( +int32_t AudioDeviceAndroidOpenSLES::MicrophoneMute( bool& enabled) const { WEBRTC_OPENSL_TRACE(kTraceWarning, kTraceAudioDevice, id_, " API call not supported on this platform"); return -1; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::MicrophoneBoostIsAvailable( +int32_t AudioDeviceAndroidOpenSLES::MicrophoneBoostIsAvailable( bool& available) { available = false; // Mic boost not supported on Android. return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetMicrophoneBoost(bool enable) { +int32_t AudioDeviceAndroidOpenSLES::SetMicrophoneBoost(bool enable) { if (!is_mic_initialized_) { WEBRTC_OPENSL_TRACE(kTraceError, kTraceAudioDevice, id_, " Microphone not initialized"); @@ -408,7 +407,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetMicrophoneBoost(bool enable) { return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::MicrophoneBoost( +int32_t AudioDeviceAndroidOpenSLES::MicrophoneBoost( bool& enabled) const { if (!is_mic_initialized_) { WEBRTC_OPENSL_TRACE(kTraceError, kTraceAudioDevice, id_, @@ -419,13 +418,13 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::MicrophoneBoost( return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::StereoRecordingIsAvailable( +int32_t AudioDeviceAndroidOpenSLES::StereoRecordingIsAvailable( bool& available) { available = false; // Stereo recording not supported on Android. return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetStereoRecording(bool enable) { +int32_t AudioDeviceAndroidOpenSLES::SetStereoRecording(bool enable) { if (enable) { WEBRTC_OPENSL_TRACE(kTraceError, kTraceAudioDevice, id_, " Enabling not available"); @@ -434,13 +433,13 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetStereoRecording(bool enable) { return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::StereoRecording( +int32_t AudioDeviceAndroidOpenSLES::StereoRecording( bool& enabled) const { enabled = false; return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::StereoPlayoutIsAvailable( +int32_t AudioDeviceAndroidOpenSLES::StereoPlayoutIsAvailable( bool& available) { // TODO(leozwang): This api is called before initplayout, we need // to detect audio device to find out if stereo is supported or not. @@ -448,7 +447,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::StereoPlayoutIsAvailable( return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetStereoPlayout(bool enable) { +int32_t AudioDeviceAndroidOpenSLES::SetStereoPlayout(bool enable) { if (enable) { return 0; } else { @@ -457,14 +456,14 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetStereoPlayout(bool enable) { } } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::StereoPlayout( +int32_t AudioDeviceAndroidOpenSLES::StereoPlayout( bool& enabled) const { enabled = (player_pcm_.numChannels == 2 ? true : false); return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetAGC(bool enable) { +int32_t AudioDeviceAndroidOpenSLES::SetAGC(bool enable) { agc_enabled_ = enable; return 0; } @@ -473,14 +472,14 @@ bool AudioDeviceAndroidOpenSLES::AGC() const { return agc_enabled_; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::MicrophoneVolumeIsAvailable( +int32_t AudioDeviceAndroidOpenSLES::MicrophoneVolumeIsAvailable( bool& available) { available = true; return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetMicrophoneVolume( - WebRtc_UWord32 volume) { +int32_t AudioDeviceAndroidOpenSLES::SetMicrophoneVolume( + uint32_t volume) { WEBRTC_OPENSL_TRACE(kTraceWarning, kTraceAudioDevice, id_, " OpenSL doesn't support contolling Mic volume yet"); // TODO(leozwang): Add microphone volume control when OpenSL apis @@ -488,34 +487,34 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetMicrophoneVolume( return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::MicrophoneVolume( - WebRtc_UWord32& volume) const { +int32_t AudioDeviceAndroidOpenSLES::MicrophoneVolume( + uint32_t& volume) const { return -1; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::MaxMicrophoneVolume( - WebRtc_UWord32& maxVolume) const { +int32_t AudioDeviceAndroidOpenSLES::MaxMicrophoneVolume( + uint32_t& maxVolume) const { return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::MinMicrophoneVolume( - WebRtc_UWord32& minVolume) const { +int32_t AudioDeviceAndroidOpenSLES::MinMicrophoneVolume( + uint32_t& minVolume) const { minVolume = 0; return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::MicrophoneVolumeStepSize( - WebRtc_UWord16& stepSize) const { +int32_t AudioDeviceAndroidOpenSLES::MicrophoneVolumeStepSize( + uint16_t& stepSize) const { stepSize = 1; return 0; } -WebRtc_Word16 AudioDeviceAndroidOpenSLES::PlayoutDevices() { +int16_t AudioDeviceAndroidOpenSLES::PlayoutDevices() { return 1; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetPlayoutDevice( - WebRtc_UWord16 index) { +int32_t AudioDeviceAndroidOpenSLES::SetPlayoutDevice( + uint16_t index) { if (is_play_initialized_) { WEBRTC_OPENSL_TRACE(kTraceError, kTraceAudioDevice, id_, " Playout already initialized"); @@ -534,7 +533,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetPlayoutDevice( return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetPlayoutDevice( +int32_t AudioDeviceAndroidOpenSLES::SetPlayoutDevice( AudioDeviceModule::WindowsDeviceType device) { WEBRTC_OPENSL_TRACE(kTraceWarning, kTraceAudioDevice, id_, @@ -542,8 +541,8 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetPlayoutDevice( return -1; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::PlayoutDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceAndroidOpenSLES::PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { if (0 != index) { @@ -561,8 +560,8 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::PlayoutDeviceName( return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::RecordingDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceAndroidOpenSLES::RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { if (0 != index) { @@ -580,12 +579,12 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::RecordingDeviceName( return 0; } -WebRtc_Word16 AudioDeviceAndroidOpenSLES::RecordingDevices() { +int16_t AudioDeviceAndroidOpenSLES::RecordingDevices() { return 1; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetRecordingDevice( - WebRtc_UWord16 index) { +int32_t AudioDeviceAndroidOpenSLES::SetRecordingDevice( + uint16_t index) { if (is_rec_initialized_) { WEBRTC_OPENSL_TRACE(kTraceError, kTraceAudioDevice, id_, " Recording already initialized"); @@ -604,17 +603,17 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetRecordingDevice( return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetRecordingDevice( +int32_t AudioDeviceAndroidOpenSLES::SetRecordingDevice( AudioDeviceModule::WindowsDeviceType device) { WEBRTC_OPENSL_TRACE(kTraceWarning, kTraceAudioDevice, id_, " API call not supported on this platform"); return -1; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::PlayoutIsAvailable( +int32_t AudioDeviceAndroidOpenSLES::PlayoutIsAvailable( bool& available) { available = false; - WebRtc_Word32 res = InitPlayout(); + int32_t res = InitPlayout(); StopPlayout(); if (res != -1) { available = true; @@ -622,10 +621,10 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::PlayoutIsAvailable( return res; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::RecordingIsAvailable( +int32_t AudioDeviceAndroidOpenSLES::RecordingIsAvailable( bool& available) { available = false; - WebRtc_Word32 res = InitRecording(); + int32_t res = InitRecording(); StopRecording(); if (res != -1) { available = true; @@ -633,7 +632,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::RecordingIsAvailable( return res; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::InitPlayout() { +int32_t AudioDeviceAndroidOpenSLES::InitPlayout() { CriticalSectionScoped lock(&crit_sect_); if (!is_initialized_) { WEBRTC_OPENSL_TRACE(kTraceError, kTraceAudioDevice, id_, @@ -680,7 +679,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::InitPlayout() { SLDataSink audio_sink = { &locator_outputmix, NULL }; // Create Output Mix object to be used by player. - WebRtc_Word32 res = -1; + int32_t res = -1; res = (*sles_engine_itf_)->CreateOutputMix(sles_engine_itf_, &sles_output_mixer_, 0, @@ -775,7 +774,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::InitPlayout() { return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::InitRecording() { +int32_t AudioDeviceAndroidOpenSLES::InitRecording() { CriticalSectionScoped lock(&crit_sect_); if (!is_initialized_) { @@ -848,7 +847,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::InitRecording() { SL_IID_ANDROIDSIMPLEBUFFERQUEUE, SL_IID_ANDROIDCONFIGURATION }; const SLboolean req[2] = { SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE }; - WebRtc_Word32 res = -1; + int32_t res = -1; res = (*sles_engine_itf_)->CreateAudioRecorder(sles_engine_itf_, &sles_recorder_, &audio_source, @@ -906,7 +905,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::InitRecording() { return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::StartRecording() { +int32_t AudioDeviceAndroidOpenSLES::StartRecording() { CriticalSectionScoped lock(&crit_sect_); if (!is_rec_initialized_) { @@ -935,7 +934,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::StartRecording() { memset(rec_buf_, 0, sizeof(rec_buf_)); memset(rec_voe_buf_, 0, sizeof(rec_voe_buf_)); - WebRtc_UWord32 num_bytes = + uint32_t num_bytes = N_REC_CHANNELS * sizeof(int16_t) * mic_sampling_rate_ / 100; while (!rec_queue_.empty()) @@ -949,7 +948,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::StartRecording() { rec_voe_ready_queue_.push(rec_voe_buf_[i]); } - WebRtc_Word32 res = -1; + int32_t res = -1; for (int i = 0; i < N_REC_QUEUE_BUFFERS; ++i) { // We assign 10ms buffer to each queue, size given in bytes. res = (*sles_recorder_sbq_itf_)->Enqueue( @@ -1000,7 +999,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::StartRecording() { return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::StopRecording() { +int32_t AudioDeviceAndroidOpenSLES::StopRecording() { { CriticalSectionScoped lock(&crit_sect_); @@ -1011,7 +1010,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::StopRecording() { } if ((sles_recorder_itf_ != NULL) && (sles_recorder_ != NULL)) { - WebRtc_Word32 res = (*sles_recorder_itf_)->SetRecordState( + int32_t res = (*sles_recorder_itf_)->SetRecordState( sles_recorder_itf_, SL_RECORDSTATE_STOPPED); if (res != SL_RESULT_SUCCESS) { @@ -1067,7 +1066,7 @@ bool AudioDeviceAndroidOpenSLES::PlayoutIsInitialized() const { return is_play_initialized_; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::StartPlayout() { +int32_t AudioDeviceAndroidOpenSLES::StartPlayout() { int i; CriticalSectionScoped lock(&crit_sect_); @@ -1094,7 +1093,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::StartPlayout() { return -1; } - WebRtc_UWord32 num_bytes = + uint32_t num_bytes = N_PLAY_CHANNELS * sizeof(int16_t) * speaker_sampling_rate_ / 100; memset(play_buf_, 0, sizeof(play_buf_)); @@ -1102,7 +1101,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::StartPlayout() { while (!play_queue_.empty()) play_queue_.pop(); - WebRtc_Word32 res = -1; + int32_t res = -1; for (i = 0; i < std::min(2, static_cast(N_PLAY_QUEUE_BUFFERS)); ++i) { res = (*sles_player_sbq_itf_)->Enqueue( sles_player_sbq_itf_, @@ -1133,7 +1132,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::StartPlayout() { return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::StopPlayout() { +int32_t AudioDeviceAndroidOpenSLES::StopPlayout() { { CriticalSectionScoped lock(&crit_sect_); if (!is_play_initialized_) { @@ -1144,7 +1143,7 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::StopPlayout() { if (!sles_player_itf_ && !sles_output_mixer_ && !sles_player_) { // Make sure player is stopped - WebRtc_Word32 res = + int32_t res = (*sles_player_itf_)->SetPlayState(sles_player_itf_, SL_PLAYSTATE_STOPPED); if (res != SL_RESULT_SUCCESS) { @@ -1179,14 +1178,14 @@ WebRtc_Word32 AudioDeviceAndroidOpenSLES::StopPlayout() { return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::PlayoutDelay( - WebRtc_UWord16& delayMS) const { +int32_t AudioDeviceAndroidOpenSLES::PlayoutDelay( + uint16_t& delayMS) const { delayMS = playout_delay_; return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::RecordingDelay( - WebRtc_UWord16& delayMS) const { +int32_t AudioDeviceAndroidOpenSLES::RecordingDelay( + uint16_t& delayMS) const { delayMS = recording_delay_; return 0; } @@ -1195,24 +1194,24 @@ bool AudioDeviceAndroidOpenSLES::Playing() const { return is_playing_; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetPlayoutBuffer( +int32_t AudioDeviceAndroidOpenSLES::SetPlayoutBuffer( const AudioDeviceModule::BufferType type, - WebRtc_UWord16 sizeMS) { + uint16_t sizeMS) { WEBRTC_OPENSL_TRACE(kTraceWarning, kTraceAudioDevice, id_, " API call not supported on this platform"); return -1; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::PlayoutBuffer( +int32_t AudioDeviceAndroidOpenSLES::PlayoutBuffer( AudioDeviceModule::BufferType& type, - WebRtc_UWord16& sizeMS) const { + uint16_t& sizeMS) const { type = AudioDeviceModule::kAdaptiveBufferSize; sizeMS = playout_delay_; // Set to current playout delay return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::CPULoad( - WebRtc_UWord16& load) const { +int32_t AudioDeviceAndroidOpenSLES::CPULoad( + uint16_t& load) const { WEBRTC_OPENSL_TRACE(kTraceWarning, kTraceAudioDevice, id_, " API call not supported on this platform"); return -1; @@ -1250,12 +1249,12 @@ void AudioDeviceAndroidOpenSLES::ClearRecordingError() { rec_error_ = 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::SetLoudspeakerStatus(bool enable) { +int32_t AudioDeviceAndroidOpenSLES::SetLoudspeakerStatus(bool enable) { loundspeaker_on_ = enable; return 0; } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::GetLoudspeakerStatus( +int32_t AudioDeviceAndroidOpenSLES::GetLoudspeakerStatus( bool& enabled) const { enabled = loundspeaker_on_; return 0; @@ -1275,8 +1274,8 @@ void AudioDeviceAndroidOpenSLES::PlayerSimpleBufferQueueCallbackHandler( const unsigned int num_samples = speaker_sampling_rate_ / 100; const unsigned int num_bytes = N_PLAY_CHANNELS * num_samples * sizeof(int16_t); - WebRtc_Word8 buf[PLAY_MAX_TEMP_BUF_SIZE_PER_10ms]; - WebRtc_Word8* audio; + int8_t buf[PLAY_MAX_TEMP_BUF_SIZE_PER_10ms]; + int8_t* audio; audio = play_queue_.front(); play_queue_.pop(); @@ -1325,7 +1324,7 @@ bool AudioDeviceAndroidOpenSLES::RecThreadFuncImpl() { const unsigned int num_bytes = N_REC_CHANNELS * num_samples * sizeof(int16_t); const unsigned int total_bytes = num_bytes; - WebRtc_Word8 buf[REC_MAX_TEMP_BUF_SIZE_PER_10ms]; + int8_t buf[REC_MAX_TEMP_BUF_SIZE_PER_10ms]; { CriticalSectionScoped lock(&crit_sect_); @@ -1334,7 +1333,7 @@ bool AudioDeviceAndroidOpenSLES::RecThreadFuncImpl() { return true; } - WebRtc_Word8* audio = rec_voe_audio_queue_.front(); + int8_t* audio = rec_voe_audio_queue_.front(); rec_voe_audio_queue_.pop(); memcpy(buf, audio, total_bytes); memset(audio, 0, total_bytes); @@ -1357,7 +1356,7 @@ void AudioDeviceAndroidOpenSLES::RecorderSimpleBufferQueueCallbackHandler( const unsigned int num_bytes = N_REC_CHANNELS * num_samples * sizeof(int16_t); const unsigned int total_bytes = num_bytes; - WebRtc_Word8* audio; + int8_t* audio; { CriticalSectionScoped lock(&crit_sect_); @@ -1376,7 +1375,7 @@ void AudioDeviceAndroidOpenSLES::RecorderSimpleBufferQueueCallbackHandler( } } - WebRtc_Word32 res = (*queue_itf)->Enqueue(queue_itf, + int32_t res = (*queue_itf)->Enqueue(queue_itf, audio, total_bytes); if (res != SL_RESULT_SUCCESS) { @@ -1402,7 +1401,7 @@ void AudioDeviceAndroidOpenSLES::CheckErr(SLresult res) { } void AudioDeviceAndroidOpenSLES::UpdatePlayoutDelay( - WebRtc_UWord32 nSamplePlayed) { + uint32_t nSamplePlayed) { // TODO(leozwang): Add accurate delay estimat. playout_delay_ = (N_PLAY_QUEUE_BUFFERS - 0.5) * 10 + N_PLAY_QUEUE_BUFFERS * nSamplePlayed / (speaker_sampling_rate_ / 1000); @@ -1411,12 +1410,12 @@ void AudioDeviceAndroidOpenSLES::UpdatePlayoutDelay( void AudioDeviceAndroidOpenSLES::UpdateRecordingDelay() { // TODO(leozwang): Add accurate delay estimat. recording_delay_ = 10; - const WebRtc_UWord32 noSamp10ms = mic_sampling_rate_ / 100; + const uint32_t noSamp10ms = mic_sampling_rate_ / 100; recording_delay_ += (N_REC_QUEUE_BUFFERS * noSamp10ms) / (mic_sampling_rate_ / 1000); } -WebRtc_Word32 AudioDeviceAndroidOpenSLES::InitSampleRate() { +int32_t AudioDeviceAndroidOpenSLES::InitSampleRate() { if (sles_engine_ == NULL) { WEBRTC_OPENSL_TRACE(kTraceError, kTraceAudioDevice, id_, " SL Object is NULL"); diff --git a/webrtc/modules/audio_device/android/audio_device_opensles_android.h b/webrtc/modules/audio_device/android/audio_device_opensles_android.h index 2b2d746380..578999fa72 100644 --- a/webrtc/modules/audio_device/android/audio_device_opensles_android.h +++ b/webrtc/modules/audio_device/android/audio_device_opensles_android.h @@ -28,30 +28,30 @@ namespace webrtc { class EventWrapper; -const WebRtc_UWord32 N_MAX_INTERFACES = 3; -const WebRtc_UWord32 N_MAX_OUTPUT_DEVICES = 6; -const WebRtc_UWord32 N_MAX_INPUT_DEVICES = 3; +const uint32_t N_MAX_INTERFACES = 3; +const uint32_t N_MAX_OUTPUT_DEVICES = 6; +const uint32_t N_MAX_INPUT_DEVICES = 3; -const WebRtc_UWord32 N_REC_SAMPLES_PER_SEC = 16000; // Default fs -const WebRtc_UWord32 N_PLAY_SAMPLES_PER_SEC = 16000; // Default fs +const uint32_t N_REC_SAMPLES_PER_SEC = 16000; // Default fs +const uint32_t N_PLAY_SAMPLES_PER_SEC = 16000; // Default fs -const WebRtc_UWord32 N_REC_CHANNELS = 1; -const WebRtc_UWord32 N_PLAY_CHANNELS = 1; +const uint32_t N_REC_CHANNELS = 1; +const uint32_t N_PLAY_CHANNELS = 1; -const WebRtc_UWord32 REC_BUF_SIZE_IN_SAMPLES = 480; -const WebRtc_UWord32 PLAY_BUF_SIZE_IN_SAMPLES = 480; +const uint32_t REC_BUF_SIZE_IN_SAMPLES = 480; +const uint32_t PLAY_BUF_SIZE_IN_SAMPLES = 480; -const WebRtc_UWord32 REC_MAX_TEMP_BUF_SIZE_PER_10ms = +const uint32_t REC_MAX_TEMP_BUF_SIZE_PER_10ms = N_REC_CHANNELS * REC_BUF_SIZE_IN_SAMPLES * sizeof(int16_t); -const WebRtc_UWord32 PLAY_MAX_TEMP_BUF_SIZE_PER_10ms = +const uint32_t PLAY_MAX_TEMP_BUF_SIZE_PER_10ms = N_PLAY_CHANNELS * PLAY_BUF_SIZE_IN_SAMPLES * sizeof(int16_t); // Number of the buffers in playout queue -const WebRtc_UWord16 N_PLAY_QUEUE_BUFFERS = 8; +const uint16_t N_PLAY_QUEUE_BUFFERS = 8; // Number of buffers in recording queue // TODO(xian): Reduce the numbers of buffers to improve the latency. -const WebRtc_UWord16 N_REC_QUEUE_BUFFERS = 8; +const uint16_t N_REC_QUEUE_BUFFERS = 8; // Some values returned from getMinBufferSize // (Nexus S playout 72ms, recording 64ms) // (Galaxy, 167ms, 44ms) @@ -62,137 +62,136 @@ class ThreadWrapper; class AudioDeviceAndroidOpenSLES: public AudioDeviceGeneric { public: - explicit AudioDeviceAndroidOpenSLES(const WebRtc_Word32 id); + explicit AudioDeviceAndroidOpenSLES(const int32_t id); ~AudioDeviceAndroidOpenSLES(); // Retrieve the currently utilized audio layer - virtual WebRtc_Word32 + virtual int32_t ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const; // NOLINT // Main initializaton and termination - virtual WebRtc_Word32 Init(); - virtual WebRtc_Word32 Terminate(); + virtual int32_t Init(); + virtual int32_t Terminate(); virtual bool Initialized() const; // Device enumeration - virtual WebRtc_Word16 PlayoutDevices(); - virtual WebRtc_Word16 RecordingDevices(); - virtual WebRtc_Word32 - PlayoutDeviceName(WebRtc_UWord16 index, + virtual int16_t PlayoutDevices(); + virtual int16_t RecordingDevices(); + virtual int32_t + PlayoutDeviceName(uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); - virtual WebRtc_Word32 - RecordingDeviceName(WebRtc_UWord16 index, + virtual int32_t + RecordingDeviceName(uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); // Device selection - virtual WebRtc_Word32 SetPlayoutDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 + virtual int32_t SetPlayoutDevice(uint16_t index); + virtual int32_t SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType device); - virtual WebRtc_Word32 SetRecordingDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 + virtual int32_t SetRecordingDevice(uint16_t index); + virtual int32_t SetRecordingDevice(AudioDeviceModule::WindowsDeviceType device); // Audio transport initialization - virtual WebRtc_Word32 PlayoutIsAvailable(bool& available); // NOLINT - virtual WebRtc_Word32 InitPlayout(); + virtual int32_t PlayoutIsAvailable(bool& available); // NOLINT + virtual int32_t InitPlayout(); virtual bool PlayoutIsInitialized() const; - virtual WebRtc_Word32 RecordingIsAvailable(bool& available); // NOLINT - virtual WebRtc_Word32 InitRecording(); + virtual int32_t RecordingIsAvailable(bool& available); // NOLINT + virtual int32_t InitRecording(); virtual bool RecordingIsInitialized() const; // Audio transport control - virtual WebRtc_Word32 StartPlayout(); - virtual WebRtc_Word32 StopPlayout(); + virtual int32_t StartPlayout(); + virtual int32_t StopPlayout(); virtual bool Playing() const; - virtual WebRtc_Word32 StartRecording(); - virtual WebRtc_Word32 StopRecording(); + virtual int32_t StartRecording(); + virtual int32_t StopRecording(); virtual bool Recording() const; // Microphone Automatic Gain Control (AGC) - virtual WebRtc_Word32 SetAGC(bool enable); + virtual int32_t SetAGC(bool enable); virtual bool AGC() const; // Volume control based on the Windows Wave API (Windows only) - virtual WebRtc_Word32 SetWaveOutVolume(WebRtc_UWord16 volumeLeft, - WebRtc_UWord16 volumeRight); - virtual WebRtc_Word32 WaveOutVolume( - WebRtc_UWord16& volumeLeft, // NOLINT - WebRtc_UWord16& volumeRight) const; // NOLINT + virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight); + virtual int32_t WaveOutVolume( + uint16_t& volumeLeft, // NOLINT + uint16_t& volumeRight) const; // NOLINT // Audio mixer initialization - virtual WebRtc_Word32 SpeakerIsAvailable(bool& available); // NOLINT - virtual WebRtc_Word32 InitSpeaker(); + virtual int32_t SpeakerIsAvailable(bool& available); // NOLINT + virtual int32_t InitSpeaker(); virtual bool SpeakerIsInitialized() const; - virtual WebRtc_Word32 MicrophoneIsAvailable( + virtual int32_t MicrophoneIsAvailable( bool& available); - virtual WebRtc_Word32 InitMicrophone(); + virtual int32_t InitMicrophone(); virtual bool MicrophoneIsInitialized() const; // Speaker volume controls - virtual WebRtc_Word32 SpeakerVolumeIsAvailable( + virtual int32_t SpeakerVolumeIsAvailable( bool& available); // NOLINT - virtual WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 SpeakerVolume( - WebRtc_UWord32& volume) const; // NOLINT - virtual WebRtc_Word32 MaxSpeakerVolume( - WebRtc_UWord32& maxVolume) const; // NOLINT - virtual WebRtc_Word32 MinSpeakerVolume( - WebRtc_UWord32& minVolume) const; // NOLINT - virtual WebRtc_Word32 SpeakerVolumeStepSize( - WebRtc_UWord16& stepSize) const; // NOLINT + virtual int32_t SetSpeakerVolume(uint32_t volume); + virtual int32_t SpeakerVolume( + uint32_t& volume) const; // NOLINT + virtual int32_t MaxSpeakerVolume( + uint32_t& maxVolume) const; // NOLINT + virtual int32_t MinSpeakerVolume( + uint32_t& minVolume) const; // NOLINT + virtual int32_t SpeakerVolumeStepSize( + uint16_t& stepSize) const; // NOLINT // Microphone volume controls - virtual WebRtc_Word32 MicrophoneVolumeIsAvailable( + virtual int32_t MicrophoneVolumeIsAvailable( bool& available); // NOLINT - virtual WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 MicrophoneVolume( - WebRtc_UWord32& volume) const; // NOLINT - virtual WebRtc_Word32 MaxMicrophoneVolume( - WebRtc_UWord32& maxVolume) const; // NOLINT - virtual WebRtc_Word32 MinMicrophoneVolume( - WebRtc_UWord32& minVolume) const; // NOLINT - virtual WebRtc_Word32 - MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const; // NOLINT + virtual int32_t SetMicrophoneVolume(uint32_t volume); + virtual int32_t MicrophoneVolume( + uint32_t& volume) const; // NOLINT + virtual int32_t MaxMicrophoneVolume( + uint32_t& maxVolume) const; // NOLINT + virtual int32_t MinMicrophoneVolume( + uint32_t& minVolume) const; // NOLINT + virtual int32_t + MicrophoneVolumeStepSize(uint16_t& stepSize) const; // NOLINT // Speaker mute control - virtual WebRtc_Word32 SpeakerMuteIsAvailable(bool& available); // NOLINT - virtual WebRtc_Word32 SetSpeakerMute(bool enable); - virtual WebRtc_Word32 SpeakerMute(bool& enabled) const; // NOLINT + virtual int32_t SpeakerMuteIsAvailable(bool& available); // NOLINT + virtual int32_t SetSpeakerMute(bool enable); + virtual int32_t SpeakerMute(bool& enabled) const; // NOLINT // Microphone mute control - virtual WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available); // NOLINT - virtual WebRtc_Word32 SetMicrophoneMute(bool enable); - virtual WebRtc_Word32 MicrophoneMute(bool& enabled) const; // NOLINT + virtual int32_t MicrophoneMuteIsAvailable(bool& available); // NOLINT + virtual int32_t SetMicrophoneMute(bool enable); + virtual int32_t MicrophoneMute(bool& enabled) const; // NOLINT // Microphone boost control - virtual WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available); // NOLINT - virtual WebRtc_Word32 SetMicrophoneBoost(bool enable); - virtual WebRtc_Word32 MicrophoneBoost(bool& enabled) const; // NOLINT + virtual int32_t MicrophoneBoostIsAvailable(bool& available); // NOLINT + virtual int32_t SetMicrophoneBoost(bool enable); + virtual int32_t MicrophoneBoost(bool& enabled) const; // NOLINT // Stereo support - virtual WebRtc_Word32 StereoPlayoutIsAvailable(bool& available); // NOLINT - virtual WebRtc_Word32 SetStereoPlayout(bool enable); - virtual WebRtc_Word32 StereoPlayout(bool& enabled) const; // NOLINT - virtual WebRtc_Word32 StereoRecordingIsAvailable(bool& available); // NOLINT - virtual WebRtc_Word32 SetStereoRecording(bool enable); - virtual WebRtc_Word32 StereoRecording(bool& enabled) const; // NOLINT + virtual int32_t StereoPlayoutIsAvailable(bool& available); // NOLINT + virtual int32_t SetStereoPlayout(bool enable); + virtual int32_t StereoPlayout(bool& enabled) const; // NOLINT + virtual int32_t StereoRecordingIsAvailable(bool& available); // NOLINT + virtual int32_t SetStereoRecording(bool enable); + virtual int32_t StereoRecording(bool& enabled) const; // NOLINT // Delay information and control - virtual WebRtc_Word32 + virtual int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type, - WebRtc_UWord16 sizeMS); - virtual WebRtc_Word32 PlayoutBuffer( + uint16_t sizeMS); + virtual int32_t PlayoutBuffer( AudioDeviceModule::BufferType& type, // NOLINT - WebRtc_UWord16& sizeMS) const; - virtual WebRtc_Word32 PlayoutDelay( - WebRtc_UWord16& delayMS) const; // NOLINT - virtual WebRtc_Word32 RecordingDelay( - WebRtc_UWord16& delayMS) const; // NOLINT + uint16_t& sizeMS) const; + virtual int32_t PlayoutDelay( + uint16_t& delayMS) const; // NOLINT + virtual int32_t RecordingDelay( + uint16_t& delayMS) const; // NOLINT // CPU load - virtual WebRtc_Word32 CPULoad(WebRtc_UWord16& load) const; // NOLINT + virtual int32_t CPULoad(uint16_t& load) const; // NOLINT // Error and warning information virtual bool PlayoutWarning() const; @@ -208,8 +207,8 @@ class AudioDeviceAndroidOpenSLES: public AudioDeviceGeneric { virtual void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer); // Speaker audio routing - virtual WebRtc_Word32 SetLoudspeakerStatus(bool enable); - virtual WebRtc_Word32 GetLoudspeakerStatus(bool& enable) const; // NOLINT + virtual int32_t SetLoudspeakerStatus(bool enable); + virtual int32_t GetLoudspeakerStatus(bool& enable) const; // NOLINT private: // Lock @@ -234,15 +233,15 @@ class AudioDeviceAndroidOpenSLES: public AudioDeviceGeneric { // Delay updates void UpdateRecordingDelay(); - void UpdatePlayoutDelay(WebRtc_UWord32 nSamplePlayed); + void UpdatePlayoutDelay(uint32_t nSamplePlayed); // Init - WebRtc_Word32 InitSampleRate(); + int32_t InitSampleRate(); // Misc AudioDeviceBuffer* voe_audio_buffer_; CriticalSectionWrapper& crit_sect_; - WebRtc_Word32 id_; + int32_t id_; // audio unit SLObjectItf sles_engine_; @@ -260,10 +259,10 @@ class AudioDeviceAndroidOpenSLES: public AudioDeviceGeneric { SLRecordItf sles_recorder_itf_; SLAndroidSimpleBufferQueueItf sles_recorder_sbq_itf_; SLDeviceVolumeItf sles_mic_volume_; - WebRtc_UWord32 mic_dev_id_; + uint32_t mic_dev_id_; - WebRtc_UWord32 play_warning_, play_error_; - WebRtc_UWord32 rec_warning_, rec_error_; + uint32_t play_warning_, play_error_; + uint32_t rec_warning_, rec_error_; // States bool is_recording_dev_specified_; @@ -277,38 +276,38 @@ class AudioDeviceAndroidOpenSLES: public AudioDeviceGeneric { bool is_speaker_initialized_; // Delay - WebRtc_UWord16 playout_delay_; - WebRtc_UWord16 recording_delay_; + uint16_t playout_delay_; + uint16_t recording_delay_; // AGC state bool agc_enabled_; // Threads ThreadWrapper* rec_thread_; - WebRtc_UWord32 rec_thread_id_; + uint32_t rec_thread_id_; static bool RecThreadFunc(void* context); bool RecThreadFuncImpl(); EventWrapper& rec_timer_; - WebRtc_UWord32 mic_sampling_rate_; - WebRtc_UWord32 speaker_sampling_rate_; - WebRtc_UWord32 max_speaker_vol_; - WebRtc_UWord32 min_speaker_vol_; + uint32_t mic_sampling_rate_; + uint32_t speaker_sampling_rate_; + uint32_t max_speaker_vol_; + uint32_t min_speaker_vol_; bool loundspeaker_on_; SLDataFormat_PCM player_pcm_; SLDataFormat_PCM record_pcm_; - std::queue rec_queue_; - std::queue rec_voe_audio_queue_; - std::queue rec_voe_ready_queue_; - WebRtc_Word8 rec_buf_[N_REC_QUEUE_BUFFERS][ + std::queue rec_queue_; + std::queue rec_voe_audio_queue_; + std::queue rec_voe_ready_queue_; + int8_t rec_buf_[N_REC_QUEUE_BUFFERS][ N_REC_CHANNELS * sizeof(int16_t) * REC_BUF_SIZE_IN_SAMPLES]; - WebRtc_Word8 rec_voe_buf_[N_REC_QUEUE_BUFFERS][ + int8_t rec_voe_buf_[N_REC_QUEUE_BUFFERS][ N_REC_CHANNELS * sizeof(int16_t) * REC_BUF_SIZE_IN_SAMPLES]; - std::queue play_queue_; - WebRtc_Word8 play_buf_[N_PLAY_QUEUE_BUFFERS][ + std::queue play_queue_; + int8_t play_buf_[N_PLAY_QUEUE_BUFFERS][ N_PLAY_CHANNELS * sizeof(int16_t) * PLAY_BUF_SIZE_IN_SAMPLES]; }; diff --git a/webrtc/modules/audio_device/android/audio_device_utility_android.cc b/webrtc/modules/audio_device/android/audio_device_utility_android.cc index ccb15d335f..20d029049b 100644 --- a/webrtc/modules/audio_device/android/audio_device_utility_android.cc +++ b/webrtc/modules/audio_device/android/audio_device_utility_android.cc @@ -20,7 +20,7 @@ namespace webrtc { -AudioDeviceUtilityAndroid::AudioDeviceUtilityAndroid(const WebRtc_Word32 id) : +AudioDeviceUtilityAndroid::AudioDeviceUtilityAndroid(const int32_t id) : _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _id(id), _lastError(AudioDeviceModule::kAdmErrNone) { @@ -39,7 +39,7 @@ AudioDeviceUtilityAndroid::~AudioDeviceUtilityAndroid() delete &_critSect; } -WebRtc_Word32 AudioDeviceUtilityAndroid::Init() +int32_t AudioDeviceUtilityAndroid::Init() { WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, diff --git a/webrtc/modules/audio_device/android/audio_device_utility_android.h b/webrtc/modules/audio_device/android/audio_device_utility_android.h index 81f685af3e..a86896d4ba 100644 --- a/webrtc/modules/audio_device/android/audio_device_utility_android.h +++ b/webrtc/modules/audio_device/android/audio_device_utility_android.h @@ -25,14 +25,14 @@ class CriticalSectionWrapper; class AudioDeviceUtilityAndroid: public AudioDeviceUtility { public: - AudioDeviceUtilityAndroid(const WebRtc_Word32 id); + AudioDeviceUtilityAndroid(const int32_t id); ~AudioDeviceUtilityAndroid(); - virtual WebRtc_Word32 Init(); + virtual int32_t Init(); private: CriticalSectionWrapper& _critSect; - WebRtc_Word32 _id; + int32_t _id; AudioDeviceModule::ErrorCode _lastError; }; diff --git a/webrtc/modules/audio_device/audio_device_buffer.cc b/webrtc/modules/audio_device/audio_device_buffer.cc index 9aa01a6adb..ff9fd93f4b 100644 --- a/webrtc/modules/audio_device/audio_device_buffer.cc +++ b/webrtc/modules/audio_device/audio_device_buffer.cc @@ -88,7 +88,7 @@ AudioDeviceBuffer::~AudioDeviceBuffer() // SetId // ---------------------------------------------------------------------------- -void AudioDeviceBuffer::SetId(WebRtc_UWord32 id) +void AudioDeviceBuffer::SetId(uint32_t id) { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id, "AudioDeviceBuffer::SetId(id=%d)", id); _id = id; @@ -98,7 +98,7 @@ void AudioDeviceBuffer::SetId(WebRtc_UWord32 id) // RegisterAudioCallback // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::RegisterAudioCallback(AudioTransport* audioCallback) +int32_t AudioDeviceBuffer::RegisterAudioCallback(AudioTransport* audioCallback) { CriticalSectionScoped lock(&_critSectCb); _ptrCbAudioTransport = audioCallback; @@ -110,7 +110,7 @@ WebRtc_Word32 AudioDeviceBuffer::RegisterAudioCallback(AudioTransport* audioCall // InitPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::InitPlayout() +int32_t AudioDeviceBuffer::InitPlayout() { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -129,7 +129,7 @@ WebRtc_Word32 AudioDeviceBuffer::InitPlayout() // InitRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::InitRecording() +int32_t AudioDeviceBuffer::InitRecording() { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -148,7 +148,7 @@ WebRtc_Word32 AudioDeviceBuffer::InitRecording() // SetRecordingSampleRate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::SetRecordingSampleRate(WebRtc_UWord32 fsHz) +int32_t AudioDeviceBuffer::SetRecordingSampleRate(uint32_t fsHz) { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "AudioDeviceBuffer::SetRecordingSampleRate(fsHz=%u)", fsHz); @@ -161,7 +161,7 @@ WebRtc_Word32 AudioDeviceBuffer::SetRecordingSampleRate(WebRtc_UWord32 fsHz) // SetPlayoutSampleRate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::SetPlayoutSampleRate(WebRtc_UWord32 fsHz) +int32_t AudioDeviceBuffer::SetPlayoutSampleRate(uint32_t fsHz) { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "AudioDeviceBuffer::SetPlayoutSampleRate(fsHz=%u)", fsHz); @@ -174,7 +174,7 @@ WebRtc_Word32 AudioDeviceBuffer::SetPlayoutSampleRate(WebRtc_UWord32 fsHz) // RecordingSampleRate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::RecordingSampleRate() const +int32_t AudioDeviceBuffer::RecordingSampleRate() const { return _recSampleRate; } @@ -183,7 +183,7 @@ WebRtc_Word32 AudioDeviceBuffer::RecordingSampleRate() const // PlayoutSampleRate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::PlayoutSampleRate() const +int32_t AudioDeviceBuffer::PlayoutSampleRate() const { return _playSampleRate; } @@ -192,7 +192,7 @@ WebRtc_Word32 AudioDeviceBuffer::PlayoutSampleRate() const // SetRecordingChannels // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::SetRecordingChannels(WebRtc_UWord8 channels) +int32_t AudioDeviceBuffer::SetRecordingChannels(uint8_t channels) { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "AudioDeviceBuffer::SetRecordingChannels(channels=%u)", channels); @@ -206,7 +206,7 @@ WebRtc_Word32 AudioDeviceBuffer::SetRecordingChannels(WebRtc_UWord8 channels) // SetPlayoutChannels // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::SetPlayoutChannels(WebRtc_UWord8 channels) +int32_t AudioDeviceBuffer::SetPlayoutChannels(uint8_t channels) { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "AudioDeviceBuffer::SetPlayoutChannels(channels=%u)", channels); @@ -228,7 +228,7 @@ WebRtc_Word32 AudioDeviceBuffer::SetPlayoutChannels(WebRtc_UWord8 channels) // will be 2 instead of 4 four these cases. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::SetRecordingChannel(const AudioDeviceModule::ChannelType channel) +int32_t AudioDeviceBuffer::SetRecordingChannel(const AudioDeviceModule::ChannelType channel) { CriticalSectionScoped lock(&_critSect); @@ -256,7 +256,7 @@ WebRtc_Word32 AudioDeviceBuffer::SetRecordingChannel(const AudioDeviceModule::Ch // RecordingChannel // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::RecordingChannel(AudioDeviceModule::ChannelType& channel) const +int32_t AudioDeviceBuffer::RecordingChannel(AudioDeviceModule::ChannelType& channel) const { channel = _recChannel; return 0; @@ -266,7 +266,7 @@ WebRtc_Word32 AudioDeviceBuffer::RecordingChannel(AudioDeviceModule::ChannelType // RecordingChannels // ---------------------------------------------------------------------------- -WebRtc_UWord8 AudioDeviceBuffer::RecordingChannels() const +uint8_t AudioDeviceBuffer::RecordingChannels() const { return _recChannels; } @@ -275,7 +275,7 @@ WebRtc_UWord8 AudioDeviceBuffer::RecordingChannels() const // PlayoutChannels // ---------------------------------------------------------------------------- -WebRtc_UWord8 AudioDeviceBuffer::PlayoutChannels() const +uint8_t AudioDeviceBuffer::PlayoutChannels() const { return _playChannels; } @@ -284,7 +284,7 @@ WebRtc_UWord8 AudioDeviceBuffer::PlayoutChannels() const // SetCurrentMicLevel // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::SetCurrentMicLevel(WebRtc_UWord32 level) +int32_t AudioDeviceBuffer::SetCurrentMicLevel(uint32_t level) { _currentMicLevel = level; return 0; @@ -294,7 +294,7 @@ WebRtc_Word32 AudioDeviceBuffer::SetCurrentMicLevel(WebRtc_UWord32 level) // NewMicLevel // ---------------------------------------------------------------------------- -WebRtc_UWord32 AudioDeviceBuffer::NewMicLevel() const +uint32_t AudioDeviceBuffer::NewMicLevel() const { return _newMicLevel; } @@ -303,7 +303,7 @@ WebRtc_UWord32 AudioDeviceBuffer::NewMicLevel() const // SetVQEData // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::SetVQEData(WebRtc_UWord32 playDelayMS, WebRtc_UWord32 recDelayMS, WebRtc_Word32 clockDrift) +int32_t AudioDeviceBuffer::SetVQEData(uint32_t playDelayMS, uint32_t recDelayMS, int32_t clockDrift) { if ((playDelayMS + recDelayMS) > 300) { @@ -321,7 +321,7 @@ WebRtc_Word32 AudioDeviceBuffer::SetVQEData(WebRtc_UWord32 playDelayMS, WebRtc_U // StartInputFileRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::StartInputFileRecording( +int32_t AudioDeviceBuffer::StartInputFileRecording( const char fileName[kAdmMaxFileNameSize]) { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -338,7 +338,7 @@ WebRtc_Word32 AudioDeviceBuffer::StartInputFileRecording( // StopInputFileRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::StopInputFileRecording() +int32_t AudioDeviceBuffer::StopInputFileRecording() { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -354,7 +354,7 @@ WebRtc_Word32 AudioDeviceBuffer::StopInputFileRecording() // StartOutputFileRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::StartOutputFileRecording( +int32_t AudioDeviceBuffer::StartOutputFileRecording( const char fileName[kAdmMaxFileNameSize]) { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -371,7 +371,7 @@ WebRtc_Word32 AudioDeviceBuffer::StartOutputFileRecording( // StopOutputFileRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::StopOutputFileRecording() +int32_t AudioDeviceBuffer::StopOutputFileRecording() { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -398,8 +398,8 @@ WebRtc_Word32 AudioDeviceBuffer::StopOutputFileRecording() // 16-bit,48kHz stereo,10ms => nSamples=480 => _recSize=4*480=1920 bytes // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::SetRecordedBuffer(const void* audioBuffer, - WebRtc_UWord32 nSamples) +int32_t AudioDeviceBuffer::SetRecordedBuffer(const void* audioBuffer, + uint32_t nSamples) { CriticalSectionScoped lock(&_critSect); @@ -430,8 +430,8 @@ WebRtc_Word32 AudioDeviceBuffer::SetRecordedBuffer(const void* audioBuffer, } else { - WebRtc_Word16* ptr16In = (WebRtc_Word16*)audioBuffer; - WebRtc_Word16* ptr16Out = (WebRtc_Word16*)&_recBuffer[0]; + int16_t* ptr16In = (int16_t*)audioBuffer; + int16_t* ptr16Out = (int16_t*)&_recBuffer[0]; if (AudioDeviceModule::kChannelRight == _recChannel) { @@ -439,7 +439,7 @@ WebRtc_Word32 AudioDeviceBuffer::SetRecordedBuffer(const void* audioBuffer, } // exctract left or right channel from input buffer to the local buffer - for (WebRtc_UWord32 i = 0; i < _recSamples; i++) + for (uint32_t i = 0; i < _recSamples; i++) { *ptr16Out = *ptr16In; ptr16Out++; @@ -461,7 +461,7 @@ WebRtc_Word32 AudioDeviceBuffer::SetRecordedBuffer(const void* audioBuffer, // DeliverRecordedData // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::DeliverRecordedData() +int32_t AudioDeviceBuffer::DeliverRecordedData() { CriticalSectionScoped lock(&_critSectCb); @@ -481,22 +481,22 @@ WebRtc_Word32 AudioDeviceBuffer::DeliverRecordedData() return 0; } - WebRtc_Word32 res(0); - WebRtc_UWord32 newMicLevel(0); - WebRtc_UWord32 totalDelayMS = _playDelayMS +_recDelayMS; + int32_t res(0); + uint32_t newMicLevel(0); + uint32_t totalDelayMS = _playDelayMS +_recDelayMS; if (_measureDelay) { CriticalSectionScoped lock(&_critSect); memset(&_recBuffer[0], 0, _recSize); - WebRtc_UWord32 time = AudioDeviceUtility::GetTimeInMS(); + uint32_t time = AudioDeviceUtility::GetTimeInMS(); if (time - _lastPulseTime > 500) { _pulseList.PushBack(time); _lastPulseTime = time; - WebRtc_Word16* ptr16 = (WebRtc_Word16*)&_recBuffer[0]; + int16_t* ptr16 = (int16_t*)&_recBuffer[0]; *ptr16 = 30000; } } @@ -522,11 +522,11 @@ WebRtc_Word32 AudioDeviceBuffer::DeliverRecordedData() // RequestPlayoutData // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::RequestPlayoutData(WebRtc_UWord32 nSamples) +int32_t AudioDeviceBuffer::RequestPlayoutData(uint32_t nSamples) { - WebRtc_UWord32 playSampleRate = 0; - WebRtc_UWord8 playBytesPerSample = 0; - WebRtc_UWord8 playChannels = 0; + uint32_t playSampleRate = 0; + uint8_t playBytesPerSample = 0; + uint8_t playChannels = 0; { CriticalSectionScoped lock(&_critSect); @@ -560,7 +560,7 @@ WebRtc_Word32 AudioDeviceBuffer::RequestPlayoutData(WebRtc_UWord32 nSamples) } } - WebRtc_UWord32 nSamplesOut(0); + uint32_t nSamplesOut(0); CriticalSectionScoped lock(&_critSectCb); @@ -572,7 +572,7 @@ WebRtc_Word32 AudioDeviceBuffer::RequestPlayoutData(WebRtc_UWord32 nSamples) if (_ptrCbAudioTransport) { - WebRtc_UWord32 res(0); + uint32_t res(0); res = _ptrCbAudioTransport->NeedMorePlayData(_playSamples, playBytesPerSample, @@ -592,19 +592,19 @@ WebRtc_Word32 AudioDeviceBuffer::RequestPlayoutData(WebRtc_UWord32 nSamples) { CriticalSectionScoped lock(&_critSect); - WebRtc_Word16 maxAbs = WebRtcSpl_MaxAbsValueW16((const WebRtc_Word16*)&_playBuffer[0], (WebRtc_Word16)nSamplesOut*_playChannels); + int16_t maxAbs = WebRtcSpl_MaxAbsValueW16((const int16_t*)&_playBuffer[0], (int16_t)nSamplesOut*_playChannels); if (maxAbs > 1000) { - WebRtc_UWord32 nowTime = AudioDeviceUtility::GetTimeInMS(); + uint32_t nowTime = AudioDeviceUtility::GetTimeInMS(); if (!_pulseList.Empty()) { ListItem* item = _pulseList.First(); if (item) { - WebRtc_Word16 maxIndex = WebRtcSpl_MaxAbsIndexW16((const WebRtc_Word16*)&_playBuffer[0], (WebRtc_Word16)nSamplesOut*_playChannels); - WebRtc_UWord32 pulseTime = item->GetUnsignedItem(); - WebRtc_UWord32 diff = nowTime - pulseTime + (10*maxIndex)/(nSamplesOut*_playChannels); + int16_t maxIndex = WebRtcSpl_MaxAbsIndexW16((const int16_t*)&_playBuffer[0], (int16_t)nSamplesOut*_playChannels); + uint32_t pulseTime = item->GetUnsignedItem(); + uint32_t diff = nowTime - pulseTime + (10*maxIndex)/(nSamplesOut*_playChannels); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "diff time in playout delay (%d)", diff); } _pulseList.PopFront(); @@ -620,7 +620,7 @@ WebRtc_Word32 AudioDeviceBuffer::RequestPlayoutData(WebRtc_UWord32 nSamples) // GetPlayoutData // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceBuffer::GetPlayoutData(void* audioBuffer) +int32_t AudioDeviceBuffer::GetPlayoutData(void* audioBuffer) { CriticalSectionScoped lock(&_critSect); @@ -654,7 +654,7 @@ void AudioDeviceBuffer::_EmptyList() ListItem* item = _pulseList.First(); if (item) { - // WebRtc_UWord32 ts = item->GetUnsignedItem(); + // uint32_t ts = item->GetUnsignedItem(); } _pulseList.PopFront(); } diff --git a/webrtc/modules/audio_device/audio_device_buffer.h b/webrtc/modules/audio_device/audio_device_buffer.h index b7c4fc85a9..25bb9bd9f2 100644 --- a/webrtc/modules/audio_device/audio_device_buffer.h +++ b/webrtc/modules/audio_device/audio_device_buffer.h @@ -20,8 +20,8 @@ namespace webrtc { class CriticalSectionWrapper; -const WebRtc_UWord32 kPulsePeriodMs = 1000; -const WebRtc_UWord32 kMaxBufferSizeBytes = 3840; // 10ms in stereo @ 96kHz +const uint32_t kPulsePeriodMs = 1000; +const uint32_t kMaxBufferSizeBytes = 3840; // 10ms in stereo @ 96kHz class AudioDeviceObserver; class MediaFile; @@ -29,44 +29,43 @@ class MediaFile; class AudioDeviceBuffer { public: - void SetId(WebRtc_UWord32 id); - WebRtc_Word32 RegisterAudioCallback(AudioTransport* audioCallback); + void SetId(uint32_t id); + int32_t RegisterAudioCallback(AudioTransport* audioCallback); - WebRtc_Word32 InitPlayout(); - WebRtc_Word32 InitRecording(); + int32_t InitPlayout(); + int32_t InitRecording(); - WebRtc_Word32 SetRecordingSampleRate(WebRtc_UWord32 fsHz); - WebRtc_Word32 SetPlayoutSampleRate(WebRtc_UWord32 fsHz); - WebRtc_Word32 RecordingSampleRate() const; - WebRtc_Word32 PlayoutSampleRate() const; + int32_t SetRecordingSampleRate(uint32_t fsHz); + int32_t SetPlayoutSampleRate(uint32_t fsHz); + int32_t RecordingSampleRate() const; + int32_t PlayoutSampleRate() const; - WebRtc_Word32 SetRecordingChannels(WebRtc_UWord8 channels); - WebRtc_Word32 SetPlayoutChannels(WebRtc_UWord8 channels); - WebRtc_UWord8 RecordingChannels() const; - WebRtc_UWord8 PlayoutChannels() const; - WebRtc_Word32 SetRecordingChannel( + int32_t SetRecordingChannels(uint8_t channels); + int32_t SetPlayoutChannels(uint8_t channels); + uint8_t RecordingChannels() const; + uint8_t PlayoutChannels() const; + int32_t SetRecordingChannel( const AudioDeviceModule::ChannelType channel); - WebRtc_Word32 RecordingChannel( + int32_t RecordingChannel( AudioDeviceModule::ChannelType& channel) const; - WebRtc_Word32 SetRecordedBuffer(const void* audioBuffer, - WebRtc_UWord32 nSamples); - WebRtc_Word32 SetCurrentMicLevel(WebRtc_UWord32 level); - WebRtc_Word32 SetVQEData(WebRtc_UWord32 playDelayMS, - WebRtc_UWord32 recDelayMS, - WebRtc_Word32 clockDrift); - WebRtc_Word32 DeliverRecordedData(); - WebRtc_UWord32 NewMicLevel() const; + int32_t SetRecordedBuffer(const void* audioBuffer, uint32_t nSamples); + int32_t SetCurrentMicLevel(uint32_t level); + int32_t SetVQEData(uint32_t playDelayMS, + uint32_t recDelayMS, + int32_t clockDrift); + int32_t DeliverRecordedData(); + uint32_t NewMicLevel() const; - WebRtc_Word32 RequestPlayoutData(WebRtc_UWord32 nSamples); - WebRtc_Word32 GetPlayoutData(void* audioBuffer); + int32_t RequestPlayoutData(uint32_t nSamples); + int32_t GetPlayoutData(void* audioBuffer); - WebRtc_Word32 StartInputFileRecording( + int32_t StartInputFileRecording( const char fileName[kAdmMaxFileNameSize]); - WebRtc_Word32 StopInputFileRecording(); - WebRtc_Word32 StartOutputFileRecording( + int32_t StopInputFileRecording(); + int32_t StartOutputFileRecording( const char fileName[kAdmMaxFileNameSize]); - WebRtc_Word32 StopOutputFileRecording(); + int32_t StopOutputFileRecording(); AudioDeviceBuffer(); ~AudioDeviceBuffer(); @@ -75,53 +74,53 @@ private: void _EmptyList(); private: - WebRtc_Word32 _id; + int32_t _id; CriticalSectionWrapper& _critSect; CriticalSectionWrapper& _critSectCb; AudioTransport* _ptrCbAudioTransport; - WebRtc_UWord32 _recSampleRate; - WebRtc_UWord32 _playSampleRate; + uint32_t _recSampleRate; + uint32_t _playSampleRate; - WebRtc_UWord8 _recChannels; - WebRtc_UWord8 _playChannels; + uint8_t _recChannels; + uint8_t _playChannels; // selected recording channel (left/right/both) AudioDeviceModule::ChannelType _recChannel; // 2 or 4 depending on mono or stereo - WebRtc_UWord8 _recBytesPerSample; - WebRtc_UWord8 _playBytesPerSample; + uint8_t _recBytesPerSample; + uint8_t _playBytesPerSample; // 10ms in stereo @ 96kHz int8_t _recBuffer[kMaxBufferSizeBytes]; // one sample <=> 2 or 4 bytes - WebRtc_UWord32 _recSamples; - WebRtc_UWord32 _recSize; // in bytes + uint32_t _recSamples; + uint32_t _recSize; // in bytes // 10ms in stereo @ 96kHz int8_t _playBuffer[kMaxBufferSizeBytes]; // one sample <=> 2 or 4 bytes - WebRtc_UWord32 _playSamples; - WebRtc_UWord32 _playSize; // in bytes + uint32_t _playSamples; + uint32_t _playSize; // in bytes FileWrapper& _recFile; FileWrapper& _playFile; - WebRtc_UWord32 _currentMicLevel; - WebRtc_UWord32 _newMicLevel; + uint32_t _currentMicLevel; + uint32_t _newMicLevel; - WebRtc_UWord32 _playDelayMS; - WebRtc_UWord32 _recDelayMS; + uint32_t _playDelayMS; + uint32_t _recDelayMS; - WebRtc_Word32 _clockDrift; + int32_t _clockDrift; bool _measureDelay; ListWrapper _pulseList; - WebRtc_UWord32 _lastPulseTime; + uint32_t _lastPulseTime; }; } // namespace webrtc diff --git a/webrtc/modules/audio_device/audio_device_generic.cc b/webrtc/modules/audio_device/audio_device_generic.cc index 7093d801f7..27ea604095 100644 --- a/webrtc/modules/audio_device/audio_device_generic.cc +++ b/webrtc/modules/audio_device/audio_device_generic.cc @@ -13,44 +13,44 @@ namespace webrtc { -WebRtc_Word32 AudioDeviceGeneric::SetRecordingSampleRate( - const WebRtc_UWord32 samplesPerSec) +int32_t AudioDeviceGeneric::SetRecordingSampleRate( + const uint32_t samplesPerSec) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, -1, "Set recording sample rate not supported on this platform"); return -1; } -WebRtc_Word32 AudioDeviceGeneric::SetPlayoutSampleRate( - const WebRtc_UWord32 samplesPerSec) +int32_t AudioDeviceGeneric::SetPlayoutSampleRate( + const uint32_t samplesPerSec) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, -1, "Set playout sample rate not supported on this platform"); return -1; } - -WebRtc_Word32 AudioDeviceGeneric::SetLoudspeakerStatus(bool enable) + +int32_t AudioDeviceGeneric::SetLoudspeakerStatus(bool enable) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, -1, "Set loudspeaker status not supported on this platform"); return -1; } -WebRtc_Word32 AudioDeviceGeneric::GetLoudspeakerStatus(bool& enable) const +int32_t AudioDeviceGeneric::GetLoudspeakerStatus(bool& enable) const { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, -1, "Get loudspeaker status not supported on this platform"); return -1; } -WebRtc_Word32 AudioDeviceGeneric::ResetAudioDevice() +int32_t AudioDeviceGeneric::ResetAudioDevice() { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, -1, "Reset audio device not supported on this platform"); return -1; } -WebRtc_Word32 AudioDeviceGeneric::SoundDeviceControl(unsigned int par1, +int32_t AudioDeviceGeneric::SoundDeviceControl(unsigned int par1, unsigned int par2, unsigned int par3, unsigned int par4) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, -1, diff --git a/webrtc/modules/audio_device/audio_device_generic.h b/webrtc/modules/audio_device/audio_device_generic.h index 0c14448ef0..0136790041 100644 --- a/webrtc/modules/audio_device/audio_device_generic.h +++ b/webrtc/modules/audio_device/audio_device_generic.h @@ -21,141 +21,141 @@ class AudioDeviceGeneric public: // Retrieve the currently utilized audio layer - virtual WebRtc_Word32 ActiveAudioLayer( + virtual int32_t ActiveAudioLayer( AudioDeviceModule::AudioLayer& audioLayer) const = 0; // Main initializaton and termination - virtual WebRtc_Word32 Init() = 0; - virtual WebRtc_Word32 Terminate() = 0; + virtual int32_t Init() = 0; + virtual int32_t Terminate() = 0; virtual bool Initialized() const = 0; // Device enumeration - virtual WebRtc_Word16 PlayoutDevices() = 0; - virtual WebRtc_Word16 RecordingDevices() = 0; - virtual WebRtc_Word32 PlayoutDeviceName( - WebRtc_UWord16 index, + virtual int16_t PlayoutDevices() = 0; + virtual int16_t RecordingDevices() = 0; + virtual int32_t PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) = 0; - virtual WebRtc_Word32 RecordingDeviceName( - WebRtc_UWord16 index, + virtual int32_t RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) = 0; // Device selection - virtual WebRtc_Word32 SetPlayoutDevice(WebRtc_UWord16 index) = 0; - virtual WebRtc_Word32 SetPlayoutDevice( + virtual int32_t SetPlayoutDevice(uint16_t index) = 0; + virtual int32_t SetPlayoutDevice( AudioDeviceModule::WindowsDeviceType device) = 0; - virtual WebRtc_Word32 SetRecordingDevice(WebRtc_UWord16 index) = 0; - virtual WebRtc_Word32 SetRecordingDevice( + virtual int32_t SetRecordingDevice(uint16_t index) = 0; + virtual int32_t SetRecordingDevice( AudioDeviceModule::WindowsDeviceType device) = 0; // Audio transport initialization - virtual WebRtc_Word32 PlayoutIsAvailable(bool& available) = 0; - virtual WebRtc_Word32 InitPlayout() = 0; + virtual int32_t PlayoutIsAvailable(bool& available) = 0; + virtual int32_t InitPlayout() = 0; virtual bool PlayoutIsInitialized() const = 0; - virtual WebRtc_Word32 RecordingIsAvailable(bool& available) = 0; - virtual WebRtc_Word32 InitRecording() = 0; + virtual int32_t RecordingIsAvailable(bool& available) = 0; + virtual int32_t InitRecording() = 0; virtual bool RecordingIsInitialized() const = 0; // Audio transport control - virtual WebRtc_Word32 StartPlayout() = 0; - virtual WebRtc_Word32 StopPlayout() = 0; + virtual int32_t StartPlayout() = 0; + virtual int32_t StopPlayout() = 0; virtual bool Playing() const = 0; - virtual WebRtc_Word32 StartRecording() = 0; - virtual WebRtc_Word32 StopRecording() = 0; + virtual int32_t StartRecording() = 0; + virtual int32_t StopRecording() = 0; virtual bool Recording() const = 0; // Microphone Automatic Gain Control (AGC) - virtual WebRtc_Word32 SetAGC(bool enable) = 0; + virtual int32_t SetAGC(bool enable) = 0; virtual bool AGC() const = 0; // Volume control based on the Windows Wave API (Windows only) - virtual WebRtc_Word32 SetWaveOutVolume(WebRtc_UWord16 volumeLeft, - WebRtc_UWord16 volumeRight) = 0; - virtual WebRtc_Word32 WaveOutVolume(WebRtc_UWord16& volumeLeft, - WebRtc_UWord16& volumeRight) const = 0; + virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, + uint16_t volumeRight) = 0; + virtual int32_t WaveOutVolume(uint16_t& volumeLeft, + uint16_t& volumeRight) const = 0; // Audio mixer initialization - virtual WebRtc_Word32 SpeakerIsAvailable(bool& available) = 0; - virtual WebRtc_Word32 InitSpeaker() = 0; + virtual int32_t SpeakerIsAvailable(bool& available) = 0; + virtual int32_t InitSpeaker() = 0; virtual bool SpeakerIsInitialized() const = 0; - virtual WebRtc_Word32 MicrophoneIsAvailable(bool& available) = 0; - virtual WebRtc_Word32 InitMicrophone() = 0; + virtual int32_t MicrophoneIsAvailable(bool& available) = 0; + virtual int32_t InitMicrophone() = 0; virtual bool MicrophoneIsInitialized() const = 0; // Speaker volume controls - virtual WebRtc_Word32 SpeakerVolumeIsAvailable(bool& available) = 0; - virtual WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume) = 0; - virtual WebRtc_Word32 SpeakerVolume(WebRtc_UWord32& volume) const = 0; - virtual WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const = 0; - virtual WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32& minVolume) const = 0; - virtual WebRtc_Word32 SpeakerVolumeStepSize( - WebRtc_UWord16& stepSize) const = 0; + virtual int32_t SpeakerVolumeIsAvailable(bool& available) = 0; + virtual int32_t SetSpeakerVolume(uint32_t volume) = 0; + virtual int32_t SpeakerVolume(uint32_t& volume) const = 0; + virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const = 0; + virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const = 0; + virtual int32_t SpeakerVolumeStepSize( + uint16_t& stepSize) const = 0; // Microphone volume controls - virtual WebRtc_Word32 MicrophoneVolumeIsAvailable(bool& available) = 0; - virtual WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume) = 0; - virtual WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32& volume) const = 0; - virtual WebRtc_Word32 MaxMicrophoneVolume( - WebRtc_UWord32& maxVolume) const = 0; - virtual WebRtc_Word32 MinMicrophoneVolume( - WebRtc_UWord32& minVolume) const = 0; - virtual WebRtc_Word32 MicrophoneVolumeStepSize( - WebRtc_UWord16& stepSize) const = 0; + virtual int32_t MicrophoneVolumeIsAvailable(bool& available) = 0; + virtual int32_t SetMicrophoneVolume(uint32_t volume) = 0; + virtual int32_t MicrophoneVolume(uint32_t& volume) const = 0; + virtual int32_t MaxMicrophoneVolume( + uint32_t& maxVolume) const = 0; + virtual int32_t MinMicrophoneVolume( + uint32_t& minVolume) const = 0; + virtual int32_t MicrophoneVolumeStepSize( + uint16_t& stepSize) const = 0; // Speaker mute control - virtual WebRtc_Word32 SpeakerMuteIsAvailable(bool& available) = 0; - virtual WebRtc_Word32 SetSpeakerMute(bool enable) = 0; - virtual WebRtc_Word32 SpeakerMute(bool& enabled) const = 0; + virtual int32_t SpeakerMuteIsAvailable(bool& available) = 0; + virtual int32_t SetSpeakerMute(bool enable) = 0; + virtual int32_t SpeakerMute(bool& enabled) const = 0; // Microphone mute control - virtual WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available) = 0; - virtual WebRtc_Word32 SetMicrophoneMute(bool enable) = 0; - virtual WebRtc_Word32 MicrophoneMute(bool& enabled) const = 0; + virtual int32_t MicrophoneMuteIsAvailable(bool& available) = 0; + virtual int32_t SetMicrophoneMute(bool enable) = 0; + virtual int32_t MicrophoneMute(bool& enabled) const = 0; // Microphone boost control - virtual WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available) = 0; - virtual WebRtc_Word32 SetMicrophoneBoost(bool enable) = 0; - virtual WebRtc_Word32 MicrophoneBoost(bool& enabled) const = 0; + virtual int32_t MicrophoneBoostIsAvailable(bool& available) = 0; + virtual int32_t SetMicrophoneBoost(bool enable) = 0; + virtual int32_t MicrophoneBoost(bool& enabled) const = 0; // Stereo support - virtual WebRtc_Word32 StereoPlayoutIsAvailable(bool& available) = 0; - virtual WebRtc_Word32 SetStereoPlayout(bool enable) = 0; - virtual WebRtc_Word32 StereoPlayout(bool& enabled) const = 0; - virtual WebRtc_Word32 StereoRecordingIsAvailable(bool& available) = 0; - virtual WebRtc_Word32 SetStereoRecording(bool enable) = 0; - virtual WebRtc_Word32 StereoRecording(bool& enabled) const = 0; + virtual int32_t StereoPlayoutIsAvailable(bool& available) = 0; + virtual int32_t SetStereoPlayout(bool enable) = 0; + virtual int32_t StereoPlayout(bool& enabled) const = 0; + virtual int32_t StereoRecordingIsAvailable(bool& available) = 0; + virtual int32_t SetStereoRecording(bool enable) = 0; + virtual int32_t StereoRecording(bool& enabled) const = 0; // Delay information and control - virtual WebRtc_Word32 SetPlayoutBuffer( + virtual int32_t SetPlayoutBuffer( const AudioDeviceModule::BufferType type, - WebRtc_UWord16 sizeMS = 0) = 0; - virtual WebRtc_Word32 PlayoutBuffer( - AudioDeviceModule::BufferType& type, WebRtc_UWord16& sizeMS) const = 0; - virtual WebRtc_Word32 PlayoutDelay(WebRtc_UWord16& delayMS) const = 0; - virtual WebRtc_Word32 RecordingDelay(WebRtc_UWord16& delayMS) const = 0; + uint16_t sizeMS = 0) = 0; + virtual int32_t PlayoutBuffer( + AudioDeviceModule::BufferType& type, uint16_t& sizeMS) const = 0; + virtual int32_t PlayoutDelay(uint16_t& delayMS) const = 0; + virtual int32_t RecordingDelay(uint16_t& delayMS) const = 0; // CPU load - virtual WebRtc_Word32 CPULoad(WebRtc_UWord16& load) const = 0; + virtual int32_t CPULoad(uint16_t& load) const = 0; // Native sample rate controls (samples/sec) - virtual WebRtc_Word32 SetRecordingSampleRate( - const WebRtc_UWord32 samplesPerSec); - virtual WebRtc_Word32 SetPlayoutSampleRate( - const WebRtc_UWord32 samplesPerSec); + virtual int32_t SetRecordingSampleRate( + const uint32_t samplesPerSec); + virtual int32_t SetPlayoutSampleRate( + const uint32_t samplesPerSec); // Speaker audio routing (for mobile devices) - virtual WebRtc_Word32 SetLoudspeakerStatus(bool enable); - virtual WebRtc_Word32 GetLoudspeakerStatus(bool& enable) const; + virtual int32_t SetLoudspeakerStatus(bool enable); + virtual int32_t GetLoudspeakerStatus(bool& enable) const; // Reset Audio Device (for mobile devices) - virtual WebRtc_Word32 ResetAudioDevice(); + virtual int32_t ResetAudioDevice(); // Sound Audio Device control (for WinCE only) - virtual WebRtc_Word32 SoundDeviceControl(unsigned int par1 = 0, - unsigned int par2 = 0, - unsigned int par3 = 0, - unsigned int par4 = 0); + virtual int32_t SoundDeviceControl(unsigned int par1 = 0, + unsigned int par2 = 0, + unsigned int par3 = 0, + unsigned int par4 = 0); // Windows Core Audio only. virtual int32_t EnableBuiltInAEC(bool enable); diff --git a/webrtc/modules/audio_device/audio_device_impl.cc b/webrtc/modules/audio_device/audio_device_impl.cc index c7c87e66f3..978a7b6573 100644 --- a/webrtc/modules/audio_device/audio_device_impl.cc +++ b/webrtc/modules/audio_device/audio_device_impl.cc @@ -68,7 +68,7 @@ namespace webrtc { AudioDeviceModule* CreateAudioDeviceModule( - WebRtc_Word32 id, AudioDeviceModule::AudioLayer audioLayer) { + int32_t id, AudioDeviceModule::AudioLayer audioLayer) { return AudioDeviceModuleImpl::Create(id, audioLayer); } @@ -81,7 +81,7 @@ AudioDeviceModule* CreateAudioDeviceModule( // AudioDeviceModule::Create() // ---------------------------------------------------------------------------- -AudioDeviceModule* AudioDeviceModuleImpl::Create(const WebRtc_Word32 id, +AudioDeviceModule* AudioDeviceModuleImpl::Create(const int32_t id, const AudioLayer audioLayer) { @@ -124,7 +124,7 @@ AudioDeviceModule* AudioDeviceModuleImpl::Create(const WebRtc_Word32 id, // AudioDeviceModuleImpl - ctor // ---------------------------------------------------------------------------- -AudioDeviceModuleImpl::AudioDeviceModuleImpl(const WebRtc_Word32 id, const AudioLayer audioLayer) : +AudioDeviceModuleImpl::AudioDeviceModuleImpl(const int32_t id, const AudioLayer audioLayer) : _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _critSectEventCb(*CriticalSectionWrapper::CreateCriticalSection()), _critSectAudioCb(*CriticalSectionWrapper::CreateCriticalSection()), @@ -145,7 +145,7 @@ AudioDeviceModuleImpl::AudioDeviceModuleImpl(const WebRtc_Word32 id, const Audio // CheckPlatform // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::CheckPlatform() +int32_t AudioDeviceModuleImpl::CheckPlatform() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -188,7 +188,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::CheckPlatform() // CreatePlatformSpecificObjects // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::CreatePlatformSpecificObjects() +int32_t AudioDeviceModuleImpl::CreatePlatformSpecificObjects() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -420,7 +420,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::CreatePlatformSpecificObjects() // number of channels in this function call. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::AttachAudioBuffer() +int32_t AudioDeviceModuleImpl::AttachAudioBuffer() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -462,7 +462,7 @@ AudioDeviceModuleImpl::~AudioDeviceModuleImpl() // Module::ChangeUniqueId // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::ChangeUniqueId(const WebRtc_Word32 id) +int32_t AudioDeviceModuleImpl::ChangeUniqueId(const int32_t id) { _id = id; return 0; @@ -475,10 +475,10 @@ WebRtc_Word32 AudioDeviceModuleImpl::ChangeUniqueId(const WebRtc_Word32 id) // to call Process(). // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::TimeUntilNextProcess() +int32_t AudioDeviceModuleImpl::TimeUntilNextProcess() { - WebRtc_UWord32 now = AudioDeviceUtility::GetTimeInMS(); - WebRtc_Word32 deltaProcess = kAdmMaxIdleTimeProcess - (now - _lastProcessTime); + uint32_t now = AudioDeviceUtility::GetTimeInMS(); + int32_t deltaProcess = kAdmMaxIdleTimeProcess - (now - _lastProcessTime); return (deltaProcess); } @@ -489,7 +489,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::TimeUntilNextProcess() // new reports exists. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::Process() +int32_t AudioDeviceModuleImpl::Process() { _lastProcessTime = AudioDeviceUtility::GetTimeInMS(); @@ -553,7 +553,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::Process() // ActiveAudioLayer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::ActiveAudioLayer(AudioLayer* audioLayer) const +int32_t AudioDeviceModuleImpl::ActiveAudioLayer(AudioLayer* audioLayer) const { AudioLayer activeAudio; @@ -598,7 +598,7 @@ AudioDeviceModule::ErrorCode AudioDeviceModuleImpl::LastError() const // Init // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::Init() +int32_t AudioDeviceModuleImpl::Init() { if (_initialized) @@ -625,7 +625,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::Init() // Terminate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::Terminate() +int32_t AudioDeviceModuleImpl::Terminate() { if (!_initialized) @@ -655,7 +655,7 @@ bool AudioDeviceModuleImpl::Initialized() const // SpeakerIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SpeakerIsAvailable(bool* available) +int32_t AudioDeviceModuleImpl::SpeakerIsAvailable(bool* available) { CHECK_INITIALIZED(); @@ -676,7 +676,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SpeakerIsAvailable(bool* available) // InitSpeaker // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::InitSpeaker() +int32_t AudioDeviceModuleImpl::InitSpeaker() { CHECK_INITIALIZED(); return (_ptrAudioDevice->InitSpeaker()); @@ -686,7 +686,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::InitSpeaker() // MicrophoneIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneIsAvailable(bool* available) +int32_t AudioDeviceModuleImpl::MicrophoneIsAvailable(bool* available) { CHECK_INITIALIZED(); @@ -707,7 +707,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneIsAvailable(bool* available) // InitMicrophone // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::InitMicrophone() +int32_t AudioDeviceModuleImpl::InitMicrophone() { CHECK_INITIALIZED(); return (_ptrAudioDevice->InitMicrophone()); @@ -717,7 +717,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::InitMicrophone() // SpeakerVolumeIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SpeakerVolumeIsAvailable(bool* available) +int32_t AudioDeviceModuleImpl::SpeakerVolumeIsAvailable(bool* available) { CHECK_INITIALIZED(); @@ -738,7 +738,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SpeakerVolumeIsAvailable(bool* available) // SetSpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetSpeakerVolume(WebRtc_UWord32 volume) +int32_t AudioDeviceModuleImpl::SetSpeakerVolume(uint32_t volume) { CHECK_INITIALIZED(); return (_ptrAudioDevice->SetSpeakerVolume(volume)); @@ -748,11 +748,11 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetSpeakerVolume(WebRtc_UWord32 volume) // SpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SpeakerVolume(WebRtc_UWord32* volume) const +int32_t AudioDeviceModuleImpl::SpeakerVolume(uint32_t* volume) const { CHECK_INITIALIZED(); - WebRtc_UWord32 level(0); + uint32_t level(0); if (_ptrAudioDevice->SpeakerVolume(level) == -1) { @@ -769,7 +769,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SpeakerVolume(WebRtc_UWord32* volume) const // SetWaveOutVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetWaveOutVolume(WebRtc_UWord16 volumeLeft, WebRtc_UWord16 volumeRight) +int32_t AudioDeviceModuleImpl::SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight) { CHECK_INITIALIZED(); return (_ptrAudioDevice->SetWaveOutVolume(volumeLeft, volumeRight)); @@ -779,12 +779,12 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetWaveOutVolume(WebRtc_UWord16 volumeLeft, // WaveOutVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::WaveOutVolume(WebRtc_UWord16* volumeLeft, WebRtc_UWord16* volumeRight) const +int32_t AudioDeviceModuleImpl::WaveOutVolume(uint16_t* volumeLeft, uint16_t* volumeRight) const { CHECK_INITIALIZED(); - WebRtc_UWord16 volLeft(0); - WebRtc_UWord16 volRight(0); + uint16_t volLeft(0); + uint16_t volRight(0); if (_ptrAudioDevice->WaveOutVolume(volLeft, volRight) == -1) { @@ -832,11 +832,11 @@ bool AudioDeviceModuleImpl::MicrophoneIsInitialized() const // MaxSpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::MaxSpeakerVolume(WebRtc_UWord32* maxVolume) const +int32_t AudioDeviceModuleImpl::MaxSpeakerVolume(uint32_t* maxVolume) const { CHECK_INITIALIZED(); - WebRtc_UWord32 maxVol(0); + uint32_t maxVol(0); if (_ptrAudioDevice->MaxSpeakerVolume(maxVol) == -1) { @@ -853,11 +853,11 @@ WebRtc_Word32 AudioDeviceModuleImpl::MaxSpeakerVolume(WebRtc_UWord32* maxVolume) // MinSpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::MinSpeakerVolume(WebRtc_UWord32* minVolume) const +int32_t AudioDeviceModuleImpl::MinSpeakerVolume(uint32_t* minVolume) const { CHECK_INITIALIZED(); - WebRtc_UWord32 minVol(0); + uint32_t minVol(0); if (_ptrAudioDevice->MinSpeakerVolume(minVol) == -1) { @@ -874,11 +874,11 @@ WebRtc_Word32 AudioDeviceModuleImpl::MinSpeakerVolume(WebRtc_UWord32* minVolume) // SpeakerVolumeStepSize // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SpeakerVolumeStepSize(WebRtc_UWord16* stepSize) const +int32_t AudioDeviceModuleImpl::SpeakerVolumeStepSize(uint16_t* stepSize) const { CHECK_INITIALIZED(); - WebRtc_UWord16 delta(0); + uint16_t delta(0); if (_ptrAudioDevice->SpeakerVolumeStepSize(delta) == -1) { @@ -896,7 +896,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SpeakerVolumeStepSize(WebRtc_UWord16* stepS // SpeakerMuteIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SpeakerMuteIsAvailable(bool* available) +int32_t AudioDeviceModuleImpl::SpeakerMuteIsAvailable(bool* available) { CHECK_INITIALIZED(); @@ -917,7 +917,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SpeakerMuteIsAvailable(bool* available) // SetSpeakerMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetSpeakerMute(bool enable) +int32_t AudioDeviceModuleImpl::SetSpeakerMute(bool enable) { CHECK_INITIALIZED(); return (_ptrAudioDevice->SetSpeakerMute(enable)); @@ -927,7 +927,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetSpeakerMute(bool enable) // SpeakerMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SpeakerMute(bool* enabled) const +int32_t AudioDeviceModuleImpl::SpeakerMute(bool* enabled) const { CHECK_INITIALIZED(); @@ -948,7 +948,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SpeakerMute(bool* enabled) const // MicrophoneMuteIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneMuteIsAvailable(bool* available) +int32_t AudioDeviceModuleImpl::MicrophoneMuteIsAvailable(bool* available) { CHECK_INITIALIZED(); @@ -969,7 +969,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneMuteIsAvailable(bool* available) // SetMicrophoneMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetMicrophoneMute(bool enable) +int32_t AudioDeviceModuleImpl::SetMicrophoneMute(bool enable) { CHECK_INITIALIZED(); return (_ptrAudioDevice->SetMicrophoneMute(enable)); @@ -979,7 +979,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetMicrophoneMute(bool enable) // MicrophoneMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneMute(bool* enabled) const +int32_t AudioDeviceModuleImpl::MicrophoneMute(bool* enabled) const { CHECK_INITIALIZED(); @@ -1000,7 +1000,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneMute(bool* enabled) const // MicrophoneBoostIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneBoostIsAvailable(bool* available) +int32_t AudioDeviceModuleImpl::MicrophoneBoostIsAvailable(bool* available) { CHECK_INITIALIZED(); @@ -1021,7 +1021,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneBoostIsAvailable(bool* available) // SetMicrophoneBoost // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetMicrophoneBoost(bool enable) +int32_t AudioDeviceModuleImpl::SetMicrophoneBoost(bool enable) { CHECK_INITIALIZED(); return (_ptrAudioDevice->SetMicrophoneBoost(enable)); @@ -1031,7 +1031,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetMicrophoneBoost(bool enable) // MicrophoneBoost // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneBoost(bool* enabled) const +int32_t AudioDeviceModuleImpl::MicrophoneBoost(bool* enabled) const { CHECK_INITIALIZED(); @@ -1052,7 +1052,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneBoost(bool* enabled) const // MicrophoneVolumeIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneVolumeIsAvailable(bool* available) +int32_t AudioDeviceModuleImpl::MicrophoneVolumeIsAvailable(bool* available) { CHECK_INITIALIZED(); @@ -1073,7 +1073,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneVolumeIsAvailable(bool* available // SetMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetMicrophoneVolume(WebRtc_UWord32 volume) +int32_t AudioDeviceModuleImpl::SetMicrophoneVolume(uint32_t volume) { CHECK_INITIALIZED(); return (_ptrAudioDevice->SetMicrophoneVolume(volume)); @@ -1083,12 +1083,12 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetMicrophoneVolume(WebRtc_UWord32 volume) // MicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneVolume(WebRtc_UWord32* volume) const +int32_t AudioDeviceModuleImpl::MicrophoneVolume(uint32_t* volume) const { WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "%s", __FUNCTION__); CHECK_INITIALIZED(); - WebRtc_UWord32 level(0); + uint32_t level(0); if (_ptrAudioDevice->MicrophoneVolume(level) == -1) { @@ -1105,7 +1105,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneVolume(WebRtc_UWord32* volume) co // StereoRecordingIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::StereoRecordingIsAvailable(bool* available) const +int32_t AudioDeviceModuleImpl::StereoRecordingIsAvailable(bool* available) const { CHECK_INITIALIZED(); @@ -1126,7 +1126,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::StereoRecordingIsAvailable(bool* available) // SetStereoRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetStereoRecording(bool enable) +int32_t AudioDeviceModuleImpl::SetStereoRecording(bool enable) { CHECK_INITIALIZED(); @@ -1142,7 +1142,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetStereoRecording(bool enable) return -1; } - WebRtc_Word8 nChannels(1); + int8_t nChannels(1); if (enable) { nChannels = 2; @@ -1156,7 +1156,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetStereoRecording(bool enable) // StereoRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::StereoRecording(bool* enabled) const +int32_t AudioDeviceModuleImpl::StereoRecording(bool* enabled) const { CHECK_INITIALIZED(); @@ -1177,7 +1177,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::StereoRecording(bool* enabled) const // SetRecordingChannel // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetRecordingChannel(const ChannelType channel) +int32_t AudioDeviceModuleImpl::SetRecordingChannel(const ChannelType channel) { if (channel == kChannelBoth) { @@ -1205,7 +1205,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetRecordingChannel(const ChannelType chann // RecordingChannel // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::RecordingChannel(ChannelType* channel) const +int32_t AudioDeviceModuleImpl::RecordingChannel(ChannelType* channel) const { CHECK_INITIALIZED(); @@ -1235,7 +1235,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::RecordingChannel(ChannelType* channel) cons // StereoPlayoutIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::StereoPlayoutIsAvailable(bool* available) const +int32_t AudioDeviceModuleImpl::StereoPlayoutIsAvailable(bool* available) const { CHECK_INITIALIZED(); @@ -1256,7 +1256,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::StereoPlayoutIsAvailable(bool* available) c // SetStereoPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetStereoPlayout(bool enable) +int32_t AudioDeviceModuleImpl::SetStereoPlayout(bool enable) { CHECK_INITIALIZED(); @@ -1272,7 +1272,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetStereoPlayout(bool enable) return -1; } - WebRtc_Word8 nChannels(1); + int8_t nChannels(1); if (enable) { nChannels = 2; @@ -1286,7 +1286,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetStereoPlayout(bool enable) // StereoPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::StereoPlayout(bool* enabled) const +int32_t AudioDeviceModuleImpl::StereoPlayout(bool* enabled) const { CHECK_INITIALIZED(); @@ -1307,7 +1307,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::StereoPlayout(bool* enabled) const // SetAGC // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetAGC(bool enable) +int32_t AudioDeviceModuleImpl::SetAGC(bool enable) { CHECK_INITIALIZED(); return (_ptrAudioDevice->SetAGC(enable)); @@ -1327,7 +1327,7 @@ bool AudioDeviceModuleImpl::AGC() const // PlayoutIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::PlayoutIsAvailable(bool* available) +int32_t AudioDeviceModuleImpl::PlayoutIsAvailable(bool* available) { CHECK_INITIALIZED(); @@ -1348,7 +1348,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::PlayoutIsAvailable(bool* available) // RecordingIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::RecordingIsAvailable(bool* available) +int32_t AudioDeviceModuleImpl::RecordingIsAvailable(bool* available) { CHECK_INITIALIZED(); @@ -1369,12 +1369,12 @@ WebRtc_Word32 AudioDeviceModuleImpl::RecordingIsAvailable(bool* available) // MaxMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::MaxMicrophoneVolume(WebRtc_UWord32* maxVolume) const +int32_t AudioDeviceModuleImpl::MaxMicrophoneVolume(uint32_t* maxVolume) const { WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "%s", __FUNCTION__); CHECK_INITIALIZED(); - WebRtc_UWord32 maxVol(0); + uint32_t maxVol(0); if (_ptrAudioDevice->MaxMicrophoneVolume(maxVol) == -1) { @@ -1391,11 +1391,11 @@ WebRtc_Word32 AudioDeviceModuleImpl::MaxMicrophoneVolume(WebRtc_UWord32* maxVolu // MinMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::MinMicrophoneVolume(WebRtc_UWord32* minVolume) const +int32_t AudioDeviceModuleImpl::MinMicrophoneVolume(uint32_t* minVolume) const { CHECK_INITIALIZED(); - WebRtc_UWord32 minVol(0); + uint32_t minVol(0); if (_ptrAudioDevice->MinMicrophoneVolume(minVol) == -1) { @@ -1412,11 +1412,11 @@ WebRtc_Word32 AudioDeviceModuleImpl::MinMicrophoneVolume(WebRtc_UWord32* minVolu // MicrophoneVolumeStepSize // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneVolumeStepSize(WebRtc_UWord16* stepSize) const +int32_t AudioDeviceModuleImpl::MicrophoneVolumeStepSize(uint16_t* stepSize) const { CHECK_INITIALIZED(); - WebRtc_UWord16 delta(0); + uint16_t delta(0); if (_ptrAudioDevice->MicrophoneVolumeStepSize(delta) == -1) { @@ -1433,21 +1433,21 @@ WebRtc_Word32 AudioDeviceModuleImpl::MicrophoneVolumeStepSize(WebRtc_UWord16* st // PlayoutDevices // ---------------------------------------------------------------------------- -WebRtc_Word16 AudioDeviceModuleImpl::PlayoutDevices() +int16_t AudioDeviceModuleImpl::PlayoutDevices() { CHECK_INITIALIZED(); - WebRtc_UWord16 nPlayoutDevices = _ptrAudioDevice->PlayoutDevices(); + uint16_t nPlayoutDevices = _ptrAudioDevice->PlayoutDevices(); WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: #playout devices=%d", nPlayoutDevices); - return ((WebRtc_Word16)(nPlayoutDevices)); + return ((int16_t)(nPlayoutDevices)); } // ---------------------------------------------------------------------------- // SetPlayoutDevice I (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetPlayoutDevice(WebRtc_UWord16 index) +int32_t AudioDeviceModuleImpl::SetPlayoutDevice(uint16_t index) { CHECK_INITIALIZED(); return (_ptrAudioDevice->SetPlayoutDevice(index)); @@ -1457,7 +1457,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetPlayoutDevice(WebRtc_UWord16 index) // SetPlayoutDevice II (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetPlayoutDevice(WindowsDeviceType device) +int32_t AudioDeviceModuleImpl::SetPlayoutDevice(WindowsDeviceType device) { if (device == kDefaultDevice) { @@ -1474,8 +1474,8 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetPlayoutDevice(WindowsDeviceType device) // PlayoutDeviceName // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::PlayoutDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceModuleImpl::PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { @@ -1508,8 +1508,8 @@ WebRtc_Word32 AudioDeviceModuleImpl::PlayoutDeviceName( // RecordingDeviceName // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::RecordingDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceModuleImpl::RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { @@ -1542,22 +1542,22 @@ WebRtc_Word32 AudioDeviceModuleImpl::RecordingDeviceName( // RecordingDevices // ---------------------------------------------------------------------------- -WebRtc_Word16 AudioDeviceModuleImpl::RecordingDevices() +int16_t AudioDeviceModuleImpl::RecordingDevices() { CHECK_INITIALIZED(); - WebRtc_UWord16 nRecordingDevices = _ptrAudioDevice->RecordingDevices(); + uint16_t nRecordingDevices = _ptrAudioDevice->RecordingDevices(); WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: #recording devices=%d", nRecordingDevices); - return ((WebRtc_Word16)nRecordingDevices); + return ((int16_t)nRecordingDevices); } // ---------------------------------------------------------------------------- // SetRecordingDevice I (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetRecordingDevice(WebRtc_UWord16 index) +int32_t AudioDeviceModuleImpl::SetRecordingDevice(uint16_t index) { CHECK_INITIALIZED(); return (_ptrAudioDevice->SetRecordingDevice(index)); @@ -1567,7 +1567,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetRecordingDevice(WebRtc_UWord16 index) // SetRecordingDevice II (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetRecordingDevice(WindowsDeviceType device) +int32_t AudioDeviceModuleImpl::SetRecordingDevice(WindowsDeviceType device) { if (device == kDefaultDevice) { @@ -1584,7 +1584,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetRecordingDevice(WindowsDeviceType device // InitPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::InitPlayout() +int32_t AudioDeviceModuleImpl::InitPlayout() { CHECK_INITIALIZED(); _audioDeviceBuffer.InitPlayout(); @@ -1595,7 +1595,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::InitPlayout() // InitRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::InitRecording() +int32_t AudioDeviceModuleImpl::InitRecording() { CHECK_INITIALIZED(); _audioDeviceBuffer.InitRecording(); @@ -1626,7 +1626,7 @@ bool AudioDeviceModuleImpl::RecordingIsInitialized() const // StartPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::StartPlayout() +int32_t AudioDeviceModuleImpl::StartPlayout() { CHECK_INITIALIZED(); return (_ptrAudioDevice->StartPlayout()); @@ -1636,7 +1636,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::StartPlayout() // StopPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::StopPlayout() +int32_t AudioDeviceModuleImpl::StopPlayout() { CHECK_INITIALIZED(); return (_ptrAudioDevice->StopPlayout()); @@ -1656,7 +1656,7 @@ bool AudioDeviceModuleImpl::Playing() const // StartRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::StartRecording() +int32_t AudioDeviceModuleImpl::StartRecording() { CHECK_INITIALIZED(); return (_ptrAudioDevice->StartRecording()); @@ -1665,7 +1665,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::StartRecording() // StopRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::StopRecording() +int32_t AudioDeviceModuleImpl::StopRecording() { CHECK_INITIALIZED(); return (_ptrAudioDevice->StopRecording()); @@ -1685,7 +1685,7 @@ bool AudioDeviceModuleImpl::Recording() const // RegisterEventObserver // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::RegisterEventObserver(AudioDeviceObserver* eventCallback) +int32_t AudioDeviceModuleImpl::RegisterEventObserver(AudioDeviceObserver* eventCallback) { CriticalSectionScoped lock(&_critSectEventCb); @@ -1698,7 +1698,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::RegisterEventObserver(AudioDeviceObserver* // RegisterAudioCallback // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::RegisterAudioCallback(AudioTransport* audioCallback) +int32_t AudioDeviceModuleImpl::RegisterAudioCallback(AudioTransport* audioCallback) { CriticalSectionScoped lock(&_critSectAudioCb); @@ -1711,7 +1711,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::RegisterAudioCallback(AudioTransport* audio // StartRawInputFileRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::StartRawInputFileRecording( +int32_t AudioDeviceModuleImpl::StartRawInputFileRecording( const char pcmFileNameUTF8[kAdmMaxFileNameSize]) { CHECK_INITIALIZED(); @@ -1728,7 +1728,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::StartRawInputFileRecording( // StopRawInputFileRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::StopRawInputFileRecording() +int32_t AudioDeviceModuleImpl::StopRawInputFileRecording() { CHECK_INITIALIZED(); @@ -1739,7 +1739,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::StopRawInputFileRecording() // StartRawOutputFileRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::StartRawOutputFileRecording( +int32_t AudioDeviceModuleImpl::StartRawOutputFileRecording( const char pcmFileNameUTF8[kAdmMaxFileNameSize]) { CHECK_INITIALIZED(); @@ -1756,7 +1756,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::StartRawOutputFileRecording( // StopRawOutputFileRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::StopRawOutputFileRecording() +int32_t AudioDeviceModuleImpl::StopRawOutputFileRecording() { CHECK_INITIALIZED(); @@ -1769,7 +1769,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::StopRawOutputFileRecording() // SetPlayoutBuffer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetPlayoutBuffer(const BufferType type, WebRtc_UWord16 sizeMS) +int32_t AudioDeviceModuleImpl::SetPlayoutBuffer(const BufferType type, uint16_t sizeMS) { CHECK_INITIALIZED(); @@ -1779,7 +1779,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetPlayoutBuffer(const BufferType type, Web return -1; } - WebRtc_Word32 ret(0); + int32_t ret(0); if (kFixedBufferSize == type) { @@ -1802,12 +1802,12 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetPlayoutBuffer(const BufferType type, Web // PlayoutBuffer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::PlayoutBuffer(BufferType* type, WebRtc_UWord16* sizeMS) const +int32_t AudioDeviceModuleImpl::PlayoutBuffer(BufferType* type, uint16_t* sizeMS) const { CHECK_INITIALIZED(); BufferType bufType; - WebRtc_UWord16 size(0); + uint16_t size(0); if (_ptrAudioDevice->PlayoutBuffer(bufType, size) == -1) { @@ -1826,12 +1826,12 @@ WebRtc_Word32 AudioDeviceModuleImpl::PlayoutBuffer(BufferType* type, WebRtc_UWor // PlayoutDelay // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::PlayoutDelay(WebRtc_UWord16* delayMS) const +int32_t AudioDeviceModuleImpl::PlayoutDelay(uint16_t* delayMS) const { WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "%s", __FUNCTION__); CHECK_INITIALIZED(); - WebRtc_UWord16 delay(0); + uint16_t delay(0); if (_ptrAudioDevice->PlayoutDelay(delay) == -1) { @@ -1849,12 +1849,12 @@ WebRtc_Word32 AudioDeviceModuleImpl::PlayoutDelay(WebRtc_UWord16* delayMS) const // RecordingDelay // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::RecordingDelay(WebRtc_UWord16* delayMS) const +int32_t AudioDeviceModuleImpl::RecordingDelay(uint16_t* delayMS) const { WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "%s", __FUNCTION__); CHECK_INITIALIZED(); - WebRtc_UWord16 delay(0); + uint16_t delay(0); if (_ptrAudioDevice->RecordingDelay(delay) == -1) { @@ -1872,11 +1872,11 @@ WebRtc_Word32 AudioDeviceModuleImpl::RecordingDelay(WebRtc_UWord16* delayMS) con // CPULoad // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::CPULoad(WebRtc_UWord16* load) const +int32_t AudioDeviceModuleImpl::CPULoad(uint16_t* load) const { CHECK_INITIALIZED(); - WebRtc_UWord16 cpuLoad(0); + uint16_t cpuLoad(0); if (_ptrAudioDevice->CPULoad(cpuLoad) == -1) { @@ -1894,7 +1894,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::CPULoad(WebRtc_UWord16* load) const // SetRecordingSampleRate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetRecordingSampleRate(const WebRtc_UWord32 samplesPerSec) +int32_t AudioDeviceModuleImpl::SetRecordingSampleRate(const uint32_t samplesPerSec) { CHECK_INITIALIZED(); @@ -1910,11 +1910,11 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetRecordingSampleRate(const WebRtc_UWord32 // RecordingSampleRate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::RecordingSampleRate(WebRtc_UWord32* samplesPerSec) const +int32_t AudioDeviceModuleImpl::RecordingSampleRate(uint32_t* samplesPerSec) const { CHECK_INITIALIZED(); - WebRtc_Word32 sampleRate = _audioDeviceBuffer.RecordingSampleRate(); + int32_t sampleRate = _audioDeviceBuffer.RecordingSampleRate(); if (sampleRate == -1) { @@ -1932,7 +1932,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::RecordingSampleRate(WebRtc_UWord32* samples // SetPlayoutSampleRate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetPlayoutSampleRate(const WebRtc_UWord32 samplesPerSec) +int32_t AudioDeviceModuleImpl::SetPlayoutSampleRate(const uint32_t samplesPerSec) { CHECK_INITIALIZED(); @@ -1948,11 +1948,11 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetPlayoutSampleRate(const WebRtc_UWord32 s // PlayoutSampleRate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::PlayoutSampleRate(WebRtc_UWord32* samplesPerSec) const +int32_t AudioDeviceModuleImpl::PlayoutSampleRate(uint32_t* samplesPerSec) const { CHECK_INITIALIZED(); - WebRtc_Word32 sampleRate = _audioDeviceBuffer.PlayoutSampleRate(); + int32_t sampleRate = _audioDeviceBuffer.PlayoutSampleRate(); if (sampleRate == -1) { @@ -1970,7 +1970,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::PlayoutSampleRate(WebRtc_UWord32* samplesPe // ResetAudioDevice // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::ResetAudioDevice() +int32_t AudioDeviceModuleImpl::ResetAudioDevice() { CHECK_INITIALIZED(); @@ -1987,7 +1987,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::ResetAudioDevice() // SetLoudspeakerStatus // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::SetLoudspeakerStatus(bool enable) +int32_t AudioDeviceModuleImpl::SetLoudspeakerStatus(bool enable) { CHECK_INITIALIZED(); @@ -2003,7 +2003,7 @@ WebRtc_Word32 AudioDeviceModuleImpl::SetLoudspeakerStatus(bool enable) // GetLoudspeakerStatus // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceModuleImpl::GetLoudspeakerStatus(bool* enabled) const +int32_t AudioDeviceModuleImpl::GetLoudspeakerStatus(bool* enabled) const { CHECK_INITIALIZED(); diff --git a/webrtc/modules/audio_device/audio_device_impl.h b/webrtc/modules/audio_device/audio_device_impl.h index 91a853466c..8cbfbf53ea 100644 --- a/webrtc/modules/audio_device/audio_device_impl.h +++ b/webrtc/modules/audio_device/audio_device_impl.h @@ -35,177 +35,176 @@ public: kPlatformIOS = 6 }; - WebRtc_Word32 CheckPlatform(); - WebRtc_Word32 CreatePlatformSpecificObjects(); - WebRtc_Word32 AttachAudioBuffer(); + int32_t CheckPlatform(); + int32_t CreatePlatformSpecificObjects(); + int32_t AttachAudioBuffer(); - AudioDeviceModuleImpl(const WebRtc_Word32 id, const AudioLayer audioLayer); + AudioDeviceModuleImpl(const int32_t id, const AudioLayer audioLayer); virtual ~AudioDeviceModuleImpl(); public: // RefCountedModule - virtual WebRtc_Word32 ChangeUniqueId(const WebRtc_Word32 id); - virtual WebRtc_Word32 TimeUntilNextProcess(); - virtual WebRtc_Word32 Process(); + virtual int32_t ChangeUniqueId(const int32_t id); + virtual int32_t TimeUntilNextProcess(); + virtual int32_t Process(); public: // Factory methods (resource allocation/deallocation) static AudioDeviceModule* Create( - const WebRtc_Word32 id, + const int32_t id, const AudioLayer audioLayer = kPlatformDefaultAudio); // Retrieve the currently utilized audio layer - virtual WebRtc_Word32 ActiveAudioLayer(AudioLayer* audioLayer) const; + virtual int32_t ActiveAudioLayer(AudioLayer* audioLayer) const; // Error handling virtual ErrorCode LastError() const; - virtual WebRtc_Word32 RegisterEventObserver( + virtual int32_t RegisterEventObserver( AudioDeviceObserver* eventCallback); // Full-duplex transportation of PCM audio - virtual WebRtc_Word32 RegisterAudioCallback( + virtual int32_t RegisterAudioCallback( AudioTransport* audioCallback); // Main initializaton and termination - virtual WebRtc_Word32 Init(); - virtual WebRtc_Word32 Terminate(); + virtual int32_t Init(); + virtual int32_t Terminate(); virtual bool Initialized() const; // Device enumeration - virtual WebRtc_Word16 PlayoutDevices(); - virtual WebRtc_Word16 RecordingDevices(); - virtual WebRtc_Word32 PlayoutDeviceName( - WebRtc_UWord16 index, + virtual int16_t PlayoutDevices(); + virtual int16_t RecordingDevices(); + virtual int32_t PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); - virtual WebRtc_Word32 RecordingDeviceName( - WebRtc_UWord16 index, + virtual int32_t RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); // Device selection - virtual WebRtc_Word32 SetPlayoutDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetPlayoutDevice(WindowsDeviceType device); - virtual WebRtc_Word32 SetRecordingDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetRecordingDevice(WindowsDeviceType device); + virtual int32_t SetPlayoutDevice(uint16_t index); + virtual int32_t SetPlayoutDevice(WindowsDeviceType device); + virtual int32_t SetRecordingDevice(uint16_t index); + virtual int32_t SetRecordingDevice(WindowsDeviceType device); // Audio transport initialization - virtual WebRtc_Word32 PlayoutIsAvailable(bool* available); - virtual WebRtc_Word32 InitPlayout(); + virtual int32_t PlayoutIsAvailable(bool* available); + virtual int32_t InitPlayout(); virtual bool PlayoutIsInitialized() const; - virtual WebRtc_Word32 RecordingIsAvailable(bool* available); - virtual WebRtc_Word32 InitRecording(); + virtual int32_t RecordingIsAvailable(bool* available); + virtual int32_t InitRecording(); virtual bool RecordingIsInitialized() const; // Audio transport control - virtual WebRtc_Word32 StartPlayout(); - virtual WebRtc_Word32 StopPlayout(); + virtual int32_t StartPlayout(); + virtual int32_t StopPlayout(); virtual bool Playing() const; - virtual WebRtc_Word32 StartRecording(); - virtual WebRtc_Word32 StopRecording(); + virtual int32_t StartRecording(); + virtual int32_t StopRecording(); virtual bool Recording() const; // Microphone Automatic Gain Control (AGC) - virtual WebRtc_Word32 SetAGC(bool enable); + virtual int32_t SetAGC(bool enable); virtual bool AGC() const; // Volume control based on the Windows Wave API (Windows only) - virtual WebRtc_Word32 SetWaveOutVolume(WebRtc_UWord16 volumeLeft, - WebRtc_UWord16 volumeRight); - virtual WebRtc_Word32 WaveOutVolume(WebRtc_UWord16* volumeLeft, - WebRtc_UWord16* volumeRight) const; + virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight); + virtual int32_t WaveOutVolume(uint16_t* volumeLeft, + uint16_t* volumeRight) const; // Audio mixer initialization - virtual WebRtc_Word32 SpeakerIsAvailable(bool* available); - virtual WebRtc_Word32 InitSpeaker(); + virtual int32_t SpeakerIsAvailable(bool* available); + virtual int32_t InitSpeaker(); virtual bool SpeakerIsInitialized() const; - virtual WebRtc_Word32 MicrophoneIsAvailable(bool* available); - virtual WebRtc_Word32 InitMicrophone(); + virtual int32_t MicrophoneIsAvailable(bool* available); + virtual int32_t InitMicrophone(); virtual bool MicrophoneIsInitialized() const; // Speaker volume controls - virtual WebRtc_Word32 SpeakerVolumeIsAvailable(bool* available); - virtual WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 SpeakerVolume(WebRtc_UWord32* volume) const; - virtual WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32* maxVolume) const; - virtual WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32* minVolume) const; - virtual WebRtc_Word32 SpeakerVolumeStepSize( - WebRtc_UWord16* stepSize) const; + virtual int32_t SpeakerVolumeIsAvailable(bool* available); + virtual int32_t SetSpeakerVolume(uint32_t volume); + virtual int32_t SpeakerVolume(uint32_t* volume) const; + virtual int32_t MaxSpeakerVolume(uint32_t* maxVolume) const; + virtual int32_t MinSpeakerVolume(uint32_t* minVolume) const; + virtual int32_t SpeakerVolumeStepSize( + uint16_t* stepSize) const; // Microphone volume controls - virtual WebRtc_Word32 MicrophoneVolumeIsAvailable(bool* available); - virtual WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32* volume) const; - virtual WebRtc_Word32 MaxMicrophoneVolume( - WebRtc_UWord32* maxVolume) const; - virtual WebRtc_Word32 MinMicrophoneVolume( - WebRtc_UWord32* minVolume) const; - virtual WebRtc_Word32 MicrophoneVolumeStepSize( - WebRtc_UWord16* stepSize) const; + virtual int32_t MicrophoneVolumeIsAvailable(bool* available); + virtual int32_t SetMicrophoneVolume(uint32_t volume); + virtual int32_t MicrophoneVolume(uint32_t* volume) const; + virtual int32_t MaxMicrophoneVolume( + uint32_t* maxVolume) const; + virtual int32_t MinMicrophoneVolume( + uint32_t* minVolume) const; + virtual int32_t MicrophoneVolumeStepSize( + uint16_t* stepSize) const; // Speaker mute control - virtual WebRtc_Word32 SpeakerMuteIsAvailable(bool* available); - virtual WebRtc_Word32 SetSpeakerMute(bool enable); - virtual WebRtc_Word32 SpeakerMute(bool* enabled) const; + virtual int32_t SpeakerMuteIsAvailable(bool* available); + virtual int32_t SetSpeakerMute(bool enable); + virtual int32_t SpeakerMute(bool* enabled) const; // Microphone mute control - virtual WebRtc_Word32 MicrophoneMuteIsAvailable(bool* available); - virtual WebRtc_Word32 SetMicrophoneMute(bool enable); - virtual WebRtc_Word32 MicrophoneMute(bool* enabled) const; + virtual int32_t MicrophoneMuteIsAvailable(bool* available); + virtual int32_t SetMicrophoneMute(bool enable); + virtual int32_t MicrophoneMute(bool* enabled) const; // Microphone boost control - virtual WebRtc_Word32 MicrophoneBoostIsAvailable(bool* available); - virtual WebRtc_Word32 SetMicrophoneBoost(bool enable); - virtual WebRtc_Word32 MicrophoneBoost(bool* enabled) const; + virtual int32_t MicrophoneBoostIsAvailable(bool* available); + virtual int32_t SetMicrophoneBoost(bool enable); + virtual int32_t MicrophoneBoost(bool* enabled) const; // Stereo support - virtual WebRtc_Word32 StereoPlayoutIsAvailable(bool* available) const; - virtual WebRtc_Word32 SetStereoPlayout(bool enable); - virtual WebRtc_Word32 StereoPlayout(bool* enabled) const; - virtual WebRtc_Word32 StereoRecordingIsAvailable(bool* available) const; - virtual WebRtc_Word32 SetStereoRecording(bool enable); - virtual WebRtc_Word32 StereoRecording(bool* enabled) const; - virtual WebRtc_Word32 SetRecordingChannel(const ChannelType channel); - virtual WebRtc_Word32 RecordingChannel(ChannelType* channel) const; + virtual int32_t StereoPlayoutIsAvailable(bool* available) const; + virtual int32_t SetStereoPlayout(bool enable); + virtual int32_t StereoPlayout(bool* enabled) const; + virtual int32_t StereoRecordingIsAvailable(bool* available) const; + virtual int32_t SetStereoRecording(bool enable); + virtual int32_t StereoRecording(bool* enabled) const; + virtual int32_t SetRecordingChannel(const ChannelType channel); + virtual int32_t RecordingChannel(ChannelType* channel) const; // Delay information and control - virtual WebRtc_Word32 SetPlayoutBuffer(const BufferType type, - WebRtc_UWord16 sizeMS = 0); - virtual WebRtc_Word32 PlayoutBuffer(BufferType* type, - WebRtc_UWord16* sizeMS) const; - virtual WebRtc_Word32 PlayoutDelay(WebRtc_UWord16* delayMS) const; - virtual WebRtc_Word32 RecordingDelay(WebRtc_UWord16* delayMS) const; + virtual int32_t SetPlayoutBuffer(const BufferType type, + uint16_t sizeMS = 0); + virtual int32_t PlayoutBuffer(BufferType* type, + uint16_t* sizeMS) const; + virtual int32_t PlayoutDelay(uint16_t* delayMS) const; + virtual int32_t RecordingDelay(uint16_t* delayMS) const; // CPU load - virtual WebRtc_Word32 CPULoad(WebRtc_UWord16* load) const; + virtual int32_t CPULoad(uint16_t* load) const; // Recording of raw PCM data - virtual WebRtc_Word32 StartRawOutputFileRecording( + virtual int32_t StartRawOutputFileRecording( const char pcmFileNameUTF8[kAdmMaxFileNameSize]); - virtual WebRtc_Word32 StopRawOutputFileRecording(); - virtual WebRtc_Word32 StartRawInputFileRecording( + virtual int32_t StopRawOutputFileRecording(); + virtual int32_t StartRawInputFileRecording( const char pcmFileNameUTF8[kAdmMaxFileNameSize]); - virtual WebRtc_Word32 StopRawInputFileRecording(); + virtual int32_t StopRawInputFileRecording(); // Native sample rate controls (samples/sec) - virtual WebRtc_Word32 SetRecordingSampleRate( - const WebRtc_UWord32 samplesPerSec); - virtual WebRtc_Word32 RecordingSampleRate( - WebRtc_UWord32* samplesPerSec) const; - virtual WebRtc_Word32 SetPlayoutSampleRate( - const WebRtc_UWord32 samplesPerSec); - virtual WebRtc_Word32 PlayoutSampleRate( - WebRtc_UWord32* samplesPerSec) const; + virtual int32_t SetRecordingSampleRate( + const uint32_t samplesPerSec); + virtual int32_t RecordingSampleRate( + uint32_t* samplesPerSec) const; + virtual int32_t SetPlayoutSampleRate( + const uint32_t samplesPerSec); + virtual int32_t PlayoutSampleRate( + uint32_t* samplesPerSec) const; // Mobile device specific functions - virtual WebRtc_Word32 ResetAudioDevice(); - virtual WebRtc_Word32 SetLoudspeakerStatus(bool enable); - virtual WebRtc_Word32 GetLoudspeakerStatus(bool* enabled) const; + virtual int32_t ResetAudioDevice(); + virtual int32_t SetLoudspeakerStatus(bool enable); + virtual int32_t GetLoudspeakerStatus(bool* enabled) const; virtual int32_t EnableBuiltInAEC(bool enable); virtual bool BuiltInAECIsEnabled() const; public: - WebRtc_Word32 Id() {return _id;} + int32_t Id() {return _id;} private: PlatformType Platform() const; @@ -223,9 +222,9 @@ private: AudioDeviceBuffer _audioDeviceBuffer; - WebRtc_Word32 _id; + int32_t _id; AudioLayer _platformAudioLayer; - WebRtc_UWord32 _lastProcessTime; + uint32_t _lastProcessTime; PlatformType _platformType; bool _initialized; mutable ErrorCode _lastError; diff --git a/webrtc/modules/audio_device/audio_device_utility.cc b/webrtc/modules/audio_device/audio_device_utility.cc index 203f09a0de..428401134a 100644 --- a/webrtc/modules/audio_device/audio_device_utility.cc +++ b/webrtc/modules/audio_device/audio_device_utility.cc @@ -32,14 +32,14 @@ void AudioDeviceUtility::WaitForKey() _getch(); } -WebRtc_UWord32 AudioDeviceUtility::GetTimeInMS() +uint32_t AudioDeviceUtility::GetTimeInMS() { return timeGetTime(); } bool AudioDeviceUtility::StringCompare( const char* str1 , const char* str2, - const WebRtc_UWord32 length) + const uint32_t length) { return ((_strnicmp(str1, str2, length) == 0) ? true : false); } @@ -90,19 +90,19 @@ void AudioDeviceUtility::WaitForKey() tcsetattr( STDIN_FILENO, TCSANOW, &oldt ); } -WebRtc_UWord32 AudioDeviceUtility::GetTimeInMS() +uint32_t AudioDeviceUtility::GetTimeInMS() { struct timeval tv; struct timezone tz; - WebRtc_UWord32 val; + uint32_t val; gettimeofday(&tv, &tz); - val = (WebRtc_UWord32)(tv.tv_sec*1000 + tv.tv_usec/1000); + val = (uint32_t)(tv.tv_sec*1000 + tv.tv_usec/1000); return val; } bool AudioDeviceUtility::StringCompare( - const char* str1 , const char* str2, const WebRtc_UWord32 length) + const char* str1 , const char* str2, const uint32_t length) { return (strncasecmp(str1, str2, length) == 0)?true: false; } diff --git a/webrtc/modules/audio_device/audio_device_utility.h b/webrtc/modules/audio_device/audio_device_utility.h index 293557efa3..10efbbc122 100644 --- a/webrtc/modules/audio_device/audio_device_utility.h +++ b/webrtc/modules/audio_device/audio_device_utility.h @@ -19,12 +19,12 @@ namespace webrtc class AudioDeviceUtility { public: - static WebRtc_UWord32 GetTimeInMS(); + static uint32_t GetTimeInMS(); static void WaitForKey(); static bool StringCompare(const char* str1, const char* str2, - const WebRtc_UWord32 length); - virtual WebRtc_Word32 Init() = 0; + const uint32_t length); + virtual int32_t Init() = 0; virtual ~AudioDeviceUtility() {} }; diff --git a/webrtc/modules/audio_device/dummy/audio_device_dummy.h b/webrtc/modules/audio_device/dummy/audio_device_dummy.h index beef1f69e6..3c0ad8917b 100644 --- a/webrtc/modules/audio_device/dummy/audio_device_dummy.h +++ b/webrtc/modules/audio_device/dummy/audio_device_dummy.h @@ -20,158 +20,158 @@ namespace webrtc { class AudioDeviceDummy : public AudioDeviceGeneric { public: - AudioDeviceDummy(const WebRtc_Word32 id) {} + AudioDeviceDummy(const int32_t id) {} ~AudioDeviceDummy() {} // Retrieve the currently utilized audio layer - virtual WebRtc_Word32 ActiveAudioLayer( + virtual int32_t ActiveAudioLayer( AudioDeviceModule::AudioLayer& audioLayer) const { return -1; } // Main initializaton and termination - virtual WebRtc_Word32 Init() { return 0; } - virtual WebRtc_Word32 Terminate() { return 0; } + virtual int32_t Init() { return 0; } + virtual int32_t Terminate() { return 0; } virtual bool Initialized() const { return true; } // Device enumeration - virtual WebRtc_Word16 PlayoutDevices() { return -1; } - virtual WebRtc_Word16 RecordingDevices() { return -1; } - virtual WebRtc_Word32 PlayoutDeviceName( - WebRtc_UWord16 index, + virtual int16_t PlayoutDevices() { return -1; } + virtual int16_t RecordingDevices() { return -1; } + virtual int32_t PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { return -1; } - virtual WebRtc_Word32 RecordingDeviceName( - WebRtc_UWord16 index, + virtual int32_t RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { return -1; } // Device selection - virtual WebRtc_Word32 SetPlayoutDevice(WebRtc_UWord16 index) { return -1; } - virtual WebRtc_Word32 SetPlayoutDevice( + virtual int32_t SetPlayoutDevice(uint16_t index) { return -1; } + virtual int32_t SetPlayoutDevice( AudioDeviceModule::WindowsDeviceType device) { return -1; } - virtual WebRtc_Word32 SetRecordingDevice(WebRtc_UWord16 index) { + virtual int32_t SetRecordingDevice(uint16_t index) { return -1; } - virtual WebRtc_Word32 SetRecordingDevice( + virtual int32_t SetRecordingDevice( AudioDeviceModule::WindowsDeviceType device) { return -1; } // Audio transport initialization - virtual WebRtc_Word32 PlayoutIsAvailable(bool& available) { + virtual int32_t PlayoutIsAvailable(bool& available) { return -1; } - virtual WebRtc_Word32 InitPlayout() { return -1; }; + virtual int32_t InitPlayout() { return -1; }; virtual bool PlayoutIsInitialized() const { return false; } - virtual WebRtc_Word32 RecordingIsAvailable(bool& available) { return -1; } - virtual WebRtc_Word32 InitRecording() { return -1; } + virtual int32_t RecordingIsAvailable(bool& available) { return -1; } + virtual int32_t InitRecording() { return -1; } virtual bool RecordingIsInitialized() const { return false; } // Audio transport control - virtual WebRtc_Word32 StartPlayout() { return -1; } - virtual WebRtc_Word32 StopPlayout() { return -1; } + virtual int32_t StartPlayout() { return -1; } + virtual int32_t StopPlayout() { return -1; } virtual bool Playing() const { return false; } - virtual WebRtc_Word32 StartRecording() { return -1; } - virtual WebRtc_Word32 StopRecording() { return -1; } + virtual int32_t StartRecording() { return -1; } + virtual int32_t StopRecording() { return -1; } virtual bool Recording() const { return false; } // Microphone Automatic Gain Control (AGC) - virtual WebRtc_Word32 SetAGC(bool enable) { return -1; } + virtual int32_t SetAGC(bool enable) { return -1; } virtual bool AGC() const { return false; } // Volume control based on the Windows Wave API (Windows only) - virtual WebRtc_Word32 SetWaveOutVolume( - WebRtc_UWord16 volumeLeft, WebRtc_UWord16 volumeRight) { return -1; } - virtual WebRtc_Word32 WaveOutVolume( - WebRtc_UWord16& volumeLeft, - WebRtc_UWord16& volumeRight) const { return -1; } + virtual int32_t SetWaveOutVolume( + uint16_t volumeLeft, uint16_t volumeRight) { return -1; } + virtual int32_t WaveOutVolume( + uint16_t& volumeLeft, + uint16_t& volumeRight) const { return -1; } // Audio mixer initialization - virtual WebRtc_Word32 SpeakerIsAvailable(bool& available) { return -1; } - virtual WebRtc_Word32 InitSpeaker() { return -1; } + virtual int32_t SpeakerIsAvailable(bool& available) { return -1; } + virtual int32_t InitSpeaker() { return -1; } virtual bool SpeakerIsInitialized() const { return false; } - virtual WebRtc_Word32 MicrophoneIsAvailable(bool& available) { return -1; } - virtual WebRtc_Word32 InitMicrophone() { return -1; } + virtual int32_t MicrophoneIsAvailable(bool& available) { return -1; } + virtual int32_t InitMicrophone() { return -1; } virtual bool MicrophoneIsInitialized() const { return false; } // Speaker volume controls - virtual WebRtc_Word32 SpeakerVolumeIsAvailable(bool& available) { + virtual int32_t SpeakerVolumeIsAvailable(bool& available) { return -1; } - virtual WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume) { return -1; } - virtual WebRtc_Word32 SpeakerVolume(WebRtc_UWord32& volume) const { + virtual int32_t SetSpeakerVolume(uint32_t volume) { return -1; } + virtual int32_t SpeakerVolume(uint32_t& volume) const { return -1; } - virtual WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const { + virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const { return -1; } - virtual WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32& minVolume) const { + virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const { return -1; } - virtual WebRtc_Word32 SpeakerVolumeStepSize( - WebRtc_UWord16& stepSize) const { return -1; } + virtual int32_t SpeakerVolumeStepSize( + uint16_t& stepSize) const { return -1; } // Microphone volume controls - virtual WebRtc_Word32 MicrophoneVolumeIsAvailable(bool& available) { + virtual int32_t MicrophoneVolumeIsAvailable(bool& available) { return -1; } - virtual WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume) { + virtual int32_t SetMicrophoneVolume(uint32_t volume) { return -1; } - virtual WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32& volume) const { + virtual int32_t MicrophoneVolume(uint32_t& volume) const { return -1; } - virtual WebRtc_Word32 MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const { + virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const { return -1; } - virtual WebRtc_Word32 MinMicrophoneVolume( - WebRtc_UWord32& minVolume) const { return -1; } - virtual WebRtc_Word32 MicrophoneVolumeStepSize( - WebRtc_UWord16& stepSize) const { return -1; } + virtual int32_t MinMicrophoneVolume( + uint32_t& minVolume) const { return -1; } + virtual int32_t MicrophoneVolumeStepSize( + uint16_t& stepSize) const { return -1; } // Speaker mute control - virtual WebRtc_Word32 SpeakerMuteIsAvailable(bool& available) { return -1; } - virtual WebRtc_Word32 SetSpeakerMute(bool enable) { return -1; } - virtual WebRtc_Word32 SpeakerMute(bool& enabled) const { return -1; } + virtual int32_t SpeakerMuteIsAvailable(bool& available) { return -1; } + virtual int32_t SetSpeakerMute(bool enable) { return -1; } + virtual int32_t SpeakerMute(bool& enabled) const { return -1; } // Microphone mute control - virtual WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available) { + virtual int32_t MicrophoneMuteIsAvailable(bool& available) { return -1; } - virtual WebRtc_Word32 SetMicrophoneMute(bool enable) { return -1; } - virtual WebRtc_Word32 MicrophoneMute(bool& enabled) const { return -1; } + virtual int32_t SetMicrophoneMute(bool enable) { return -1; } + virtual int32_t MicrophoneMute(bool& enabled) const { return -1; } // Microphone boost control - virtual WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available) { + virtual int32_t MicrophoneBoostIsAvailable(bool& available) { return -1; } - virtual WebRtc_Word32 SetMicrophoneBoost(bool enable) { return -1; } - virtual WebRtc_Word32 MicrophoneBoost(bool& enabled) const { return -1; } + virtual int32_t SetMicrophoneBoost(bool enable) { return -1; } + virtual int32_t MicrophoneBoost(bool& enabled) const { return -1; } // Stereo support - virtual WebRtc_Word32 StereoPlayoutIsAvailable(bool& available) { + virtual int32_t StereoPlayoutIsAvailable(bool& available) { return -1; } - virtual WebRtc_Word32 SetStereoPlayout(bool enable) { return -1; } - virtual WebRtc_Word32 StereoPlayout(bool& enabled) const { return -1; } - virtual WebRtc_Word32 StereoRecordingIsAvailable(bool& available) { + virtual int32_t SetStereoPlayout(bool enable) { return -1; } + virtual int32_t StereoPlayout(bool& enabled) const { return -1; } + virtual int32_t StereoRecordingIsAvailable(bool& available) { return -1; } - virtual WebRtc_Word32 SetStereoRecording(bool enable) { return -1; } - virtual WebRtc_Word32 StereoRecording(bool& enabled) const { return -1; } + virtual int32_t SetStereoRecording(bool enable) { return -1; } + virtual int32_t StereoRecording(bool& enabled) const { return -1; } // Delay information and control - virtual WebRtc_Word32 SetPlayoutBuffer( + virtual int32_t SetPlayoutBuffer( const AudioDeviceModule::BufferType type, - WebRtc_UWord16 sizeMS) { return -1; } - virtual WebRtc_Word32 PlayoutBuffer( + uint16_t sizeMS) { return -1; } + virtual int32_t PlayoutBuffer( AudioDeviceModule::BufferType& type, - WebRtc_UWord16& sizeMS) const { return -1; } - virtual WebRtc_Word32 PlayoutDelay(WebRtc_UWord16& delayMS) const { + uint16_t& sizeMS) const { return -1; } + virtual int32_t PlayoutDelay(uint16_t& delayMS) const { return -1; } - virtual WebRtc_Word32 RecordingDelay(WebRtc_UWord16& delayMS) const { + virtual int32_t RecordingDelay(uint16_t& delayMS) const { return -1; } // CPU load - virtual WebRtc_Word32 CPULoad(WebRtc_UWord16& load) const { return -1; } + virtual int32_t CPULoad(uint16_t& load) const { return -1; } virtual bool PlayoutWarning() const { return false; } virtual bool PlayoutError() const { return false; } diff --git a/webrtc/modules/audio_device/dummy/audio_device_utility_dummy.h b/webrtc/modules/audio_device/dummy/audio_device_utility_dummy.h index 5bf72373c5..c8bb1808a5 100644 --- a/webrtc/modules/audio_device/dummy/audio_device_utility_dummy.h +++ b/webrtc/modules/audio_device/dummy/audio_device_utility_dummy.h @@ -21,10 +21,10 @@ class CriticalSectionWrapper; class AudioDeviceUtilityDummy: public AudioDeviceUtility { public: - AudioDeviceUtilityDummy(const WebRtc_Word32 id) {} + AudioDeviceUtilityDummy(const int32_t id) {} ~AudioDeviceUtilityDummy() {} - virtual WebRtc_Word32 Init() { return 0; } + virtual int32_t Init() { return 0; } }; } // namespace webrtc diff --git a/webrtc/modules/audio_device/include/audio_device.h b/webrtc/modules/audio_device/include/audio_device.h index 8b1ef16697..7b6d5e11c3 100644 --- a/webrtc/modules/audio_device/include/audio_device.h +++ b/webrtc/modules/audio_device/include/audio_device.h @@ -200,7 +200,7 @@ class AudioDeviceModule : public RefCountedModule { }; AudioDeviceModule* CreateAudioDeviceModule( - WebRtc_Word32 id, AudioDeviceModule::AudioLayer audioLayer); + int32_t id, AudioDeviceModule::AudioLayer audioLayer); } // namespace webrtc diff --git a/webrtc/modules/audio_device/ios/audio_device_ios.cc b/webrtc/modules/audio_device/ios/audio_device_ios.cc index 13818595fb..f9691f35fc 100644 --- a/webrtc/modules/audio_device/ios/audio_device_ios.cc +++ b/webrtc/modules/audio_device/ios/audio_device_ios.cc @@ -16,7 +16,7 @@ #include "thread_wrapper.h" namespace webrtc { -AudioDeviceIPhone::AudioDeviceIPhone(const WebRtc_Word32 id) +AudioDeviceIPhone::AudioDeviceIPhone(const int32_t id) : _ptrAudioBuffer(NULL), _critSect(*CriticalSectionWrapper::CreateCriticalSection()), @@ -86,7 +86,7 @@ void AudioDeviceIPhone::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) { _ptrAudioBuffer->SetPlayoutChannels(N_PLAY_CHANNELS); } -WebRtc_Word32 AudioDeviceIPhone::ActiveAudioLayer( +int32_t AudioDeviceIPhone::ActiveAudioLayer( AudioDeviceModule::AudioLayer& audioLayer) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -94,7 +94,7 @@ WebRtc_Word32 AudioDeviceIPhone::ActiveAudioLayer( return 0; } -WebRtc_Word32 AudioDeviceIPhone::Init() { +int32_t AudioDeviceIPhone::Init() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -120,7 +120,7 @@ WebRtc_Word32 AudioDeviceIPhone::Init() { unsigned int threadID(0); bool res = _captureWorkerThread->Start(threadID); - _captureWorkerThreadId = static_cast(threadID); + _captureWorkerThreadId = static_cast(threadID); WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "CaptureWorkerThread started (res=%d)", res); } else { @@ -137,7 +137,7 @@ WebRtc_Word32 AudioDeviceIPhone::Init() { return 0; } -WebRtc_Word32 AudioDeviceIPhone::Terminate() { +int32_t AudioDeviceIPhone::Terminate() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -175,7 +175,7 @@ bool AudioDeviceIPhone::Initialized() const { return (_initialized); } -WebRtc_Word32 AudioDeviceIPhone::SpeakerIsAvailable(bool& available) { +int32_t AudioDeviceIPhone::SpeakerIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -184,7 +184,7 @@ WebRtc_Word32 AudioDeviceIPhone::SpeakerIsAvailable(bool& available) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::InitSpeaker() { +int32_t AudioDeviceIPhone::InitSpeaker() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -214,7 +214,7 @@ WebRtc_Word32 AudioDeviceIPhone::InitSpeaker() { return 0; } -WebRtc_Word32 AudioDeviceIPhone::MicrophoneIsAvailable(bool& available) { +int32_t AudioDeviceIPhone::MicrophoneIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -238,7 +238,7 @@ WebRtc_Word32 AudioDeviceIPhone::MicrophoneIsAvailable(bool& available) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::InitMicrophone() { +int32_t AudioDeviceIPhone::InitMicrophone() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -281,7 +281,7 @@ bool AudioDeviceIPhone::MicrophoneIsInitialized() const { return _micIsInitialized; } -WebRtc_Word32 AudioDeviceIPhone::SpeakerVolumeIsAvailable(bool& available) { +int32_t AudioDeviceIPhone::SpeakerVolumeIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -290,7 +290,7 @@ WebRtc_Word32 AudioDeviceIPhone::SpeakerVolumeIsAvailable(bool& available) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::SetSpeakerVolume(WebRtc_UWord32 volume) { +int32_t AudioDeviceIPhone::SetSpeakerVolume(uint32_t volume) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIPhone::SetSpeakerVolume(volume=%u)", volume); @@ -299,7 +299,7 @@ WebRtc_Word32 AudioDeviceIPhone::SetSpeakerVolume(WebRtc_UWord32 volume) { return -1; } -WebRtc_Word32 AudioDeviceIPhone::SpeakerVolume(WebRtc_UWord32& volume) const { +int32_t AudioDeviceIPhone::SpeakerVolume(uint32_t& volume) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -308,9 +308,9 @@ WebRtc_Word32 AudioDeviceIPhone::SpeakerVolume(WebRtc_UWord32& volume) const { return -1; } -WebRtc_Word32 - AudioDeviceIPhone::SetWaveOutVolume(WebRtc_UWord16 volumeLeft, - WebRtc_UWord16 volumeRight) { +int32_t + AudioDeviceIPhone::SetWaveOutVolume(uint16_t volumeLeft, + uint16_t volumeRight) { WEBRTC_TRACE( kTraceModuleCall, kTraceAudioDevice, @@ -324,9 +324,9 @@ WebRtc_Word32 return -1; } -WebRtc_Word32 -AudioDeviceIPhone::WaveOutVolume(WebRtc_UWord16& /*volumeLeft*/, - WebRtc_UWord16& /*volumeRight*/) const { +int32_t +AudioDeviceIPhone::WaveOutVolume(uint16_t& /*volumeLeft*/, + uint16_t& /*volumeRight*/) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -335,8 +335,8 @@ AudioDeviceIPhone::WaveOutVolume(WebRtc_UWord16& /*volumeLeft*/, return -1; } -WebRtc_Word32 - AudioDeviceIPhone::MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const { +int32_t + AudioDeviceIPhone::MaxSpeakerVolume(uint32_t& maxVolume) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -345,8 +345,8 @@ WebRtc_Word32 return -1; } -WebRtc_Word32 AudioDeviceIPhone::MinSpeakerVolume( - WebRtc_UWord32& minVolume) const { +int32_t AudioDeviceIPhone::MinSpeakerVolume( + uint32_t& minVolume) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -355,8 +355,8 @@ WebRtc_Word32 AudioDeviceIPhone::MinSpeakerVolume( return -1; } -WebRtc_Word32 - AudioDeviceIPhone::SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const { +int32_t + AudioDeviceIPhone::SpeakerVolumeStepSize(uint16_t& stepSize) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -365,7 +365,7 @@ WebRtc_Word32 return -1; } -WebRtc_Word32 AudioDeviceIPhone::SpeakerMuteIsAvailable(bool& available) { +int32_t AudioDeviceIPhone::SpeakerMuteIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -374,7 +374,7 @@ WebRtc_Word32 AudioDeviceIPhone::SpeakerMuteIsAvailable(bool& available) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::SetSpeakerMute(bool enable) { +int32_t AudioDeviceIPhone::SetSpeakerMute(bool enable) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -383,7 +383,7 @@ WebRtc_Word32 AudioDeviceIPhone::SetSpeakerMute(bool enable) { return -1; } -WebRtc_Word32 AudioDeviceIPhone::SpeakerMute(bool& enabled) const { +int32_t AudioDeviceIPhone::SpeakerMute(bool& enabled) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -392,7 +392,7 @@ WebRtc_Word32 AudioDeviceIPhone::SpeakerMute(bool& enabled) const { return -1; } -WebRtc_Word32 AudioDeviceIPhone::MicrophoneMuteIsAvailable(bool& available) { +int32_t AudioDeviceIPhone::MicrophoneMuteIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -401,7 +401,7 @@ WebRtc_Word32 AudioDeviceIPhone::MicrophoneMuteIsAvailable(bool& available) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::SetMicrophoneMute(bool enable) { +int32_t AudioDeviceIPhone::SetMicrophoneMute(bool enable) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -410,7 +410,7 @@ WebRtc_Word32 AudioDeviceIPhone::SetMicrophoneMute(bool enable) { return -1; } -WebRtc_Word32 AudioDeviceIPhone::MicrophoneMute(bool& enabled) const { +int32_t AudioDeviceIPhone::MicrophoneMute(bool& enabled) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -419,7 +419,7 @@ WebRtc_Word32 AudioDeviceIPhone::MicrophoneMute(bool& enabled) const { return -1; } -WebRtc_Word32 AudioDeviceIPhone::MicrophoneBoostIsAvailable(bool& available) { +int32_t AudioDeviceIPhone::MicrophoneBoostIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -428,7 +428,7 @@ WebRtc_Word32 AudioDeviceIPhone::MicrophoneBoostIsAvailable(bool& available) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::SetMicrophoneBoost(bool enable) { +int32_t AudioDeviceIPhone::SetMicrophoneBoost(bool enable) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIPhone::SetMicrophoneBoost(enable=%u)", enable); @@ -447,7 +447,7 @@ WebRtc_Word32 AudioDeviceIPhone::SetMicrophoneBoost(bool enable) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::MicrophoneBoost(bool& enabled) const { +int32_t AudioDeviceIPhone::MicrophoneBoost(bool& enabled) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); if (!_micIsInitialized) { @@ -461,7 +461,7 @@ WebRtc_Word32 AudioDeviceIPhone::MicrophoneBoost(bool& enabled) const { return 0; } -WebRtc_Word32 AudioDeviceIPhone::StereoRecordingIsAvailable(bool& available) { +int32_t AudioDeviceIPhone::StereoRecordingIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -470,7 +470,7 @@ WebRtc_Word32 AudioDeviceIPhone::StereoRecordingIsAvailable(bool& available) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::SetStereoRecording(bool enable) { +int32_t AudioDeviceIPhone::SetStereoRecording(bool enable) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIPhone::SetStereoRecording(enable=%u)", enable); @@ -482,7 +482,7 @@ WebRtc_Word32 AudioDeviceIPhone::SetStereoRecording(bool enable) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::StereoRecording(bool& enabled) const { +int32_t AudioDeviceIPhone::StereoRecording(bool& enabled) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -490,7 +490,7 @@ WebRtc_Word32 AudioDeviceIPhone::StereoRecording(bool& enabled) const { return 0; } -WebRtc_Word32 AudioDeviceIPhone::StereoPlayoutIsAvailable(bool& available) { +int32_t AudioDeviceIPhone::StereoPlayoutIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -499,7 +499,7 @@ WebRtc_Word32 AudioDeviceIPhone::StereoPlayoutIsAvailable(bool& available) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::SetStereoPlayout(bool enable) { +int32_t AudioDeviceIPhone::SetStereoPlayout(bool enable) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIPhone::SetStereoPlayout(enable=%u)", enable); @@ -511,7 +511,7 @@ WebRtc_Word32 AudioDeviceIPhone::SetStereoPlayout(bool enable) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::StereoPlayout(bool& enabled) const { +int32_t AudioDeviceIPhone::StereoPlayout(bool& enabled) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -519,7 +519,7 @@ WebRtc_Word32 AudioDeviceIPhone::StereoPlayout(bool& enabled) const { return 0; } -WebRtc_Word32 AudioDeviceIPhone::SetAGC(bool enable) { +int32_t AudioDeviceIPhone::SetAGC(bool enable) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIPhone::SetAGC(enable=%d)", enable); @@ -535,7 +535,7 @@ bool AudioDeviceIPhone::AGC() const { return _AGC; } -WebRtc_Word32 AudioDeviceIPhone::MicrophoneVolumeIsAvailable(bool& available) { +int32_t AudioDeviceIPhone::MicrophoneVolumeIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -544,7 +544,7 @@ WebRtc_Word32 AudioDeviceIPhone::MicrophoneVolumeIsAvailable(bool& available) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::SetMicrophoneVolume(WebRtc_UWord32 volume) { +int32_t AudioDeviceIPhone::SetMicrophoneVolume(uint32_t volume) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIPhone::SetMicrophoneVolume(volume=%u)", volume); @@ -553,8 +553,8 @@ WebRtc_Word32 AudioDeviceIPhone::SetMicrophoneVolume(WebRtc_UWord32 volume) { return -1; } -WebRtc_Word32 - AudioDeviceIPhone::MicrophoneVolume(WebRtc_UWord32& volume) const { +int32_t + AudioDeviceIPhone::MicrophoneVolume(uint32_t& volume) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -563,8 +563,8 @@ WebRtc_Word32 return -1; } -WebRtc_Word32 - AudioDeviceIPhone::MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const { +int32_t + AudioDeviceIPhone::MaxMicrophoneVolume(uint32_t& maxVolume) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -573,8 +573,8 @@ WebRtc_Word32 return -1; } -WebRtc_Word32 - AudioDeviceIPhone::MinMicrophoneVolume(WebRtc_UWord32& minVolume) const { +int32_t + AudioDeviceIPhone::MinMicrophoneVolume(uint32_t& minVolume) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -583,9 +583,9 @@ WebRtc_Word32 return -1; } -WebRtc_Word32 +int32_t AudioDeviceIPhone::MicrophoneVolumeStepSize( - WebRtc_UWord16& stepSize) const { + uint16_t& stepSize) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -594,14 +594,14 @@ WebRtc_Word32 return -1; } -WebRtc_Word16 AudioDeviceIPhone::PlayoutDevices() { +int16_t AudioDeviceIPhone::PlayoutDevices() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); - return (WebRtc_Word16)1; + return (int16_t)1; } -WebRtc_Word32 AudioDeviceIPhone::SetPlayoutDevice(WebRtc_UWord16 index) { +int32_t AudioDeviceIPhone::SetPlayoutDevice(uint16_t index) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIPhone::SetPlayoutDevice(index=%u)", index); @@ -621,15 +621,15 @@ WebRtc_Word32 AudioDeviceIPhone::SetPlayoutDevice(WebRtc_UWord16 index) { return 0; } -WebRtc_Word32 +int32_t AudioDeviceIPhone::SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "WindowsDeviceType not supported"); return -1; } -WebRtc_Word32 - AudioDeviceIPhone::PlayoutDeviceName(WebRtc_UWord16 index, +int32_t + AudioDeviceIPhone::PlayoutDeviceName(uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, @@ -647,8 +647,8 @@ WebRtc_Word32 return 0; } -WebRtc_Word32 - AudioDeviceIPhone::RecordingDeviceName(WebRtc_UWord16 index, +int32_t + AudioDeviceIPhone::RecordingDeviceName(uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, @@ -666,13 +666,13 @@ WebRtc_Word32 return 0; } -WebRtc_Word16 AudioDeviceIPhone::RecordingDevices() { +int16_t AudioDeviceIPhone::RecordingDevices() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); - return (WebRtc_Word16)1; + return (int16_t)1; } -WebRtc_Word32 AudioDeviceIPhone::SetRecordingDevice(WebRtc_UWord16 index) { +int32_t AudioDeviceIPhone::SetRecordingDevice(uint16_t index) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIPhone::SetRecordingDevice(index=%u)", index); @@ -693,7 +693,7 @@ WebRtc_Word32 AudioDeviceIPhone::SetRecordingDevice(WebRtc_UWord16 index) { return 0; } -WebRtc_Word32 +int32_t AudioDeviceIPhone::SetRecordingDevice( AudioDeviceModule::WindowsDeviceType) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, @@ -709,7 +709,7 @@ WebRtc_Word32 // documentation. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceIPhone::SetLoudspeakerStatus(bool enable) { +int32_t AudioDeviceIPhone::SetLoudspeakerStatus(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioDeviceIPhone::SetLoudspeakerStatus(enable=%d)", enable); @@ -728,7 +728,7 @@ WebRtc_Word32 AudioDeviceIPhone::SetLoudspeakerStatus(bool enable) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::GetLoudspeakerStatus(bool &enabled) const { +int32_t AudioDeviceIPhone::GetLoudspeakerStatus(bool &enabled) const { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioDeviceIPhone::SetLoudspeakerStatus(enabled=?)"); @@ -749,13 +749,13 @@ WebRtc_Word32 AudioDeviceIPhone::GetLoudspeakerStatus(bool &enabled) const { return 0; } -WebRtc_Word32 AudioDeviceIPhone::PlayoutIsAvailable(bool& available) { +int32_t AudioDeviceIPhone::PlayoutIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); available = false; // Try to initialize the playout side - WebRtc_Word32 res = InitPlayout(); + int32_t res = InitPlayout(); // Cancel effect of initialization StopPlayout(); @@ -767,13 +767,13 @@ WebRtc_Word32 AudioDeviceIPhone::PlayoutIsAvailable(bool& available) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::RecordingIsAvailable(bool& available) { +int32_t AudioDeviceIPhone::RecordingIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); available = false; // Try to initialize the recording side - WebRtc_Word32 res = InitRecording(); + int32_t res = InitRecording(); // Cancel effect of initialization StopRecording(); @@ -785,7 +785,7 @@ WebRtc_Word32 AudioDeviceIPhone::RecordingIsAvailable(bool& available) { return 0; } -WebRtc_Word32 AudioDeviceIPhone::InitPlayout() { +int32_t AudioDeviceIPhone::InitPlayout() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); @@ -841,7 +841,7 @@ bool AudioDeviceIPhone::PlayoutIsInitialized() const { return (_playIsInitialized); } -WebRtc_Word32 AudioDeviceIPhone::InitRecording() { +int32_t AudioDeviceIPhone::InitRecording() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); @@ -899,7 +899,7 @@ bool AudioDeviceIPhone::RecordingIsInitialized() const { return (_recIsInitialized); } -WebRtc_Word32 AudioDeviceIPhone::StartRecording() { +int32_t AudioDeviceIPhone::StartRecording() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); @@ -946,7 +946,7 @@ WebRtc_Word32 AudioDeviceIPhone::StartRecording() { return 0; } -WebRtc_Word32 AudioDeviceIPhone::StopRecording() { +int32_t AudioDeviceIPhone::StopRecording() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); @@ -975,7 +975,7 @@ bool AudioDeviceIPhone::Recording() const { return (_recording); } -WebRtc_Word32 AudioDeviceIPhone::StartPlayout() { +int32_t AudioDeviceIPhone::StartPlayout() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); // This lock is (among other things) needed to avoid concurrency issues @@ -1021,7 +1021,7 @@ WebRtc_Word32 AudioDeviceIPhone::StartPlayout() { return 0; } -WebRtc_Word32 AudioDeviceIPhone::StopPlayout() { +int32_t AudioDeviceIPhone::StopPlayout() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); @@ -1058,7 +1058,7 @@ bool AudioDeviceIPhone::Playing() const { // and set enable states after shutdown to same as current. // In capture thread audio device will be shutdown, then started again. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceIPhone::ResetAudioDevice() { +int32_t AudioDeviceIPhone::ResetAudioDevice() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); @@ -1100,20 +1100,20 @@ WebRtc_Word32 AudioDeviceIPhone::ResetAudioDevice() { return 0; } -WebRtc_Word32 AudioDeviceIPhone::PlayoutDelay(WebRtc_UWord16& delayMS) const { +int32_t AudioDeviceIPhone::PlayoutDelay(uint16_t& delayMS) const { delayMS = _playoutDelay; return 0; } -WebRtc_Word32 AudioDeviceIPhone::RecordingDelay(WebRtc_UWord16& delayMS) const { +int32_t AudioDeviceIPhone::RecordingDelay(uint16_t& delayMS) const { delayMS = _recordingDelay; return 0; } -WebRtc_Word32 +int32_t AudioDeviceIPhone::SetPlayoutBuffer( const AudioDeviceModule::BufferType type, - WebRtc_UWord16 sizeMS) { + uint16_t sizeMS) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIPhone::SetPlayoutBuffer(type=%u, sizeMS=%u)", type, sizeMS); @@ -1123,9 +1123,9 @@ WebRtc_Word32 return -1; } -WebRtc_Word32 +int32_t AudioDeviceIPhone::PlayoutBuffer(AudioDeviceModule::BufferType& type, - WebRtc_UWord16& sizeMS) const { + uint16_t& sizeMS) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); type = AudioDeviceModule::kAdaptiveBufferSize; @@ -1135,7 +1135,7 @@ WebRtc_Word32 return 0; } -WebRtc_Word32 AudioDeviceIPhone::CPULoad(WebRtc_UWord16& /*load*/) const { +int32_t AudioDeviceIPhone::CPULoad(uint16_t& /*load*/) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -1179,7 +1179,7 @@ void AudioDeviceIPhone::ClearRecordingError() { // Private Methods // ============================================================================ -WebRtc_Word32 AudioDeviceIPhone::InitPlayOrRecord() { +int32_t AudioDeviceIPhone::InitPlayOrRecord() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); OSStatus result = -1; @@ -1229,7 +1229,7 @@ WebRtc_Word32 AudioDeviceIPhone::InitPlayOrRecord() { "Could not set preferred sample rate (result=%d)", result); } - WebRtc_UWord32 voiceChat = kAudioSessionMode_VoiceChat; + uint32_t voiceChat = kAudioSessionMode_VoiceChat; AudioSessionSetProperty(kAudioSessionProperty_Mode, sizeof(voiceChat), &voiceChat); @@ -1441,7 +1441,7 @@ WebRtc_Word32 AudioDeviceIPhone::InitPlayOrRecord() { return 0; } -WebRtc_Word32 AudioDeviceIPhone::ShutdownPlayOrRecord() { +int32_t AudioDeviceIPhone::ShutdownPlayOrRecord() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); // Close and delete AU @@ -1487,13 +1487,13 @@ OSStatus AudioDeviceIPhone::RecordProcessImpl( AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, - WebRtc_UWord32 inBusNumber, - WebRtc_UWord32 inNumberFrames) { + uint32_t inBusNumber, + uint32_t inNumberFrames) { // Setup some basic stuff // Use temp buffer not to lock up recording buffer more than necessary // todo: Make dataTmp a member variable with static size that holds // max possible frames? - WebRtc_Word16* dataTmp = new WebRtc_Word16[inNumberFrames]; + int16_t* dataTmp = new int16_t[inNumberFrames]; memset(dataTmp, 0, 2*inNumberFrames); AudioBufferList abList; @@ -1528,8 +1528,8 @@ OSStatus const unsigned int noSamp10ms = _adbSampFreq / 100; unsigned int dataPos = 0; - WebRtc_UWord16 bufPos = 0; - WebRtc_Word16 insertPos = -1; + uint16_t bufPos = 0; + int16_t insertPos = -1; unsigned int nCopy = 0; // Number of samples to copy while (dataPos < inNumberFrames) { @@ -1544,13 +1544,13 @@ OSStatus if ((_recordingLength[bufPos] > 0) && (_recordingLength[bufPos] < noSamp10ms)) { // Found the partially full buffer - insertPos = static_cast(bufPos); + insertPos = static_cast(bufPos); // Don't need to search more, quit loop bufPos = N_REC_BUFFERS; } else if ((-1 == insertPos) && (0 == _recordingLength[bufPos])) { // Found an empty buffer - insertPos = static_cast(bufPos); + insertPos = static_cast(bufPos); } ++bufPos; } @@ -1564,7 +1564,7 @@ OSStatus nCopy = (dataToCopy < roomInBuffer ? dataToCopy : roomInBuffer); memcpy(&_recordingBuffer[insertPos][currentRecLen], - &dataTmp[dataPos], nCopy*sizeof(WebRtc_Word16)); + &dataTmp[dataPos], nCopy*sizeof(int16_t)); if (0 == currentRecLen) { _recordingSeqNumber[insertPos] = _recordingCurrentSeq; ++_recordingCurrentSeq; @@ -1606,13 +1606,13 @@ OSStatus } OSStatus - AudioDeviceIPhone::PlayoutProcessImpl(WebRtc_UWord32 inNumberFrames, + AudioDeviceIPhone::PlayoutProcessImpl(uint32_t inNumberFrames, AudioBufferList *ioData) { // Setup some basic stuff // assert(sizeof(short) == 2); // Assumption for implementation - WebRtc_Word16* data = - static_cast(ioData->mBuffers[0].mData); + int16_t* data = + static_cast(ioData->mBuffers[0].mData); unsigned int dataSizeBytes = ioData->mBuffers[0].mDataByteSize; unsigned int dataSize = dataSizeBytes/2; // Number of samples if (dataSize != inNumberFrames) { // Should always be the same @@ -1633,7 +1633,7 @@ OSStatus if (_playing) { unsigned int noSamp10ms = _adbSampFreq / 100; // todo: Member variable and allocate when samp freq is determined - WebRtc_Word16* dataTmp = new WebRtc_Word16[noSamp10ms]; + int16_t* dataTmp = new int16_t[noSamp10ms]; memset(dataTmp, 0, 2*noSamp10ms); unsigned int dataPos = 0; int noSamplesOut = 0; @@ -1673,7 +1673,7 @@ OSStatus // Get data from Audio Device Buffer noSamplesOut = _ptrAudioBuffer->GetPlayoutData( - reinterpret_cast(dataTmp)); + reinterpret_cast(dataTmp)); // Cast OK since only equality comparison if (noSamp10ms != (unsigned int)noSamplesOut) { // Should never happen @@ -1812,7 +1812,7 @@ void AudioDeviceIPhone::UpdateRecordingDelay() { // ADB recording buffer size, update every time // Don't count the one next 10 ms to be sent, then convert samples => ms - const WebRtc_UWord32 noSamp10ms = _adbSampFreq / 100; + const uint32_t noSamp10ms = _adbSampFreq / 100; if (_recordingBufferTotalSize > noSamp10ms) { _recordingDelay += (_recordingBufferTotalSize - noSamp10ms) / (_adbSampFreq / 1000); @@ -1856,7 +1856,7 @@ bool AudioDeviceIPhone::CaptureWorkerThread() { // Set the recorded buffer _ptrAudioBuffer->SetRecordedBuffer( - reinterpret_cast( + reinterpret_cast( _recordingBuffer[lowestSeqBufPos]), _recordingLength[lowestSeqBufPos]); diff --git a/webrtc/modules/audio_device/ios/audio_device_ios.h b/webrtc/modules/audio_device/ios/audio_device_ios.h index dc32482305..2e5cdc28f6 100644 --- a/webrtc/modules/audio_device/ios/audio_device_ios.h +++ b/webrtc/modules/audio_device/ios/audio_device_ios.h @@ -19,138 +19,135 @@ namespace webrtc { class ThreadWrapper; -const WebRtc_UWord32 N_REC_SAMPLES_PER_SEC = 44000; -const WebRtc_UWord32 N_PLAY_SAMPLES_PER_SEC = 44000; +const uint32_t N_REC_SAMPLES_PER_SEC = 44000; +const uint32_t N_PLAY_SAMPLES_PER_SEC = 44000; -const WebRtc_UWord32 N_REC_CHANNELS = 1; // default is mono recording -const WebRtc_UWord32 N_PLAY_CHANNELS = 1; // default is mono playout -const WebRtc_UWord32 N_DEVICE_CHANNELS = 8; +const uint32_t N_REC_CHANNELS = 1; // default is mono recording +const uint32_t N_PLAY_CHANNELS = 1; // default is mono playout +const uint32_t N_DEVICE_CHANNELS = 8; -const WebRtc_UWord32 ENGINE_REC_BUF_SIZE_IN_SAMPLES = (N_REC_SAMPLES_PER_SEC - / 100); -const WebRtc_UWord32 ENGINE_PLAY_BUF_SIZE_IN_SAMPLES = (N_PLAY_SAMPLES_PER_SEC - / 100); +const uint32_t ENGINE_REC_BUF_SIZE_IN_SAMPLES = (N_REC_SAMPLES_PER_SEC / 100); +const uint32_t ENGINE_PLAY_BUF_SIZE_IN_SAMPLES = (N_PLAY_SAMPLES_PER_SEC / 100); // Number of 10 ms recording blocks in recording buffer -const WebRtc_UWord16 N_REC_BUFFERS = 20; +const uint16_t N_REC_BUFFERS = 20; class AudioDeviceIPhone : public AudioDeviceGeneric { public: - AudioDeviceIPhone(const WebRtc_Word32 id); + AudioDeviceIPhone(const int32_t id); ~AudioDeviceIPhone(); // Retrieve the currently utilized audio layer - virtual WebRtc_Word32 + virtual int32_t ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const; // Main initializaton and termination - virtual WebRtc_Word32 Init(); - virtual WebRtc_Word32 Terminate(); + virtual int32_t Init(); + virtual int32_t Terminate(); virtual bool Initialized() const; // Device enumeration - virtual WebRtc_Word16 PlayoutDevices(); - virtual WebRtc_Word16 RecordingDevices(); - virtual WebRtc_Word32 PlayoutDeviceName(WebRtc_UWord16 index, - char name[kAdmMaxDeviceNameSize], - char guid[kAdmMaxGuidSize]); - virtual WebRtc_Word32 RecordingDeviceName(WebRtc_UWord16 index, - char name[kAdmMaxDeviceNameSize], - char guid[kAdmMaxGuidSize]); + virtual int16_t PlayoutDevices(); + virtual int16_t RecordingDevices(); + virtual int32_t PlayoutDeviceName(uint16_t index, + char name[kAdmMaxDeviceNameSize], + char guid[kAdmMaxGuidSize]); + virtual int32_t RecordingDeviceName(uint16_t index, + char name[kAdmMaxDeviceNameSize], + char guid[kAdmMaxGuidSize]); // Device selection - virtual WebRtc_Word32 SetPlayoutDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 + virtual int32_t SetPlayoutDevice(uint16_t index); + virtual int32_t SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType device); - virtual WebRtc_Word32 SetRecordingDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetRecordingDevice( + virtual int32_t SetRecordingDevice(uint16_t index); + virtual int32_t SetRecordingDevice( AudioDeviceModule::WindowsDeviceType device); // Audio transport initialization - virtual WebRtc_Word32 PlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 InitPlayout(); + virtual int32_t PlayoutIsAvailable(bool& available); + virtual int32_t InitPlayout(); virtual bool PlayoutIsInitialized() const; - virtual WebRtc_Word32 RecordingIsAvailable(bool& available); - virtual WebRtc_Word32 InitRecording(); + virtual int32_t RecordingIsAvailable(bool& available); + virtual int32_t InitRecording(); virtual bool RecordingIsInitialized() const; // Audio transport control - virtual WebRtc_Word32 StartPlayout(); - virtual WebRtc_Word32 StopPlayout(); + virtual int32_t StartPlayout(); + virtual int32_t StopPlayout(); virtual bool Playing() const; - virtual WebRtc_Word32 StartRecording(); - virtual WebRtc_Word32 StopRecording(); + virtual int32_t StartRecording(); + virtual int32_t StopRecording(); virtual bool Recording() const; // Microphone Automatic Gain Control (AGC) - virtual WebRtc_Word32 SetAGC(bool enable); + virtual int32_t SetAGC(bool enable); virtual bool AGC() const; // Volume control based on the Windows Wave API (Windows only) - virtual WebRtc_Word32 SetWaveOutVolume(WebRtc_UWord16 volumeLeft, - WebRtc_UWord16 volumeRight); - virtual WebRtc_Word32 WaveOutVolume(WebRtc_UWord16& volumeLeft, - WebRtc_UWord16& volumeRight) const; + virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight); + virtual int32_t WaveOutVolume(uint16_t& volumeLeft, + uint16_t& volumeRight) const; // Audio mixer initialization - virtual WebRtc_Word32 SpeakerIsAvailable(bool& available); - virtual WebRtc_Word32 InitSpeaker(); + virtual int32_t SpeakerIsAvailable(bool& available); + virtual int32_t InitSpeaker(); virtual bool SpeakerIsInitialized() const; - virtual WebRtc_Word32 MicrophoneIsAvailable(bool& available); - virtual WebRtc_Word32 InitMicrophone(); + virtual int32_t MicrophoneIsAvailable(bool& available); + virtual int32_t InitMicrophone(); virtual bool MicrophoneIsInitialized() const; // Speaker volume controls - virtual WebRtc_Word32 SpeakerVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 SpeakerVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const; + virtual int32_t SpeakerVolumeIsAvailable(bool& available); + virtual int32_t SetSpeakerVolume(uint32_t volume); + virtual int32_t SpeakerVolume(uint32_t& volume) const; + virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const; + virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const; + virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const; // Microphone volume controls - virtual WebRtc_Word32 MicrophoneVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinMicrophoneVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 - MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const; + virtual int32_t MicrophoneVolumeIsAvailable(bool& available); + virtual int32_t SetMicrophoneVolume(uint32_t volume); + virtual int32_t MicrophoneVolume(uint32_t& volume) const; + virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const; + virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const; + virtual int32_t + MicrophoneVolumeStepSize(uint16_t& stepSize) const; // Microphone mute control - virtual WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneMute(bool enable); - virtual WebRtc_Word32 MicrophoneMute(bool& enabled) const; + virtual int32_t MicrophoneMuteIsAvailable(bool& available); + virtual int32_t SetMicrophoneMute(bool enable); + virtual int32_t MicrophoneMute(bool& enabled) const; // Speaker mute control - virtual WebRtc_Word32 SpeakerMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerMute(bool enable); - virtual WebRtc_Word32 SpeakerMute(bool& enabled) const; + virtual int32_t SpeakerMuteIsAvailable(bool& available); + virtual int32_t SetSpeakerMute(bool enable); + virtual int32_t SpeakerMute(bool& enabled) const; // Microphone boost control - virtual WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneBoost(bool enable); - virtual WebRtc_Word32 MicrophoneBoost(bool& enabled) const; + virtual int32_t MicrophoneBoostIsAvailable(bool& available); + virtual int32_t SetMicrophoneBoost(bool enable); + virtual int32_t MicrophoneBoost(bool& enabled) const; // Stereo support - virtual WebRtc_Word32 StereoPlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoPlayout(bool enable); - virtual WebRtc_Word32 StereoPlayout(bool& enabled) const; - virtual WebRtc_Word32 StereoRecordingIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoRecording(bool enable); - virtual WebRtc_Word32 StereoRecording(bool& enabled) const; + virtual int32_t StereoPlayoutIsAvailable(bool& available); + virtual int32_t SetStereoPlayout(bool enable); + virtual int32_t StereoPlayout(bool& enabled) const; + virtual int32_t StereoRecordingIsAvailable(bool& available); + virtual int32_t SetStereoRecording(bool enable); + virtual int32_t StereoRecording(bool& enabled) const; // Delay information and control - virtual WebRtc_Word32 + virtual int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type, - WebRtc_UWord16 sizeMS); - virtual WebRtc_Word32 PlayoutBuffer(AudioDeviceModule::BufferType& type, - WebRtc_UWord16& sizeMS) const; - virtual WebRtc_Word32 PlayoutDelay(WebRtc_UWord16& delayMS) const; - virtual WebRtc_Word32 RecordingDelay(WebRtc_UWord16& delayMS) const; + uint16_t sizeMS); + virtual int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type, + uint16_t& sizeMS) const; + virtual int32_t PlayoutDelay(uint16_t& delayMS) const; + virtual int32_t RecordingDelay(uint16_t& delayMS) const; // CPU load - virtual WebRtc_Word32 CPULoad(WebRtc_UWord16& load) const; + virtual int32_t CPULoad(uint16_t& load) const; public: virtual bool PlayoutWarning() const; @@ -166,11 +163,11 @@ public: virtual void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer); // Reset Audio Deivce (for mobile devices only) - virtual WebRtc_Word32 ResetAudioDevice(); + virtual int32_t ResetAudioDevice(); // enable or disable loud speaker (for iphone only) - virtual WebRtc_Word32 SetLoudspeakerStatus(bool enable); - virtual WebRtc_Word32 GetLoudspeakerStatus(bool& enabled) const; + virtual int32_t SetLoudspeakerStatus(bool enable); + virtual int32_t GetLoudspeakerStatus(bool& enabled) const; private: void Lock() { @@ -181,13 +178,13 @@ private: _critSect.Leave(); } - WebRtc_Word32 Id() { + int32_t Id() { return _id; } // Init and shutdown - WebRtc_Word32 InitPlayOrRecord(); - WebRtc_Word32 ShutdownPlayOrRecord(); + int32_t InitPlayOrRecord(); + int32_t ShutdownPlayOrRecord(); void UpdateRecordingDelay(); void UpdatePlayoutDelay(); @@ -208,10 +205,10 @@ private: OSStatus RecordProcessImpl(AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *WebRtc_Word32imeStamp, - WebRtc_UWord32 inBusNumber, - WebRtc_UWord32 inNumberFrames); + uint32_t inBusNumber, + uint32_t inNumberFrames); - OSStatus PlayoutProcessImpl(WebRtc_UWord32 inNumberFrames, + OSStatus PlayoutProcessImpl(uint32_t inNumberFrames, AudioBufferList *ioData); static bool RunCapture(void* ptrThis); @@ -223,9 +220,9 @@ private: CriticalSectionWrapper& _critSect; ThreadWrapper* _captureWorkerThread; - WebRtc_UWord32 _captureWorkerThreadId; + uint32_t _captureWorkerThreadId; - WebRtc_Word32 _id; + int32_t _id; AudioUnit _auVoiceProcessing; @@ -245,34 +242,34 @@ private: bool _AGC; // The sampling rate to use with Audio Device Buffer - WebRtc_UWord32 _adbSampFreq; + uint32_t _adbSampFreq; // Delay calculation - WebRtc_UWord32 _recordingDelay; - WebRtc_UWord32 _playoutDelay; - WebRtc_UWord32 _playoutDelayMeasurementCounter; - WebRtc_UWord32 _recordingDelayHWAndOS; - WebRtc_UWord32 _recordingDelayMeasurementCounter; + uint32_t _recordingDelay; + uint32_t _playoutDelay; + uint32_t _playoutDelayMeasurementCounter; + uint32_t _recordingDelayHWAndOS; + uint32_t _recordingDelayMeasurementCounter; // Errors and warnings count - WebRtc_UWord16 _playWarning; - WebRtc_UWord16 _playError; - WebRtc_UWord16 _recWarning; - WebRtc_UWord16 _recError; + uint16_t _playWarning; + uint16_t _playError; + uint16_t _recWarning; + uint16_t _recError; // Playout buffer, needed for 44.0 / 44.1 kHz mismatch - WebRtc_Word16 _playoutBuffer[ENGINE_PLAY_BUF_SIZE_IN_SAMPLES]; - WebRtc_UWord32 _playoutBufferUsed; // How much is filled + int16_t _playoutBuffer[ENGINE_PLAY_BUF_SIZE_IN_SAMPLES]; + uint32_t _playoutBufferUsed; // How much is filled // Recording buffers - WebRtc_Word16 + int16_t _recordingBuffer[N_REC_BUFFERS][ENGINE_REC_BUF_SIZE_IN_SAMPLES]; - WebRtc_UWord32 _recordingLength[N_REC_BUFFERS]; - WebRtc_UWord32 _recordingSeqNumber[N_REC_BUFFERS]; - WebRtc_UWord32 _recordingCurrentSeq; + uint32_t _recordingLength[N_REC_BUFFERS]; + uint32_t _recordingSeqNumber[N_REC_BUFFERS]; + uint32_t _recordingCurrentSeq; // Current total size all data in buffers, used for delay estimate - WebRtc_UWord32 _recordingBufferTotalSize; + uint32_t _recordingBufferTotalSize; }; } // namespace webrtc diff --git a/webrtc/modules/audio_device/ios/audio_device_utility_ios.cc b/webrtc/modules/audio_device/ios/audio_device_utility_ios.cc index 965d13ff4b..bb4a1c1870 100644 --- a/webrtc/modules/audio_device/ios/audio_device_utility_ios.cc +++ b/webrtc/modules/audio_device/ios/audio_device_utility_ios.cc @@ -15,7 +15,7 @@ #include "trace.h" namespace webrtc { -AudioDeviceUtilityIPhone::AudioDeviceUtilityIPhone(const WebRtc_Word32 id) +AudioDeviceUtilityIPhone::AudioDeviceUtilityIPhone(const int32_t id) : _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _id(id), @@ -32,7 +32,7 @@ AudioDeviceUtilityIPhone::~AudioDeviceUtilityIPhone() { delete &_critSect; } -WebRtc_Word32 AudioDeviceUtilityIPhone::Init() { +int32_t AudioDeviceUtilityIPhone::Init() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); diff --git a/webrtc/modules/audio_device/ios/audio_device_utility_ios.h b/webrtc/modules/audio_device/ios/audio_device_utility_ios.h index 663b1f771a..2892a7d009 100644 --- a/webrtc/modules/audio_device/ios/audio_device_utility_ios.h +++ b/webrtc/modules/audio_device/ios/audio_device_utility_ios.h @@ -19,15 +19,15 @@ class CriticalSectionWrapper; class AudioDeviceUtilityIPhone: public AudioDeviceUtility { public: - AudioDeviceUtilityIPhone(const WebRtc_Word32 id); + AudioDeviceUtilityIPhone(const int32_t id); AudioDeviceUtilityIPhone(); virtual ~AudioDeviceUtilityIPhone(); - virtual WebRtc_Word32 Init(); + virtual int32_t Init(); private: CriticalSectionWrapper& _critSect; - WebRtc_Word32 _id; + int32_t _id; AudioDeviceModule::ErrorCode _lastError; }; diff --git a/webrtc/modules/audio_device/linux/audio_device_alsa_linux.cc b/webrtc/modules/audio_device/linux/audio_device_alsa_linux.cc index 14e166745f..2b7ed2e0bd 100644 --- a/webrtc/modules/audio_device/linux/audio_device_alsa_linux.cc +++ b/webrtc/modules/audio_device/linux/audio_device_alsa_linux.cc @@ -63,7 +63,7 @@ static const unsigned int ALSA_CAPTURE_WAIT_TIMEOUT = 5; // in ms #define FUNC_GET_DEVICE_NAME 1 #define FUNC_GET_DEVICE_NAME_FOR_AN_ENUM 2 -AudioDeviceLinuxALSA::AudioDeviceLinuxALSA(const WebRtc_Word32 id) : +AudioDeviceLinuxALSA::AudioDeviceLinuxALSA(const int32_t id) : _ptrAudioBuffer(NULL), _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _ptrThreadRec(NULL), @@ -155,14 +155,14 @@ void AudioDeviceLinuxALSA::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) _ptrAudioBuffer->SetPlayoutChannels(0); } -WebRtc_Word32 AudioDeviceLinuxALSA::ActiveAudioLayer( +int32_t AudioDeviceLinuxALSA::ActiveAudioLayer( AudioDeviceModule::AudioLayer& audioLayer) const { audioLayer = AudioDeviceModule::kLinuxAlsaAudio; return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::Init() +int32_t AudioDeviceLinuxALSA::Init() { CriticalSectionScoped lock(&_critSect); @@ -192,7 +192,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::Init() return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::Terminate() +int32_t AudioDeviceLinuxALSA::Terminate() { if (!_initialized) @@ -260,7 +260,7 @@ bool AudioDeviceLinuxALSA::Initialized() const return (_initialized); } -WebRtc_Word32 AudioDeviceLinuxALSA::SpeakerIsAvailable(bool& available) +int32_t AudioDeviceLinuxALSA::SpeakerIsAvailable(bool& available) { bool wasInitialized = _mixerManager.SpeakerIsInitialized(); @@ -288,7 +288,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SpeakerIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::InitSpeaker() +int32_t AudioDeviceLinuxALSA::InitSpeaker() { CriticalSectionScoped lock(&_critSect); @@ -303,7 +303,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::InitSpeaker() return _mixerManager.OpenSpeaker(devName); } -WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneIsAvailable(bool& available) +int32_t AudioDeviceLinuxALSA::MicrophoneIsAvailable(bool& available) { bool wasInitialized = _mixerManager.MicrophoneIsInitialized(); @@ -331,7 +331,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::InitMicrophone() +int32_t AudioDeviceLinuxALSA::InitMicrophone() { CriticalSectionScoped lock(&_critSect); @@ -356,7 +356,7 @@ bool AudioDeviceLinuxALSA::MicrophoneIsInitialized() const return (_mixerManager.MicrophoneIsInitialized()); } -WebRtc_Word32 AudioDeviceLinuxALSA::SpeakerVolumeIsAvailable(bool& available) +int32_t AudioDeviceLinuxALSA::SpeakerVolumeIsAvailable(bool& available) { bool wasInitialized = _mixerManager.SpeakerIsInitialized(); @@ -384,16 +384,16 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SpeakerVolumeIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::SetSpeakerVolume(WebRtc_UWord32 volume) +int32_t AudioDeviceLinuxALSA::SetSpeakerVolume(uint32_t volume) { return (_mixerManager.SetSpeakerVolume(volume)); } -WebRtc_Word32 AudioDeviceLinuxALSA::SpeakerVolume(WebRtc_UWord32& volume) const +int32_t AudioDeviceLinuxALSA::SpeakerVolume(uint32_t& volume) const { - WebRtc_UWord32 level(0); + uint32_t level(0); if (_mixerManager.SpeakerVolume(level) == -1) { @@ -406,8 +406,8 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SpeakerVolume(WebRtc_UWord32& volume) const } -WebRtc_Word32 AudioDeviceLinuxALSA::SetWaveOutVolume(WebRtc_UWord16 volumeLeft, - WebRtc_UWord16 volumeRight) +int32_t AudioDeviceLinuxALSA::SetWaveOutVolume(uint16_t volumeLeft, + uint16_t volumeRight) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -415,9 +415,9 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SetWaveOutVolume(WebRtc_UWord16 volumeLeft, return -1; } -WebRtc_Word32 AudioDeviceLinuxALSA::WaveOutVolume( - WebRtc_UWord16& /*volumeLeft*/, - WebRtc_UWord16& /*volumeRight*/) const +int32_t AudioDeviceLinuxALSA::WaveOutVolume( + uint16_t& /*volumeLeft*/, + uint16_t& /*volumeRight*/) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -425,11 +425,11 @@ WebRtc_Word32 AudioDeviceLinuxALSA::WaveOutVolume( return -1; } -WebRtc_Word32 AudioDeviceLinuxALSA::MaxSpeakerVolume( - WebRtc_UWord32& maxVolume) const +int32_t AudioDeviceLinuxALSA::MaxSpeakerVolume( + uint32_t& maxVolume) const { - WebRtc_UWord32 maxVol(0); + uint32_t maxVol(0); if (_mixerManager.MaxSpeakerVolume(maxVol) == -1) { @@ -441,11 +441,11 @@ WebRtc_Word32 AudioDeviceLinuxALSA::MaxSpeakerVolume( return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::MinSpeakerVolume( - WebRtc_UWord32& minVolume) const +int32_t AudioDeviceLinuxALSA::MinSpeakerVolume( + uint32_t& minVolume) const { - WebRtc_UWord32 minVol(0); + uint32_t minVol(0); if (_mixerManager.MinSpeakerVolume(minVol) == -1) { @@ -457,11 +457,11 @@ WebRtc_Word32 AudioDeviceLinuxALSA::MinSpeakerVolume( return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::SpeakerVolumeStepSize( - WebRtc_UWord16& stepSize) const +int32_t AudioDeviceLinuxALSA::SpeakerVolumeStepSize( + uint16_t& stepSize) const { - WebRtc_UWord16 delta(0); + uint16_t delta(0); if (_mixerManager.SpeakerVolumeStepSize(delta) == -1) { @@ -473,7 +473,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SpeakerVolumeStepSize( return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::SpeakerMuteIsAvailable(bool& available) +int32_t AudioDeviceLinuxALSA::SpeakerMuteIsAvailable(bool& available) { bool isAvailable(false); @@ -505,12 +505,12 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SpeakerMuteIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::SetSpeakerMute(bool enable) +int32_t AudioDeviceLinuxALSA::SetSpeakerMute(bool enable) { return (_mixerManager.SetSpeakerMute(enable)); } -WebRtc_Word32 AudioDeviceLinuxALSA::SpeakerMute(bool& enabled) const +int32_t AudioDeviceLinuxALSA::SpeakerMute(bool& enabled) const { bool muted(0); @@ -525,7 +525,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SpeakerMute(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneMuteIsAvailable(bool& available) +int32_t AudioDeviceLinuxALSA::MicrophoneMuteIsAvailable(bool& available) { bool isAvailable(false); @@ -558,7 +558,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneMuteIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::SetMicrophoneMute(bool enable) +int32_t AudioDeviceLinuxALSA::SetMicrophoneMute(bool enable) { return (_mixerManager.SetMicrophoneMute(enable)); } @@ -567,7 +567,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SetMicrophoneMute(bool enable) // MicrophoneMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneMute(bool& enabled) const +int32_t AudioDeviceLinuxALSA::MicrophoneMute(bool& enabled) const { bool muted(0); @@ -581,7 +581,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneMute(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneBoostIsAvailable(bool& available) +int32_t AudioDeviceLinuxALSA::MicrophoneBoostIsAvailable(bool& available) { bool isAvailable(false); @@ -612,13 +612,13 @@ WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneBoostIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::SetMicrophoneBoost(bool enable) +int32_t AudioDeviceLinuxALSA::SetMicrophoneBoost(bool enable) { return (_mixerManager.SetMicrophoneBoost(enable)); } -WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneBoost(bool& enabled) const +int32_t AudioDeviceLinuxALSA::MicrophoneBoost(bool& enabled) const { bool onOff(0); @@ -633,7 +633,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneBoost(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::StereoRecordingIsAvailable(bool& available) +int32_t AudioDeviceLinuxALSA::StereoRecordingIsAvailable(bool& available) { CriticalSectionScoped lock(&_critSect); @@ -682,7 +682,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::StereoRecordingIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::SetStereoRecording(bool enable) +int32_t AudioDeviceLinuxALSA::SetStereoRecording(bool enable) { if (enable) @@ -693,7 +693,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SetStereoRecording(bool enable) return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::StereoRecording(bool& enabled) const +int32_t AudioDeviceLinuxALSA::StereoRecording(bool& enabled) const { if (_recChannels == 2) @@ -704,7 +704,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::StereoRecording(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::StereoPlayoutIsAvailable(bool& available) +int32_t AudioDeviceLinuxALSA::StereoPlayoutIsAvailable(bool& available) { CriticalSectionScoped lock(&_critSect); @@ -753,7 +753,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::StereoPlayoutIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::SetStereoPlayout(bool enable) +int32_t AudioDeviceLinuxALSA::SetStereoPlayout(bool enable) { if (enable) @@ -764,7 +764,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SetStereoPlayout(bool enable) return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::StereoPlayout(bool& enabled) const +int32_t AudioDeviceLinuxALSA::StereoPlayout(bool& enabled) const { if (_playChannels == 2) @@ -775,7 +775,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::StereoPlayout(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::SetAGC(bool enable) +int32_t AudioDeviceLinuxALSA::SetAGC(bool enable) { _AGC = enable; @@ -789,7 +789,7 @@ bool AudioDeviceLinuxALSA::AGC() const return _AGC; } -WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneVolumeIsAvailable(bool& available) +int32_t AudioDeviceLinuxALSA::MicrophoneVolumeIsAvailable(bool& available) { bool wasInitialized = _mixerManager.MicrophoneIsInitialized(); @@ -817,7 +817,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneVolumeIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::SetMicrophoneVolume(WebRtc_UWord32 volume) +int32_t AudioDeviceLinuxALSA::SetMicrophoneVolume(uint32_t volume) { return (_mixerManager.SetMicrophoneVolume(volume)); @@ -825,10 +825,10 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SetMicrophoneVolume(WebRtc_UWord32 volume) return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneVolume(WebRtc_UWord32& volume) const +int32_t AudioDeviceLinuxALSA::MicrophoneVolume(uint32_t& volume) const { - WebRtc_UWord32 level(0); + uint32_t level(0); if (_mixerManager.MicrophoneVolume(level) == -1) { @@ -842,11 +842,11 @@ WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneVolume(WebRtc_UWord32& volume) con return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::MaxMicrophoneVolume( - WebRtc_UWord32& maxVolume) const +int32_t AudioDeviceLinuxALSA::MaxMicrophoneVolume( + uint32_t& maxVolume) const { - WebRtc_UWord32 maxVol(0); + uint32_t maxVol(0); if (_mixerManager.MaxMicrophoneVolume(maxVol) == -1) { @@ -858,11 +858,11 @@ WebRtc_Word32 AudioDeviceLinuxALSA::MaxMicrophoneVolume( return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::MinMicrophoneVolume( - WebRtc_UWord32& minVolume) const +int32_t AudioDeviceLinuxALSA::MinMicrophoneVolume( + uint32_t& minVolume) const { - WebRtc_UWord32 minVol(0); + uint32_t minVol(0); if (_mixerManager.MinMicrophoneVolume(minVol) == -1) { @@ -874,11 +874,11 @@ WebRtc_Word32 AudioDeviceLinuxALSA::MinMicrophoneVolume( return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneVolumeStepSize( - WebRtc_UWord16& stepSize) const +int32_t AudioDeviceLinuxALSA::MicrophoneVolumeStepSize( + uint16_t& stepSize) const { - WebRtc_UWord16 delta(0); + uint16_t delta(0); if (_mixerManager.MicrophoneVolumeStepSize(delta) == -1) { @@ -890,13 +890,13 @@ WebRtc_Word32 AudioDeviceLinuxALSA::MicrophoneVolumeStepSize( return 0; } -WebRtc_Word16 AudioDeviceLinuxALSA::PlayoutDevices() +int16_t AudioDeviceLinuxALSA::PlayoutDevices() { - return (WebRtc_Word16)GetDevicesInfo(0, true); + return (int16_t)GetDevicesInfo(0, true); } -WebRtc_Word32 AudioDeviceLinuxALSA::SetPlayoutDevice(WebRtc_UWord16 index) +int32_t AudioDeviceLinuxALSA::SetPlayoutDevice(uint16_t index) { if (_playIsInitialized) @@ -904,7 +904,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SetPlayoutDevice(WebRtc_UWord16 index) return -1; } - WebRtc_UWord32 nDevices = GetDevicesInfo(0, true); + uint32_t nDevices = GetDevicesInfo(0, true); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " number of availiable audio output devices is %u", nDevices); @@ -921,7 +921,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SetPlayoutDevice(WebRtc_UWord16 index) return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::SetPlayoutDevice( +int32_t AudioDeviceLinuxALSA::SetPlayoutDevice( AudioDeviceModule::WindowsDeviceType /*device*/) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, @@ -929,13 +929,13 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SetPlayoutDevice( return -1; } -WebRtc_Word32 AudioDeviceLinuxALSA::PlayoutDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceLinuxALSA::PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { - const WebRtc_UWord16 nDevices(PlayoutDevices()); + const uint16_t nDevices(PlayoutDevices()); if ((index > (nDevices-1)) || (name == NULL)) { @@ -952,13 +952,13 @@ WebRtc_Word32 AudioDeviceLinuxALSA::PlayoutDeviceName( return GetDevicesInfo(1, true, index, name, kAdmMaxDeviceNameSize); } -WebRtc_Word32 AudioDeviceLinuxALSA::RecordingDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceLinuxALSA::RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { - const WebRtc_UWord16 nDevices(RecordingDevices()); + const uint16_t nDevices(RecordingDevices()); if ((index > (nDevices-1)) || (name == NULL)) { @@ -975,13 +975,13 @@ WebRtc_Word32 AudioDeviceLinuxALSA::RecordingDeviceName( return GetDevicesInfo(1, false, index, name, kAdmMaxDeviceNameSize); } -WebRtc_Word16 AudioDeviceLinuxALSA::RecordingDevices() +int16_t AudioDeviceLinuxALSA::RecordingDevices() { - return (WebRtc_Word16)GetDevicesInfo(0, false); + return (int16_t)GetDevicesInfo(0, false); } -WebRtc_Word32 AudioDeviceLinuxALSA::SetRecordingDevice(WebRtc_UWord16 index) +int32_t AudioDeviceLinuxALSA::SetRecordingDevice(uint16_t index) { if (_recIsInitialized) @@ -989,7 +989,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SetRecordingDevice(WebRtc_UWord16 index) return -1; } - WebRtc_UWord32 nDevices = GetDevicesInfo(0, false); + uint32_t nDevices = GetDevicesInfo(0, false); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " number of availiable audio input devices is %u", nDevices); @@ -1010,7 +1010,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SetRecordingDevice(WebRtc_UWord16 index) // SetRecordingDevice II (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceLinuxALSA::SetRecordingDevice( +int32_t AudioDeviceLinuxALSA::SetRecordingDevice( AudioDeviceModule::WindowsDeviceType /*device*/) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, @@ -1018,7 +1018,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SetRecordingDevice( return -1; } -WebRtc_Word32 AudioDeviceLinuxALSA::PlayoutIsAvailable(bool& available) +int32_t AudioDeviceLinuxALSA::PlayoutIsAvailable(bool& available) { available = false; @@ -1026,7 +1026,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::PlayoutIsAvailable(bool& available) // Try to initialize the playout side with mono // Assumes that user set num channels after calling this function _playChannels = 1; - WebRtc_Word32 res = InitPlayout(); + int32_t res = InitPlayout(); // Cancel effect of initialization StopPlayout(); @@ -1049,7 +1049,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::PlayoutIsAvailable(bool& available) return res; } -WebRtc_Word32 AudioDeviceLinuxALSA::RecordingIsAvailable(bool& available) +int32_t AudioDeviceLinuxALSA::RecordingIsAvailable(bool& available) { available = false; @@ -1057,7 +1057,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::RecordingIsAvailable(bool& available) // Try to initialize the recording side with mono // Assumes that user set num channels after calling this function _recChannels = 1; - WebRtc_Word32 res = InitRecording(); + int32_t res = InitRecording(); // Cancel effect of initialization StopRecording(); @@ -1080,7 +1080,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::RecordingIsAvailable(bool& available) return res; } -WebRtc_Word32 AudioDeviceLinuxALSA::InitPlayout() +int32_t AudioDeviceLinuxALSA::InitPlayout() { int errVal = 0; @@ -1233,7 +1233,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::InitPlayout() return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::InitRecording() +int32_t AudioDeviceLinuxALSA::InitRecording() { int errVal = 0; @@ -1404,7 +1404,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::InitRecording() return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::StartRecording() +int32_t AudioDeviceLinuxALSA::StartRecording() { if (!_recIsInitialized) @@ -1424,7 +1424,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::StartRecording() // Make sure we only create the buffer once. if (!_recordingBuffer) - _recordingBuffer = new WebRtc_Word8[_recordingBufferSizeIn10MS]; + _recordingBuffer = new int8_t[_recordingBufferSizeIn10MS]; if (!_recordingBuffer) { WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, @@ -1492,7 +1492,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::StartRecording() return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::StopRecording() +int32_t AudioDeviceLinuxALSA::StopRecording() { { @@ -1579,7 +1579,7 @@ bool AudioDeviceLinuxALSA::PlayoutIsInitialized() const return (_playIsInitialized); } -WebRtc_Word32 AudioDeviceLinuxALSA::StartPlayout() +int32_t AudioDeviceLinuxALSA::StartPlayout() { if (!_playIsInitialized) { @@ -1595,7 +1595,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::StartPlayout() _playoutFramesLeft = 0; if (!_playoutBuffer) - _playoutBuffer = new WebRtc_Word8[_playoutBufferSizeIn10MS]; + _playoutBuffer = new int8_t[_playoutBufferSizeIn10MS]; if (!_playoutBuffer) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, @@ -1647,7 +1647,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::StartPlayout() return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::StopPlayout() +int32_t AudioDeviceLinuxALSA::StopPlayout() { { @@ -1708,16 +1708,16 @@ WebRtc_Word32 AudioDeviceLinuxALSA::StopPlayout() return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::PlayoutDelay(WebRtc_UWord16& delayMS) const +int32_t AudioDeviceLinuxALSA::PlayoutDelay(uint16_t& delayMS) const { - delayMS = (WebRtc_UWord16)_playoutDelay * 1000 / _playoutFreq; + delayMS = (uint16_t)_playoutDelay * 1000 / _playoutFreq; return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::RecordingDelay(WebRtc_UWord16& delayMS) const +int32_t AudioDeviceLinuxALSA::RecordingDelay(uint16_t& delayMS) const { // Adding 10ms adjusted value to the record delay due to 10ms buffering. - delayMS = (WebRtc_UWord16)(10 + _recordingDelay * 1000 / _recordingFreq); + delayMS = (uint16_t)(10 + _recordingDelay * 1000 / _recordingFreq); return 0; } @@ -1729,9 +1729,9 @@ bool AudioDeviceLinuxALSA::Playing() const // SetPlayoutBuffer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceLinuxALSA::SetPlayoutBuffer( +int32_t AudioDeviceLinuxALSA::SetPlayoutBuffer( const AudioDeviceModule::BufferType type, - WebRtc_UWord16 sizeMS) + uint16_t sizeMS) { _playBufType = type; if (type == AudioDeviceModule::kFixedBufferSize) @@ -1741,9 +1741,9 @@ WebRtc_Word32 AudioDeviceLinuxALSA::SetPlayoutBuffer( return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::PlayoutBuffer( +int32_t AudioDeviceLinuxALSA::PlayoutBuffer( AudioDeviceModule::BufferType& type, - WebRtc_UWord16& sizeMS) const + uint16_t& sizeMS) const { type = _playBufType; if (type == AudioDeviceModule::kFixedBufferSize) @@ -1758,7 +1758,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::PlayoutBuffer( return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::CPULoad(WebRtc_UWord16& load) const +int32_t AudioDeviceLinuxALSA::CPULoad(uint16_t& load) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -1810,12 +1810,12 @@ void AudioDeviceLinuxALSA::ClearRecordingError() // Private Methods // ============================================================================ -WebRtc_Word32 AudioDeviceLinuxALSA::GetDevicesInfo( - const WebRtc_Word32 function, +int32_t AudioDeviceLinuxALSA::GetDevicesInfo( + const int32_t function, const bool playback, - const WebRtc_Word32 enumDeviceNo, + const int32_t enumDeviceNo, char* enumDeviceName, - const WebRtc_Word32 ednLen) const + const int32_t ednLen) const { // Device enumeration based on libjingle implementation @@ -1973,7 +1973,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::GetDevicesInfo( return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::InputSanityCheckAfterUnlockedPeriod() const +int32_t AudioDeviceLinuxALSA::InputSanityCheckAfterUnlockedPeriod() const { if (_handleRecord == NULL) { @@ -1984,7 +1984,7 @@ WebRtc_Word32 AudioDeviceLinuxALSA::InputSanityCheckAfterUnlockedPeriod() const return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::OutputSanityCheckAfterUnlockedPeriod() const +int32_t AudioDeviceLinuxALSA::OutputSanityCheckAfterUnlockedPeriod() const { if (_handlePlayout == NULL) { @@ -1995,8 +1995,8 @@ WebRtc_Word32 AudioDeviceLinuxALSA::OutputSanityCheckAfterUnlockedPeriod() const return 0; } -WebRtc_Word32 AudioDeviceLinuxALSA::ErrorRecovery(WebRtc_Word32 error, - snd_pcm_t* deviceHandle) +int32_t AudioDeviceLinuxALSA::ErrorRecovery(int32_t error, + snd_pcm_t* deviceHandle) { int st = LATE(snd_pcm_state)(deviceHandle); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, @@ -2141,7 +2141,7 @@ bool AudioDeviceLinuxALSA::PlayThreadProcess() assert(_playoutFramesLeft == _playoutFramesIn10MS); } - if (static_cast(avail_frames) > _playoutFramesLeft) + if (static_cast(avail_frames) > _playoutFramesLeft) avail_frames = _playoutFramesLeft; int size = LATE(snd_pcm_frames_to_bytes)(_handlePlayout, @@ -2178,7 +2178,7 @@ bool AudioDeviceLinuxALSA::RecThreadProcess() int err; snd_pcm_sframes_t frames; snd_pcm_sframes_t avail_frames; - WebRtc_Word8 buffer[_recordingBufferSizeIn10MS]; + int8_t buffer[_recordingBufferSizeIn10MS]; Lock(); @@ -2207,7 +2207,7 @@ bool AudioDeviceLinuxALSA::RecThreadProcess() return true; } - if (static_cast(avail_frames) > _recordingFramesLeft) + if (static_cast(avail_frames) > _recordingFramesLeft) avail_frames = _recordingFramesLeft; frames = LATE(snd_pcm_readi)(_handleRecord, @@ -2242,8 +2242,8 @@ bool AudioDeviceLinuxALSA::RecThreadProcess() _ptrAudioBuffer->SetRecordedBuffer(_recordingBuffer, _recordingFramesIn10MS); - WebRtc_UWord32 currentMicLevel = 0; - WebRtc_UWord32 newMicLevel = 0; + uint32_t currentMicLevel = 0; + uint32_t newMicLevel = 0; if (AGC()) { diff --git a/webrtc/modules/audio_device/linux/audio_device_alsa_linux.h b/webrtc/modules/audio_device/linux/audio_device_alsa_linux.h index 20e555cbc5..dd94e34dfd 100644 --- a/webrtc/modules/audio_device/linux/audio_device_alsa_linux.h +++ b/webrtc/modules/audio_device/linux/audio_device_alsa_linux.h @@ -28,124 +28,123 @@ class ThreadWrapper; class AudioDeviceLinuxALSA : public AudioDeviceGeneric { public: - AudioDeviceLinuxALSA(const WebRtc_Word32 id); + AudioDeviceLinuxALSA(const int32_t id); ~AudioDeviceLinuxALSA(); // Retrieve the currently utilized audio layer - virtual WebRtc_Word32 ActiveAudioLayer( + virtual int32_t ActiveAudioLayer( AudioDeviceModule::AudioLayer& audioLayer) const; // Main initializaton and termination - virtual WebRtc_Word32 Init(); - virtual WebRtc_Word32 Terminate(); + virtual int32_t Init(); + virtual int32_t Terminate(); virtual bool Initialized() const; // Device enumeration - virtual WebRtc_Word16 PlayoutDevices(); - virtual WebRtc_Word16 RecordingDevices(); - virtual WebRtc_Word32 PlayoutDeviceName( - WebRtc_UWord16 index, + virtual int16_t PlayoutDevices(); + virtual int16_t RecordingDevices(); + virtual int32_t PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); - virtual WebRtc_Word32 RecordingDeviceName( - WebRtc_UWord16 index, + virtual int32_t RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); // Device selection - virtual WebRtc_Word32 SetPlayoutDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetPlayoutDevice( + virtual int32_t SetPlayoutDevice(uint16_t index); + virtual int32_t SetPlayoutDevice( AudioDeviceModule::WindowsDeviceType device); - virtual WebRtc_Word32 SetRecordingDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetRecordingDevice( + virtual int32_t SetRecordingDevice(uint16_t index); + virtual int32_t SetRecordingDevice( AudioDeviceModule::WindowsDeviceType device); // Audio transport initialization - virtual WebRtc_Word32 PlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 InitPlayout(); + virtual int32_t PlayoutIsAvailable(bool& available); + virtual int32_t InitPlayout(); virtual bool PlayoutIsInitialized() const; - virtual WebRtc_Word32 RecordingIsAvailable(bool& available); - virtual WebRtc_Word32 InitRecording(); + virtual int32_t RecordingIsAvailable(bool& available); + virtual int32_t InitRecording(); virtual bool RecordingIsInitialized() const; // Audio transport control - virtual WebRtc_Word32 StartPlayout(); - virtual WebRtc_Word32 StopPlayout(); + virtual int32_t StartPlayout(); + virtual int32_t StopPlayout(); virtual bool Playing() const; - virtual WebRtc_Word32 StartRecording(); - virtual WebRtc_Word32 StopRecording(); + virtual int32_t StartRecording(); + virtual int32_t StopRecording(); virtual bool Recording() const; // Microphone Automatic Gain Control (AGC) - virtual WebRtc_Word32 SetAGC(bool enable); + virtual int32_t SetAGC(bool enable); virtual bool AGC() const; // Volume control based on the Windows Wave API (Windows only) - virtual WebRtc_Word32 SetWaveOutVolume(WebRtc_UWord16 volumeLeft, - WebRtc_UWord16 volumeRight); - virtual WebRtc_Word32 WaveOutVolume(WebRtc_UWord16& volumeLeft, - WebRtc_UWord16& volumeRight) const; + virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight); + virtual int32_t WaveOutVolume(uint16_t& volumeLeft, + uint16_t& volumeRight) const; // Audio mixer initialization - virtual WebRtc_Word32 SpeakerIsAvailable(bool& available); - virtual WebRtc_Word32 InitSpeaker(); + virtual int32_t SpeakerIsAvailable(bool& available); + virtual int32_t InitSpeaker(); virtual bool SpeakerIsInitialized() const; - virtual WebRtc_Word32 MicrophoneIsAvailable(bool& available); - virtual WebRtc_Word32 InitMicrophone(); + virtual int32_t MicrophoneIsAvailable(bool& available); + virtual int32_t InitMicrophone(); virtual bool MicrophoneIsInitialized() const; // Speaker volume controls - virtual WebRtc_Word32 SpeakerVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 SpeakerVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const; + virtual int32_t SpeakerVolumeIsAvailable(bool& available); + virtual int32_t SetSpeakerVolume(uint32_t volume); + virtual int32_t SpeakerVolume(uint32_t& volume) const; + virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const; + virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const; + virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const; // Microphone volume controls - virtual WebRtc_Word32 MicrophoneVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinMicrophoneVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 MicrophoneVolumeStepSize( - WebRtc_UWord16& stepSize) const; + virtual int32_t MicrophoneVolumeIsAvailable(bool& available); + virtual int32_t SetMicrophoneVolume(uint32_t volume); + virtual int32_t MicrophoneVolume(uint32_t& volume) const; + virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const; + virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const; + virtual int32_t MicrophoneVolumeStepSize( + uint16_t& stepSize) const; // Speaker mute control - virtual WebRtc_Word32 SpeakerMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerMute(bool enable); - virtual WebRtc_Word32 SpeakerMute(bool& enabled) const; + virtual int32_t SpeakerMuteIsAvailable(bool& available); + virtual int32_t SetSpeakerMute(bool enable); + virtual int32_t SpeakerMute(bool& enabled) const; // Microphone mute control - virtual WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneMute(bool enable); - virtual WebRtc_Word32 MicrophoneMute(bool& enabled) const; + virtual int32_t MicrophoneMuteIsAvailable(bool& available); + virtual int32_t SetMicrophoneMute(bool enable); + virtual int32_t MicrophoneMute(bool& enabled) const; // Microphone boost control - virtual WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneBoost(bool enable); - virtual WebRtc_Word32 MicrophoneBoost(bool& enabled) const; + virtual int32_t MicrophoneBoostIsAvailable(bool& available); + virtual int32_t SetMicrophoneBoost(bool enable); + virtual int32_t MicrophoneBoost(bool& enabled) const; // Stereo support - virtual WebRtc_Word32 StereoPlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoPlayout(bool enable); - virtual WebRtc_Word32 StereoPlayout(bool& enabled) const; - virtual WebRtc_Word32 StereoRecordingIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoRecording(bool enable); - virtual WebRtc_Word32 StereoRecording(bool& enabled) const; + virtual int32_t StereoPlayoutIsAvailable(bool& available); + virtual int32_t SetStereoPlayout(bool enable); + virtual int32_t StereoPlayout(bool& enabled) const; + virtual int32_t StereoRecordingIsAvailable(bool& available); + virtual int32_t SetStereoRecording(bool enable); + virtual int32_t StereoRecording(bool& enabled) const; // Delay information and control - virtual WebRtc_Word32 SetPlayoutBuffer( + virtual int32_t SetPlayoutBuffer( const AudioDeviceModule::BufferType type, - WebRtc_UWord16 sizeMS); - virtual WebRtc_Word32 PlayoutBuffer( + uint16_t sizeMS); + virtual int32_t PlayoutBuffer( AudioDeviceModule::BufferType& type, - WebRtc_UWord16& sizeMS) const; - virtual WebRtc_Word32 PlayoutDelay(WebRtc_UWord16& delayMS) const; - virtual WebRtc_Word32 RecordingDelay(WebRtc_UWord16& delayMS) const; + uint16_t& sizeMS) const; + virtual int32_t PlayoutDelay(uint16_t& delayMS) const; + virtual int32_t RecordingDelay(uint16_t& delayMS) const; // CPU load - virtual WebRtc_Word32 CPULoad(WebRtc_UWord16& load) const; + virtual int32_t CPULoad(uint16_t& load) const; public: virtual bool PlayoutWarning() const; @@ -161,19 +160,19 @@ public: virtual void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer); private: - WebRtc_Word32 GetDevicesInfo(const WebRtc_Word32 function, - const bool playback, - const WebRtc_Word32 enumDeviceNo = 0, - char* enumDeviceName = NULL, - const WebRtc_Word32 ednLen = 0) const; - WebRtc_Word32 ErrorRecovery(WebRtc_Word32 error, snd_pcm_t* deviceHandle); + int32_t GetDevicesInfo(const int32_t function, + const bool playback, + const int32_t enumDeviceNo = 0, + char* enumDeviceName = NULL, + const int32_t ednLen = 0) const; + int32_t ErrorRecovery(int32_t error, snd_pcm_t* deviceHandle); private: void Lock() { _critSect.Enter(); }; void UnLock() { _critSect.Leave(); }; private: - inline WebRtc_Word32 InputSanityCheckAfterUnlockedPeriod() const; - inline WebRtc_Word32 OutputSanityCheckAfterUnlockedPeriod() const; + inline int32_t InputSanityCheckAfterUnlockedPeriod() const; + inline int32_t OutputSanityCheckAfterUnlockedPeriod() const; private: static bool RecThreadFunc(void*); @@ -188,15 +187,15 @@ private: ThreadWrapper* _ptrThreadRec; ThreadWrapper* _ptrThreadPlay; - WebRtc_UWord32 _recThreadID; - WebRtc_UWord32 _playThreadID; + uint32_t _recThreadID; + uint32_t _playThreadID; - WebRtc_Word32 _id; + int32_t _id; AudioMixerManagerLinuxALSA _mixerManager; - WebRtc_UWord16 _inputDeviceIndex; - WebRtc_UWord16 _outputDeviceIndex; + uint16_t _inputDeviceIndex; + uint16_t _outputDeviceIndex; bool _inputDeviceIsSpecified; bool _outputDeviceIsSpecified; @@ -210,18 +209,18 @@ private: ssize_t _recordingBufferSizeIn10MS; ssize_t _playoutBufferSizeIn10MS; - WebRtc_UWord32 _recordingFramesIn10MS; - WebRtc_UWord32 _playoutFramesIn10MS; + uint32_t _recordingFramesIn10MS; + uint32_t _playoutFramesIn10MS; - WebRtc_UWord32 _recordingFreq; - WebRtc_UWord32 _playoutFreq; - WebRtc_UWord8 _recChannels; - WebRtc_UWord8 _playChannels; + uint32_t _recordingFreq; + uint32_t _playoutFreq; + uint8_t _recChannels; + uint8_t _playChannels; - WebRtc_Word8* _recordingBuffer; // in byte - WebRtc_Word8* _playoutBuffer; // in byte - WebRtc_UWord32 _recordingFramesLeft; - WebRtc_UWord32 _playoutFramesLeft; + int8_t* _recordingBuffer; // in byte + int8_t* _playoutBuffer; // in byte + uint32_t _recordingFramesLeft; + uint32_t _playoutFramesLeft; AudioDeviceModule::BufferType _playBufType; @@ -236,13 +235,13 @@ private: snd_pcm_sframes_t _recordingDelay; snd_pcm_sframes_t _playoutDelay; - WebRtc_UWord16 _playWarning; - WebRtc_UWord16 _playError; - WebRtc_UWord16 _recWarning; - WebRtc_UWord16 _recError; + uint16_t _playWarning; + uint16_t _playError; + uint16_t _recWarning; + uint16_t _recError; - WebRtc_UWord16 _playBufDelay; // playback delay - WebRtc_UWord16 _playBufDelayFixed; // fixed playback delay + uint16_t _playBufDelay; // playback delay + uint16_t _playBufDelayFixed; // fixed playback delay }; } diff --git a/webrtc/modules/audio_device/linux/audio_device_pulse_linux.cc b/webrtc/modules/audio_device/linux/audio_device_pulse_linux.cc index 7e143dea4e..17751bfe87 100644 --- a/webrtc/modules/audio_device/linux/audio_device_pulse_linux.cc +++ b/webrtc/modules/audio_device/linux/audio_device_pulse_linux.cc @@ -62,7 +62,7 @@ bool AudioDeviceLinuxPulse::PulseAudioIsSupported() return (pulseAudioIsSupported); } -AudioDeviceLinuxPulse::AudioDeviceLinuxPulse(const WebRtc_Word32 id) : +AudioDeviceLinuxPulse::AudioDeviceLinuxPulse(const int32_t id) : _ptrAudioBuffer(NULL), _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _timeEventRec(*EventWrapper::Create()), @@ -193,14 +193,14 @@ void AudioDeviceLinuxPulse::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) // ActiveAudioLayer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceLinuxPulse::ActiveAudioLayer( +int32_t AudioDeviceLinuxPulse::ActiveAudioLayer( AudioDeviceModule::AudioLayer& audioLayer) const { audioLayer = AudioDeviceModule::kLinuxPulseAudio; return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::Init() +int32_t AudioDeviceLinuxPulse::Init() { CriticalSectionScoped lock(&_critSect); @@ -281,7 +281,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::Init() return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::Terminate() +int32_t AudioDeviceLinuxPulse::Terminate() { if (!_initialized) @@ -355,7 +355,7 @@ bool AudioDeviceLinuxPulse::Initialized() const return (_initialized); } -WebRtc_Word32 AudioDeviceLinuxPulse::SpeakerIsAvailable(bool& available) +int32_t AudioDeviceLinuxPulse::SpeakerIsAvailable(bool& available) { bool wasInitialized = _mixerManager.SpeakerIsInitialized(); @@ -383,7 +383,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SpeakerIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::InitSpeaker() +int32_t AudioDeviceLinuxPulse::InitSpeaker() { CriticalSectionScoped lock(&_critSect); @@ -401,7 +401,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitSpeaker() // check if default device if (_outputDeviceIndex == 0) { - WebRtc_UWord16 deviceIndex = 0; + uint16_t deviceIndex = 0; GetDefaultDeviceInfo(false, NULL, deviceIndex); _paDeviceIndex = deviceIndex; } else @@ -428,7 +428,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitSpeaker() return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneIsAvailable(bool& available) +int32_t AudioDeviceLinuxPulse::MicrophoneIsAvailable(bool& available) { bool wasInitialized = _mixerManager.MicrophoneIsInitialized(); @@ -456,7 +456,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::InitMicrophone() +int32_t AudioDeviceLinuxPulse::InitMicrophone() { CriticalSectionScoped lock(&_critSect); @@ -474,7 +474,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitMicrophone() // Check if default device if (_inputDeviceIndex == 0) { - WebRtc_UWord16 deviceIndex = 0; + uint16_t deviceIndex = 0; GetDefaultDeviceInfo(true, NULL, deviceIndex); _paDeviceIndex = deviceIndex; } else @@ -511,7 +511,7 @@ bool AudioDeviceLinuxPulse::MicrophoneIsInitialized() const return (_mixerManager.MicrophoneIsInitialized()); } -WebRtc_Word32 AudioDeviceLinuxPulse::SpeakerVolumeIsAvailable(bool& available) +int32_t AudioDeviceLinuxPulse::SpeakerVolumeIsAvailable(bool& available) { bool wasInitialized = _mixerManager.SpeakerIsInitialized(); @@ -538,7 +538,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SpeakerVolumeIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::SetSpeakerVolume(WebRtc_UWord32 volume) +int32_t AudioDeviceLinuxPulse::SetSpeakerVolume(uint32_t volume) { if (!_playing) { // Only update the volume if it's been set while we weren't playing. @@ -547,10 +547,10 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SetSpeakerVolume(WebRtc_UWord32 volume) return (_mixerManager.SetSpeakerVolume(volume)); } -WebRtc_Word32 AudioDeviceLinuxPulse::SpeakerVolume(WebRtc_UWord32& volume) const +int32_t AudioDeviceLinuxPulse::SpeakerVolume(uint32_t& volume) const { - WebRtc_UWord32 level(0); + uint32_t level(0); if (_mixerManager.SpeakerVolume(level) == -1) { @@ -562,9 +562,9 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SpeakerVolume(WebRtc_UWord32& volume) const return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::SetWaveOutVolume( - WebRtc_UWord16 volumeLeft, - WebRtc_UWord16 volumeRight) +int32_t AudioDeviceLinuxPulse::SetWaveOutVolume( + uint16_t volumeLeft, + uint16_t volumeRight) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -572,9 +572,9 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SetWaveOutVolume( return -1; } -WebRtc_Word32 AudioDeviceLinuxPulse::WaveOutVolume( - WebRtc_UWord16& /*volumeLeft*/, - WebRtc_UWord16& /*volumeRight*/) const +int32_t AudioDeviceLinuxPulse::WaveOutVolume( + uint16_t& /*volumeLeft*/, + uint16_t& /*volumeRight*/) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -582,11 +582,11 @@ WebRtc_Word32 AudioDeviceLinuxPulse::WaveOutVolume( return -1; } -WebRtc_Word32 AudioDeviceLinuxPulse::MaxSpeakerVolume( - WebRtc_UWord32& maxVolume) const +int32_t AudioDeviceLinuxPulse::MaxSpeakerVolume( + uint32_t& maxVolume) const { - WebRtc_UWord32 maxVol(0); + uint32_t maxVol(0); if (_mixerManager.MaxSpeakerVolume(maxVol) == -1) { @@ -598,11 +598,11 @@ WebRtc_Word32 AudioDeviceLinuxPulse::MaxSpeakerVolume( return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::MinSpeakerVolume( - WebRtc_UWord32& minVolume) const +int32_t AudioDeviceLinuxPulse::MinSpeakerVolume( + uint32_t& minVolume) const { - WebRtc_UWord32 minVol(0); + uint32_t minVol(0); if (_mixerManager.MinSpeakerVolume(minVol) == -1) { @@ -614,11 +614,11 @@ WebRtc_Word32 AudioDeviceLinuxPulse::MinSpeakerVolume( return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::SpeakerVolumeStepSize( - WebRtc_UWord16& stepSize) const +int32_t AudioDeviceLinuxPulse::SpeakerVolumeStepSize( + uint16_t& stepSize) const { - WebRtc_UWord16 delta(0); + uint16_t delta(0); if (_mixerManager.SpeakerVolumeStepSize(delta) == -1) { @@ -630,7 +630,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SpeakerVolumeStepSize( return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::SpeakerMuteIsAvailable(bool& available) +int32_t AudioDeviceLinuxPulse::SpeakerMuteIsAvailable(bool& available) { bool isAvailable(false); @@ -662,13 +662,13 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SpeakerMuteIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::SetSpeakerMute(bool enable) +int32_t AudioDeviceLinuxPulse::SetSpeakerMute(bool enable) { return (_mixerManager.SetSpeakerMute(enable)); } -WebRtc_Word32 AudioDeviceLinuxPulse::SpeakerMute(bool& enabled) const +int32_t AudioDeviceLinuxPulse::SpeakerMute(bool& enabled) const { bool muted(0); @@ -681,7 +681,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SpeakerMute(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneMuteIsAvailable(bool& available) +int32_t AudioDeviceLinuxPulse::MicrophoneMuteIsAvailable(bool& available) { bool isAvailable(false); @@ -714,13 +714,13 @@ WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneMuteIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::SetMicrophoneMute(bool enable) +int32_t AudioDeviceLinuxPulse::SetMicrophoneMute(bool enable) { return (_mixerManager.SetMicrophoneMute(enable)); } -WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneMute(bool& enabled) const +int32_t AudioDeviceLinuxPulse::MicrophoneMute(bool& enabled) const { bool muted(0); @@ -733,7 +733,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneMute(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneBoostIsAvailable(bool& available) +int32_t AudioDeviceLinuxPulse::MicrophoneBoostIsAvailable(bool& available) { bool isAvailable(false); @@ -764,13 +764,13 @@ WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneBoostIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::SetMicrophoneBoost(bool enable) +int32_t AudioDeviceLinuxPulse::SetMicrophoneBoost(bool enable) { return (_mixerManager.SetMicrophoneBoost(enable)); } -WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneBoost(bool& enabled) const +int32_t AudioDeviceLinuxPulse::MicrophoneBoost(bool& enabled) const { bool onOff(0); @@ -785,7 +785,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneBoost(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::StereoRecordingIsAvailable(bool& available) +int32_t AudioDeviceLinuxPulse::StereoRecordingIsAvailable(bool& available) { if (_recChannels == 2 && _recording) { @@ -821,7 +821,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::StereoRecordingIsAvailable(bool& available) return error; } -WebRtc_Word32 AudioDeviceLinuxPulse::SetStereoRecording(bool enable) +int32_t AudioDeviceLinuxPulse::SetStereoRecording(bool enable) { #ifndef WEBRTC_PA_GTALK @@ -834,7 +834,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SetStereoRecording(bool enable) return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::StereoRecording(bool& enabled) const +int32_t AudioDeviceLinuxPulse::StereoRecording(bool& enabled) const { if (_recChannels == 2) @@ -845,7 +845,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::StereoRecording(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::StereoPlayoutIsAvailable(bool& available) +int32_t AudioDeviceLinuxPulse::StereoPlayoutIsAvailable(bool& available) { if (_playChannels == 2 && _playing) { @@ -880,7 +880,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::StereoPlayoutIsAvailable(bool& available) return error; } -WebRtc_Word32 AudioDeviceLinuxPulse::SetStereoPlayout(bool enable) +int32_t AudioDeviceLinuxPulse::SetStereoPlayout(bool enable) { #ifndef WEBRTC_PA_GTALK @@ -893,7 +893,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SetStereoPlayout(bool enable) return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::StereoPlayout(bool& enabled) const +int32_t AudioDeviceLinuxPulse::StereoPlayout(bool& enabled) const { if (_playChannels == 2) @@ -904,7 +904,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::StereoPlayout(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::SetAGC(bool enable) +int32_t AudioDeviceLinuxPulse::SetAGC(bool enable) { _AGC = enable; @@ -918,7 +918,7 @@ bool AudioDeviceLinuxPulse::AGC() const return _AGC; } -WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneVolumeIsAvailable( +int32_t AudioDeviceLinuxPulse::MicrophoneVolumeIsAvailable( bool& available) { @@ -947,17 +947,17 @@ WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneVolumeIsAvailable( return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::SetMicrophoneVolume(WebRtc_UWord32 volume) +int32_t AudioDeviceLinuxPulse::SetMicrophoneVolume(uint32_t volume) { return (_mixerManager.SetMicrophoneVolume(volume)); } -WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneVolume( - WebRtc_UWord32& volume) const +int32_t AudioDeviceLinuxPulse::MicrophoneVolume( + uint32_t& volume) const { - WebRtc_UWord32 level(0); + uint32_t level(0); if (_mixerManager.MicrophoneVolume(level) == -1) { @@ -971,11 +971,11 @@ WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneVolume( return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::MaxMicrophoneVolume( - WebRtc_UWord32& maxVolume) const +int32_t AudioDeviceLinuxPulse::MaxMicrophoneVolume( + uint32_t& maxVolume) const { - WebRtc_UWord32 maxVol(0); + uint32_t maxVol(0); if (_mixerManager.MaxMicrophoneVolume(maxVol) == -1) { @@ -987,11 +987,11 @@ WebRtc_Word32 AudioDeviceLinuxPulse::MaxMicrophoneVolume( return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::MinMicrophoneVolume( - WebRtc_UWord32& minVolume) const +int32_t AudioDeviceLinuxPulse::MinMicrophoneVolume( + uint32_t& minVolume) const { - WebRtc_UWord32 minVol(0); + uint32_t minVol(0); if (_mixerManager.MinMicrophoneVolume(minVol) == -1) { @@ -1003,11 +1003,11 @@ WebRtc_Word32 AudioDeviceLinuxPulse::MinMicrophoneVolume( return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneVolumeStepSize( - WebRtc_UWord16& stepSize) const +int32_t AudioDeviceLinuxPulse::MicrophoneVolumeStepSize( + uint16_t& stepSize) const { - WebRtc_UWord16 delta(0); + uint16_t delta(0); if (_mixerManager.MicrophoneVolumeStepSize(delta) == -1) { @@ -1019,7 +1019,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::MicrophoneVolumeStepSize( return 0; } -WebRtc_Word16 AudioDeviceLinuxPulse::PlayoutDevices() +int16_t AudioDeviceLinuxPulse::PlayoutDevices() { PaLock(); @@ -1039,7 +1039,7 @@ WebRtc_Word16 AudioDeviceLinuxPulse::PlayoutDevices() return _numPlayDevices; } -WebRtc_Word32 AudioDeviceLinuxPulse::SetPlayoutDevice(WebRtc_UWord16 index) +int32_t AudioDeviceLinuxPulse::SetPlayoutDevice(uint16_t index) { if (_playIsInitialized) @@ -1047,7 +1047,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SetPlayoutDevice(WebRtc_UWord16 index) return -1; } - const WebRtc_UWord16 nDevices = PlayoutDevices(); + const uint16_t nDevices = PlayoutDevices(); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " number of availiable output devices is %u", nDevices); @@ -1065,7 +1065,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SetPlayoutDevice(WebRtc_UWord16 index) return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::SetPlayoutDevice( +int32_t AudioDeviceLinuxPulse::SetPlayoutDevice( AudioDeviceModule::WindowsDeviceType /*device*/) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, @@ -1073,13 +1073,13 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SetPlayoutDevice( return -1; } -WebRtc_Word32 AudioDeviceLinuxPulse::PlayoutDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceLinuxPulse::PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { - const WebRtc_UWord16 nDevices = PlayoutDevices(); + const uint16_t nDevices = PlayoutDevices(); if ((index > (nDevices - 1)) || (name == NULL)) { @@ -1096,7 +1096,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::PlayoutDeviceName( // Check if default device if (index == 0) { - WebRtc_UWord16 deviceIndex = 0; + uint16_t deviceIndex = 0; return GetDefaultDeviceInfo(false, name, deviceIndex); } @@ -1115,13 +1115,13 @@ WebRtc_Word32 AudioDeviceLinuxPulse::PlayoutDeviceName( return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::RecordingDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceLinuxPulse::RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { - const WebRtc_UWord16 nDevices(RecordingDevices()); + const uint16_t nDevices(RecordingDevices()); if ((index > (nDevices - 1)) || (name == NULL)) { @@ -1138,7 +1138,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::RecordingDeviceName( // Check if default device if (index == 0) { - WebRtc_UWord16 deviceIndex = 0; + uint16_t deviceIndex = 0; return GetDefaultDeviceInfo(true, name, deviceIndex); } @@ -1157,7 +1157,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::RecordingDeviceName( return 0; } -WebRtc_Word16 AudioDeviceLinuxPulse::RecordingDevices() +int16_t AudioDeviceLinuxPulse::RecordingDevices() { PaLock(); @@ -1177,7 +1177,7 @@ WebRtc_Word16 AudioDeviceLinuxPulse::RecordingDevices() return _numRecDevices; } -WebRtc_Word32 AudioDeviceLinuxPulse::SetRecordingDevice(WebRtc_UWord16 index) +int32_t AudioDeviceLinuxPulse::SetRecordingDevice(uint16_t index) { if (_recIsInitialized) @@ -1185,7 +1185,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SetRecordingDevice(WebRtc_UWord16 index) return -1; } - const WebRtc_UWord16 nDevices(RecordingDevices()); + const uint16_t nDevices(RecordingDevices()); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " number of availiable input devices is %u", nDevices); @@ -1203,7 +1203,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SetRecordingDevice(WebRtc_UWord16 index) return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::SetRecordingDevice( +int32_t AudioDeviceLinuxPulse::SetRecordingDevice( AudioDeviceModule::WindowsDeviceType /*device*/) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, @@ -1211,13 +1211,13 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SetRecordingDevice( return -1; } -WebRtc_Word32 AudioDeviceLinuxPulse::PlayoutIsAvailable(bool& available) +int32_t AudioDeviceLinuxPulse::PlayoutIsAvailable(bool& available) { available = false; // Try to initialize the playout side - WebRtc_Word32 res = InitPlayout(); + int32_t res = InitPlayout(); // Cancel effect of initialization StopPlayout(); @@ -1230,13 +1230,13 @@ WebRtc_Word32 AudioDeviceLinuxPulse::PlayoutIsAvailable(bool& available) return res; } -WebRtc_Word32 AudioDeviceLinuxPulse::RecordingIsAvailable(bool& available) +int32_t AudioDeviceLinuxPulse::RecordingIsAvailable(bool& available) { available = false; // Try to initialize the playout side - WebRtc_Word32 res = InitRecording(); + int32_t res = InitRecording(); // Cancel effect of initialization StopRecording(); @@ -1249,7 +1249,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::RecordingIsAvailable(bool& available) return res; } -WebRtc_Word32 AudioDeviceLinuxPulse::InitPlayout() +int32_t AudioDeviceLinuxPulse::InitPlayout() { CriticalSectionScoped lock(&_critSect); @@ -1277,7 +1277,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitPlayout() } // Set sampling rate to use - WebRtc_UWord32 samplingRate = _samplingFreq * 1000; + uint32_t samplingRate = _samplingFreq * 1000; if (samplingRate == 44000) { samplingRate = 44100; @@ -1308,7 +1308,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitPlayout() { // Update audio buffer with the selected parameters _ptrAudioBuffer->SetPlayoutSampleRate(_samplingFreq * 1000); - _ptrAudioBuffer->SetPlayoutChannels((WebRtc_UWord8) _playChannels); + _ptrAudioBuffer->SetPlayoutChannels((uint8_t) _playChannels); } WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, @@ -1341,7 +1341,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitPlayout() } size_t bytesPerSec = LATE(pa_bytes_per_second)(spec); - WebRtc_UWord32 latency = bytesPerSec + uint32_t latency = bytesPerSec * WEBRTC_PA_PLAYBACK_LATENCY_MINIMUM_MSECS / WEBRTC_PA_MSECS_PER_SEC; // Set the play buffer attributes @@ -1358,7 +1358,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitPlayout() // num samples in bytes * num channels _playbackBufferSize = _samplingFreq * 10 * 2 * _playChannels; _playbackBufferUnused = _playbackBufferSize; - _playBuffer = new WebRtc_Word8[_playbackBufferSize]; + _playBuffer = new int8_t[_playbackBufferSize]; // Enable underflow callback LATE(pa_stream_set_underflow_callback)(_playStream, @@ -1375,7 +1375,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitPlayout() return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::InitRecording() +int32_t AudioDeviceLinuxPulse::InitRecording() { CriticalSectionScoped lock(&_critSect); @@ -1403,7 +1403,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitRecording() } // Set sampling rate to use - WebRtc_UWord32 samplingRate = _samplingFreq * 1000; + uint32_t samplingRate = _samplingFreq * 1000; if (samplingRate == 44000) { samplingRate = 44100; @@ -1433,7 +1433,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitRecording() { // Update audio buffer with the selected parameters _ptrAudioBuffer->SetRecordingSampleRate(_samplingFreq * 1000); - _ptrAudioBuffer->SetRecordingChannels((WebRtc_UWord8) _recChannels); + _ptrAudioBuffer->SetRecordingChannels((uint8_t) _recChannels); } if (_configuredLatencyRec != WEBRTC_PA_NO_LATENCY_REQUIREMENTS) @@ -1462,7 +1462,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitRecording() } size_t bytesPerSec = LATE(pa_bytes_per_second)(spec); - WebRtc_UWord32 latency = bytesPerSec + uint32_t latency = bytesPerSec * WEBRTC_PA_LOW_CAPTURE_LATENCY_MSECS / WEBRTC_PA_MSECS_PER_SEC; // Set the rec buffer attributes @@ -1477,7 +1477,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitRecording() _recordBufferSize = _samplingFreq * 10 * 2 * _recChannels; _recordBufferUsed = 0; - _recBuffer = new WebRtc_Word8[_recordBufferSize]; + _recBuffer = new int8_t[_recordBufferSize]; // Enable overflow callback LATE(pa_stream_set_overflow_callback)(_recStream, PaStreamOverflowCallback, @@ -1492,7 +1492,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitRecording() return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::StartRecording() +int32_t AudioDeviceLinuxPulse::StartRecording() { if (!_recIsInitialized) @@ -1538,7 +1538,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::StartRecording() return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::StopRecording() +int32_t AudioDeviceLinuxPulse::StopRecording() { CriticalSectionScoped lock(&_critSect); @@ -1617,7 +1617,7 @@ bool AudioDeviceLinuxPulse::PlayoutIsInitialized() const return (_playIsInitialized); } -WebRtc_Word32 AudioDeviceLinuxPulse::StartPlayout() +int32_t AudioDeviceLinuxPulse::StartPlayout() { if (!_playIsInitialized) { @@ -1665,7 +1665,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::StartPlayout() return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::StopPlayout() +int32_t AudioDeviceLinuxPulse::StopPlayout() { CriticalSectionScoped lock(&_critSect); @@ -1730,17 +1730,17 @@ WebRtc_Word32 AudioDeviceLinuxPulse::StopPlayout() return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::PlayoutDelay(WebRtc_UWord16& delayMS) const +int32_t AudioDeviceLinuxPulse::PlayoutDelay(uint16_t& delayMS) const { CriticalSectionScoped lock(&_critSect); - delayMS = (WebRtc_UWord16) _sndCardPlayDelay; + delayMS = (uint16_t) _sndCardPlayDelay; return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::RecordingDelay(WebRtc_UWord16& delayMS) const +int32_t AudioDeviceLinuxPulse::RecordingDelay(uint16_t& delayMS) const { CriticalSectionScoped lock(&_critSect); - delayMS = (WebRtc_UWord16) _sndCardRecDelay; + delayMS = (uint16_t) _sndCardRecDelay; return 0; } @@ -1750,9 +1750,9 @@ bool AudioDeviceLinuxPulse::Playing() const return (_playing); } -WebRtc_Word32 AudioDeviceLinuxPulse::SetPlayoutBuffer( +int32_t AudioDeviceLinuxPulse::SetPlayoutBuffer( const AudioDeviceModule::BufferType type, - WebRtc_UWord16 sizeMS) + uint16_t sizeMS) { if (type != AudioDeviceModule::kFixedBufferSize) @@ -1768,9 +1768,9 @@ WebRtc_Word32 AudioDeviceLinuxPulse::SetPlayoutBuffer( return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::PlayoutBuffer( +int32_t AudioDeviceLinuxPulse::PlayoutBuffer( AudioDeviceModule::BufferType& type, - WebRtc_UWord16& sizeMS) const + uint16_t& sizeMS) const { type = _playBufType; @@ -1779,7 +1779,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::PlayoutBuffer( return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::CPULoad(WebRtc_UWord16& /*load*/) const +int32_t AudioDeviceLinuxPulse::CPULoad(uint16_t& /*load*/) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -1985,7 +1985,7 @@ void AudioDeviceLinuxPulse::PaSourceInfoCallbackHandler( void AudioDeviceLinuxPulse::PaServerInfoCallbackHandler(const pa_server_info *i) { // Use PA native sampling rate - WebRtc_UWord32 paSampleRate = i->sample_spec.rate; + uint32_t paSampleRate = i->sample_spec.rate; if (paSampleRate == 44100) { #ifdef WEBRTC_PA_GTALK @@ -2050,12 +2050,12 @@ void AudioDeviceLinuxPulse::PaStreamStateCallbackHandler(pa_stream *p) LATE(pa_threaded_mainloop_signal)(_paMainloop, 0); } -WebRtc_Word32 AudioDeviceLinuxPulse::CheckPulseAudioVersion() +int32_t AudioDeviceLinuxPulse::CheckPulseAudioVersion() { - /*WebRtc_Word32 index = 0; - WebRtc_Word32 partIndex = 0; - WebRtc_Word32 partNum = 1; - WebRtc_Word32 minVersion[3] = {0, 9, 15}; + /*int32_t index = 0; + int32_t partIndex = 0; + int32_t partNum = 1; + int32_t minVersion[3] = {0, 9, 15}; bool versionOk = false; char str[8] = {0};*/ @@ -2125,7 +2125,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::CheckPulseAudioVersion() return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::InitSamplingFrequency() +int32_t AudioDeviceLinuxPulse::InitSamplingFrequency() { PaLock(); @@ -2142,13 +2142,13 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitSamplingFrequency() return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::GetDefaultDeviceInfo(bool recDevice, - char* name, - WebRtc_UWord16& index) +int32_t AudioDeviceLinuxPulse::GetDefaultDeviceInfo(bool recDevice, + char* name, + uint16_t& index) { char tmpName[kAdmMaxDeviceNameSize] = {0}; // subtract length of "default: " - WebRtc_UWord16 nameLen = kAdmMaxDeviceNameSize - 9; + uint16_t nameLen = kAdmMaxDeviceNameSize - 9; char* pName = NULL; if (name) @@ -2224,7 +2224,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::GetDefaultDeviceInfo(bool recDevice, return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::InitPulseAudio() +int32_t AudioDeviceLinuxPulse::InitPulseAudio() { int retVal = 0; @@ -2365,7 +2365,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::InitPulseAudio() return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::TerminatePulseAudio() +int32_t AudioDeviceLinuxPulse::TerminatePulseAudio() { // Do nothing if the instance doesn't exist // likely PaSymbolTable.Load() fails @@ -2515,7 +2515,7 @@ void AudioDeviceLinuxPulse::PaStreamUnderflowCallbackHandler() } size_t bytesPerSec = LATE(pa_bytes_per_second)(spec); - WebRtc_UWord32 newLatency = _configuredLatencyPlay + bytesPerSec + uint32_t newLatency = _configuredLatencyPlay + bytesPerSec * WEBRTC_PA_PLAYBACK_LATENCY_INCREMENT_MSECS / WEBRTC_PA_MSECS_PER_SEC; // Set the play buffer attributes @@ -2589,7 +2589,7 @@ void AudioDeviceLinuxPulse::PaStreamOverflowCallbackHandler() " Recording overflow"); } -WebRtc_Word32 AudioDeviceLinuxPulse::LatencyUsecs(pa_stream *stream) +int32_t AudioDeviceLinuxPulse::LatencyUsecs(pa_stream *stream) { if (!WEBRTC_PA_REPORT_LATENCY) { @@ -2620,7 +2620,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::LatencyUsecs(pa_stream *stream) // The delay can be negative for monitoring streams if the captured // samples haven't been played yet. In such a case, "latency" contains the // magnitude, so we must negate it to get the real value. - WebRtc_Word32 tmpLatency = (WebRtc_Word32) -latency; + int32_t tmpLatency = (int32_t) -latency; if (tmpLatency < 0) { // Make sure that we don't use a negative delay @@ -2630,18 +2630,18 @@ WebRtc_Word32 AudioDeviceLinuxPulse::LatencyUsecs(pa_stream *stream) return tmpLatency; } else { - return (WebRtc_Word32) latency; + return (int32_t) latency; } } -WebRtc_Word32 AudioDeviceLinuxPulse::ReadRecordedData(const void* bufferData, - size_t bufferSize) +int32_t AudioDeviceLinuxPulse::ReadRecordedData(const void* bufferData, + size_t bufferSize) { size_t size = bufferSize; - WebRtc_UWord32 numRecSamples = _recordBufferSize / (2 * _recChannels); + uint32_t numRecSamples = _recordBufferSize / (2 * _recChannels); // Account for the peeked data and the used data - WebRtc_UWord32 recDelay = (WebRtc_UWord32) ((LatencyUsecs(_recStream) + uint32_t recDelay = (uint32_t) ((LatencyUsecs(_recStream) / 1000) + 10 * ((size + _recordBufferUsed) / _recordBufferSize)); _sndCardRecDelay = recDelay; @@ -2649,7 +2649,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::ReadRecordedData(const void* bufferData, if (_playStream) { // Get the playout delay - _sndCardPlayDelay = (WebRtc_UWord32) (LatencyUsecs(_playStream) / 1000); + _sndCardPlayDelay = (uint32_t) (LatencyUsecs(_playStream) / 1000); } if (_recordBufferUsed > 0) @@ -2687,7 +2687,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::ReadRecordedData(const void* bufferData, { // Provide data to VoiceEngine if (ProcessRecordedData( - static_cast (const_cast (bufferData)), + static_cast (const_cast (bufferData)), numRecSamples, recDelay) == -1) { // We have stopped recording @@ -2711,13 +2711,13 @@ WebRtc_Word32 AudioDeviceLinuxPulse::ReadRecordedData(const void* bufferData, return 0; } -WebRtc_Word32 AudioDeviceLinuxPulse::ProcessRecordedData( - WebRtc_Word8 *bufferData, - WebRtc_UWord32 bufferSizeInSamples, - WebRtc_UWord32 recDelay) +int32_t AudioDeviceLinuxPulse::ProcessRecordedData( + int8_t *bufferData, + uint32_t bufferSizeInSamples, + uint32_t recDelay) { - WebRtc_UWord32 currentMicLevel(0); - WebRtc_UWord32 newMicLevel(0); + uint32_t currentMicLevel(0); + uint32_t newMicLevel(0); _ptrAudioBuffer->SetRecordedBuffer(bufferData, bufferSizeInSamples); @@ -2731,7 +2731,7 @@ WebRtc_Word32 AudioDeviceLinuxPulse::ProcessRecordedData( } } - const WebRtc_UWord32 clockDrift(0); + const uint32_t clockDrift(0); // TODO(andrew): this is a temporary hack, to avoid non-causal far- and // near-end signals at the AEC for PulseAudio. I think the system delay is // being correctly calculated here, but for legacy reasons we add +10 ms to @@ -2839,7 +2839,7 @@ bool AudioDeviceLinuxPulse::PlayThreadProcess() } // Get the currently saved speaker volume - WebRtc_UWord32 volume = 0; + uint32_t volume = 0; if (update_speaker_volume_at_startup_) _mixerManager.SpeakerVolume(volume); @@ -2907,7 +2907,7 @@ bool AudioDeviceLinuxPulse::PlayThreadProcess() if (!_recording) { // Update the playout delay - _sndCardPlayDelay = (WebRtc_UWord32) (LatencyUsecs(_playStream) + _sndCardPlayDelay = (uint32_t) (LatencyUsecs(_playStream) / 1000); } @@ -2954,8 +2954,7 @@ bool AudioDeviceLinuxPulse::PlayThreadProcess() _tempBufferSpace -= write; } - WebRtc_UWord32 numPlaySamples = _playbackBufferSize / (2 - * _playChannels); + uint32_t numPlaySamples = _playbackBufferSize / (2 * _playChannels); if (_tempBufferSpace > 0) // Might have been reduced to zero by the above { // Ask for new PCM data to be played out using the AudioDeviceBuffer @@ -2964,7 +2963,7 @@ bool AudioDeviceLinuxPulse::PlayThreadProcess() UnLock(); WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, " requesting data"); - WebRtc_UWord32 nSamples = + uint32_t nSamples = _ptrAudioBuffer->RequestPlayoutData(numPlaySamples); Lock(); @@ -3157,7 +3156,7 @@ bool AudioDeviceLinuxPulse::RecThreadProcess() break; } - _sndCardRecDelay = (WebRtc_UWord32) (LatencyUsecs(_recStream) + _sndCardRecDelay = (uint32_t) (LatencyUsecs(_recStream) / 1000); // Drop lock for sigslot dispatch, which could take a while. diff --git a/webrtc/modules/audio_device/linux/audio_device_pulse_linux.h b/webrtc/modules/audio_device/linux/audio_device_pulse_linux.h index 1a71fe5704..ab079efffe 100644 --- a/webrtc/modules/audio_device/linux/audio_device_pulse_linux.h +++ b/webrtc/modules/audio_device/linux/audio_device_pulse_linux.h @@ -31,12 +31,12 @@ #endif // Set this constant to 0 to disable latency reading -const WebRtc_UWord32 WEBRTC_PA_REPORT_LATENCY = 1; +const uint32_t WEBRTC_PA_REPORT_LATENCY = 1; // Constants from implementation by Tristan Schmelcher [tschmelcher@google.com] // First PulseAudio protocol version that supports PA_STREAM_ADJUST_LATENCY. -const WebRtc_UWord32 WEBRTC_PA_ADJUST_LATENCY_PROTOCOL_VERSION = 13; +const uint32_t WEBRTC_PA_ADJUST_LATENCY_PROTOCOL_VERSION = 13; // Some timing constants for optimal operation. See // https://tango.0pointer.de/pipermail/pulseaudio-discuss/2008-January/001170.html @@ -50,17 +50,17 @@ const WebRtc_UWord32 WEBRTC_PA_ADJUST_LATENCY_PROTOCOL_VERSION = 13; // also enforce a sane minimum at start-up time. Anything lower would be // virtually guaranteed to underflow at least once, so there's no point in // allowing lower latencies. -const WebRtc_UWord32 WEBRTC_PA_PLAYBACK_LATENCY_MINIMUM_MSECS = 20; +const uint32_t WEBRTC_PA_PLAYBACK_LATENCY_MINIMUM_MSECS = 20; // Every time a playback stream underflows, we will reconfigure it with target // latency that is greater by this amount. -const WebRtc_UWord32 WEBRTC_PA_PLAYBACK_LATENCY_INCREMENT_MSECS = 20; +const uint32_t WEBRTC_PA_PLAYBACK_LATENCY_INCREMENT_MSECS = 20; // We also need to configure a suitable request size. Too small and we'd burn // CPU from the overhead of transfering small amounts of data at once. Too large // and the amount of data remaining in the buffer right before refilling it // would be a buffer underflow risk. We set it to half of the buffer size. -const WebRtc_UWord32 WEBRTC_PA_PLAYBACK_REQUEST_FACTOR = 2; +const uint32_t WEBRTC_PA_PLAYBACK_REQUEST_FACTOR = 2; // Capture. @@ -69,22 +69,22 @@ const WebRtc_UWord32 WEBRTC_PA_PLAYBACK_REQUEST_FACTOR = 2; // a recommended value that we use for the kLowLatency constant (but if the user // explicitly requests something lower then we will honour it). // 1ms takes about 6-7% CPU. 5ms takes about 5%. 10ms takes about 4.x%. -const WebRtc_UWord32 WEBRTC_PA_LOW_CAPTURE_LATENCY_MSECS = 10; +const uint32_t WEBRTC_PA_LOW_CAPTURE_LATENCY_MSECS = 10; // There is a round-trip delay to ack the data to the server, so the // server-side buffer needs extra space to prevent buffer overflow. 20ms is // sufficient, but there is no penalty to making it bigger, so we make it huge. // (750ms is libpulse's default value for the _total_ buffer size in the // kNoLatencyRequirements case.) -const WebRtc_UWord32 WEBRTC_PA_CAPTURE_BUFFER_EXTRA_MSECS = 750; +const uint32_t WEBRTC_PA_CAPTURE_BUFFER_EXTRA_MSECS = 750; -const WebRtc_UWord32 WEBRTC_PA_MSECS_PER_SEC = 1000; +const uint32_t WEBRTC_PA_MSECS_PER_SEC = 1000; // Init _configuredLatencyRec/Play to this value to disable latency requirements -const WebRtc_Word32 WEBRTC_PA_NO_LATENCY_REQUIREMENTS = -1; +const int32_t WEBRTC_PA_NO_LATENCY_REQUIREMENTS = -1; // Set this const to 1 to account for peeked and used data in latency calculation -const WebRtc_UWord32 WEBRTC_PA_CAPTURE_BUFFER_LATENCY_ADJUSTMENT = 0; +const uint32_t WEBRTC_PA_CAPTURE_BUFFER_LATENCY_ADJUSTMENT = 0; namespace webrtc { @@ -94,125 +94,124 @@ class ThreadWrapper; class AudioDeviceLinuxPulse: public AudioDeviceGeneric { public: - AudioDeviceLinuxPulse(const WebRtc_Word32 id); + AudioDeviceLinuxPulse(const int32_t id); ~AudioDeviceLinuxPulse(); static bool PulseAudioIsSupported(); // Retrieve the currently utilized audio layer - virtual WebRtc_Word32 + virtual int32_t ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const; // Main initializaton and termination - virtual WebRtc_Word32 Init(); - virtual WebRtc_Word32 Terminate(); + virtual int32_t Init(); + virtual int32_t Terminate(); virtual bool Initialized() const; // Device enumeration - virtual WebRtc_Word16 PlayoutDevices(); - virtual WebRtc_Word16 RecordingDevices(); - virtual WebRtc_Word32 PlayoutDeviceName( - WebRtc_UWord16 index, + virtual int16_t PlayoutDevices(); + virtual int16_t RecordingDevices(); + virtual int32_t PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); - virtual WebRtc_Word32 RecordingDeviceName( - WebRtc_UWord16 index, + virtual int32_t RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); // Device selection - virtual WebRtc_Word32 SetPlayoutDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetPlayoutDevice( + virtual int32_t SetPlayoutDevice(uint16_t index); + virtual int32_t SetPlayoutDevice( AudioDeviceModule::WindowsDeviceType device); - virtual WebRtc_Word32 SetRecordingDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetRecordingDevice( + virtual int32_t SetRecordingDevice(uint16_t index); + virtual int32_t SetRecordingDevice( AudioDeviceModule::WindowsDeviceType device); // Audio transport initialization - virtual WebRtc_Word32 PlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 InitPlayout(); + virtual int32_t PlayoutIsAvailable(bool& available); + virtual int32_t InitPlayout(); virtual bool PlayoutIsInitialized() const; - virtual WebRtc_Word32 RecordingIsAvailable(bool& available); - virtual WebRtc_Word32 InitRecording(); + virtual int32_t RecordingIsAvailable(bool& available); + virtual int32_t InitRecording(); virtual bool RecordingIsInitialized() const; // Audio transport control - virtual WebRtc_Word32 StartPlayout(); - virtual WebRtc_Word32 StopPlayout(); + virtual int32_t StartPlayout(); + virtual int32_t StopPlayout(); virtual bool Playing() const; - virtual WebRtc_Word32 StartRecording(); - virtual WebRtc_Word32 StopRecording(); + virtual int32_t StartRecording(); + virtual int32_t StopRecording(); virtual bool Recording() const; // Microphone Automatic Gain Control (AGC) - virtual WebRtc_Word32 SetAGC(bool enable); + virtual int32_t SetAGC(bool enable); virtual bool AGC() const; // Volume control based on the Windows Wave API (Windows only) - virtual WebRtc_Word32 SetWaveOutVolume(WebRtc_UWord16 volumeLeft, - WebRtc_UWord16 volumeRight); - virtual WebRtc_Word32 WaveOutVolume(WebRtc_UWord16& volumeLeft, - WebRtc_UWord16& volumeRight) const; + virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight); + virtual int32_t WaveOutVolume(uint16_t& volumeLeft, + uint16_t& volumeRight) const; // Audio mixer initialization - virtual WebRtc_Word32 SpeakerIsAvailable(bool& available); - virtual WebRtc_Word32 InitSpeaker(); + virtual int32_t SpeakerIsAvailable(bool& available); + virtual int32_t InitSpeaker(); virtual bool SpeakerIsInitialized() const; - virtual WebRtc_Word32 MicrophoneIsAvailable(bool& available); - virtual WebRtc_Word32 InitMicrophone(); + virtual int32_t MicrophoneIsAvailable(bool& available); + virtual int32_t InitMicrophone(); virtual bool MicrophoneIsInitialized() const; // Speaker volume controls - virtual WebRtc_Word32 SpeakerVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 SpeakerVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const; + virtual int32_t SpeakerVolumeIsAvailable(bool& available); + virtual int32_t SetSpeakerVolume(uint32_t volume); + virtual int32_t SpeakerVolume(uint32_t& volume) const; + virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const; + virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const; + virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const; // Microphone volume controls - virtual WebRtc_Word32 MicrophoneVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinMicrophoneVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 MicrophoneVolumeStepSize( - WebRtc_UWord16& stepSize) const; + virtual int32_t MicrophoneVolumeIsAvailable(bool& available); + virtual int32_t SetMicrophoneVolume(uint32_t volume); + virtual int32_t MicrophoneVolume(uint32_t& volume) const; + virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const; + virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const; + virtual int32_t MicrophoneVolumeStepSize( + uint16_t& stepSize) const; // Speaker mute control - virtual WebRtc_Word32 SpeakerMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerMute(bool enable); - virtual WebRtc_Word32 SpeakerMute(bool& enabled) const; + virtual int32_t SpeakerMuteIsAvailable(bool& available); + virtual int32_t SetSpeakerMute(bool enable); + virtual int32_t SpeakerMute(bool& enabled) const; // Microphone mute control - virtual WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneMute(bool enable); - virtual WebRtc_Word32 MicrophoneMute(bool& enabled) const; + virtual int32_t MicrophoneMuteIsAvailable(bool& available); + virtual int32_t SetMicrophoneMute(bool enable); + virtual int32_t MicrophoneMute(bool& enabled) const; // Microphone boost control - virtual WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneBoost(bool enable); - virtual WebRtc_Word32 MicrophoneBoost(bool& enabled) const; + virtual int32_t MicrophoneBoostIsAvailable(bool& available); + virtual int32_t SetMicrophoneBoost(bool enable); + virtual int32_t MicrophoneBoost(bool& enabled) const; // Stereo support - virtual WebRtc_Word32 StereoPlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoPlayout(bool enable); - virtual WebRtc_Word32 StereoPlayout(bool& enabled) const; - virtual WebRtc_Word32 StereoRecordingIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoRecording(bool enable); - virtual WebRtc_Word32 StereoRecording(bool& enabled) const; + virtual int32_t StereoPlayoutIsAvailable(bool& available); + virtual int32_t SetStereoPlayout(bool enable); + virtual int32_t StereoPlayout(bool& enabled) const; + virtual int32_t StereoRecordingIsAvailable(bool& available); + virtual int32_t SetStereoRecording(bool enable); + virtual int32_t StereoRecording(bool& enabled) const; // Delay information and control - virtual WebRtc_Word32 + virtual int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type, - WebRtc_UWord16 sizeMS); - virtual WebRtc_Word32 PlayoutBuffer(AudioDeviceModule::BufferType& type, - WebRtc_UWord16& sizeMS) const; - virtual WebRtc_Word32 PlayoutDelay(WebRtc_UWord16& delayMS) const; - virtual WebRtc_Word32 RecordingDelay(WebRtc_UWord16& delayMS) const; + uint16_t sizeMS); + virtual int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type, + uint16_t& sizeMS) const; + virtual int32_t PlayoutDelay(uint16_t& delayMS) const; + virtual int32_t RecordingDelay(uint16_t& delayMS) const; // CPU load - virtual WebRtc_Word32 CPULoad(WebRtc_UWord16& load) const; + virtual int32_t CPULoad(uint16_t& load) const; public: virtual bool PlayoutWarning() const; @@ -270,18 +269,17 @@ private: void PaStreamReadCallbackHandler(); static void PaStreamOverflowCallback(pa_stream *unused, void *pThis); void PaStreamOverflowCallbackHandler(); - WebRtc_Word32 LatencyUsecs(pa_stream *stream); - WebRtc_Word32 ReadRecordedData(const void* bufferData, size_t bufferSize); - WebRtc_Word32 ProcessRecordedData(WebRtc_Word8 *bufferData, - WebRtc_UWord32 bufferSizeInSamples, - WebRtc_UWord32 recDelay); + int32_t LatencyUsecs(pa_stream *stream); + int32_t ReadRecordedData(const void* bufferData, size_t bufferSize); + int32_t ProcessRecordedData(int8_t *bufferData, + uint32_t bufferSizeInSamples, + uint32_t recDelay); - WebRtc_Word32 CheckPulseAudioVersion(); - WebRtc_Word32 InitSamplingFrequency(); - WebRtc_Word32 GetDefaultDeviceInfo(bool recDevice, char* name, - WebRtc_UWord16& index); - WebRtc_Word32 InitPulseAudio(); - WebRtc_Word32 TerminatePulseAudio(); + int32_t CheckPulseAudioVersion(); + int32_t InitSamplingFrequency(); + int32_t GetDefaultDeviceInfo(bool recDevice, char* name, uint16_t& index); + int32_t InitPulseAudio(); + int32_t TerminatePulseAudio(); void PaLock(); void PaUnLock(); @@ -302,20 +300,20 @@ private: ThreadWrapper* _ptrThreadPlay; ThreadWrapper* _ptrThreadRec; - WebRtc_UWord32 _recThreadID; - WebRtc_UWord32 _playThreadID; - WebRtc_Word32 _id; + uint32_t _recThreadID; + uint32_t _playThreadID; + int32_t _id; AudioMixerManagerLinuxPulse _mixerManager; - WebRtc_UWord16 _inputDeviceIndex; - WebRtc_UWord16 _outputDeviceIndex; + uint16_t _inputDeviceIndex; + uint16_t _outputDeviceIndex; bool _inputDeviceIsSpecified; bool _outputDeviceIsSpecified; - WebRtc_UWord32 _samplingFreq; - WebRtc_UWord8 _recChannels; - WebRtc_UWord8 _playChannels; + uint32_t _samplingFreq; + uint8_t _recChannels; + uint8_t _playChannels; AudioDeviceModule::BufferType _playBufType; @@ -333,40 +331,40 @@ private: bool update_speaker_volume_at_startup_; private: - WebRtc_UWord16 _playBufDelayFixed; // fixed playback delay + uint16_t _playBufDelayFixed; // fixed playback delay - WebRtc_UWord32 _sndCardPlayDelay; - WebRtc_UWord32 _sndCardRecDelay; + uint32_t _sndCardPlayDelay; + uint32_t _sndCardRecDelay; - WebRtc_Word32 _writeErrors; - WebRtc_UWord16 _playWarning; - WebRtc_UWord16 _playError; - WebRtc_UWord16 _recWarning; - WebRtc_UWord16 _recError; + int32_t _writeErrors; + uint16_t _playWarning; + uint16_t _playError; + uint16_t _recWarning; + uint16_t _recError; - WebRtc_UWord16 _deviceIndex; - WebRtc_Word16 _numPlayDevices; - WebRtc_Word16 _numRecDevices; + uint16_t _deviceIndex; + int16_t _numPlayDevices; + int16_t _numRecDevices; char* _playDeviceName; char* _recDeviceName; char* _playDisplayDeviceName; char* _recDisplayDeviceName; char _paServerVersion[32]; - WebRtc_Word8* _playBuffer; + int8_t* _playBuffer; size_t _playbackBufferSize; size_t _playbackBufferUnused; size_t _tempBufferSpace; - WebRtc_Word8* _recBuffer; + int8_t* _recBuffer; size_t _recordBufferSize; size_t _recordBufferUsed; const void* _tempSampleData; size_t _tempSampleDataSize; - WebRtc_Word32 _configuredLatencyPlay; - WebRtc_Word32 _configuredLatencyRec; + int32_t _configuredLatencyPlay; + int32_t _configuredLatencyRec; // PulseAudio - WebRtc_UWord16 _paDeviceIndex; + uint16_t _paDeviceIndex; bool _paStateChanged; pa_threaded_mainloop* _paMainloop; @@ -375,8 +373,8 @@ private: pa_stream* _recStream; pa_stream* _playStream; - WebRtc_UWord32 _recStreamFlags; - WebRtc_UWord32 _playStreamFlags; + uint32_t _recStreamFlags; + uint32_t _playStreamFlags; pa_buffer_attr _playBufferAttr; pa_buffer_attr _recBufferAttr; }; diff --git a/webrtc/modules/audio_device/linux/audio_device_utility_linux.cc b/webrtc/modules/audio_device/linux/audio_device_utility_linux.cc index 25abcc9ae7..2de4bacf4d 100644 --- a/webrtc/modules/audio_device/linux/audio_device_utility_linux.cc +++ b/webrtc/modules/audio_device/linux/audio_device_utility_linux.cc @@ -16,7 +16,7 @@ namespace webrtc { -AudioDeviceUtilityLinux::AudioDeviceUtilityLinux(const WebRtc_Word32 id) : +AudioDeviceUtilityLinux::AudioDeviceUtilityLinux(const int32_t id) : _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _id(id) { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id, @@ -41,7 +41,7 @@ AudioDeviceUtilityLinux::~AudioDeviceUtilityLinux() // ============================================================================ -WebRtc_Word32 AudioDeviceUtilityLinux::Init() +int32_t AudioDeviceUtilityLinux::Init() { WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, diff --git a/webrtc/modules/audio_device/linux/audio_device_utility_linux.h b/webrtc/modules/audio_device/linux/audio_device_utility_linux.h index 0e3c4103e3..22549c6104 100644 --- a/webrtc/modules/audio_device/linux/audio_device_utility_linux.h +++ b/webrtc/modules/audio_device/linux/audio_device_utility_linux.h @@ -21,14 +21,14 @@ class CriticalSectionWrapper; class AudioDeviceUtilityLinux: public AudioDeviceUtility { public: - AudioDeviceUtilityLinux(const WebRtc_Word32 id); + AudioDeviceUtilityLinux(const int32_t id); ~AudioDeviceUtilityLinux(); - virtual WebRtc_Word32 Init(); + virtual int32_t Init(); private: CriticalSectionWrapper& _critSect; - WebRtc_Word32 _id; + int32_t _id; }; } // namespace webrtc diff --git a/webrtc/modules/audio_device/linux/audio_mixer_manager_alsa_linux.cc b/webrtc/modules/audio_device/linux/audio_mixer_manager_alsa_linux.cc index 2e12f0ac57..e3acebd039 100644 --- a/webrtc/modules/audio_device/linux/audio_mixer_manager_alsa_linux.cc +++ b/webrtc/modules/audio_device/linux/audio_mixer_manager_alsa_linux.cc @@ -24,7 +24,7 @@ extern webrtc_adm_linux_alsa::AlsaSymbolTable AlsaSymbolTable; namespace webrtc { -AudioMixerManagerLinuxALSA::AudioMixerManagerLinuxALSA(const WebRtc_Word32 id) : +AudioMixerManagerLinuxALSA::AudioMixerManagerLinuxALSA(const int32_t id) : _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _id(id), _outputMixerHandle(NULL), @@ -53,7 +53,7 @@ AudioMixerManagerLinuxALSA::~AudioMixerManagerLinuxALSA() // PUBLIC METHODS // ============================================================================ -WebRtc_Word32 AudioMixerManagerLinuxALSA::Close() +int32_t AudioMixerManagerLinuxALSA::Close() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -67,7 +67,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::Close() } -WebRtc_Word32 AudioMixerManagerLinuxALSA::CloseSpeaker() +int32_t AudioMixerManagerLinuxALSA::CloseSpeaker() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -109,7 +109,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::CloseSpeaker() return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::CloseMicrophone() +int32_t AudioMixerManagerLinuxALSA::CloseMicrophone() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -160,7 +160,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::CloseMicrophone() return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::OpenSpeaker(char* deviceName) +int32_t AudioMixerManagerLinuxALSA::OpenSpeaker(char* deviceName) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxALSA::OpenSpeaker(name=%s)", deviceName); @@ -253,7 +253,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::OpenSpeaker(char* deviceName) return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::OpenMicrophone(char *deviceName) +int32_t AudioMixerManagerLinuxALSA::OpenMicrophone(char *deviceName) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxALSA::OpenMicrophone(name=%s)", @@ -371,8 +371,8 @@ bool AudioMixerManagerLinuxALSA::MicrophoneIsInitialized() const return (_inputMixerHandle != NULL); } -WebRtc_Word32 AudioMixerManagerLinuxALSA::SetSpeakerVolume( - WebRtc_UWord32 volume) +int32_t AudioMixerManagerLinuxALSA::SetSpeakerVolume( + uint32_t volume) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxALSA::SetSpeakerVolume(volume=%u)", @@ -401,8 +401,8 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::SetSpeakerVolume( return (0); } -WebRtc_Word32 AudioMixerManagerLinuxALSA::SpeakerVolume( - WebRtc_UWord32& volume) const +int32_t AudioMixerManagerLinuxALSA::SpeakerVolume( + uint32_t& volume) const { if (_outputMixerElement == NULL) @@ -430,13 +430,13 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::SpeakerVolume( " AudioMixerManagerLinuxALSA::SpeakerVolume() => vol=%i", vol); - volume = static_cast (vol); + volume = static_cast (vol); return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::MaxSpeakerVolume( - WebRtc_UWord32& maxVolume) const +int32_t AudioMixerManagerLinuxALSA::MaxSpeakerVolume( + uint32_t& maxVolume) const { if (_outputMixerElement == NULL) @@ -464,13 +464,13 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MaxSpeakerVolume( LATE(snd_strerror)(errVal)); } - maxVolume = static_cast (maxVol); + maxVolume = static_cast (maxVol); return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::MinSpeakerVolume( - WebRtc_UWord32& minVolume) const +int32_t AudioMixerManagerLinuxALSA::MinSpeakerVolume( + uint32_t& minVolume) const { if (_outputMixerElement == NULL) @@ -498,7 +498,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MinSpeakerVolume( LATE(snd_strerror)(errVal)); } - minVolume = static_cast (minVol); + minVolume = static_cast (minVol); return 0; } @@ -510,8 +510,8 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MinSpeakerVolume( // SetMaxSpeakerVolume // ---------------------------------------------------------------------------- - WebRtc_Word32 AudioMixerManagerLinuxALSA::SetMaxSpeakerVolume( - WebRtc_UWord32 maxVolume) + int32_t AudioMixerManagerLinuxALSA::SetMaxSpeakerVolume( + uint32_t maxVolume) { if (_outputMixerElement == NULL) @@ -551,8 +551,8 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MinSpeakerVolume( // SetMinSpeakerVolume // ---------------------------------------------------------------------------- - WebRtc_Word32 AudioMixerManagerLinuxALSA::SetMinSpeakerVolume( - WebRtc_UWord32 minVolume) + int32_t AudioMixerManagerLinuxALSA::SetMinSpeakerVolume( + uint32_t minVolume) { if (_outputMixerElement == NULL) @@ -589,8 +589,8 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MinSpeakerVolume( } */ -WebRtc_Word32 AudioMixerManagerLinuxALSA::SpeakerVolumeStepSize( - WebRtc_UWord16& stepSize) const +int32_t AudioMixerManagerLinuxALSA::SpeakerVolumeStepSize( + uint16_t& stepSize) const { if (_outputMixerHandle == NULL) @@ -606,7 +606,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::SpeakerVolumeStepSize( return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::SpeakerVolumeIsAvailable( +int32_t AudioMixerManagerLinuxALSA::SpeakerVolumeIsAvailable( bool& available) { if (_outputMixerElement == NULL) @@ -621,7 +621,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::SpeakerVolumeIsAvailable( return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::SpeakerMuteIsAvailable( +int32_t AudioMixerManagerLinuxALSA::SpeakerMuteIsAvailable( bool& available) { if (_outputMixerElement == NULL) @@ -636,7 +636,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::SpeakerMuteIsAvailable( return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::SetSpeakerMute(bool enable) +int32_t AudioMixerManagerLinuxALSA::SetSpeakerMute(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxALSA::SetSpeakerMute(enable=%u)", @@ -676,7 +676,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::SetSpeakerMute(bool enable) return (0); } -WebRtc_Word32 AudioMixerManagerLinuxALSA::SpeakerMute(bool& enabled) const +int32_t AudioMixerManagerLinuxALSA::SpeakerMute(bool& enabled) const { if (_outputMixerElement == NULL) @@ -719,7 +719,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::SpeakerMute(bool& enabled) const return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneMuteIsAvailable( +int32_t AudioMixerManagerLinuxALSA::MicrophoneMuteIsAvailable( bool& available) { if (_inputMixerElement == NULL) @@ -733,7 +733,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneMuteIsAvailable( return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::SetMicrophoneMute(bool enable) +int32_t AudioMixerManagerLinuxALSA::SetMicrophoneMute(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxALSA::SetMicrophoneMute(enable=%u)", @@ -773,7 +773,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::SetMicrophoneMute(bool enable) return (0); } -WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneMute(bool& enabled) const +int32_t AudioMixerManagerLinuxALSA::MicrophoneMute(bool& enabled) const { if (_inputMixerElement == NULL) @@ -816,7 +816,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneMute(bool& enabled) const return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneBoostIsAvailable( +int32_t AudioMixerManagerLinuxALSA::MicrophoneBoostIsAvailable( bool& available) { if (_inputMixerHandle == NULL) @@ -832,7 +832,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneBoostIsAvailable( return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::SetMicrophoneBoost(bool enable) +int32_t AudioMixerManagerLinuxALSA::SetMicrophoneBoost(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxALSA::SetMicrophoneBoost(enable=%u)", @@ -862,7 +862,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::SetMicrophoneBoost(bool enable) return (0); } -WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneBoost(bool& enabled) const +int32_t AudioMixerManagerLinuxALSA::MicrophoneBoost(bool& enabled) const { if (_inputMixerHandle == NULL) @@ -878,7 +878,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneBoost(bool& enabled) const return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneVolumeIsAvailable( +int32_t AudioMixerManagerLinuxALSA::MicrophoneVolumeIsAvailable( bool& available) { if (_inputMixerElement == NULL) @@ -893,8 +893,8 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneVolumeIsAvailable( return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::SetMicrophoneVolume( - WebRtc_UWord32 volume) +int32_t AudioMixerManagerLinuxALSA::SetMicrophoneVolume( + uint32_t volume) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxALSA::SetMicrophoneVolume(volume=%u)", @@ -931,8 +931,8 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::SetMicrophoneVolume( // SetMaxMicrophoneVolume // ---------------------------------------------------------------------------- - WebRtc_Word32 AudioMixerManagerLinuxALSA::SetMaxMicrophoneVolume( - WebRtc_UWord32 maxVolume) + int32_t AudioMixerManagerLinuxALSA::SetMaxMicrophoneVolume( + uint32_t maxVolume) { if (_inputMixerElement == NULL) @@ -972,8 +972,8 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::SetMicrophoneVolume( // SetMinMicrophoneVolume // ---------------------------------------------------------------------------- - WebRtc_Word32 AudioMixerManagerLinuxALSA::SetMinMicrophoneVolume( - WebRtc_UWord32 minVolume) + int32_t AudioMixerManagerLinuxALSA::SetMinMicrophoneVolume( + uint32_t minVolume) { if (_inputMixerElement == NULL) @@ -1012,8 +1012,8 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::SetMicrophoneVolume( } */ -WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneVolume( - WebRtc_UWord32& volume) const +int32_t AudioMixerManagerLinuxALSA::MicrophoneVolume( + uint32_t& volume) const { if (_inputMixerElement == NULL) @@ -1042,13 +1042,13 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneVolume( " AudioMixerManagerLinuxALSA::MicrophoneVolume() => vol=%i", vol); - volume = static_cast (vol); + volume = static_cast (vol); return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::MaxMicrophoneVolume( - WebRtc_UWord32& maxVolume) const +int32_t AudioMixerManagerLinuxALSA::MaxMicrophoneVolume( + uint32_t& maxVolume) const { if (_inputMixerElement == NULL) @@ -1083,13 +1083,13 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MaxMicrophoneVolume( LATE(snd_strerror)(errVal)); } - maxVolume = static_cast (maxVol); + maxVolume = static_cast (maxVol); return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::MinMicrophoneVolume( - WebRtc_UWord32& minVolume) const +int32_t AudioMixerManagerLinuxALSA::MinMicrophoneVolume( + uint32_t& minVolume) const { if (_inputMixerElement == NULL) @@ -1116,13 +1116,13 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MinMicrophoneVolume( LATE(snd_strerror)(errVal)); } - minVolume = static_cast (minVol); + minVolume = static_cast (minVol); return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneVolumeStepSize( - WebRtc_UWord16& stepSize) const +int32_t AudioMixerManagerLinuxALSA::MicrophoneVolumeStepSize( + uint16_t& stepSize) const { if (_inputMixerHandle == NULL) @@ -1142,7 +1142,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::MicrophoneVolumeStepSize( // Private Methods // ============================================================================ -WebRtc_Word32 AudioMixerManagerLinuxALSA::LoadMicMixerElement() const +int32_t AudioMixerManagerLinuxALSA::LoadMicMixerElement() const { int errVal = LATE(snd_mixer_load)(_inputMixerHandle); if (errVal < 0) @@ -1208,7 +1208,7 @@ WebRtc_Word32 AudioMixerManagerLinuxALSA::LoadMicMixerElement() const return 0; } -WebRtc_Word32 AudioMixerManagerLinuxALSA::LoadSpeakerMixerElement() const +int32_t AudioMixerManagerLinuxALSA::LoadSpeakerMixerElement() const { int errVal = LATE(snd_mixer_load)(_outputMixerHandle); if (errVal < 0) diff --git a/webrtc/modules/audio_device/linux/audio_mixer_manager_alsa_linux.h b/webrtc/modules/audio_device/linux/audio_mixer_manager_alsa_linux.h index 94ea9820fd..99ca29615c 100644 --- a/webrtc/modules/audio_device/linux/audio_mixer_manager_alsa_linux.h +++ b/webrtc/modules/audio_device/linux/audio_mixer_manager_alsa_linux.h @@ -24,47 +24,47 @@ namespace webrtc class AudioMixerManagerLinuxALSA { public: - WebRtc_Word32 OpenSpeaker(char* deviceName); - WebRtc_Word32 OpenMicrophone(char* deviceName); - WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume); - WebRtc_Word32 SpeakerVolume(WebRtc_UWord32& volume) const; - WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const; - WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32& minVolume) const; - WebRtc_Word32 SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const; - WebRtc_Word32 SpeakerVolumeIsAvailable(bool& available); - WebRtc_Word32 SpeakerMuteIsAvailable(bool& available); - WebRtc_Word32 SetSpeakerMute(bool enable); - WebRtc_Word32 SpeakerMute(bool& enabled) const; - WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available); - WebRtc_Word32 SetMicrophoneMute(bool enable); - WebRtc_Word32 MicrophoneMute(bool& enabled) const; - WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available); - WebRtc_Word32 SetMicrophoneBoost(bool enable); - WebRtc_Word32 MicrophoneBoost(bool& enabled) const; - WebRtc_Word32 MicrophoneVolumeIsAvailable(bool& available); - WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume); - WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32& volume) const; - WebRtc_Word32 MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const; - WebRtc_Word32 MinMicrophoneVolume(WebRtc_UWord32& minVolume) const; - WebRtc_Word32 MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const; - WebRtc_Word32 Close(); - WebRtc_Word32 CloseSpeaker(); - WebRtc_Word32 CloseMicrophone(); + int32_t OpenSpeaker(char* deviceName); + int32_t OpenMicrophone(char* deviceName); + int32_t SetSpeakerVolume(uint32_t volume); + int32_t SpeakerVolume(uint32_t& volume) const; + int32_t MaxSpeakerVolume(uint32_t& maxVolume) const; + int32_t MinSpeakerVolume(uint32_t& minVolume) const; + int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const; + int32_t SpeakerVolumeIsAvailable(bool& available); + int32_t SpeakerMuteIsAvailable(bool& available); + int32_t SetSpeakerMute(bool enable); + int32_t SpeakerMute(bool& enabled) const; + int32_t MicrophoneMuteIsAvailable(bool& available); + int32_t SetMicrophoneMute(bool enable); + int32_t MicrophoneMute(bool& enabled) const; + int32_t MicrophoneBoostIsAvailable(bool& available); + int32_t SetMicrophoneBoost(bool enable); + int32_t MicrophoneBoost(bool& enabled) const; + int32_t MicrophoneVolumeIsAvailable(bool& available); + int32_t SetMicrophoneVolume(uint32_t volume); + int32_t MicrophoneVolume(uint32_t& volume) const; + int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const; + int32_t MinMicrophoneVolume(uint32_t& minVolume) const; + int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const; + int32_t Close(); + int32_t CloseSpeaker(); + int32_t CloseMicrophone(); bool SpeakerIsInitialized() const; bool MicrophoneIsInitialized() const; public: - AudioMixerManagerLinuxALSA(const WebRtc_Word32 id); + AudioMixerManagerLinuxALSA(const int32_t id); ~AudioMixerManagerLinuxALSA(); private: - WebRtc_Word32 LoadMicMixerElement() const; - WebRtc_Word32 LoadSpeakerMixerElement() const; + int32_t LoadMicMixerElement() const; + int32_t LoadSpeakerMixerElement() const; void GetControlName(char *controlName, char* deviceName) const; private: CriticalSectionWrapper& _critSect; - WebRtc_Word32 _id; + int32_t _id; mutable snd_mixer_t* _outputMixerHandle; char _outputMixerStr[kAdmMaxDeviceNameSize]; mutable snd_mixer_t* _inputMixerHandle; diff --git a/webrtc/modules/audio_device/linux/audio_mixer_manager_pulse_linux.cc b/webrtc/modules/audio_device/linux/audio_mixer_manager_pulse_linux.cc index a0b6852355..b32718c149 100644 --- a/webrtc/modules/audio_device/linux/audio_mixer_manager_pulse_linux.cc +++ b/webrtc/modules/audio_device/linux/audio_mixer_manager_pulse_linux.cc @@ -26,7 +26,7 @@ namespace webrtc enum { kMaxRetryOnFailure = 2 }; -AudioMixerManagerLinuxPulse::AudioMixerManagerLinuxPulse(const WebRtc_Word32 id) : +AudioMixerManagerLinuxPulse::AudioMixerManagerLinuxPulse(const int32_t id) : _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _id(id), _paOutputDeviceIndex(-1), @@ -62,7 +62,7 @@ AudioMixerManagerLinuxPulse::~AudioMixerManagerLinuxPulse() // PUBLIC METHODS // ============================================================================ -WebRtc_Word32 AudioMixerManagerLinuxPulse::SetPulseAudioObjects( +int32_t AudioMixerManagerLinuxPulse::SetPulseAudioObjects( pa_threaded_mainloop* mainloop, pa_context* context) { @@ -88,7 +88,7 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::SetPulseAudioObjects( return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::Close() +int32_t AudioMixerManagerLinuxPulse::Close() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -106,7 +106,7 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::Close() } -WebRtc_Word32 AudioMixerManagerLinuxPulse::CloseSpeaker() +int32_t AudioMixerManagerLinuxPulse::CloseSpeaker() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -120,7 +120,7 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::CloseSpeaker() return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::CloseMicrophone() +int32_t AudioMixerManagerLinuxPulse::CloseMicrophone() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -134,7 +134,7 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::CloseMicrophone() return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::SetPlayStream(pa_stream* playStream) +int32_t AudioMixerManagerLinuxPulse::SetPlayStream(pa_stream* playStream) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxPulse::SetPlayStream(playStream)"); @@ -144,7 +144,7 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::SetPlayStream(pa_stream* playStream) return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::SetRecStream(pa_stream* recStream) +int32_t AudioMixerManagerLinuxPulse::SetRecStream(pa_stream* recStream) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxPulse::SetRecStream(recStream)"); @@ -154,8 +154,8 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::SetRecStream(pa_stream* recStream) return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::OpenSpeaker( - WebRtc_UWord16 deviceIndex) +int32_t AudioMixerManagerLinuxPulse::OpenSpeaker( + uint16_t deviceIndex) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxPulse::OpenSpeaker(deviceIndex=%d)", @@ -182,8 +182,8 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::OpenSpeaker( return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::OpenMicrophone( - WebRtc_UWord16 deviceIndex) +int32_t AudioMixerManagerLinuxPulse::OpenMicrophone( + uint16_t deviceIndex) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxPulse::OpenMicrophone(deviceIndex=%d)", @@ -226,8 +226,8 @@ bool AudioMixerManagerLinuxPulse::MicrophoneIsInitialized() const return (_paInputDeviceIndex != -1); } -WebRtc_Word32 AudioMixerManagerLinuxPulse::SetSpeakerVolume( - WebRtc_UWord32 volume) +int32_t AudioMixerManagerLinuxPulse::SetSpeakerVolume( + uint32_t volume) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxPulse::SetSpeakerVolume(volume=%u)", @@ -299,8 +299,8 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::SetSpeakerVolume( return 0; } -WebRtc_Word32 -AudioMixerManagerLinuxPulse::SpeakerVolume(WebRtc_UWord32& volume) const +int32_t +AudioMixerManagerLinuxPulse::SpeakerVolume(uint32_t& volume) const { if (_paOutputDeviceIndex == -1) @@ -317,7 +317,7 @@ AudioMixerManagerLinuxPulse::SpeakerVolume(WebRtc_UWord32& volume) const if (!GetSinkInputInfo()) return -1; - volume = static_cast (_paVolume); + volume = static_cast (_paVolume); ResetCallbackVariables(); } else { @@ -331,8 +331,8 @@ AudioMixerManagerLinuxPulse::SpeakerVolume(WebRtc_UWord32& volume) const return 0; } -WebRtc_Word32 -AudioMixerManagerLinuxPulse::MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const +int32_t +AudioMixerManagerLinuxPulse::MaxSpeakerVolume(uint32_t& maxVolume) const { if (_paOutputDeviceIndex == -1) @@ -344,13 +344,13 @@ AudioMixerManagerLinuxPulse::MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const // PA_VOLUME_NORM corresponds to 100% (0db) // but PA allows up to 150 db amplification - maxVolume = static_cast (PA_VOLUME_NORM); + maxVolume = static_cast (PA_VOLUME_NORM); return 0; } -WebRtc_Word32 -AudioMixerManagerLinuxPulse::MinSpeakerVolume(WebRtc_UWord32& minVolume) const +int32_t +AudioMixerManagerLinuxPulse::MinSpeakerVolume(uint32_t& minVolume) const { if (_paOutputDeviceIndex == -1) @@ -360,13 +360,13 @@ AudioMixerManagerLinuxPulse::MinSpeakerVolume(WebRtc_UWord32& minVolume) const return -1; } - minVolume = static_cast (PA_VOLUME_MUTED); + minVolume = static_cast (PA_VOLUME_MUTED); return 0; } -WebRtc_Word32 -AudioMixerManagerLinuxPulse::SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const +int32_t +AudioMixerManagerLinuxPulse::SpeakerVolumeStepSize(uint16_t& stepSize) const { if (_paOutputDeviceIndex == -1) @@ -390,7 +390,7 @@ AudioMixerManagerLinuxPulse::SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) con return 0; } -WebRtc_Word32 +int32_t AudioMixerManagerLinuxPulse::SpeakerVolumeIsAvailable(bool& available) { if (_paOutputDeviceIndex == -1) @@ -406,7 +406,7 @@ AudioMixerManagerLinuxPulse::SpeakerVolumeIsAvailable(bool& available) return 0; } -WebRtc_Word32 +int32_t AudioMixerManagerLinuxPulse::SpeakerMuteIsAvailable(bool& available) { if (_paOutputDeviceIndex == -1) @@ -422,7 +422,7 @@ AudioMixerManagerLinuxPulse::SpeakerMuteIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::SetSpeakerMute(bool enable) +int32_t AudioMixerManagerLinuxPulse::SetSpeakerMute(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxPulse::SetSpeakerMute(enable=%u)", @@ -479,7 +479,7 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::SetSpeakerMute(bool enable) return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::SpeakerMute(bool& enabled) const +int32_t AudioMixerManagerLinuxPulse::SpeakerMute(bool& enabled) const { if (_paOutputDeviceIndex == -1) @@ -510,7 +510,7 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::SpeakerMute(bool& enabled) const return 0; } -WebRtc_Word32 +int32_t AudioMixerManagerLinuxPulse::StereoPlayoutIsAvailable(bool& available) { if (_paOutputDeviceIndex == -1) @@ -546,7 +546,7 @@ AudioMixerManagerLinuxPulse::StereoPlayoutIsAvailable(bool& available) return 0; } -WebRtc_Word32 +int32_t AudioMixerManagerLinuxPulse::StereoRecordingIsAvailable(bool& available) { if (_paInputDeviceIndex == -1) @@ -602,7 +602,7 @@ AudioMixerManagerLinuxPulse::StereoRecordingIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::MicrophoneMuteIsAvailable( +int32_t AudioMixerManagerLinuxPulse::MicrophoneMuteIsAvailable( bool& available) { if (_paInputDeviceIndex == -1) @@ -618,7 +618,7 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::MicrophoneMuteIsAvailable( return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::SetMicrophoneMute(bool enable) +int32_t AudioMixerManagerLinuxPulse::SetMicrophoneMute(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxPulse::SetMicrophoneMute(enable=%u)", @@ -680,7 +680,7 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::SetMicrophoneMute(bool enable) return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::MicrophoneMute(bool& enabled) const +int32_t AudioMixerManagerLinuxPulse::MicrophoneMute(bool& enabled) const { if (_paInputDeviceIndex == -1) @@ -720,7 +720,7 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::MicrophoneMute(bool& enabled) const return 0; } -WebRtc_Word32 +int32_t AudioMixerManagerLinuxPulse::MicrophoneBoostIsAvailable(bool& available) { if (_paInputDeviceIndex == -1) @@ -738,7 +738,7 @@ AudioMixerManagerLinuxPulse::MicrophoneBoostIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::SetMicrophoneBoost(bool enable) +int32_t AudioMixerManagerLinuxPulse::SetMicrophoneBoost(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxPulse::SetMicrophoneBoost(enable=%u)", @@ -768,7 +768,7 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::SetMicrophoneBoost(bool enable) return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::MicrophoneBoost(bool& enabled) const +int32_t AudioMixerManagerLinuxPulse::MicrophoneBoost(bool& enabled) const { if (_paInputDeviceIndex == -1) @@ -784,7 +784,7 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::MicrophoneBoost(bool& enabled) const return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::MicrophoneVolumeIsAvailable( +int32_t AudioMixerManagerLinuxPulse::MicrophoneVolumeIsAvailable( bool& available) { if (_paInputDeviceIndex == -1) @@ -800,8 +800,8 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::MicrophoneVolumeIsAvailable( return 0; } -WebRtc_Word32 -AudioMixerManagerLinuxPulse::SetMicrophoneVolume(WebRtc_UWord32 volume) +int32_t +AudioMixerManagerLinuxPulse::SetMicrophoneVolume(uint32_t volume) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerLinuxPulse::SetMicrophoneVolume(volume=%u)", @@ -862,7 +862,7 @@ AudioMixerManagerLinuxPulse::SetMicrophoneVolume(WebRtc_UWord32 volume) return -1; } - WebRtc_UWord8 channels = _paChannels; + uint8_t channels = _paChannels; ResetCallbackVariables(); pa_cvolume cVolumes; @@ -898,8 +898,8 @@ AudioMixerManagerLinuxPulse::SetMicrophoneVolume(WebRtc_UWord32 volume) return 0; } -WebRtc_Word32 -AudioMixerManagerLinuxPulse::MicrophoneVolume(WebRtc_UWord32& volume) const +int32_t +AudioMixerManagerLinuxPulse::MicrophoneVolume(uint32_t& volume) const { if (_paInputDeviceIndex == -1) @@ -927,7 +927,7 @@ AudioMixerManagerLinuxPulse::MicrophoneVolume(WebRtc_UWord32& volume) const if (!GetSourceInfoByIndex(deviceIndex)) return -1; - volume = static_cast (_paVolume); + volume = static_cast (_paVolume); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " AudioMixerManagerLinuxPulse::MicrophoneVolume() => vol=%i, volume"); @@ -938,8 +938,8 @@ AudioMixerManagerLinuxPulse::MicrophoneVolume(WebRtc_UWord32& volume) const return 0; } -WebRtc_Word32 -AudioMixerManagerLinuxPulse::MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const +int32_t +AudioMixerManagerLinuxPulse::MaxMicrophoneVolume(uint32_t& maxVolume) const { if (_paInputDeviceIndex == -1) @@ -952,13 +952,13 @@ AudioMixerManagerLinuxPulse::MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) cons // PA_VOLUME_NORM corresponds to 100% (0db) // PA allows up to 150 db amplification (PA_VOLUME_MAX) // but that doesn't work well for all sound cards - maxVolume = static_cast (PA_VOLUME_NORM); + maxVolume = static_cast (PA_VOLUME_NORM); return 0; } -WebRtc_Word32 -AudioMixerManagerLinuxPulse::MinMicrophoneVolume(WebRtc_UWord32& minVolume) const +int32_t +AudioMixerManagerLinuxPulse::MinMicrophoneVolume(uint32_t& minVolume) const { if (_paInputDeviceIndex == -1) @@ -968,13 +968,13 @@ AudioMixerManagerLinuxPulse::MinMicrophoneVolume(WebRtc_UWord32& minVolume) cons return -1; } - minVolume = static_cast (PA_VOLUME_MUTED); + minVolume = static_cast (PA_VOLUME_MUTED); return 0; } -WebRtc_Word32 AudioMixerManagerLinuxPulse::MicrophoneVolumeStepSize( - WebRtc_UWord16& stepSize) const +int32_t AudioMixerManagerLinuxPulse::MicrophoneVolumeStepSize( + uint16_t& stepSize) const { if (_paInputDeviceIndex == -1) @@ -1018,7 +1018,7 @@ WebRtc_Word32 AudioMixerManagerLinuxPulse::MicrophoneVolumeStepSize( return -1; } - stepSize = static_cast ((PA_VOLUME_NORM + 1) / _paVolSteps); + stepSize = static_cast ((PA_VOLUME_NORM + 1) / _paVolSteps); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " AudioMixerManagerLinuxPulse::MicrophoneVolumeStepSize()" diff --git a/webrtc/modules/audio_device/linux/audio_mixer_manager_pulse_linux.h b/webrtc/modules/audio_device/linux/audio_mixer_manager_pulse_linux.h index db0a5592a5..3d913955df 100644 --- a/webrtc/modules/audio_device/linux/audio_mixer_manager_pulse_linux.h +++ b/webrtc/modules/audio_device/linux/audio_mixer_manager_pulse_linux.h @@ -29,43 +29,43 @@ namespace webrtc class AudioMixerManagerLinuxPulse { public: - WebRtc_Word32 SetPlayStream(pa_stream* playStream); - WebRtc_Word32 SetRecStream(pa_stream* recStream); - WebRtc_Word32 OpenSpeaker(WebRtc_UWord16 deviceIndex); - WebRtc_Word32 OpenMicrophone(WebRtc_UWord16 deviceIndex); - WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume); - WebRtc_Word32 SpeakerVolume(WebRtc_UWord32& volume) const; - WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const; - WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32& minVolume) const; - WebRtc_Word32 SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const; - WebRtc_Word32 SpeakerVolumeIsAvailable(bool& available); - WebRtc_Word32 SpeakerMuteIsAvailable(bool& available); - WebRtc_Word32 SetSpeakerMute(bool enable); - WebRtc_Word32 StereoPlayoutIsAvailable(bool& available); - WebRtc_Word32 StereoRecordingIsAvailable(bool& available); - WebRtc_Word32 SpeakerMute(bool& enabled) const; - WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available); - WebRtc_Word32 SetMicrophoneMute(bool enable); - WebRtc_Word32 MicrophoneMute(bool& enabled) const; - WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available); - WebRtc_Word32 SetMicrophoneBoost(bool enable); - WebRtc_Word32 MicrophoneBoost(bool& enabled) const; - WebRtc_Word32 MicrophoneVolumeIsAvailable(bool& available); - WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume); - WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32& volume) const; - WebRtc_Word32 MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const; - WebRtc_Word32 MinMicrophoneVolume(WebRtc_UWord32& minVolume) const; - WebRtc_Word32 MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const; - WebRtc_Word32 SetPulseAudioObjects(pa_threaded_mainloop* mainloop, - pa_context* context); - WebRtc_Word32 Close(); - WebRtc_Word32 CloseSpeaker(); - WebRtc_Word32 CloseMicrophone(); + int32_t SetPlayStream(pa_stream* playStream); + int32_t SetRecStream(pa_stream* recStream); + int32_t OpenSpeaker(uint16_t deviceIndex); + int32_t OpenMicrophone(uint16_t deviceIndex); + int32_t SetSpeakerVolume(uint32_t volume); + int32_t SpeakerVolume(uint32_t& volume) const; + int32_t MaxSpeakerVolume(uint32_t& maxVolume) const; + int32_t MinSpeakerVolume(uint32_t& minVolume) const; + int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const; + int32_t SpeakerVolumeIsAvailable(bool& available); + int32_t SpeakerMuteIsAvailable(bool& available); + int32_t SetSpeakerMute(bool enable); + int32_t StereoPlayoutIsAvailable(bool& available); + int32_t StereoRecordingIsAvailable(bool& available); + int32_t SpeakerMute(bool& enabled) const; + int32_t MicrophoneMuteIsAvailable(bool& available); + int32_t SetMicrophoneMute(bool enable); + int32_t MicrophoneMute(bool& enabled) const; + int32_t MicrophoneBoostIsAvailable(bool& available); + int32_t SetMicrophoneBoost(bool enable); + int32_t MicrophoneBoost(bool& enabled) const; + int32_t MicrophoneVolumeIsAvailable(bool& available); + int32_t SetMicrophoneVolume(uint32_t volume); + int32_t MicrophoneVolume(uint32_t& volume) const; + int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const; + int32_t MinMicrophoneVolume(uint32_t& minVolume) const; + int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const; + int32_t SetPulseAudioObjects(pa_threaded_mainloop* mainloop, + pa_context* context); + int32_t Close(); + int32_t CloseSpeaker(); + int32_t CloseMicrophone(); bool SpeakerIsInitialized() const; bool MicrophoneIsInitialized() const; public: - AudioMixerManagerLinuxPulse(const WebRtc_Word32 id); + AudioMixerManagerLinuxPulse(const int32_t id); ~AudioMixerManagerLinuxPulse(); private: @@ -93,9 +93,9 @@ private: private: CriticalSectionWrapper& _critSect; - WebRtc_Word32 _id; - WebRtc_Word16 _paOutputDeviceIndex; - WebRtc_Word16 _paInputDeviceIndex; + int32_t _id; + int16_t _paOutputDeviceIndex; + int16_t _paInputDeviceIndex; pa_stream* _paPlayStream; pa_stream* _paRecStream; @@ -103,12 +103,12 @@ private: pa_threaded_mainloop* _paMainloop; pa_context* _paContext; - mutable WebRtc_UWord32 _paVolume; - mutable WebRtc_UWord32 _paMute; - mutable WebRtc_UWord32 _paVolSteps; + mutable uint32_t _paVolume; + mutable uint32_t _paMute; + mutable uint32_t _paVolSteps; bool _paSpeakerMute; - mutable WebRtc_UWord32 _paSpeakerVolume; - mutable WebRtc_UWord8 _paChannels; + mutable uint32_t _paSpeakerVolume; + mutable uint8_t _paChannels; bool _paObjectsSet; mutable bool _callbackValues; }; diff --git a/webrtc/modules/audio_device/mac/audio_device_mac.cc b/webrtc/modules/audio_device/mac/audio_device_mac.cc index ecc95d7c65..25514c451e 100644 --- a/webrtc/modules/audio_device/mac/audio_device_mac.cc +++ b/webrtc/modules/audio_device/mac/audio_device_mac.cc @@ -76,7 +76,7 @@ int32_t AudioDeviceMac::AtomicGet32(int32_t* theValue) { while (1) { - WebRtc_Word32 value = *theValue; + int32_t value = *theValue; if (OSAtomicCompareAndSwap32Barrier(value, value, theValue) == true) { return value; @@ -87,7 +87,7 @@ int32_t AudioDeviceMac::AtomicGet32(int32_t* theValue) // CoreAudio errors are best interpreted as four character strings. void AudioDeviceMac::logCAMsg(const TraceLevel level, const TraceModule module, - const WebRtc_Word32 id, const char *msg, + const int32_t id, const char *msg, const char *err) { assert(msg != NULL); @@ -102,7 +102,7 @@ void AudioDeviceMac::logCAMsg(const TraceLevel level, #endif } -AudioDeviceMac::AudioDeviceMac(const WebRtc_Word32 id) : +AudioDeviceMac::AudioDeviceMac(const int32_t id) : _ptrAudioBuffer(NULL), _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _stopEventRec(*EventWrapper::Create()), @@ -251,14 +251,14 @@ void AudioDeviceMac::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) _ptrAudioBuffer->SetPlayoutChannels(N_PLAY_CHANNELS); } -WebRtc_Word32 AudioDeviceMac::ActiveAudioLayer( +int32_t AudioDeviceMac::ActiveAudioLayer( AudioDeviceModule::AudioLayer& audioLayer) const { audioLayer = AudioDeviceModule::kPlatformDefaultAudio; return 0; } -WebRtc_Word32 AudioDeviceMac::Init() +int32_t AudioDeviceMac::Init() { CriticalSectionScoped lock(&_critSect); @@ -421,7 +421,7 @@ WebRtc_Word32 AudioDeviceMac::Init() return 0; } -WebRtc_Word32 AudioDeviceMac::Terminate() +int32_t AudioDeviceMac::Terminate() { if (!_initialized) @@ -479,7 +479,7 @@ bool AudioDeviceMac::Initialized() const return (_initialized); } -WebRtc_Word32 AudioDeviceMac::SpeakerIsAvailable(bool& available) +int32_t AudioDeviceMac::SpeakerIsAvailable(bool& available) { bool wasInitialized = _mixerManager.SpeakerIsInitialized(); @@ -507,7 +507,7 @@ WebRtc_Word32 AudioDeviceMac::SpeakerIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceMac::InitSpeaker() +int32_t AudioDeviceMac::InitSpeaker() { CriticalSectionScoped lock(&_critSect); @@ -538,7 +538,7 @@ WebRtc_Word32 AudioDeviceMac::InitSpeaker() return 0; } -WebRtc_Word32 AudioDeviceMac::MicrophoneIsAvailable(bool& available) +int32_t AudioDeviceMac::MicrophoneIsAvailable(bool& available) { bool wasInitialized = _mixerManager.MicrophoneIsInitialized(); @@ -567,7 +567,7 @@ WebRtc_Word32 AudioDeviceMac::MicrophoneIsAvailable(bool& available) } -WebRtc_Word32 AudioDeviceMac::InitMicrophone() +int32_t AudioDeviceMac::InitMicrophone() { CriticalSectionScoped lock(&_critSect); @@ -608,7 +608,7 @@ bool AudioDeviceMac::MicrophoneIsInitialized() const return (_mixerManager.MicrophoneIsInitialized()); } -WebRtc_Word32 AudioDeviceMac::SpeakerVolumeIsAvailable(bool& available) +int32_t AudioDeviceMac::SpeakerVolumeIsAvailable(bool& available) { bool wasInitialized = _mixerManager.SpeakerIsInitialized(); @@ -638,16 +638,16 @@ WebRtc_Word32 AudioDeviceMac::SpeakerVolumeIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceMac::SetSpeakerVolume(WebRtc_UWord32 volume) +int32_t AudioDeviceMac::SetSpeakerVolume(uint32_t volume) { return (_mixerManager.SetSpeakerVolume(volume)); } -WebRtc_Word32 AudioDeviceMac::SpeakerVolume(WebRtc_UWord32& volume) const +int32_t AudioDeviceMac::SpeakerVolume(uint32_t& volume) const { - WebRtc_UWord32 level(0); + uint32_t level(0); if (_mixerManager.SpeakerVolume(level) == -1) { @@ -658,8 +658,8 @@ WebRtc_Word32 AudioDeviceMac::SpeakerVolume(WebRtc_UWord32& volume) const return 0; } -WebRtc_Word32 AudioDeviceMac::SetWaveOutVolume(WebRtc_UWord16 volumeLeft, - WebRtc_UWord16 volumeRight) +int32_t AudioDeviceMac::SetWaveOutVolume(uint16_t volumeLeft, + uint16_t volumeRight) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -667,9 +667,9 @@ WebRtc_Word32 AudioDeviceMac::SetWaveOutVolume(WebRtc_UWord16 volumeLeft, return -1; } -WebRtc_Word32 -AudioDeviceMac::WaveOutVolume(WebRtc_UWord16& /*volumeLeft*/, - WebRtc_UWord16& /*volumeRight*/) const +int32_t +AudioDeviceMac::WaveOutVolume(uint16_t& /*volumeLeft*/, + uint16_t& /*volumeRight*/) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -677,10 +677,10 @@ AudioDeviceMac::WaveOutVolume(WebRtc_UWord16& /*volumeLeft*/, return -1; } -WebRtc_Word32 AudioDeviceMac::MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const +int32_t AudioDeviceMac::MaxSpeakerVolume(uint32_t& maxVolume) const { - WebRtc_UWord32 maxVol(0); + uint32_t maxVol(0); if (_mixerManager.MaxSpeakerVolume(maxVol) == -1) { @@ -691,10 +691,10 @@ WebRtc_Word32 AudioDeviceMac::MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const return 0; } -WebRtc_Word32 AudioDeviceMac::MinSpeakerVolume(WebRtc_UWord32& minVolume) const +int32_t AudioDeviceMac::MinSpeakerVolume(uint32_t& minVolume) const { - WebRtc_UWord32 minVol(0); + uint32_t minVol(0); if (_mixerManager.MinSpeakerVolume(minVol) == -1) { @@ -705,11 +705,11 @@ WebRtc_Word32 AudioDeviceMac::MinSpeakerVolume(WebRtc_UWord32& minVolume) const return 0; } -WebRtc_Word32 -AudioDeviceMac::SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const +int32_t +AudioDeviceMac::SpeakerVolumeStepSize(uint16_t& stepSize) const { - WebRtc_UWord16 delta(0); + uint16_t delta(0); if (_mixerManager.SpeakerVolumeStepSize(delta) == -1) { @@ -720,7 +720,7 @@ AudioDeviceMac::SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const return 0; } -WebRtc_Word32 AudioDeviceMac::SpeakerMuteIsAvailable(bool& available) +int32_t AudioDeviceMac::SpeakerMuteIsAvailable(bool& available) { bool isAvailable(false); @@ -754,12 +754,12 @@ WebRtc_Word32 AudioDeviceMac::SpeakerMuteIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceMac::SetSpeakerMute(bool enable) +int32_t AudioDeviceMac::SetSpeakerMute(bool enable) { return (_mixerManager.SetSpeakerMute(enable)); } -WebRtc_Word32 AudioDeviceMac::SpeakerMute(bool& enabled) const +int32_t AudioDeviceMac::SpeakerMute(bool& enabled) const { bool muted(0); @@ -773,7 +773,7 @@ WebRtc_Word32 AudioDeviceMac::SpeakerMute(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceMac::MicrophoneMuteIsAvailable(bool& available) +int32_t AudioDeviceMac::MicrophoneMuteIsAvailable(bool& available) { bool isAvailable(false); @@ -806,12 +806,12 @@ WebRtc_Word32 AudioDeviceMac::MicrophoneMuteIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceMac::SetMicrophoneMute(bool enable) +int32_t AudioDeviceMac::SetMicrophoneMute(bool enable) { return (_mixerManager.SetMicrophoneMute(enable)); } -WebRtc_Word32 AudioDeviceMac::MicrophoneMute(bool& enabled) const +int32_t AudioDeviceMac::MicrophoneMute(bool& enabled) const { bool muted(0); @@ -825,7 +825,7 @@ WebRtc_Word32 AudioDeviceMac::MicrophoneMute(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceMac::MicrophoneBoostIsAvailable(bool& available) +int32_t AudioDeviceMac::MicrophoneBoostIsAvailable(bool& available) { bool isAvailable(false); @@ -858,13 +858,13 @@ WebRtc_Word32 AudioDeviceMac::MicrophoneBoostIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceMac::SetMicrophoneBoost(bool enable) +int32_t AudioDeviceMac::SetMicrophoneBoost(bool enable) { return (_mixerManager.SetMicrophoneBoost(enable)); } -WebRtc_Word32 AudioDeviceMac::MicrophoneBoost(bool& enabled) const +int32_t AudioDeviceMac::MicrophoneBoost(bool& enabled) const { bool onOff(0); @@ -878,7 +878,7 @@ WebRtc_Word32 AudioDeviceMac::MicrophoneBoost(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceMac::StereoRecordingIsAvailable(bool& available) +int32_t AudioDeviceMac::StereoRecordingIsAvailable(bool& available) { bool isAvailable(false); @@ -906,7 +906,7 @@ WebRtc_Word32 AudioDeviceMac::StereoRecordingIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceMac::SetStereoRecording(bool enable) +int32_t AudioDeviceMac::SetStereoRecording(bool enable) { if (enable) @@ -917,7 +917,7 @@ WebRtc_Word32 AudioDeviceMac::SetStereoRecording(bool enable) return 0; } -WebRtc_Word32 AudioDeviceMac::StereoRecording(bool& enabled) const +int32_t AudioDeviceMac::StereoRecording(bool& enabled) const { if (_recChannels == 2) @@ -928,7 +928,7 @@ WebRtc_Word32 AudioDeviceMac::StereoRecording(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceMac::StereoPlayoutIsAvailable(bool& available) +int32_t AudioDeviceMac::StereoPlayoutIsAvailable(bool& available) { bool isAvailable(false); @@ -956,7 +956,7 @@ WebRtc_Word32 AudioDeviceMac::StereoPlayoutIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceMac::SetStereoPlayout(bool enable) +int32_t AudioDeviceMac::SetStereoPlayout(bool enable) { if (enable) @@ -967,7 +967,7 @@ WebRtc_Word32 AudioDeviceMac::SetStereoPlayout(bool enable) return 0; } -WebRtc_Word32 AudioDeviceMac::StereoPlayout(bool& enabled) const +int32_t AudioDeviceMac::StereoPlayout(bool& enabled) const { if (_playChannels == 2) @@ -978,7 +978,7 @@ WebRtc_Word32 AudioDeviceMac::StereoPlayout(bool& enabled) const return 0; } -WebRtc_Word32 AudioDeviceMac::SetAGC(bool enable) +int32_t AudioDeviceMac::SetAGC(bool enable) { _AGC = enable; @@ -992,7 +992,7 @@ bool AudioDeviceMac::AGC() const return _AGC; } -WebRtc_Word32 AudioDeviceMac::MicrophoneVolumeIsAvailable(bool& available) +int32_t AudioDeviceMac::MicrophoneVolumeIsAvailable(bool& available) { bool wasInitialized = _mixerManager.MicrophoneIsInitialized(); @@ -1023,16 +1023,16 @@ WebRtc_Word32 AudioDeviceMac::MicrophoneVolumeIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceMac::SetMicrophoneVolume(WebRtc_UWord32 volume) +int32_t AudioDeviceMac::SetMicrophoneVolume(uint32_t volume) { return (_mixerManager.SetMicrophoneVolume(volume)); } -WebRtc_Word32 AudioDeviceMac::MicrophoneVolume(WebRtc_UWord32& volume) const +int32_t AudioDeviceMac::MicrophoneVolume(uint32_t& volume) const { - WebRtc_UWord32 level(0); + uint32_t level(0); if (_mixerManager.MicrophoneVolume(level) == -1) { @@ -1045,11 +1045,11 @@ WebRtc_Word32 AudioDeviceMac::MicrophoneVolume(WebRtc_UWord32& volume) const return 0; } -WebRtc_Word32 -AudioDeviceMac::MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const +int32_t +AudioDeviceMac::MaxMicrophoneVolume(uint32_t& maxVolume) const { - WebRtc_UWord32 maxVol(0); + uint32_t maxVol(0); if (_mixerManager.MaxMicrophoneVolume(maxVol) == -1) { @@ -1060,11 +1060,11 @@ AudioDeviceMac::MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const return 0; } -WebRtc_Word32 -AudioDeviceMac::MinMicrophoneVolume(WebRtc_UWord32& minVolume) const +int32_t +AudioDeviceMac::MinMicrophoneVolume(uint32_t& minVolume) const { - WebRtc_UWord32 minVol(0); + uint32_t minVol(0); if (_mixerManager.MinMicrophoneVolume(minVol) == -1) { @@ -1075,11 +1075,11 @@ AudioDeviceMac::MinMicrophoneVolume(WebRtc_UWord32& minVolume) const return 0; } -WebRtc_Word32 -AudioDeviceMac::MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const +int32_t +AudioDeviceMac::MicrophoneVolumeStepSize(uint16_t& stepSize) const { - WebRtc_UWord16 delta(0); + uint16_t delta(0); if (_mixerManager.MicrophoneVolumeStepSize(delta) == -1) { @@ -1090,7 +1090,7 @@ AudioDeviceMac::MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const return 0; } -WebRtc_Word16 AudioDeviceMac::PlayoutDevices() +int16_t AudioDeviceMac::PlayoutDevices() { AudioDeviceID playDevices[MaxNumberDevices]; @@ -1098,7 +1098,7 @@ WebRtc_Word16 AudioDeviceMac::PlayoutDevices() MaxNumberDevices); } -WebRtc_Word32 AudioDeviceMac::SetPlayoutDevice(WebRtc_UWord16 index) +int32_t AudioDeviceMac::SetPlayoutDevice(uint16_t index) { if (_playIsInitialized) @@ -1107,8 +1107,8 @@ WebRtc_Word32 AudioDeviceMac::SetPlayoutDevice(WebRtc_UWord16 index) } AudioDeviceID playDevices[MaxNumberDevices]; - WebRtc_UWord32 nDevices = GetNumberDevices(kAudioDevicePropertyScopeOutput, - playDevices, MaxNumberDevices); + uint32_t nDevices = GetNumberDevices(kAudioDevicePropertyScopeOutput, + playDevices, MaxNumberDevices); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " number of availiable waveform-audio output devices is %u", nDevices); @@ -1126,7 +1126,7 @@ WebRtc_Word32 AudioDeviceMac::SetPlayoutDevice(WebRtc_UWord16 index) return 0; } -WebRtc_Word32 AudioDeviceMac::SetPlayoutDevice( +int32_t AudioDeviceMac::SetPlayoutDevice( AudioDeviceModule::WindowsDeviceType /*device*/) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, @@ -1134,13 +1134,13 @@ WebRtc_Word32 AudioDeviceMac::SetPlayoutDevice( return -1; } -WebRtc_Word32 AudioDeviceMac::PlayoutDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceMac::PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { - const WebRtc_UWord16 nDevices(PlayoutDevices()); + const uint16_t nDevices(PlayoutDevices()); if ((index > (nDevices - 1)) || (name == NULL)) { @@ -1157,13 +1157,13 @@ WebRtc_Word32 AudioDeviceMac::PlayoutDeviceName( return GetDeviceName(kAudioDevicePropertyScopeOutput, index, name); } -WebRtc_Word32 AudioDeviceMac::RecordingDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceMac::RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { - const WebRtc_UWord16 nDevices(RecordingDevices()); + const uint16_t nDevices(RecordingDevices()); if ((index > (nDevices - 1)) || (name == NULL)) { @@ -1180,7 +1180,7 @@ WebRtc_Word32 AudioDeviceMac::RecordingDeviceName( return GetDeviceName(kAudioDevicePropertyScopeInput, index, name); } -WebRtc_Word16 AudioDeviceMac::RecordingDevices() +int16_t AudioDeviceMac::RecordingDevices() { AudioDeviceID recDevices[MaxNumberDevices]; @@ -1188,7 +1188,7 @@ WebRtc_Word16 AudioDeviceMac::RecordingDevices() MaxNumberDevices); } -WebRtc_Word32 AudioDeviceMac::SetRecordingDevice(WebRtc_UWord16 index) +int32_t AudioDeviceMac::SetRecordingDevice(uint16_t index) { if (_recIsInitialized) @@ -1197,8 +1197,8 @@ WebRtc_Word32 AudioDeviceMac::SetRecordingDevice(WebRtc_UWord16 index) } AudioDeviceID recDevices[MaxNumberDevices]; - WebRtc_UWord32 nDevices = GetNumberDevices(kAudioDevicePropertyScopeInput, - recDevices, MaxNumberDevices); + uint32_t nDevices = GetNumberDevices(kAudioDevicePropertyScopeInput, + recDevices, MaxNumberDevices); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " number of availiable waveform-audio input devices is %u", nDevices); @@ -1217,7 +1217,7 @@ WebRtc_Word32 AudioDeviceMac::SetRecordingDevice(WebRtc_UWord16 index) } -WebRtc_Word32 +int32_t AudioDeviceMac::SetRecordingDevice(AudioDeviceModule::WindowsDeviceType /*device*/) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, @@ -1225,7 +1225,7 @@ AudioDeviceMac::SetRecordingDevice(AudioDeviceModule::WindowsDeviceType /*device return -1; } -WebRtc_Word32 AudioDeviceMac::PlayoutIsAvailable(bool& available) +int32_t AudioDeviceMac::PlayoutIsAvailable(bool& available) { available = true; @@ -1253,7 +1253,7 @@ WebRtc_Word32 AudioDeviceMac::PlayoutIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceMac::RecordingIsAvailable(bool& available) +int32_t AudioDeviceMac::RecordingIsAvailable(bool& available) { available = true; @@ -1281,7 +1281,7 @@ WebRtc_Word32 AudioDeviceMac::RecordingIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioDeviceMac::InitPlayout() +int32_t AudioDeviceMac::InitPlayout() { CriticalSectionScoped lock(&_critSect); @@ -1437,7 +1437,7 @@ WebRtc_Word32 AudioDeviceMac::InitPlayout() { // Update audio buffer with the selected parameters _ptrAudioBuffer->SetPlayoutSampleRate(N_PLAY_SAMPLES_PER_SEC); - _ptrAudioBuffer->SetPlayoutChannels((WebRtc_UWord8) _playChannels); + _ptrAudioBuffer->SetPlayoutChannels((uint8_t) _playChannels); } _renderDelayOffsetSamples = _renderBufSizeSamples - N_BUFFERS_OUT @@ -1500,7 +1500,7 @@ WebRtc_Word32 AudioDeviceMac::InitPlayout() size = sizeof(UInt32); WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_outputDeviceID, &propertyAddress, 0, NULL, &size, &latency)); - _renderLatencyUs = (WebRtc_UWord32) ((1.0e6 * latency) + _renderLatencyUs = (uint32_t) ((1.0e6 * latency) / _outStreamFormat.mSampleRate); // Get render stream latency @@ -1514,7 +1514,7 @@ WebRtc_Word32 AudioDeviceMac::InitPlayout() latency = 0; WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(_outputDeviceID, &propertyAddress, 0, NULL, &size, &latency)); - _renderLatencyUs += (WebRtc_UWord32) ((1.0e6 * latency) + _renderLatencyUs += (uint32_t) ((1.0e6 * latency) / _outStreamFormat.mSampleRate); // Listen for format changes @@ -1544,7 +1544,7 @@ WebRtc_Word32 AudioDeviceMac::InitPlayout() return 0; } -WebRtc_Word32 AudioDeviceMac::InitRecording() +int32_t AudioDeviceMac::InitRecording() { CriticalSectionScoped lock(&_critSect); @@ -1655,7 +1655,7 @@ WebRtc_Word32 AudioDeviceMac::InitRecording() { // Update audio buffer with the selected parameters _ptrAudioBuffer->SetRecordingSampleRate(N_REC_SAMPLES_PER_SEC); - _ptrAudioBuffer->SetRecordingChannels((WebRtc_UWord8) _recChannels); + _ptrAudioBuffer->SetRecordingChannels((uint8_t) _recChannels); } _inDesiredFormat.mSampleRate = N_REC_SAMPLES_PER_SEC; @@ -1760,7 +1760,7 @@ WebRtc_Word32 AudioDeviceMac::InitRecording() return 0; } -WebRtc_Word32 AudioDeviceMac::StartRecording() +int32_t AudioDeviceMac::StartRecording() { CriticalSectionScoped lock(&_critSect); @@ -1804,7 +1804,7 @@ WebRtc_Word32 AudioDeviceMac::StartRecording() return 0; } -WebRtc_Word32 AudioDeviceMac::StopRecording() +int32_t AudioDeviceMac::StopRecording() { CriticalSectionScoped lock(&_critSect); @@ -1927,7 +1927,7 @@ bool AudioDeviceMac::PlayoutIsInitialized() const return (_playIsInitialized); } -WebRtc_Word32 AudioDeviceMac::StartPlayout() +int32_t AudioDeviceMac::StartPlayout() { CriticalSectionScoped lock(&_critSect); @@ -1960,7 +1960,7 @@ WebRtc_Word32 AudioDeviceMac::StartPlayout() return 0; } -WebRtc_Word32 AudioDeviceMac::StopPlayout() +int32_t AudioDeviceMac::StopPlayout() { CriticalSectionScoped lock(&_critSect); @@ -2050,19 +2050,19 @@ WebRtc_Word32 AudioDeviceMac::StopPlayout() return 0; } -WebRtc_Word32 AudioDeviceMac::PlayoutDelay(WebRtc_UWord16& delayMS) const +int32_t AudioDeviceMac::PlayoutDelay(uint16_t& delayMS) const { int32_t renderDelayUs = AtomicGet32(&_renderDelayUs); - delayMS = static_cast (1e-3 * (renderDelayUs - + _renderLatencyUs) + 0.5); + delayMS = static_cast (1e-3 * (renderDelayUs + _renderLatencyUs) + + 0.5); return 0; } -WebRtc_Word32 AudioDeviceMac::RecordingDelay(WebRtc_UWord16& delayMS) const +int32_t AudioDeviceMac::RecordingDelay(uint16_t& delayMS) const { int32_t captureDelayUs = AtomicGet32(&_captureDelayUs); - delayMS = static_cast (1e-3 * (captureDelayUs - + _captureLatencyUs) + 0.5); + delayMS = static_cast (1e-3 * (captureDelayUs + + _captureLatencyUs) + 0.5); return 0; } @@ -2071,9 +2071,9 @@ bool AudioDeviceMac::Playing() const return (_playing); } -WebRtc_Word32 AudioDeviceMac::SetPlayoutBuffer( +int32_t AudioDeviceMac::SetPlayoutBuffer( const AudioDeviceModule::BufferType type, - WebRtc_UWord16 sizeMS) + uint16_t sizeMS) { if (type != AudioDeviceModule::kFixedBufferSize) @@ -2088,9 +2088,9 @@ WebRtc_Word32 AudioDeviceMac::SetPlayoutBuffer( return 0; } -WebRtc_Word32 AudioDeviceMac::PlayoutBuffer( +int32_t AudioDeviceMac::PlayoutBuffer( AudioDeviceModule::BufferType& type, - WebRtc_UWord16& sizeMS) const + uint16_t& sizeMS) const { type = _playBufType; @@ -2100,7 +2100,7 @@ WebRtc_Word32 AudioDeviceMac::PlayoutBuffer( } // Not implemented for Mac. -WebRtc_Word32 AudioDeviceMac::CPULoad(WebRtc_UWord16& /*load*/) const +int32_t AudioDeviceMac::CPULoad(uint16_t& /*load*/) const { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -2153,10 +2153,10 @@ void AudioDeviceMac::ClearRecordingError() // Private Methods // ============================================================================ -WebRtc_Word32 +int32_t AudioDeviceMac::GetNumberDevices(const AudioObjectPropertyScope scope, AudioDeviceID scopedDeviceIds[], - const WebRtc_UWord32 deviceListLength) + const uint32_t deviceListLength) { OSStatus err = noErr; @@ -2291,9 +2291,9 @@ AudioDeviceMac::GetNumberDevices(const AudioObjectPropertyScope scope, return numberScopedDevices; } -WebRtc_Word32 +int32_t AudioDeviceMac::GetDeviceName(const AudioObjectPropertyScope scope, - const WebRtc_UWord16 index, + const uint16_t index, char* name) { OSStatus err = noErr; @@ -2371,9 +2371,9 @@ AudioDeviceMac::GetDeviceName(const AudioObjectPropertyScope scope, return 0; } -WebRtc_Word32 AudioDeviceMac::InitDevice(const WebRtc_UWord16 userDeviceIndex, - AudioDeviceID& deviceId, - const bool isInput) +int32_t AudioDeviceMac::InitDevice(const uint16_t userDeviceIndex, + AudioDeviceID& deviceId, + const bool isInput) { OSStatus err = noErr; UInt32 size = 0; @@ -2507,7 +2507,7 @@ OSStatus AudioDeviceMac::implObjectListenerProc( return 0; } -WebRtc_Word32 AudioDeviceMac::HandleDeviceChange() +int32_t AudioDeviceMac::HandleDeviceChange() { OSStatus err = noErr; @@ -2579,7 +2579,7 @@ WebRtc_Word32 AudioDeviceMac::HandleDeviceChange() return 0; } -WebRtc_Word32 AudioDeviceMac::HandleStreamFormatChange( +int32_t AudioDeviceMac::HandleStreamFormatChange( const AudioObjectID objectId, const AudioObjectPropertyAddress propertyAddress) { @@ -2652,7 +2652,7 @@ WebRtc_Word32 AudioDeviceMac::HandleStreamFormatChange( { // Update audio buffer with the selected parameters _ptrAudioBuffer->SetRecordingSampleRate(N_REC_SAMPLES_PER_SEC); - _ptrAudioBuffer->SetRecordingChannels((WebRtc_UWord8) _recChannels); + _ptrAudioBuffer->SetRecordingChannels((uint8_t) _recChannels); } // Recreate the converter with the new format @@ -2681,7 +2681,7 @@ WebRtc_Word32 AudioDeviceMac::HandleStreamFormatChange( { // Update audio buffer with the selected parameters _ptrAudioBuffer->SetPlayoutSampleRate(N_PLAY_SAMPLES_PER_SEC); - _ptrAudioBuffer->SetPlayoutChannels((WebRtc_UWord8) _playChannels); + _ptrAudioBuffer->SetPlayoutChannels((uint8_t) _playChannels); } _renderDelayOffsetSamples = _renderBufSizeSamples - N_BUFFERS_OUT @@ -2699,7 +2699,7 @@ WebRtc_Word32 AudioDeviceMac::HandleStreamFormatChange( return 0; } -WebRtc_Word32 AudioDeviceMac::HandleDataSourceChange( +int32_t AudioDeviceMac::HandleDataSourceChange( const AudioObjectID objectId, const AudioObjectPropertyAddress propertyAddress) { @@ -2730,7 +2730,7 @@ WebRtc_Word32 AudioDeviceMac::HandleDataSourceChange( return 0; } -WebRtc_Word32 AudioDeviceMac::HandleProcessorOverload( +int32_t AudioDeviceMac::HandleProcessorOverload( const AudioObjectPropertyAddress propertyAddress) { // TODO(xians): we probably want to notify the user in some way of the @@ -3077,7 +3077,7 @@ bool AudioDeviceMac::RenderWorkerThread() } } - WebRtc_Word8 playBuffer[4 * ENGINE_PLAY_BUF_SIZE_IN_SAMPLES]; + int8_t playBuffer[4 * ENGINE_PLAY_BUF_SIZE_IN_SAMPLES]; if (!_ptrAudioBuffer) { @@ -3087,7 +3087,7 @@ bool AudioDeviceMac::RenderWorkerThread() } // Ask for new PCM data to be played out using the AudioDeviceBuffer. - WebRtc_UWord32 nSamples = + uint32_t nSamples = _ptrAudioBuffer->RequestPlayoutData(ENGINE_PLAY_BUF_SIZE_IN_SAMPLES); nSamples = _ptrAudioBuffer->GetPlayoutData(playBuffer); @@ -3097,14 +3097,14 @@ bool AudioDeviceMac::RenderWorkerThread() " invalid number of output samples(%d)", nSamples); } - WebRtc_UWord32 nOutSamples = nSamples * _outDesiredFormat.mChannelsPerFrame; + uint32_t nOutSamples = nSamples * _outDesiredFormat.mChannelsPerFrame; SInt16 *pPlayBuffer = (SInt16 *) &playBuffer; if (_macBookProPanRight && (_playChannels == 2)) { // Mix entirely into the right channel and zero the left channel. SInt32 sampleInt32 = 0; - for (WebRtc_UWord32 sampleIdx = 0; sampleIdx < nOutSamples; sampleIdx + for (uint32_t sampleIdx = 0; sampleIdx < nOutSamples; sampleIdx += 2) { sampleInt32 = pPlayBuffer[sampleIdx]; @@ -3169,18 +3169,19 @@ bool AudioDeviceMac::CaptureWorkerThread() // TODO(xians): what if the returned size is incorrect? if (size == ENGINE_REC_BUF_SIZE_IN_SAMPLES) { - WebRtc_UWord32 currentMicLevel(0); - WebRtc_UWord32 newMicLevel(0); - WebRtc_Word32 msecOnPlaySide; - WebRtc_Word32 msecOnRecordSide; + uint32_t currentMicLevel(0); + uint32_t newMicLevel(0); + int32_t msecOnPlaySide; + int32_t msecOnRecordSide; int32_t captureDelayUs = AtomicGet32(&_captureDelayUs); int32_t renderDelayUs = AtomicGet32(&_renderDelayUs); - msecOnPlaySide = static_cast (1e-3 * (renderDelayUs - + _renderLatencyUs) + 0.5); - msecOnRecordSide = static_cast (1e-3 * (captureDelayUs - + _captureLatencyUs) + 0.5); + msecOnPlaySide = static_cast (1e-3 * (renderDelayUs + + _renderLatencyUs) + 0.5); + msecOnRecordSide = static_cast (1e-3 * (captureDelayUs + + _captureLatencyUs) + + 0.5); if (!_ptrAudioBuffer) { @@ -3191,8 +3192,8 @@ bool AudioDeviceMac::CaptureWorkerThread() // store the recorded buffer (no action will be taken if the // #recorded samples is not a full buffer) - _ptrAudioBuffer->SetRecordedBuffer((WebRtc_Word8*) &recordBuffer, - (WebRtc_UWord32) size); + _ptrAudioBuffer->SetRecordedBuffer((int8_t*) &recordBuffer, + (uint32_t) size); if (AGC()) { diff --git a/webrtc/modules/audio_device/mac/audio_device_mac.h b/webrtc/modules/audio_device/mac/audio_device_mac.h index 5106153bbd..9a05e8d38a 100644 --- a/webrtc/modules/audio_device/mac/audio_device_mac.h +++ b/webrtc/modules/audio_device/mac/audio_device_mac.h @@ -26,17 +26,15 @@ namespace webrtc class EventWrapper; class ThreadWrapper; -const WebRtc_UWord32 N_REC_SAMPLES_PER_SEC = 48000; -const WebRtc_UWord32 N_PLAY_SAMPLES_PER_SEC = 48000; +const uint32_t N_REC_SAMPLES_PER_SEC = 48000; +const uint32_t N_PLAY_SAMPLES_PER_SEC = 48000; -const WebRtc_UWord32 N_REC_CHANNELS = 1; // default is mono recording -const WebRtc_UWord32 N_PLAY_CHANNELS = 2; // default is stereo playout -const WebRtc_UWord32 N_DEVICE_CHANNELS = 8; +const uint32_t N_REC_CHANNELS = 1; // default is mono recording +const uint32_t N_PLAY_CHANNELS = 2; // default is stereo playout +const uint32_t N_DEVICE_CHANNELS = 8; -const WebRtc_UWord32 ENGINE_REC_BUF_SIZE_IN_SAMPLES = (N_REC_SAMPLES_PER_SEC - / 100); -const WebRtc_UWord32 ENGINE_PLAY_BUF_SIZE_IN_SAMPLES = (N_PLAY_SAMPLES_PER_SEC - / 100); +const uint32_t ENGINE_REC_BUF_SIZE_IN_SAMPLES = (N_REC_SAMPLES_PER_SEC / 100); +const uint32_t ENGINE_PLAY_BUF_SIZE_IN_SAMPLES = (N_PLAY_SAMPLES_PER_SEC / 100); enum { @@ -51,133 +49,132 @@ enum N_BUFFERS_OUT = 3 }; // Must be at least N_BLOCKS_IO -const WebRtc_UWord32 TIMER_PERIOD_MS = (2 * 10 * N_BLOCKS_IO * 1000000); +const uint32_t TIMER_PERIOD_MS = (2 * 10 * N_BLOCKS_IO * 1000000); -const WebRtc_UWord32 REC_BUF_SIZE_IN_SAMPLES = (ENGINE_REC_BUF_SIZE_IN_SAMPLES +const uint32_t REC_BUF_SIZE_IN_SAMPLES = (ENGINE_REC_BUF_SIZE_IN_SAMPLES * N_DEVICE_CHANNELS * N_BUFFERS_IN); -const WebRtc_UWord32 PLAY_BUF_SIZE_IN_SAMPLES = +const uint32_t PLAY_BUF_SIZE_IN_SAMPLES = (ENGINE_PLAY_BUF_SIZE_IN_SAMPLES * N_PLAY_CHANNELS * N_BUFFERS_OUT); class AudioDeviceMac: public AudioDeviceGeneric { public: - AudioDeviceMac(const WebRtc_Word32 id); + AudioDeviceMac(const int32_t id); ~AudioDeviceMac(); // Retrieve the currently utilized audio layer - virtual WebRtc_Word32 + virtual int32_t ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const; // Main initializaton and termination - virtual WebRtc_Word32 Init(); - virtual WebRtc_Word32 Terminate(); + virtual int32_t Init(); + virtual int32_t Terminate(); virtual bool Initialized() const; // Device enumeration - virtual WebRtc_Word16 PlayoutDevices(); - virtual WebRtc_Word16 RecordingDevices(); - virtual WebRtc_Word32 PlayoutDeviceName( - WebRtc_UWord16 index, + virtual int16_t PlayoutDevices(); + virtual int16_t RecordingDevices(); + virtual int32_t PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); - virtual WebRtc_Word32 RecordingDeviceName( - WebRtc_UWord16 index, + virtual int32_t RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); // Device selection - virtual WebRtc_Word32 SetPlayoutDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetPlayoutDevice( + virtual int32_t SetPlayoutDevice(uint16_t index); + virtual int32_t SetPlayoutDevice( AudioDeviceModule::WindowsDeviceType device); - virtual WebRtc_Word32 SetRecordingDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetRecordingDevice( + virtual int32_t SetRecordingDevice(uint16_t index); + virtual int32_t SetRecordingDevice( AudioDeviceModule::WindowsDeviceType device); // Audio transport initialization - virtual WebRtc_Word32 PlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 InitPlayout(); + virtual int32_t PlayoutIsAvailable(bool& available); + virtual int32_t InitPlayout(); virtual bool PlayoutIsInitialized() const; - virtual WebRtc_Word32 RecordingIsAvailable(bool& available); - virtual WebRtc_Word32 InitRecording(); + virtual int32_t RecordingIsAvailable(bool& available); + virtual int32_t InitRecording(); virtual bool RecordingIsInitialized() const; // Audio transport control - virtual WebRtc_Word32 StartPlayout(); - virtual WebRtc_Word32 StopPlayout(); + virtual int32_t StartPlayout(); + virtual int32_t StopPlayout(); virtual bool Playing() const; - virtual WebRtc_Word32 StartRecording(); - virtual WebRtc_Word32 StopRecording(); + virtual int32_t StartRecording(); + virtual int32_t StopRecording(); virtual bool Recording() const; // Microphone Automatic Gain Control (AGC) - virtual WebRtc_Word32 SetAGC(bool enable); + virtual int32_t SetAGC(bool enable); virtual bool AGC() const; // Volume control based on the Windows Wave API (Windows only) - virtual WebRtc_Word32 SetWaveOutVolume(WebRtc_UWord16 volumeLeft, - WebRtc_UWord16 volumeRight); - virtual WebRtc_Word32 WaveOutVolume(WebRtc_UWord16& volumeLeft, - WebRtc_UWord16& volumeRight) const; + virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight); + virtual int32_t WaveOutVolume(uint16_t& volumeLeft, + uint16_t& volumeRight) const; // Audio mixer initialization - virtual WebRtc_Word32 SpeakerIsAvailable(bool& available); - virtual WebRtc_Word32 InitSpeaker(); + virtual int32_t SpeakerIsAvailable(bool& available); + virtual int32_t InitSpeaker(); virtual bool SpeakerIsInitialized() const; - virtual WebRtc_Word32 MicrophoneIsAvailable(bool& available); - virtual WebRtc_Word32 InitMicrophone(); + virtual int32_t MicrophoneIsAvailable(bool& available); + virtual int32_t InitMicrophone(); virtual bool MicrophoneIsInitialized() const; // Speaker volume controls - virtual WebRtc_Word32 SpeakerVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 SpeakerVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const; + virtual int32_t SpeakerVolumeIsAvailable(bool& available); + virtual int32_t SetSpeakerVolume(uint32_t volume); + virtual int32_t SpeakerVolume(uint32_t& volume) const; + virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const; + virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const; + virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const; // Microphone volume controls - virtual WebRtc_Word32 MicrophoneVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinMicrophoneVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 - MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const; + virtual int32_t MicrophoneVolumeIsAvailable(bool& available); + virtual int32_t SetMicrophoneVolume(uint32_t volume); + virtual int32_t MicrophoneVolume(uint32_t& volume) const; + virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const; + virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const; + virtual int32_t + MicrophoneVolumeStepSize(uint16_t& stepSize) const; // Microphone mute control - virtual WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneMute(bool enable); - virtual WebRtc_Word32 MicrophoneMute(bool& enabled) const; + virtual int32_t MicrophoneMuteIsAvailable(bool& available); + virtual int32_t SetMicrophoneMute(bool enable); + virtual int32_t MicrophoneMute(bool& enabled) const; // Speaker mute control - virtual WebRtc_Word32 SpeakerMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerMute(bool enable); - virtual WebRtc_Word32 SpeakerMute(bool& enabled) const; + virtual int32_t SpeakerMuteIsAvailable(bool& available); + virtual int32_t SetSpeakerMute(bool enable); + virtual int32_t SpeakerMute(bool& enabled) const; // Microphone boost control - virtual WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneBoost(bool enable); - virtual WebRtc_Word32 MicrophoneBoost(bool& enabled) const; + virtual int32_t MicrophoneBoostIsAvailable(bool& available); + virtual int32_t SetMicrophoneBoost(bool enable); + virtual int32_t MicrophoneBoost(bool& enabled) const; // Stereo support - virtual WebRtc_Word32 StereoPlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoPlayout(bool enable); - virtual WebRtc_Word32 StereoPlayout(bool& enabled) const; - virtual WebRtc_Word32 StereoRecordingIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoRecording(bool enable); - virtual WebRtc_Word32 StereoRecording(bool& enabled) const; + virtual int32_t StereoPlayoutIsAvailable(bool& available); + virtual int32_t SetStereoPlayout(bool enable); + virtual int32_t StereoPlayout(bool& enabled) const; + virtual int32_t StereoRecordingIsAvailable(bool& available); + virtual int32_t SetStereoRecording(bool enable); + virtual int32_t StereoRecording(bool& enabled) const; // Delay information and control - virtual WebRtc_Word32 + virtual int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type, - WebRtc_UWord16 sizeMS); - virtual WebRtc_Word32 PlayoutBuffer(AudioDeviceModule::BufferType& type, - WebRtc_UWord16& sizeMS) const; - virtual WebRtc_Word32 PlayoutDelay(WebRtc_UWord16& delayMS) const; - virtual WebRtc_Word32 RecordingDelay(WebRtc_UWord16& delayMS) const; + uint16_t sizeMS); + virtual int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type, + uint16_t& sizeMS) const; + virtual int32_t PlayoutDelay(uint16_t& delayMS) const; + virtual int32_t RecordingDelay(uint16_t& delayMS) const; // CPU load - virtual WebRtc_Word32 CPULoad(WebRtc_UWord16& load) const; + virtual int32_t CPULoad(uint16_t& load) const; public: virtual bool PlayoutWarning() const; @@ -203,7 +200,7 @@ private: _critSect.Leave(); } ; - WebRtc_Word32 Id() + int32_t Id() { return _id; } @@ -213,18 +210,18 @@ private: static void logCAMsg(const TraceLevel level, const TraceModule module, - const WebRtc_Word32 id, const char *msg, + const int32_t id, const char *msg, const char *err); - WebRtc_Word32 GetNumberDevices(const AudioObjectPropertyScope scope, - AudioDeviceID scopedDeviceIds[], - const WebRtc_UWord32 deviceListLength); + int32_t GetNumberDevices(const AudioObjectPropertyScope scope, + AudioDeviceID scopedDeviceIds[], + const uint32_t deviceListLength); - WebRtc_Word32 GetDeviceName(const AudioObjectPropertyScope scope, - const WebRtc_UWord16 index, char* name); + int32_t GetDeviceName(const AudioObjectPropertyScope scope, + const uint16_t index, char* name); - WebRtc_Word32 InitDevice(WebRtc_UWord16 userDeviceIndex, - AudioDeviceID& deviceId, bool isInput); + int32_t InitDevice(uint16_t userDeviceIndex, + AudioDeviceID& deviceId, bool isInput); static OSStatus objectListenerProc(AudioObjectID objectId, UInt32 numberAddresses, @@ -235,17 +232,17 @@ private: implObjectListenerProc(AudioObjectID objectId, UInt32 numberAddresses, const AudioObjectPropertyAddress addresses[]); - WebRtc_Word32 HandleDeviceChange(); + int32_t HandleDeviceChange(); - WebRtc_Word32 + int32_t HandleStreamFormatChange(AudioObjectID objectId, AudioObjectPropertyAddress propertyAddress); - WebRtc_Word32 + int32_t HandleDataSourceChange(AudioObjectID objectId, AudioObjectPropertyAddress propertyAddress); - WebRtc_Word32 + int32_t HandleProcessorOverload(AudioObjectPropertyAddress propertyAddress); private: @@ -306,15 +303,15 @@ private: ThreadWrapper* _captureWorkerThread; ThreadWrapper* _renderWorkerThread; - WebRtc_UWord32 _captureWorkerThreadId; - WebRtc_UWord32 _renderWorkerThreadId; + uint32_t _captureWorkerThreadId; + uint32_t _renderWorkerThreadId; - WebRtc_Word32 _id; + int32_t _id; AudioMixerManagerMac _mixerManager; - WebRtc_UWord16 _inputDeviceIndex; - WebRtc_UWord16 _outputDeviceIndex; + uint16_t _inputDeviceIndex; + uint16_t _outputDeviceIndex; AudioDeviceID _inputDeviceID; AudioDeviceID _outputDeviceID; #if __MAC_OS_X_VERSION_MAX_ALLOWED >= 1050 @@ -324,8 +321,8 @@ private: bool _inputDeviceIsSpecified; bool _outputDeviceIsSpecified; - WebRtc_UWord8 _recChannels; - WebRtc_UWord8 _playChannels; + uint8_t _recChannels; + uint8_t _playChannels; Float32* _captureBufData; SInt16* _renderBufData; @@ -361,22 +358,22 @@ private: AudioStreamBasicDescription _inStreamFormat; AudioStreamBasicDescription _inDesiredFormat; - WebRtc_UWord32 _captureLatencyUs; - WebRtc_UWord32 _renderLatencyUs; + uint32_t _captureLatencyUs; + uint32_t _renderLatencyUs; // Atomically set variables mutable int32_t _captureDelayUs; mutable int32_t _renderDelayUs; - WebRtc_Word32 _renderDelayOffsetSamples; + int32_t _renderDelayOffsetSamples; private: - WebRtc_UWord16 _playBufDelayFixed; // fixed playback delay + uint16_t _playBufDelayFixed; // fixed playback delay - WebRtc_UWord16 _playWarning; - WebRtc_UWord16 _playError; - WebRtc_UWord16 _recWarning; - WebRtc_UWord16 _recError; + uint16_t _playWarning; + uint16_t _playError; + uint16_t _recWarning; + uint16_t _recError; PaUtilRingBuffer* _paCaptureBuffer; PaUtilRingBuffer* _paRenderBuffer; @@ -384,8 +381,8 @@ private: semaphore_t _renderSemaphore; semaphore_t _captureSemaphore; - WebRtc_UWord32 _captureBufSizeSamples; - WebRtc_UWord32 _renderBufSizeSamples; + uint32_t _captureBufSizeSamples; + uint32_t _renderBufSizeSamples; }; } // namespace webrtc diff --git a/webrtc/modules/audio_device/mac/audio_device_utility_mac.cc b/webrtc/modules/audio_device/mac/audio_device_utility_mac.cc index f59fd5bb93..ac8e118e2d 100644 --- a/webrtc/modules/audio_device/mac/audio_device_utility_mac.cc +++ b/webrtc/modules/audio_device/mac/audio_device_utility_mac.cc @@ -16,7 +16,7 @@ namespace webrtc { -AudioDeviceUtilityMac::AudioDeviceUtilityMac(const WebRtc_Word32 id) : +AudioDeviceUtilityMac::AudioDeviceUtilityMac(const int32_t id) : _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _id(id) { @@ -41,7 +41,7 @@ AudioDeviceUtilityMac::~AudioDeviceUtilityMac() delete &_critSect; } -WebRtc_Word32 AudioDeviceUtilityMac::Init() +int32_t AudioDeviceUtilityMac::Init() { WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, diff --git a/webrtc/modules/audio_device/mac/audio_device_utility_mac.h b/webrtc/modules/audio_device/mac/audio_device_utility_mac.h index 4743e2211b..6c48b38053 100644 --- a/webrtc/modules/audio_device/mac/audio_device_utility_mac.h +++ b/webrtc/modules/audio_device/mac/audio_device_utility_mac.h @@ -21,14 +21,14 @@ class CriticalSectionWrapper; class AudioDeviceUtilityMac: public AudioDeviceUtility { public: - AudioDeviceUtilityMac(const WebRtc_Word32 id); + AudioDeviceUtilityMac(const int32_t id); ~AudioDeviceUtilityMac(); - virtual WebRtc_Word32 Init(); + virtual int32_t Init(); private: CriticalSectionWrapper& _critSect; - WebRtc_Word32 _id; + int32_t _id; }; } // namespace webrtc diff --git a/webrtc/modules/audio_device/mac/audio_mixer_manager_mac.cc b/webrtc/modules/audio_device/mac/audio_mixer_manager_mac.cc index bd53c57247..db4cfab820 100644 --- a/webrtc/modules/audio_device/mac/audio_mixer_manager_mac.cc +++ b/webrtc/modules/audio_device/mac/audio_mixer_manager_mac.cc @@ -43,7 +43,7 @@ namespace webrtc { } \ } while(0) -AudioMixerManagerMac::AudioMixerManagerMac(const WebRtc_Word32 id) : +AudioMixerManagerMac::AudioMixerManagerMac(const int32_t id) : _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _id(id), _inputDeviceID(kAudioObjectUnknown), @@ -69,7 +69,7 @@ AudioMixerManagerMac::~AudioMixerManagerMac() // PUBLIC METHODS // ============================================================================ -WebRtc_Word32 AudioMixerManagerMac::Close() +int32_t AudioMixerManagerMac::Close() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -83,7 +83,7 @@ WebRtc_Word32 AudioMixerManagerMac::Close() } -WebRtc_Word32 AudioMixerManagerMac::CloseSpeaker() +int32_t AudioMixerManagerMac::CloseSpeaker() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -96,7 +96,7 @@ WebRtc_Word32 AudioMixerManagerMac::CloseSpeaker() return 0; } -WebRtc_Word32 AudioMixerManagerMac::CloseMicrophone() +int32_t AudioMixerManagerMac::CloseMicrophone() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -109,7 +109,7 @@ WebRtc_Word32 AudioMixerManagerMac::CloseMicrophone() return 0; } -WebRtc_Word32 AudioMixerManagerMac::OpenSpeaker(AudioDeviceID deviceID) +int32_t AudioMixerManagerMac::OpenSpeaker(AudioDeviceID deviceID) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerMac::OpenSpeaker(id=%d)", deviceID); @@ -164,7 +164,7 @@ WebRtc_Word32 AudioMixerManagerMac::OpenSpeaker(AudioDeviceID deviceID) return 0; } -WebRtc_Word32 AudioMixerManagerMac::OpenMicrophone(AudioDeviceID deviceID) +int32_t AudioMixerManagerMac::OpenMicrophone(AudioDeviceID deviceID) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerMac::OpenMicrophone(id=%d)", deviceID); @@ -233,7 +233,7 @@ bool AudioMixerManagerMac::MicrophoneIsInitialized() const return (_inputDeviceID != kAudioObjectUnknown); } -WebRtc_Word32 AudioMixerManagerMac::SetSpeakerVolume(WebRtc_UWord32 volume) +int32_t AudioMixerManagerMac::SetSpeakerVolume(uint32_t volume) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerMac::SetSpeakerVolume(volume=%u)", volume); @@ -299,7 +299,7 @@ WebRtc_Word32 AudioMixerManagerMac::SetSpeakerVolume(WebRtc_UWord32 volume) return 0; } -WebRtc_Word32 AudioMixerManagerMac::SpeakerVolume(WebRtc_UWord32& volume) const +int32_t AudioMixerManagerMac::SpeakerVolume(uint32_t& volume) const { if (_outputDeviceID == kAudioObjectUnknown) @@ -329,7 +329,7 @@ WebRtc_Word32 AudioMixerManagerMac::SpeakerVolume(WebRtc_UWord32& volume) const &propertyAddress, 0, NULL, &size, &vol)); // vol 0.0 to 1.0 -> convert to 0 - 255 - volume = static_cast (vol * 255 + 0.5); + volume = static_cast (vol * 255 + 0.5); } else { // Otherwise get the average volume across channels. @@ -360,7 +360,7 @@ WebRtc_Word32 AudioMixerManagerMac::SpeakerVolume(WebRtc_UWord32& volume) const assert(channels > 0); // vol 0.0 to 1.0 -> convert to 0 - 255 - volume = static_cast (255 * vol / channels + 0.5); + volume = static_cast (255 * vol / channels + 0.5); } WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, @@ -369,8 +369,8 @@ WebRtc_Word32 AudioMixerManagerMac::SpeakerVolume(WebRtc_UWord32& volume) const return 0; } -WebRtc_Word32 -AudioMixerManagerMac::MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const +int32_t +AudioMixerManagerMac::MaxSpeakerVolume(uint32_t& maxVolume) const { if (_outputDeviceID == kAudioObjectUnknown) @@ -387,8 +387,8 @@ AudioMixerManagerMac::MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const return 0; } -WebRtc_Word32 -AudioMixerManagerMac::MinSpeakerVolume(WebRtc_UWord32& minVolume) const +int32_t +AudioMixerManagerMac::MinSpeakerVolume(uint32_t& minVolume) const { if (_outputDeviceID == kAudioObjectUnknown) @@ -405,8 +405,8 @@ AudioMixerManagerMac::MinSpeakerVolume(WebRtc_UWord32& minVolume) const return 0; } -WebRtc_Word32 -AudioMixerManagerMac::SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const +int32_t +AudioMixerManagerMac::SpeakerVolumeStepSize(uint16_t& stepSize) const { if (_outputDeviceID == kAudioObjectUnknown) @@ -423,7 +423,7 @@ AudioMixerManagerMac::SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const return 0; } -WebRtc_Word32 AudioMixerManagerMac::SpeakerVolumeIsAvailable(bool& available) +int32_t AudioMixerManagerMac::SpeakerVolumeIsAvailable(bool& available) { if (_outputDeviceID == kAudioObjectUnknown) { @@ -469,7 +469,7 @@ WebRtc_Word32 AudioMixerManagerMac::SpeakerVolumeIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioMixerManagerMac::SpeakerMuteIsAvailable(bool& available) +int32_t AudioMixerManagerMac::SpeakerMuteIsAvailable(bool& available) { if (_outputDeviceID == kAudioObjectUnknown) { @@ -514,7 +514,7 @@ WebRtc_Word32 AudioMixerManagerMac::SpeakerMuteIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioMixerManagerMac::SetSpeakerMute(bool enable) +int32_t AudioMixerManagerMac::SetSpeakerMute(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerMac::SetSpeakerMute(enable=%u)", enable); @@ -575,7 +575,7 @@ WebRtc_Word32 AudioMixerManagerMac::SetSpeakerMute(bool enable) return 0; } -WebRtc_Word32 AudioMixerManagerMac::SpeakerMute(bool& enabled) const +int32_t AudioMixerManagerMac::SpeakerMute(bool& enabled) const { if (_outputDeviceID == kAudioObjectUnknown) @@ -643,7 +643,7 @@ WebRtc_Word32 AudioMixerManagerMac::SpeakerMute(bool& enabled) const return 0; } -WebRtc_Word32 AudioMixerManagerMac::StereoPlayoutIsAvailable(bool& available) +int32_t AudioMixerManagerMac::StereoPlayoutIsAvailable(bool& available) { if (_outputDeviceID == kAudioObjectUnknown) { @@ -656,7 +656,7 @@ WebRtc_Word32 AudioMixerManagerMac::StereoPlayoutIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioMixerManagerMac::StereoRecordingIsAvailable(bool& available) +int32_t AudioMixerManagerMac::StereoRecordingIsAvailable(bool& available) { if (_inputDeviceID == kAudioObjectUnknown) { @@ -669,7 +669,7 @@ WebRtc_Word32 AudioMixerManagerMac::StereoRecordingIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioMixerManagerMac::MicrophoneMuteIsAvailable(bool& available) +int32_t AudioMixerManagerMac::MicrophoneMuteIsAvailable(bool& available) { if (_inputDeviceID == kAudioObjectUnknown) { @@ -714,7 +714,7 @@ WebRtc_Word32 AudioMixerManagerMac::MicrophoneMuteIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioMixerManagerMac::SetMicrophoneMute(bool enable) +int32_t AudioMixerManagerMac::SetMicrophoneMute(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerMac::SetMicrophoneMute(enable=%u)", enable); @@ -775,7 +775,7 @@ WebRtc_Word32 AudioMixerManagerMac::SetMicrophoneMute(bool enable) return 0; } -WebRtc_Word32 AudioMixerManagerMac::MicrophoneMute(bool& enabled) const +int32_t AudioMixerManagerMac::MicrophoneMute(bool& enabled) const { if (_inputDeviceID == kAudioObjectUnknown) @@ -844,7 +844,7 @@ WebRtc_Word32 AudioMixerManagerMac::MicrophoneMute(bool& enabled) const return 0; } -WebRtc_Word32 AudioMixerManagerMac::MicrophoneBoostIsAvailable(bool& available) +int32_t AudioMixerManagerMac::MicrophoneBoostIsAvailable(bool& available) { if (_inputDeviceID == kAudioObjectUnknown) { @@ -858,7 +858,7 @@ WebRtc_Word32 AudioMixerManagerMac::MicrophoneBoostIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioMixerManagerMac::SetMicrophoneBoost(bool enable) +int32_t AudioMixerManagerMac::SetMicrophoneBoost(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerMac::SetMicrophoneBoost(enable=%u)", enable); @@ -886,7 +886,7 @@ WebRtc_Word32 AudioMixerManagerMac::SetMicrophoneBoost(bool enable) return 0; } -WebRtc_Word32 AudioMixerManagerMac::MicrophoneBoost(bool& enabled) const +int32_t AudioMixerManagerMac::MicrophoneBoost(bool& enabled) const { if (_inputDeviceID == kAudioObjectUnknown) @@ -902,7 +902,7 @@ WebRtc_Word32 AudioMixerManagerMac::MicrophoneBoost(bool& enabled) const return 0; } -WebRtc_Word32 AudioMixerManagerMac::MicrophoneVolumeIsAvailable(bool& available) +int32_t AudioMixerManagerMac::MicrophoneVolumeIsAvailable(bool& available) { if (_inputDeviceID == kAudioObjectUnknown) { @@ -948,7 +948,7 @@ WebRtc_Word32 AudioMixerManagerMac::MicrophoneVolumeIsAvailable(bool& available) return 0; } -WebRtc_Word32 AudioMixerManagerMac::SetMicrophoneVolume(WebRtc_UWord32 volume) +int32_t AudioMixerManagerMac::SetMicrophoneVolume(uint32_t volume) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManagerMac::SetMicrophoneVolume(volume=%u)", volume); @@ -1014,8 +1014,8 @@ WebRtc_Word32 AudioMixerManagerMac::SetMicrophoneVolume(WebRtc_UWord32 volume) return 0; } -WebRtc_Word32 -AudioMixerManagerMac::MicrophoneVolume(WebRtc_UWord32& volume) const +int32_t +AudioMixerManagerMac::MicrophoneVolume(uint32_t& volume) const { if (_inputDeviceID == kAudioObjectUnknown) @@ -1045,7 +1045,7 @@ AudioMixerManagerMac::MicrophoneVolume(WebRtc_UWord32& volume) const &propertyAddress, 0, NULL, &size, &volFloat32)); // vol 0.0 to 1.0 -> convert to 0 - 255 - volume = static_cast (volFloat32 * 255 + 0.5); + volume = static_cast (volFloat32 * 255 + 0.5); } else { // Otherwise get the average volume across channels. @@ -1076,7 +1076,7 @@ AudioMixerManagerMac::MicrophoneVolume(WebRtc_UWord32& volume) const assert(channels > 0); // vol 0.0 to 1.0 -> convert to 0 - 255 - volume = static_cast + volume = static_cast (255 * volFloat32 / channels + 0.5); } @@ -1087,8 +1087,8 @@ AudioMixerManagerMac::MicrophoneVolume(WebRtc_UWord32& volume) const return 0; } -WebRtc_Word32 -AudioMixerManagerMac::MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const +int32_t +AudioMixerManagerMac::MaxMicrophoneVolume(uint32_t& maxVolume) const { if (_inputDeviceID == kAudioObjectUnknown) @@ -1105,8 +1105,8 @@ AudioMixerManagerMac::MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const return 0; } -WebRtc_Word32 -AudioMixerManagerMac::MinMicrophoneVolume(WebRtc_UWord32& minVolume) const +int32_t +AudioMixerManagerMac::MinMicrophoneVolume(uint32_t& minVolume) const { if (_inputDeviceID == kAudioObjectUnknown) @@ -1123,8 +1123,8 @@ AudioMixerManagerMac::MinMicrophoneVolume(WebRtc_UWord32& minVolume) const return 0; } -WebRtc_Word32 -AudioMixerManagerMac::MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const +int32_t +AudioMixerManagerMac::MicrophoneVolumeStepSize(uint16_t& stepSize) const { if (_inputDeviceID == kAudioObjectUnknown) @@ -1148,7 +1148,7 @@ AudioMixerManagerMac::MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const // CoreAudio errors are best interpreted as four character strings. void AudioMixerManagerMac::logCAMsg(const TraceLevel level, const TraceModule module, - const WebRtc_Word32 id, const char *msg, + const int32_t id, const char *msg, const char *err) { assert(msg != NULL); diff --git a/webrtc/modules/audio_device/mac/audio_mixer_manager_mac.h b/webrtc/modules/audio_device/mac/audio_mixer_manager_mac.h index 7209f91225..8c89e71984 100644 --- a/webrtc/modules/audio_device/mac/audio_mixer_manager_mac.h +++ b/webrtc/modules/audio_device/mac/audio_mixer_manager_mac.h @@ -22,56 +22,56 @@ namespace webrtc { class AudioMixerManagerMac { public: - WebRtc_Word32 OpenSpeaker(AudioDeviceID deviceID); - WebRtc_Word32 OpenMicrophone(AudioDeviceID deviceID); - WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume); - WebRtc_Word32 SpeakerVolume(WebRtc_UWord32& volume) const; - WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const; - WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32& minVolume) const; - WebRtc_Word32 SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const; - WebRtc_Word32 SpeakerVolumeIsAvailable(bool& available); - WebRtc_Word32 SpeakerMuteIsAvailable(bool& available); - WebRtc_Word32 SetSpeakerMute(bool enable); - WebRtc_Word32 SpeakerMute(bool& enabled) const; - WebRtc_Word32 StereoPlayoutIsAvailable(bool& available); - WebRtc_Word32 StereoRecordingIsAvailable(bool& available); - WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available); - WebRtc_Word32 SetMicrophoneMute(bool enable); - WebRtc_Word32 MicrophoneMute(bool& enabled) const; - WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available); - WebRtc_Word32 SetMicrophoneBoost(bool enable); - WebRtc_Word32 MicrophoneBoost(bool& enabled) const; - WebRtc_Word32 MicrophoneVolumeIsAvailable(bool& available); - WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume); - WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32& volume) const; - WebRtc_Word32 MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const; - WebRtc_Word32 MinMicrophoneVolume(WebRtc_UWord32& minVolume) const; - WebRtc_Word32 MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const; - WebRtc_Word32 Close(); - WebRtc_Word32 CloseSpeaker(); - WebRtc_Word32 CloseMicrophone(); + int32_t OpenSpeaker(AudioDeviceID deviceID); + int32_t OpenMicrophone(AudioDeviceID deviceID); + int32_t SetSpeakerVolume(uint32_t volume); + int32_t SpeakerVolume(uint32_t& volume) const; + int32_t MaxSpeakerVolume(uint32_t& maxVolume) const; + int32_t MinSpeakerVolume(uint32_t& minVolume) const; + int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const; + int32_t SpeakerVolumeIsAvailable(bool& available); + int32_t SpeakerMuteIsAvailable(bool& available); + int32_t SetSpeakerMute(bool enable); + int32_t SpeakerMute(bool& enabled) const; + int32_t StereoPlayoutIsAvailable(bool& available); + int32_t StereoRecordingIsAvailable(bool& available); + int32_t MicrophoneMuteIsAvailable(bool& available); + int32_t SetMicrophoneMute(bool enable); + int32_t MicrophoneMute(bool& enabled) const; + int32_t MicrophoneBoostIsAvailable(bool& available); + int32_t SetMicrophoneBoost(bool enable); + int32_t MicrophoneBoost(bool& enabled) const; + int32_t MicrophoneVolumeIsAvailable(bool& available); + int32_t SetMicrophoneVolume(uint32_t volume); + int32_t MicrophoneVolume(uint32_t& volume) const; + int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const; + int32_t MinMicrophoneVolume(uint32_t& minVolume) const; + int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const; + int32_t Close(); + int32_t CloseSpeaker(); + int32_t CloseMicrophone(); bool SpeakerIsInitialized() const; bool MicrophoneIsInitialized() const; public: - AudioMixerManagerMac(const WebRtc_Word32 id); + AudioMixerManagerMac(const int32_t id); ~AudioMixerManagerMac(); private: static void logCAMsg(const TraceLevel level, const TraceModule module, - const WebRtc_Word32 id, const char *msg, + const int32_t id, const char *msg, const char *err); private: CriticalSectionWrapper& _critSect; - WebRtc_Word32 _id; + int32_t _id; AudioDeviceID _inputDeviceID; AudioDeviceID _outputDeviceID; - WebRtc_UWord16 _noInputChannels; - WebRtc_UWord16 _noOutputChannels; + uint16_t _noInputChannels; + uint16_t _noOutputChannels; }; diff --git a/webrtc/modules/audio_device/test/audio_device_test_api.cc b/webrtc/modules/audio_device/test/audio_device_test_api.cc index b232878e27..a1b841d239 100644 --- a/webrtc/modules/audio_device/test/audio_device_test_api.cc +++ b/webrtc/modules/audio_device/test/audio_device_test_api.cc @@ -83,16 +83,16 @@ class AudioTransportAPI: public AudioTransport { ~AudioTransportAPI() {} - virtual WebRtc_Word32 RecordedDataIsAvailable( + virtual int32_t RecordedDataIsAvailable( const void* audioSamples, - const WebRtc_UWord32 nSamples, - const WebRtc_UWord8 nBytesPerSample, - const WebRtc_UWord8 nChannels, - const WebRtc_UWord32 sampleRate, - const WebRtc_UWord32 totalDelay, - const WebRtc_Word32 clockSkew, - const WebRtc_UWord32 currentMicLevel, - WebRtc_UWord32& newMicLevel) { + const uint32_t nSamples, + const uint8_t nBytesPerSample, + const uint8_t nChannels, + const uint32_t sampleRate, + const uint32_t totalDelay, + const int32_t clockSkew, + const uint32_t currentMicLevel, + uint32_t& newMicLevel) { rec_count_++; if (rec_count_ % 100 == 0) { if (nChannels == 1) { @@ -109,13 +109,13 @@ class AudioTransportAPI: public AudioTransport { return 0; } - virtual WebRtc_Word32 NeedMorePlayData( - const WebRtc_UWord32 nSamples, - const WebRtc_UWord8 nBytesPerSample, - const WebRtc_UWord8 nChannels, - const WebRtc_UWord32 sampleRate, + virtual int32_t NeedMorePlayData( + const uint32_t nSamples, + const uint8_t nBytesPerSample, + const uint8_t nChannels, + const uint32_t sampleRate, void* audioSamples, - WebRtc_UWord32& nSamplesOut) { + uint32_t& nSamplesOut) { play_count_++; if (play_count_ % 100 == 0) { if (nChannels == 1) { @@ -129,8 +129,8 @@ class AudioTransportAPI: public AudioTransport { } private: - WebRtc_UWord32 rec_count_; - WebRtc_UWord32 play_count_; + uint32_t rec_count_; + uint32_t play_count_; }; class AudioDeviceAPITest: public testing::Test { @@ -148,7 +148,7 @@ class AudioDeviceAPITest: public testing::Test { // user can select between default (Core) or Wave // else // user can select between default (Wave) or Wave - const WebRtc_Word32 kId = 444; + const int32_t kId = 444; #if defined(_WIN32) EXPECT_TRUE((audio_device_ = AudioDeviceModuleImpl::Create( @@ -276,7 +276,7 @@ class AudioDeviceAPITest: public testing::Test { EXPECT_EQ(0, audio_device_->Terminate()); } - void CheckVolume(WebRtc_UWord32 expected, WebRtc_UWord32 actual) { + void CheckVolume(uint32_t expected, uint32_t actual) { // Mac and Windows have lower resolution on the volume settings. #if defined(WEBRTC_MAC) || defined(_WIN32) int diff = abs(static_cast(expected - actual)); @@ -363,7 +363,7 @@ TEST_F(AudioDeviceAPITest, RecordingDevices) { TEST_F(AudioDeviceAPITest, PlayoutDeviceName) { char name[kAdmMaxDeviceNameSize]; char guid[kAdmMaxGuidSize]; - WebRtc_Word16 no_devices = audio_device_->PlayoutDevices(); + int16_t no_devices = audio_device_->PlayoutDevices(); // fail tests EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(-2, name, guid)); @@ -387,7 +387,7 @@ TEST_F(AudioDeviceAPITest, PlayoutDeviceName) { TEST_F(AudioDeviceAPITest, RecordingDeviceName) { char name[kAdmMaxDeviceNameSize]; char guid[kAdmMaxGuidSize]; - WebRtc_Word16 no_devices = audio_device_->RecordingDevices(); + int16_t no_devices = audio_device_->RecordingDevices(); // fail tests EXPECT_EQ(-1, audio_device_->RecordingDeviceName(-2, name, guid)); @@ -409,7 +409,7 @@ TEST_F(AudioDeviceAPITest, RecordingDeviceName) { } TEST_F(AudioDeviceAPITest, SetPlayoutDevice) { - WebRtc_Word16 no_devices = audio_device_->PlayoutDevices(); + int16_t no_devices = audio_device_->PlayoutDevices(); // fail tests EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(-1)); @@ -434,7 +434,7 @@ TEST_F(AudioDeviceAPITest, SetPlayoutDevice) { TEST_F(AudioDeviceAPITest, SetRecordingDevice) { EXPECT_EQ(0, audio_device_->Init()); - WebRtc_Word16 no_devices = audio_device_->RecordingDevices(); + int16_t no_devices = audio_device_->RecordingDevices(); // fail tests EXPECT_EQ(-1, audio_device_->SetRecordingDevice(-1)); @@ -472,7 +472,7 @@ TEST_F(AudioDeviceAPITest, PlayoutIsAvailable) { EXPECT_FALSE(audio_device_->PlayoutIsInitialized()); #endif - WebRtc_Word16 no_devices = audio_device_->PlayoutDevices(); + int16_t no_devices = audio_device_->PlayoutDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); @@ -494,7 +494,7 @@ TEST_F(AudioDeviceAPITest, RecordingIsAvailable) { EXPECT_FALSE(audio_device_->RecordingIsInitialized()); #endif - WebRtc_Word16 no_devices = audio_device_->RecordingDevices(); + int16_t no_devices = audio_device_->RecordingDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); @@ -536,7 +536,7 @@ TEST_F(AudioDeviceAPITest, InitPlayout) { EXPECT_TRUE(audio_device_->PlayoutIsInitialized()); } - WebRtc_Word16 no_devices = audio_device_->PlayoutDevices(); + int16_t no_devices = audio_device_->PlayoutDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); if (available) { @@ -585,7 +585,7 @@ TEST_F(AudioDeviceAPITest, InitRecording) { EXPECT_TRUE(audio_device_->RecordingIsInitialized()); } - WebRtc_Word16 no_devices = audio_device_->RecordingDevices(); + int16_t no_devices = audio_device_->RecordingDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); if (available) { @@ -643,7 +643,7 @@ TEST_F(AudioDeviceAPITest, StartAndStopPlayout) { } // repeat test for all devices - WebRtc_Word16 no_devices = audio_device_->PlayoutDevices(); + int16_t no_devices = audio_device_->PlayoutDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available)); @@ -700,7 +700,7 @@ TEST_F(AudioDeviceAPITest, StartAndStopRecording) { } // repeat test for all devices - WebRtc_Word16 no_devices = audio_device_->RecordingDevices(); + int16_t no_devices = audio_device_->RecordingDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available)); @@ -718,17 +718,17 @@ TEST_F(AudioDeviceAPITest, StartAndStopRecording) { #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD) TEST_F(AudioDeviceAPITest, SetAndGetWaveOutVolume) { - WebRtc_UWord32 vol(0); + uint32_t vol(0); // NOTE 1: Windows Wave only! // NOTE 2: It seems like the waveOutSetVolume API returns // MMSYSERR_NOTSUPPORTED on some Vista machines! - const WebRtc_UWord16 maxVol(0xFFFF); - WebRtc_UWord16 volL, volR; + const uint16_t maxVol(0xFFFF); + uint16_t volL, volR; CheckInitialPlayoutStates(); // make dummy test to see if this API is supported - WebRtc_Word32 works = audio_device_->SetWaveOutVolume(vol, vol); + int32_t works = audio_device_->SetWaveOutVolume(vol, vol); WARNING(works == 0); if (works == 0) @@ -788,7 +788,7 @@ TEST_F(AudioDeviceAPITest, SpeakerIsAvailable) { EXPECT_FALSE(audio_device_->SpeakerIsInitialized()); // check all availiable devices - WebRtc_Word16 no_devices = audio_device_->PlayoutDevices(); + int16_t no_devices = audio_device_->PlayoutDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); EXPECT_EQ(0, audio_device_->SpeakerIsAvailable(&available)); @@ -829,7 +829,7 @@ TEST_F(AudioDeviceAPITest, InitSpeaker) { } // repeat test for all devices - WebRtc_Word16 no_devices = audio_device_->PlayoutDevices(); + int16_t no_devices = audio_device_->PlayoutDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); EXPECT_EQ(0, audio_device_->SpeakerIsAvailable(&available)); @@ -857,7 +857,7 @@ TEST_F(AudioDeviceAPITest, MicrophoneIsAvailable) { EXPECT_FALSE(audio_device_->MicrophoneIsInitialized()); // check all availiable devices - WebRtc_Word16 no_devices = audio_device_->RecordingDevices(); + int16_t no_devices = audio_device_->RecordingDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); EXPECT_EQ(0, audio_device_->MicrophoneIsAvailable(&available)); @@ -898,7 +898,7 @@ TEST_F(AudioDeviceAPITest, InitMicrophone) { } // repeat test for all devices - WebRtc_Word16 no_devices = audio_device_->RecordingDevices(); + int16_t no_devices = audio_device_->RecordingDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); EXPECT_EQ(0, audio_device_->MicrophoneIsAvailable(&available)); @@ -927,7 +927,7 @@ TEST_F(AudioDeviceAPITest, SpeakerVolumeIsAvailable) { EXPECT_FALSE(audio_device_->SpeakerIsInitialized()); // check all availiable devices - WebRtc_Word16 no_devices = audio_device_->PlayoutDevices(); + int16_t no_devices = audio_device_->PlayoutDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available)); @@ -943,11 +943,11 @@ TEST_F(AudioDeviceAPITest, SpeakerVolumeIsAvailable) { // NOTE: Disabled on mac due to issue 257. #ifndef WEBRTC_MAC TEST_F(AudioDeviceAPITest, SpeakerVolumeTests) { - WebRtc_UWord32 vol(0); - WebRtc_UWord32 volume(0); - WebRtc_UWord32 maxVolume(0); - WebRtc_UWord32 minVolume(0); - WebRtc_UWord16 stepSize(0); + uint32_t vol(0); + uint32_t volume(0); + uint32_t maxVolume(0); + uint32_t minVolume(0); + uint16_t stepSize(0); bool available; CheckInitialPlayoutStates(); @@ -998,7 +998,7 @@ TEST_F(AudioDeviceAPITest, SpeakerVolumeTests) { EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume)); EXPECT_EQ(0, audio_device_->MinSpeakerVolume(&minVolume)); EXPECT_EQ(0, audio_device_->SpeakerVolumeStepSize(&stepSize)); - WebRtc_UWord32 step = (maxVolume - minVolume) / 10; + uint32_t step = (maxVolume - minVolume) / 10; step = (step < stepSize ? stepSize : step); for (vol = minVolume; vol <= maxVolume; vol += step) { EXPECT_EQ(0, audio_device_->SetSpeakerVolume(vol)); @@ -1008,7 +1008,7 @@ TEST_F(AudioDeviceAPITest, SpeakerVolumeTests) { } // use all (indexed) devices and modify/retrieve the volume - WebRtc_Word16 no_devices = audio_device_->PlayoutDevices(); + int16_t no_devices = audio_device_->PlayoutDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); EXPECT_EQ(0, audio_device_->SpeakerVolumeIsAvailable(&available)); @@ -1017,7 +1017,7 @@ TEST_F(AudioDeviceAPITest, SpeakerVolumeTests) { EXPECT_EQ(0, audio_device_->MaxSpeakerVolume(&maxVolume)); EXPECT_EQ(0, audio_device_->MinSpeakerVolume(&minVolume)); EXPECT_EQ(0, audio_device_->SpeakerVolumeStepSize(&stepSize)); - WebRtc_UWord32 step = (maxVolume - minVolume) / 10; + uint32_t step = (maxVolume - minVolume) / 10; step = (step < stepSize ? stepSize : step); for (vol = minVolume; vol <= maxVolume; vol += step) { EXPECT_EQ(0, audio_device_->SetSpeakerVolume(vol)); @@ -1071,7 +1071,7 @@ TEST_F(AudioDeviceAPITest, MicrophoneVolumeIsAvailable) { EXPECT_FALSE(audio_device_->MicrophoneIsInitialized()); // check all availiable devices - WebRtc_Word16 no_devices = audio_device_->RecordingDevices(); + int16_t no_devices = audio_device_->RecordingDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available)); @@ -1087,11 +1087,11 @@ TEST_F(AudioDeviceAPITest, MicrophoneVolumeIsAvailable) { // NOTE: Disabled on mac due to issue 257. #ifndef WEBRTC_MAC TEST_F(AudioDeviceAPITest, MicrophoneVolumeTests) { - WebRtc_UWord32 vol(0); - WebRtc_UWord32 volume(0); - WebRtc_UWord32 maxVolume(0); - WebRtc_UWord32 minVolume(0); - WebRtc_UWord16 stepSize(0); + uint32_t vol(0); + uint32_t volume(0); + uint32_t maxVolume(0); + uint32_t minVolume(0); + uint16_t stepSize(0); bool available; CheckInitialRecordingStates(); @@ -1153,7 +1153,7 @@ TEST_F(AudioDeviceAPITest, MicrophoneVolumeTests) { } // use all (indexed) devices and modify/retrieve the volume - WebRtc_Word16 no_devices = audio_device_->RecordingDevices(); + int16_t no_devices = audio_device_->RecordingDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); EXPECT_EQ(0, audio_device_->MicrophoneVolumeIsAvailable(&available)); @@ -1199,7 +1199,7 @@ TEST_F(AudioDeviceAPITest, SpeakerMuteIsAvailable) { EXPECT_FALSE(audio_device_->SpeakerIsInitialized()); // check all availiable devices - WebRtc_Word16 no_devices = audio_device_->PlayoutDevices(); + int16_t no_devices = audio_device_->PlayoutDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i)); EXPECT_EQ(0, audio_device_->SpeakerMuteIsAvailable(&available)); @@ -1225,7 +1225,7 @@ TEST_F(AudioDeviceAPITest, MicrophoneMuteIsAvailable) { EXPECT_FALSE(audio_device_->MicrophoneIsInitialized()); // check all availiable devices - WebRtc_Word16 no_devices = audio_device_->RecordingDevices(); + int16_t no_devices = audio_device_->RecordingDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); EXPECT_EQ(0, audio_device_->MicrophoneMuteIsAvailable(&available)); @@ -1251,7 +1251,7 @@ TEST_F(AudioDeviceAPITest, MicrophoneBoostIsAvailable) { EXPECT_FALSE(audio_device_->MicrophoneIsInitialized()); // check all availiable devices - WebRtc_Word16 no_devices = audio_device_->RecordingDevices(); + int16_t no_devices = audio_device_->RecordingDevices(); for (int i = 0; i < no_devices; i++) { EXPECT_EQ(0, audio_device_->SetRecordingDevice(i)); EXPECT_EQ(0, audio_device_->MicrophoneBoostIsAvailable(&available)); @@ -1584,7 +1584,7 @@ TEST_F(AudioDeviceAPITest, RecordingChannelTests) { TEST_F(AudioDeviceAPITest, PlayoutBufferTests) { AudioDeviceModule::BufferType bufferType; - WebRtc_UWord16 sizeMS(0); + uint16_t sizeMS(0); CheckInitialPlayoutStates(); EXPECT_EQ(0, audio_device_->PlayoutBuffer(&bufferType, &sizeMS)); @@ -1657,7 +1657,7 @@ TEST_F(AudioDeviceAPITest, PlayoutBufferTests) { TEST_F(AudioDeviceAPITest, PlayoutDelay) { // NOTE: this API is better tested in a functional test - WebRtc_UWord16 sizeMS(0); + uint16_t sizeMS(0); CheckInitialPlayoutStates(); // bulk tests EXPECT_EQ(0, audio_device_->PlayoutDelay(&sizeMS)); @@ -1666,7 +1666,7 @@ TEST_F(AudioDeviceAPITest, PlayoutDelay) { TEST_F(AudioDeviceAPITest, RecordingDelay) { // NOTE: this API is better tested in a functional test - WebRtc_UWord16 sizeMS(0); + uint16_t sizeMS(0); CheckInitialRecordingStates(); // bulk tests @@ -1676,7 +1676,7 @@ TEST_F(AudioDeviceAPITest, RecordingDelay) { TEST_F(AudioDeviceAPITest, CPULoad) { // NOTE: this API is better tested in a functional test - WebRtc_UWord16 load(0); + uint16_t load(0); // bulk tests #ifdef _WIN32 @@ -1761,7 +1761,7 @@ TEST_F(AudioDeviceAPITest, StartAndStopRawInputFileRecording) { #endif // !WIN32 && !WEBRTC_LINUX TEST_F(AudioDeviceAPITest, RecordingSampleRate) { - WebRtc_UWord32 sampleRate(0); + uint32_t sampleRate(0); // bulk tests EXPECT_EQ(0, audio_device_->RecordingSampleRate(&sampleRate)); @@ -1780,7 +1780,7 @@ TEST_F(AudioDeviceAPITest, RecordingSampleRate) { } TEST_F(AudioDeviceAPITest, PlayoutSampleRate) { - WebRtc_UWord32 sampleRate(0); + uint32_t sampleRate(0); // bulk tests EXPECT_EQ(0, audio_device_->PlayoutSampleRate(&sampleRate)); diff --git a/webrtc/modules/audio_device/test/func_test_manager.cc b/webrtc/modules/audio_device/test/func_test_manager.cc index 9ecec7ce6c..bc0dd78485 100644 --- a/webrtc/modules/audio_device/test/func_test_manager.cc +++ b/webrtc/modules/audio_device/test/func_test_manager.cc @@ -39,11 +39,11 @@ const char* RecordedSpeakerFile = "recorded_speaker_48.pcm"; struct AudioPacket { - WebRtc_UWord8 dataBuffer[4 * 960]; - WebRtc_UWord16 nSamples; - WebRtc_UWord16 nBytesPerSample; - WebRtc_UWord8 nChannels; - WebRtc_UWord32 samplesPerSec; + uint8_t dataBuffer[4 * 960]; + uint16_t nSamples; + uint16_t nBytesPerSample; + uint8_t nChannels; + uint32_t samplesPerSec; }; // Helper functions @@ -134,8 +134,7 @@ AudioTransportImpl::~AudioTransportImpl() // AudioTransportImpl::SetFilePlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioTransportImpl::SetFilePlayout(bool enable, - const char* fileName) +int32_t AudioTransportImpl::SetFilePlayout(bool enable, const char* fileName) { _playFromFile = enable; if (enable) @@ -168,22 +167,22 @@ void AudioTransportImpl::SetFullDuplex(bool enable) } } -WebRtc_Word32 AudioTransportImpl::RecordedDataIsAvailable( +int32_t AudioTransportImpl::RecordedDataIsAvailable( const void* audioSamples, - const WebRtc_UWord32 nSamples, - const WebRtc_UWord8 nBytesPerSample, - const WebRtc_UWord8 nChannels, - const WebRtc_UWord32 samplesPerSec, - const WebRtc_UWord32 totalDelayMS, - const WebRtc_Word32 clockDrift, - const WebRtc_UWord32 currentMicLevel, - WebRtc_UWord32& newMicLevel) + const uint32_t nSamples, + const uint8_t nBytesPerSample, + const uint8_t nChannels, + const uint32_t samplesPerSec, + const uint32_t totalDelayMS, + const int32_t clockDrift, + const uint32_t currentMicLevel, + uint32_t& newMicLevel) { if (_fullDuplex && _audioList.GetSize() < 15) { AudioPacket* packet = new AudioPacket(); memcpy(packet->dataBuffer, audioSamples, nSamples * nBytesPerSample); - packet->nSamples = (WebRtc_UWord16) nSamples; + packet->nSamples = (uint16_t) nSamples; packet->nBytesPerSample = nBytesPerSample; packet->nChannels = nChannels; packet->samplesPerSec = samplesPerSec; @@ -202,10 +201,10 @@ WebRtc_Word32 AudioTransportImpl::RecordedDataIsAvailable( if (_microphoneVolume) { - WebRtc_UWord32 maxVolume(0); - WebRtc_UWord32 minVolume(0); - WebRtc_UWord32 volume(0); - WebRtc_UWord16 stepSize(0); + uint32_t maxVolume(0); + uint32_t minVolume(0); + uint32_t volume(0); + uint16_t stepSize(0); EXPECT_EQ(0, _audioDevice->MaxMicrophoneVolume(&maxVolume)); EXPECT_EQ(0, _audioDevice->MinMicrophoneVolume(&minVolume)); EXPECT_EQ(0, _audioDevice->MicrophoneVolumeStepSize(&stepSize)); @@ -228,9 +227,9 @@ WebRtc_Word32 AudioTransportImpl::RecordedDataIsAvailable( if (_microphoneAGC) { - WebRtc_UWord32 maxVolume(0); - WebRtc_UWord32 minVolume(0); - WebRtc_UWord16 stepSize(0); + uint32_t maxVolume(0); + uint32_t minVolume(0); + uint16_t stepSize(0); EXPECT_EQ(0, _audioDevice->MaxMicrophoneVolume(&maxVolume)); EXPECT_EQ(0, _audioDevice->MinMicrophoneVolume(&minVolume)); EXPECT_EQ(0, _audioDevice->MicrophoneVolumeStepSize(&stepSize)); @@ -313,13 +312,13 @@ WebRtc_Word32 AudioTransportImpl::RecordedDataIsAvailable( } -WebRtc_Word32 AudioTransportImpl::NeedMorePlayData( - const WebRtc_UWord32 nSamples, - const WebRtc_UWord8 nBytesPerSample, - const WebRtc_UWord8 nChannels, - const WebRtc_UWord32 samplesPerSec, +int32_t AudioTransportImpl::NeedMorePlayData( + const uint32_t nSamples, + const uint8_t nBytesPerSample, + const uint8_t nChannels, + const uint32_t samplesPerSec, void* audioSamples, - WebRtc_UWord32& nSamplesOut) + uint32_t& nSamplesOut) { if (_fullDuplex) { @@ -335,18 +334,18 @@ WebRtc_Word32 AudioTransportImpl::NeedMorePlayData( { int ret(0); int lenOut(0); - WebRtc_Word16 tmpBuf_96kHz[80 * 12]; - WebRtc_Word16* ptr16In = NULL; - WebRtc_Word16* ptr16Out = NULL; + int16_t tmpBuf_96kHz[80 * 12]; + int16_t* ptr16In = NULL; + int16_t* ptr16Out = NULL; - const WebRtc_UWord16 nSamplesIn = packet->nSamples; - const WebRtc_UWord8 nChannelsIn = packet->nChannels; - const WebRtc_UWord32 samplesPerSecIn = packet->samplesPerSec; - const WebRtc_UWord16 nBytesPerSampleIn = + const uint16_t nSamplesIn = packet->nSamples; + const uint8_t nChannelsIn = packet->nChannels; + const uint32_t samplesPerSecIn = packet->samplesPerSec; + const uint16_t nBytesPerSampleIn = packet->nBytesPerSample; - WebRtc_Word32 fsInHz(samplesPerSecIn); - WebRtc_Word32 fsOutHz(samplesPerSec); + int32_t fsInHz(samplesPerSecIn); + int32_t fsOutHz(samplesPerSec); if (fsInHz == 44100) fsInHz = 44000; @@ -364,19 +363,19 @@ WebRtc_Word32 AudioTransportImpl::NeedMorePlayData( if (nChannels == 2) { _resampler.Push( - (const WebRtc_Word16*) packet->dataBuffer, + (const int16_t*) packet->dataBuffer, 2 * nSamplesIn, - (WebRtc_Word16*) audioSamples, 2 + (int16_t*) audioSamples, 2 * nSamples, lenOut); } else { _resampler.Push( - (const WebRtc_Word16*) packet->dataBuffer, + (const int16_t*) packet->dataBuffer, 2 * nSamplesIn, tmpBuf_96kHz, 2 * nSamples, lenOut); ptr16In = &tmpBuf_96kHz[0]; - ptr16Out = (WebRtc_Word16*) audioSamples; + ptr16Out = (int16_t*) audioSamples; // do stereo -> mono for (unsigned int i = 0; i < nSamples; i++) @@ -387,7 +386,7 @@ WebRtc_Word32 AudioTransportImpl::NeedMorePlayData( ptr16In++; } } - assert(2*nSamples == (WebRtc_UWord32)lenOut); + assert(2*nSamples == (uint32_t)lenOut); } else { if (_playCount % 100 == 0) @@ -406,19 +405,19 @@ WebRtc_Word32 AudioTransportImpl::NeedMorePlayData( if (nChannels == 1) { _resampler.Push( - (const WebRtc_Word16*) packet->dataBuffer, + (const int16_t*) packet->dataBuffer, nSamplesIn, - (WebRtc_Word16*) audioSamples, + (int16_t*) audioSamples, nSamples, lenOut); } else { _resampler.Push( - (const WebRtc_Word16*) packet->dataBuffer, + (const int16_t*) packet->dataBuffer, nSamplesIn, tmpBuf_96kHz, nSamples, lenOut); ptr16In = &tmpBuf_96kHz[0]; - ptr16Out = (WebRtc_Word16*) audioSamples; + ptr16Out = (int16_t*) audioSamples; // do mono -> stereo for (unsigned int i = 0; i < nSamples; i++) @@ -430,7 +429,7 @@ WebRtc_Word32 AudioTransportImpl::NeedMorePlayData( ptr16In++; } } - assert(nSamples == (WebRtc_UWord32)lenOut); + assert(nSamples == (uint32_t)lenOut); } else { if (_playCount % 100 == 0) @@ -447,15 +446,15 @@ WebRtc_Word32 AudioTransportImpl::NeedMorePlayData( if (_playFromFile && _playFile.Open()) { - WebRtc_Word16 fileBuf[480]; + int16_t fileBuf[480]; // read mono-file - WebRtc_Word32 len = _playFile.Read((WebRtc_Word8*) fileBuf, 2 + int32_t len = _playFile.Read((int8_t*) fileBuf, 2 * nSamples); - if (len != 2 * (WebRtc_Word32) nSamples) + if (len != 2 * (int32_t) nSamples) { _playFile.Rewind(); - _playFile.Read((WebRtc_Word8*) fileBuf, 2 * nSamples); + _playFile.Read((int8_t*) fileBuf, 2 * nSamples); } // convert to stero if required @@ -466,7 +465,7 @@ WebRtc_Word32 AudioTransportImpl::NeedMorePlayData( { // mono sample from file is duplicated and sent to left and right // channels - WebRtc_Word16* audio16 = (WebRtc_Word16*) audioSamples; + int16_t* audio16 = (int16_t*) audioSamples; for (unsigned int i = 0; i < nSamples; i++) { (*audio16) = fileBuf[i]; // left @@ -485,10 +484,10 @@ WebRtc_Word32 AudioTransportImpl::NeedMorePlayData( if (_speakerVolume) { - WebRtc_UWord32 maxVolume(0); - WebRtc_UWord32 minVolume(0); - WebRtc_UWord32 volume(0); - WebRtc_UWord16 stepSize(0); + uint32_t maxVolume(0); + uint32_t minVolume(0); + uint32_t volume(0); + uint16_t stepSize(0); EXPECT_EQ(0, _audioDevice->MaxSpeakerVolume(&maxVolume)); EXPECT_EQ(0, _audioDevice->MinSpeakerVolume(&minVolume)); EXPECT_EQ(0, _audioDevice->SpeakerVolumeStepSize(&stepSize)); @@ -498,7 +497,7 @@ WebRtc_Word32 AudioTransportImpl::NeedMorePlayData( TEST_LOG("[0]"); addMarker = false; } - WebRtc_UWord32 step = (maxVolume - minVolume) / 10; + uint32_t step = (maxVolume - minVolume) / 10; step = (step < stepSize ? stepSize : step); volume += step; if (volume > maxVolume) @@ -529,9 +528,9 @@ WebRtc_Word32 AudioTransportImpl::NeedMorePlayData( if (_loopBackMeasurements) { - WebRtc_UWord16 recDelayMS(0); - WebRtc_UWord16 playDelayMS(0); - WebRtc_UWord32 nItemsInList(0); + uint16_t recDelayMS(0); + uint16_t playDelayMS(0); + uint32_t nItemsInList(0); nItemsInList = _audioList.GetSize(); EXPECT_EQ(0, _audioDevice->RecordingDelay(&recDelayMS)); @@ -577,7 +576,7 @@ FuncTestManager::~FuncTestManager() { } -WebRtc_Word32 FuncTestManager::Init() +int32_t FuncTestManager::Init() { EXPECT_TRUE((_processThread = ProcessThread::CreateProcessThread()) != NULL); if (_processThread == NULL) @@ -609,7 +608,7 @@ WebRtc_Word32 FuncTestManager::Init() return 0; } -WebRtc_Word32 FuncTestManager::Close() +int32_t FuncTestManager::Close() { EXPECT_EQ(0, _audioDevice->RegisterEventObserver(NULL)); EXPECT_EQ(0, _audioDevice->RegisterAudioCallback(NULL)); @@ -652,7 +651,7 @@ WebRtc_Word32 FuncTestManager::Close() return 0; } -WebRtc_Word32 FuncTestManager::DoTest(const TestType testType) +int32_t FuncTestManager::DoTest(const TestType testType) { switch (testType) { @@ -712,7 +711,7 @@ WebRtc_Word32 FuncTestManager::DoTest(const TestType testType) return 0; } -WebRtc_Word32 FuncTestManager::TestAudioLayerSelection() +int32_t FuncTestManager::TestAudioLayerSelection() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Audio Layer test:\n"); @@ -887,7 +886,7 @@ WebRtc_Word32 FuncTestManager::TestAudioLayerSelection() return 0; } -WebRtc_Word32 FuncTestManager::TestDeviceEnumeration() +int32_t FuncTestManager::TestDeviceEnumeration() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Device Enumeration test:\n"); @@ -908,7 +907,7 @@ WebRtc_Word32 FuncTestManager::TestDeviceEnumeration() char name[kAdmMaxDeviceNameSize]; char guid[kAdmMaxGuidSize]; - const WebRtc_Word16 nPlayoutDevices(audioDevice->PlayoutDevices()); + const int16_t nPlayoutDevices(audioDevice->PlayoutDevices()); EXPECT_TRUE(nPlayoutDevices >= 0); TEST_LOG("\nPlayoutDevices: %u\n \n", nPlayoutDevices); for (int n = 0; n < nPlayoutDevices; n++) @@ -930,7 +929,7 @@ WebRtc_Word32 FuncTestManager::TestDeviceEnumeration() EXPECT_EQ(-1, audioDevice->PlayoutDeviceName(-1, name, guid)); #endif - const WebRtc_Word16 nRecordingDevices(audioDevice->RecordingDevices()); + const int16_t nRecordingDevices(audioDevice->RecordingDevices()); EXPECT_TRUE(nRecordingDevices >= 0); TEST_LOG("\nRecordingDevices: %u\n \n", nRecordingDevices); for (int n = 0; n < nRecordingDevices; n++) @@ -960,7 +959,7 @@ WebRtc_Word32 FuncTestManager::TestDeviceEnumeration() return 0; } -WebRtc_Word32 FuncTestManager::TestDeviceSelection() +int32_t FuncTestManager::TestDeviceSelection() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Device Selection test:\n"); @@ -996,7 +995,7 @@ WebRtc_Word32 FuncTestManager::TestDeviceSelection() EXPECT_TRUE(audioDevice->Initialized()); bool available(false); - WebRtc_Word16 nDevices(-1); + int16_t nDevices(-1); char name[kAdmMaxDeviceNameSize]; char guid[kAdmMaxGuidSize]; @@ -1172,7 +1171,7 @@ WebRtc_Word32 FuncTestManager::TestDeviceSelection() return 0; } -WebRtc_Word32 FuncTestManager::TestAudioTransport() +int32_t FuncTestManager::TestAudioTransport() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Audio Transport test:\n"); @@ -1223,7 +1222,7 @@ WebRtc_Word32 FuncTestManager::TestAudioTransport() } bool available(false); - WebRtc_UWord32 samplesPerSec(0); + uint32_t samplesPerSec(0); if (playIsAvailable) { @@ -1233,7 +1232,7 @@ WebRtc_Word32 FuncTestManager::TestAudioTransport() EXPECT_EQ(0, audioDevice->SpeakerVolumeIsAvailable(&available)); if (available) { - WebRtc_UWord32 maxVolume(0); + uint32_t maxVolume(0); EXPECT_EQ(0, audioDevice->MaxSpeakerVolume(&maxVolume)); EXPECT_EQ(0, audioDevice->SetSpeakerVolume(maxVolume/2)); } @@ -1285,7 +1284,7 @@ WebRtc_Word32 FuncTestManager::TestAudioTransport() EXPECT_EQ(0, audioDevice->MicrophoneVolumeIsAvailable(&available)); if (available) { - WebRtc_UWord32 maxVolume(0); + uint32_t maxVolume(0); EXPECT_EQ(0, audioDevice->MaxMicrophoneVolume(&maxVolume)); EXPECT_EQ(0, audioDevice->SetMicrophoneVolume(maxVolume)); } @@ -1361,8 +1360,8 @@ WebRtc_Word32 FuncTestManager::TestAudioTransport() // ============================== // Finally, make full duplex test - WebRtc_UWord32 playSamplesPerSec(0); - WebRtc_UWord32 recSamplesPerSecRec(0); + uint32_t playSamplesPerSec(0); + uint32_t recSamplesPerSecRec(0); EXPECT_EQ(0, audioDevice->RegisterAudioCallback(_audioTransport)); @@ -1371,7 +1370,7 @@ WebRtc_Word32 FuncTestManager::TestAudioTransport() EXPECT_EQ(0, audioDevice->MicrophoneVolumeIsAvailable(&available)); if (available) { - WebRtc_UWord32 maxVolume(0); + uint32_t maxVolume(0); EXPECT_EQ(0, audioDevice->MaxMicrophoneVolume(&maxVolume)); EXPECT_EQ(0, audioDevice->SetMicrophoneVolume(maxVolume)); } @@ -1420,7 +1419,7 @@ WebRtc_Word32 FuncTestManager::TestAudioTransport() return 0; } -WebRtc_Word32 FuncTestManager::TestSpeakerVolume() +int32_t FuncTestManager::TestSpeakerVolume() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Speaker Volume test:\n"); @@ -1445,8 +1444,8 @@ WebRtc_Word32 FuncTestManager::TestSpeakerVolume() } bool available(false); - WebRtc_UWord32 startVolume(0); - WebRtc_UWord32 samplesPerSec(0); + uint32_t startVolume(0); + uint32_t samplesPerSec(0); EXPECT_EQ(0, audioDevice->SpeakerVolumeIsAvailable(&available)); if (available) @@ -1521,7 +1520,7 @@ WebRtc_Word32 FuncTestManager::TestSpeakerVolume() return 0; } -WebRtc_Word32 FuncTestManager::TestSpeakerMute() +int32_t FuncTestManager::TestSpeakerMute() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Speaker Mute test:\n"); @@ -1547,7 +1546,7 @@ WebRtc_Word32 FuncTestManager::TestSpeakerMute() bool available(false); bool startMute(false); - WebRtc_UWord32 samplesPerSec(0); + uint32_t samplesPerSec(0); EXPECT_EQ(0, audioDevice->SpeakerMuteIsAvailable(&available)); if (available) @@ -1616,7 +1615,7 @@ WebRtc_Word32 FuncTestManager::TestSpeakerMute() return 0; } -WebRtc_Word32 FuncTestManager::TestMicrophoneVolume() +int32_t FuncTestManager::TestMicrophoneVolume() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Microphone Volume test:\n"); @@ -1681,7 +1680,7 @@ WebRtc_Word32 FuncTestManager::TestMicrophoneVolume() fileRecording = true; } - WebRtc_UWord32 startVolume(0); + uint32_t startVolume(0); bool enabled(false); // store initial volume setting @@ -1755,7 +1754,7 @@ WebRtc_Word32 FuncTestManager::TestMicrophoneVolume() return 0; } -WebRtc_Word32 FuncTestManager::TestMicrophoneMute() +int32_t FuncTestManager::TestMicrophoneMute() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Microphone Mute test:\n"); @@ -1892,7 +1891,7 @@ WebRtc_Word32 FuncTestManager::TestMicrophoneMute() return 0; } -WebRtc_Word32 FuncTestManager::TestMicrophoneBoost() +int32_t FuncTestManager::TestMicrophoneBoost() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Microphone Boost test:\n"); @@ -2029,7 +2028,7 @@ WebRtc_Word32 FuncTestManager::TestMicrophoneBoost() return 0; } -WebRtc_Word32 FuncTestManager::TestMicrophoneAGC() +int32_t FuncTestManager::TestMicrophoneAGC() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Microphone AGC test:\n"); @@ -2093,7 +2092,7 @@ WebRtc_Word32 FuncTestManager::TestMicrophoneAGC() fileRecording = true; } - WebRtc_UWord32 startVolume(0); + uint32_t startVolume(0); bool enabled(false); // store initial volume setting @@ -2168,7 +2167,7 @@ WebRtc_Word32 FuncTestManager::TestMicrophoneAGC() return 0; } -WebRtc_Word32 FuncTestManager::TestLoopback() +int32_t FuncTestManager::TestLoopback() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Loopback measurement test:\n"); @@ -2188,8 +2187,8 @@ WebRtc_Word32 FuncTestManager::TestLoopback() bool recIsAvailable(false); bool playIsAvailable(false); - WebRtc_UWord8 nPlayChannels(0); - WebRtc_UWord8 nRecChannels(0); + uint8_t nPlayChannels(0); + uint8_t nRecChannels(0); if (SelectRecordingDevice() == -1) { @@ -2226,8 +2225,8 @@ WebRtc_Word32 FuncTestManager::TestLoopback() if (recIsAvailable && playIsAvailable) { - WebRtc_UWord32 playSamplesPerSec(0); - WebRtc_UWord32 recSamplesPerSecRec(0); + uint32_t playSamplesPerSec(0); + uint32_t recSamplesPerSecRec(0); EXPECT_EQ(0, audioDevice->RegisterAudioCallback(_audioTransport)); @@ -2248,7 +2247,7 @@ WebRtc_Word32 FuncTestManager::TestLoopback() EXPECT_EQ(0, audioDevice->MicrophoneVolumeIsAvailable(&available)); if (available) { - WebRtc_UWord32 maxVolume(0); + uint32_t maxVolume(0); EXPECT_EQ(0, audioDevice->MaxMicrophoneVolume(&maxVolume)); EXPECT_EQ(0, audioDevice->SetMicrophoneVolume(maxVolume)); } @@ -2294,7 +2293,7 @@ WebRtc_Word32 FuncTestManager::TestLoopback() return 0; } -WebRtc_Word32 FuncTestManager::TestDeviceRemoval() +int32_t FuncTestManager::TestDeviceRemoval() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Device removal test:\n"); @@ -2314,9 +2313,9 @@ WebRtc_Word32 FuncTestManager::TestDeviceRemoval() bool recIsAvailable(false); bool playIsAvailable(false); - WebRtc_UWord8 nPlayChannels(0); - WebRtc_UWord8 nRecChannels(0); - WebRtc_UWord8 loopCount(0); + uint8_t nPlayChannels(0); + uint8_t nRecChannels(0); + uint8_t loopCount(0); while (loopCount < 2) { @@ -2354,8 +2353,8 @@ WebRtc_Word32 FuncTestManager::TestDeviceRemoval() if (recIsAvailable && playIsAvailable) { - WebRtc_UWord32 playSamplesPerSec(0); - WebRtc_UWord32 recSamplesPerSecRec(0); + uint32_t playSamplesPerSec(0); + uint32_t recSamplesPerSecRec(0); EXPECT_EQ(0, audioDevice->RegisterAudioCallback(_audioTransport)); @@ -2376,7 +2375,7 @@ WebRtc_Word32 FuncTestManager::TestDeviceRemoval() EXPECT_EQ(0, audioDevice->MicrophoneVolumeIsAvailable(&available)); if (available) { - WebRtc_UWord32 maxVolume(0); + uint32_t maxVolume(0); EXPECT_EQ(0, audioDevice->MaxMicrophoneVolume(&maxVolume)); EXPECT_EQ(0, audioDevice->SetMicrophoneVolume(maxVolume)); } @@ -2471,7 +2470,7 @@ WebRtc_Word32 FuncTestManager::TestDeviceRemoval() return 0; } -WebRtc_Word32 FuncTestManager::TestExtra() +int32_t FuncTestManager::TestExtra() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Extra test:\n"); @@ -2498,12 +2497,12 @@ WebRtc_Word32 FuncTestManager::TestExtra() return 0; } -WebRtc_Word32 FuncTestManager::SelectRecordingDevice() +int32_t FuncTestManager::SelectRecordingDevice() { - WebRtc_Word16 nDevices = _audioDevice->RecordingDevices(); + int16_t nDevices = _audioDevice->RecordingDevices(); char name[kAdmMaxDeviceNameSize]; char guid[kAdmMaxGuidSize]; - WebRtc_Word32 ret(-1); + int32_t ret(-1); #ifdef _WIN32 TEST_LOG("\nSelect Recording Device\n \n"); @@ -2560,9 +2559,9 @@ WebRtc_Word32 FuncTestManager::SelectRecordingDevice() return ret; } -WebRtc_Word32 FuncTestManager::SelectPlayoutDevice() +int32_t FuncTestManager::SelectPlayoutDevice() { - WebRtc_Word16 nDevices = _audioDevice->PlayoutDevices(); + int16_t nDevices = _audioDevice->PlayoutDevices(); char name[kAdmMaxDeviceNameSize]; char guid[kAdmMaxGuidSize]; @@ -2582,7 +2581,7 @@ WebRtc_Word32 FuncTestManager::SelectPlayoutDevice() scanf("%u", &sel); - WebRtc_Word32 ret(0); + int32_t ret(0); if (sel == 0) { @@ -2612,7 +2611,7 @@ WebRtc_Word32 FuncTestManager::SelectPlayoutDevice() TEST_LOG("\n: "); int sel(0); EXPECT_TRUE(scanf("%u", &sel) > 0); - WebRtc_Word32 ret(0); + int32_t ret(0); if (sel < (nDevices)) { EXPECT_EQ(0, (ret = _audioDevice->SetPlayoutDevice(sel))); @@ -2625,7 +2624,7 @@ WebRtc_Word32 FuncTestManager::SelectPlayoutDevice() return ret; } -WebRtc_Word32 FuncTestManager::TestAdvancedMBAPI() +int32_t FuncTestManager::TestAdvancedMBAPI() { TEST_LOG("\n=======================================\n"); TEST_LOG(" Advanced mobile device API test:\n"); diff --git a/webrtc/modules/audio_device/test/func_test_manager.h b/webrtc/modules/audio_device/test/func_test_manager.h index 94de802c71..aafd4d8199 100644 --- a/webrtc/modules/audio_device/test/func_test_manager.h +++ b/webrtc/modules/audio_device/test/func_test_manager.h @@ -92,29 +92,29 @@ public: class AudioTransportImpl: public AudioTransport { public: - virtual WebRtc_Word32 + virtual int32_t RecordedDataIsAvailable(const void* audioSamples, - const WebRtc_UWord32 nSamples, - const WebRtc_UWord8 nBytesPerSample, - const WebRtc_UWord8 nChannels, - const WebRtc_UWord32 samplesPerSec, - const WebRtc_UWord32 totalDelayMS, - const WebRtc_Word32 clockDrift, - const WebRtc_UWord32 currentMicLevel, - WebRtc_UWord32& newMicLevel); + const uint32_t nSamples, + const uint8_t nBytesPerSample, + const uint8_t nChannels, + const uint32_t samplesPerSec, + const uint32_t totalDelayMS, + const int32_t clockDrift, + const uint32_t currentMicLevel, + uint32_t& newMicLevel); - virtual WebRtc_Word32 NeedMorePlayData(const WebRtc_UWord32 nSamples, - const WebRtc_UWord8 nBytesPerSample, - const WebRtc_UWord8 nChannels, - const WebRtc_UWord32 samplesPerSec, - void* audioSamples, - WebRtc_UWord32& nSamplesOut); + virtual int32_t NeedMorePlayData(const uint32_t nSamples, + const uint8_t nBytesPerSample, + const uint8_t nChannels, + const uint32_t samplesPerSec, + void* audioSamples, + uint32_t& nSamplesOut); AudioTransportImpl(AudioDeviceModule* audioDevice); ~AudioTransportImpl(); public: - WebRtc_Word32 SetFilePlayout(bool enable, const char* fileName = NULL); + int32_t SetFilePlayout(bool enable, const char* fileName = NULL); void SetFullDuplex(bool enable); void SetSpeakerVolume(bool enable) { @@ -167,8 +167,8 @@ private: FileWrapper& _playFile; - WebRtc_UWord32 _recCount; - WebRtc_UWord32 _playCount; + uint32_t _recCount; + uint32_t _playCount; ListWrapper _audioList; @@ -184,26 +184,26 @@ class FuncTestManager public: FuncTestManager(); ~FuncTestManager(); - WebRtc_Word32 Init(); - WebRtc_Word32 Close(); - WebRtc_Word32 DoTest(const TestType testType); + int32_t Init(); + int32_t Close(); + int32_t DoTest(const TestType testType); private: - WebRtc_Word32 TestAudioLayerSelection(); - WebRtc_Word32 TestDeviceEnumeration(); - WebRtc_Word32 TestDeviceSelection(); - WebRtc_Word32 TestAudioTransport(); - WebRtc_Word32 TestSpeakerVolume(); - WebRtc_Word32 TestMicrophoneVolume(); - WebRtc_Word32 TestSpeakerMute(); - WebRtc_Word32 TestMicrophoneMute(); - WebRtc_Word32 TestMicrophoneBoost(); - WebRtc_Word32 TestLoopback(); - WebRtc_Word32 TestDeviceRemoval(); - WebRtc_Word32 TestExtra(); - WebRtc_Word32 TestMicrophoneAGC(); - WebRtc_Word32 SelectPlayoutDevice(); - WebRtc_Word32 SelectRecordingDevice(); - WebRtc_Word32 TestAdvancedMBAPI(); + int32_t TestAudioLayerSelection(); + int32_t TestDeviceEnumeration(); + int32_t TestDeviceSelection(); + int32_t TestAudioTransport(); + int32_t TestSpeakerVolume(); + int32_t TestMicrophoneVolume(); + int32_t TestSpeakerMute(); + int32_t TestMicrophoneMute(); + int32_t TestMicrophoneBoost(); + int32_t TestLoopback(); + int32_t TestDeviceRemoval(); + int32_t TestExtra(); + int32_t TestMicrophoneAGC(); + int32_t SelectPlayoutDevice(); + int32_t SelectRecordingDevice(); + int32_t TestAdvancedMBAPI(); private: // Paths to where the resource files to be used for this test are located. std::string _playoutFile48; diff --git a/webrtc/modules/audio_device/win/audio_device_core_win.cc b/webrtc/modules/audio_device/win/audio_device_core_win.cc index 8c61d10668..0d4c60d511 100644 --- a/webrtc/modules/audio_device/win/audio_device_core_win.cc +++ b/webrtc/modules/audio_device/win/audio_device_core_win.cc @@ -338,8 +338,8 @@ bool AudioDeviceWindowsCore::CoreAudioIsSupported() ok |= p->Init(); - WebRtc_Word16 numDevsRec = p->RecordingDevices(); - for (WebRtc_UWord16 i = 0; i < numDevsRec; i++) + int16_t numDevsRec = p->RecordingDevices(); + for (uint16_t i = 0; i < numDevsRec; i++) { ok |= p->SetRecordingDevice(i); temp_ok = p->RecordingIsAvailable(available); @@ -356,8 +356,8 @@ bool AudioDeviceWindowsCore::CoreAudioIsSupported() } } - WebRtc_Word16 numDevsPlay = p->PlayoutDevices(); - for (WebRtc_UWord16 i = 0; i < numDevsPlay; i++) + int16_t numDevsPlay = p->PlayoutDevices(); + for (uint16_t i = 0; i < numDevsPlay; i++) { ok |= p->SetPlayoutDevice(i); temp_ok = p->PlayoutIsAvailable(available); @@ -404,7 +404,7 @@ bool AudioDeviceWindowsCore::CoreAudioIsSupported() // AudioDeviceWindowsCore() - ctor // ---------------------------------------------------------------------------- -AudioDeviceWindowsCore::AudioDeviceWindowsCore(const WebRtc_Word32 id) : +AudioDeviceWindowsCore::AudioDeviceWindowsCore(const int32_t id) : _comInit(ScopedCOMInitializer::kMTA), _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _volumeMutex(*CriticalSectionWrapper::CreateCriticalSection()), @@ -670,7 +670,7 @@ void AudioDeviceWindowsCore::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) // ActiveAudioLayer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const +int32_t AudioDeviceWindowsCore::ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const { audioLayer = AudioDeviceModule::kWindowsCoreAudio; return 0; @@ -680,7 +680,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::ActiveAudioLayer(AudioDeviceModule::AudioL // Init // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::Init() +int32_t AudioDeviceWindowsCore::Init() { CriticalSectionScoped lock(&_critSect); @@ -711,7 +711,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::Init() // Terminate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::Terminate() +int32_t AudioDeviceWindowsCore::Terminate() { CriticalSectionScoped lock(&_critSect); @@ -753,7 +753,7 @@ bool AudioDeviceWindowsCore::Initialized() const // SpeakerIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SpeakerIsAvailable(bool& available) +int32_t AudioDeviceWindowsCore::SpeakerIsAvailable(bool& available) { CriticalSectionScoped lock(&_critSect); @@ -772,7 +772,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::SpeakerIsAvailable(bool& available) // InitSpeaker // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::InitSpeaker() +int32_t AudioDeviceWindowsCore::InitSpeaker() { CriticalSectionScoped lock(&_critSect); @@ -789,7 +789,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::InitSpeaker() if (_usingOutputDeviceIndex) { - WebRtc_Word16 nDevices = PlayoutDevices(); + int16_t nDevices = PlayoutDevices(); if (_outputDeviceIndex > (nDevices - 1)) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "current device selection is invalid => unable to initialize"); @@ -797,7 +797,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::InitSpeaker() } } - WebRtc_Word32 ret(0); + int32_t ret(0); SAFE_RELEASE(_ptrDeviceOut); if (_usingOutputDeviceIndex) @@ -854,7 +854,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::InitSpeaker() // MicrophoneIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::MicrophoneIsAvailable(bool& available) +int32_t AudioDeviceWindowsCore::MicrophoneIsAvailable(bool& available) { CriticalSectionScoped lock(&_critSect); @@ -873,7 +873,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::MicrophoneIsAvailable(bool& available) // InitMicrophone // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::InitMicrophone() +int32_t AudioDeviceWindowsCore::InitMicrophone() { CriticalSectionScoped lock(&_critSect); @@ -890,7 +890,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::InitMicrophone() if (_usingInputDeviceIndex) { - WebRtc_Word16 nDevices = RecordingDevices(); + int16_t nDevices = RecordingDevices(); if (_inputDeviceIndex > (nDevices - 1)) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "current device selection is invalid => unable to initialize"); @@ -898,7 +898,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::InitMicrophone() } } - WebRtc_Word32 ret(0); + int32_t ret(0); SAFE_RELEASE(_ptrDeviceIn); if (_usingInputDeviceIndex) @@ -962,7 +962,7 @@ bool AudioDeviceWindowsCore::MicrophoneIsInitialized() const // SpeakerVolumeIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SpeakerVolumeIsAvailable(bool& available) +int32_t AudioDeviceWindowsCore::SpeakerVolumeIsAvailable(bool& available) { CriticalSectionScoped lock(&_critSect); @@ -1006,7 +1006,7 @@ Exit: // SetSpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetSpeakerVolume(WebRtc_UWord32 volume) +int32_t AudioDeviceWindowsCore::SetSpeakerVolume(uint32_t volume) { { @@ -1023,8 +1023,8 @@ WebRtc_Word32 AudioDeviceWindowsCore::SetSpeakerVolume(WebRtc_UWord32 volume) } } - if (volume < (WebRtc_UWord32)MIN_CORE_SPEAKER_VOLUME || - volume > (WebRtc_UWord32)MAX_CORE_SPEAKER_VOLUME) + if (volume < (uint32_t)MIN_CORE_SPEAKER_VOLUME || + volume > (uint32_t)MAX_CORE_SPEAKER_VOLUME) { return -1; } @@ -1049,7 +1049,7 @@ Exit: // SpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SpeakerVolume(WebRtc_UWord32& volume) const +int32_t AudioDeviceWindowsCore::SpeakerVolume(uint32_t& volume) const { { @@ -1075,7 +1075,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::SpeakerVolume(WebRtc_UWord32& volume) cons EXIT_ON_ERROR(hr); // scale input volume range [0.0,1.0] to valid output range - volume = static_cast (fLevel*MAX_CORE_SPEAKER_VOLUME); + volume = static_cast (fLevel*MAX_CORE_SPEAKER_VOLUME); return 0; @@ -1088,7 +1088,7 @@ Exit: // SetWaveOutVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetWaveOutVolume(WebRtc_UWord16 volumeLeft, WebRtc_UWord16 volumeRight) +int32_t AudioDeviceWindowsCore::SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight) { return -1; } @@ -1097,7 +1097,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::SetWaveOutVolume(WebRtc_UWord16 volumeLeft // WaveOutVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::WaveOutVolume(WebRtc_UWord16& volumeLeft, WebRtc_UWord16& volumeRight) const +int32_t AudioDeviceWindowsCore::WaveOutVolume(uint16_t& volumeLeft, uint16_t& volumeRight) const { return -1; } @@ -1111,7 +1111,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::WaveOutVolume(WebRtc_UWord16& volumeLeft, // how it is used today in VoE. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const +int32_t AudioDeviceWindowsCore::MaxSpeakerVolume(uint32_t& maxVolume) const { if (!_speakerIsInitialized) @@ -1119,7 +1119,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::MaxSpeakerVolume(WebRtc_UWord32& maxVolume return -1; } - maxVolume = static_cast (MAX_CORE_SPEAKER_VOLUME); + maxVolume = static_cast (MAX_CORE_SPEAKER_VOLUME); return 0; } @@ -1128,7 +1128,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::MaxSpeakerVolume(WebRtc_UWord32& maxVolume // MinSpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::MinSpeakerVolume(WebRtc_UWord32& minVolume) const +int32_t AudioDeviceWindowsCore::MinSpeakerVolume(uint32_t& minVolume) const { if (!_speakerIsInitialized) @@ -1136,7 +1136,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::MinSpeakerVolume(WebRtc_UWord32& minVolume return -1; } - minVolume = static_cast (MIN_CORE_SPEAKER_VOLUME); + minVolume = static_cast (MIN_CORE_SPEAKER_VOLUME); return 0; } @@ -1145,7 +1145,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::MinSpeakerVolume(WebRtc_UWord32& minVolume // SpeakerVolumeStepSize // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const +int32_t AudioDeviceWindowsCore::SpeakerVolumeStepSize(uint16_t& stepSize) const { if (!_speakerIsInitialized) @@ -1162,7 +1162,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::SpeakerVolumeStepSize(WebRtc_UWord16& step // SpeakerMuteIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SpeakerMuteIsAvailable(bool& available) +int32_t AudioDeviceWindowsCore::SpeakerMuteIsAvailable(bool& available) { CriticalSectionScoped lock(&_critSect); @@ -1201,7 +1201,7 @@ Exit: // SetSpeakerMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetSpeakerMute(bool enable) +int32_t AudioDeviceWindowsCore::SetSpeakerMute(bool enable) { CriticalSectionScoped lock(&_critSect); @@ -1241,7 +1241,7 @@ Exit: // SpeakerMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SpeakerMute(bool& enabled) const +int32_t AudioDeviceWindowsCore::SpeakerMute(bool& enabled) const { if (!_speakerIsInitialized) @@ -1281,7 +1281,7 @@ Exit: // MicrophoneMuteIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::MicrophoneMuteIsAvailable(bool& available) +int32_t AudioDeviceWindowsCore::MicrophoneMuteIsAvailable(bool& available) { CriticalSectionScoped lock(&_critSect); @@ -1318,7 +1318,7 @@ Exit: // SetMicrophoneMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetMicrophoneMute(bool enable) +int32_t AudioDeviceWindowsCore::SetMicrophoneMute(bool enable) { if (!_microphoneIsInitialized) @@ -1355,7 +1355,7 @@ Exit: // MicrophoneMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::MicrophoneMute(bool& enabled) const +int32_t AudioDeviceWindowsCore::MicrophoneMute(bool& enabled) const { if (!_microphoneIsInitialized) @@ -1389,7 +1389,7 @@ Exit: // MicrophoneBoostIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::MicrophoneBoostIsAvailable(bool& available) +int32_t AudioDeviceWindowsCore::MicrophoneBoostIsAvailable(bool& available) { available = false; @@ -1400,7 +1400,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::MicrophoneBoostIsAvailable(bool& available // SetMicrophoneBoost // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetMicrophoneBoost(bool enable) +int32_t AudioDeviceWindowsCore::SetMicrophoneBoost(bool enable) { if (!_microphoneIsInitialized) @@ -1415,7 +1415,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::SetMicrophoneBoost(bool enable) // MicrophoneBoost // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::MicrophoneBoost(bool& enabled) const +int32_t AudioDeviceWindowsCore::MicrophoneBoost(bool& enabled) const { if (!_microphoneIsInitialized) @@ -1430,7 +1430,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::MicrophoneBoost(bool& enabled) const // StereoRecordingIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::StereoRecordingIsAvailable(bool& available) +int32_t AudioDeviceWindowsCore::StereoRecordingIsAvailable(bool& available) { available = true; @@ -1441,7 +1441,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::StereoRecordingIsAvailable(bool& available // SetStereoRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetStereoRecording(bool enable) +int32_t AudioDeviceWindowsCore::SetStereoRecording(bool enable) { CriticalSectionScoped lock(&_critSect); @@ -1466,7 +1466,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::SetStereoRecording(bool enable) // StereoRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::StereoRecording(bool& enabled) const +int32_t AudioDeviceWindowsCore::StereoRecording(bool& enabled) const { if (_recChannels == 2) @@ -1481,7 +1481,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::StereoRecording(bool& enabled) const // StereoPlayoutIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::StereoPlayoutIsAvailable(bool& available) +int32_t AudioDeviceWindowsCore::StereoPlayoutIsAvailable(bool& available) { available = true; @@ -1492,7 +1492,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::StereoPlayoutIsAvailable(bool& available) // SetStereoPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetStereoPlayout(bool enable) +int32_t AudioDeviceWindowsCore::SetStereoPlayout(bool enable) { CriticalSectionScoped lock(&_critSect); @@ -1517,7 +1517,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::SetStereoPlayout(bool enable) // StereoPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::StereoPlayout(bool& enabled) const +int32_t AudioDeviceWindowsCore::StereoPlayout(bool& enabled) const { if (_playChannels == 2) @@ -1532,7 +1532,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::StereoPlayout(bool& enabled) const // SetAGC // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetAGC(bool enable) +int32_t AudioDeviceWindowsCore::SetAGC(bool enable) { CriticalSectionScoped lock(&_critSect); _AGC = enable; @@ -1553,7 +1553,7 @@ bool AudioDeviceWindowsCore::AGC() const // MicrophoneVolumeIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::MicrophoneVolumeIsAvailable(bool& available) +int32_t AudioDeviceWindowsCore::MicrophoneVolumeIsAvailable(bool& available) { CriticalSectionScoped lock(&_critSect); @@ -1590,7 +1590,7 @@ Exit: // SetMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetMicrophoneVolume(WebRtc_UWord32 volume) +int32_t AudioDeviceWindowsCore::SetMicrophoneVolume(uint32_t volume) { WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "AudioDeviceWindowsCore::SetMicrophoneVolume(volume=%u)", volume); @@ -1608,8 +1608,8 @@ WebRtc_Word32 AudioDeviceWindowsCore::SetMicrophoneVolume(WebRtc_UWord32 volume) } } - if (volume < static_cast(MIN_CORE_MICROPHONE_VOLUME) || - volume > static_cast(MAX_CORE_MICROPHONE_VOLUME)) + if (volume < static_cast(MIN_CORE_MICROPHONE_VOLUME) || + volume > static_cast(MAX_CORE_MICROPHONE_VOLUME)) { return -1; } @@ -1633,7 +1633,7 @@ Exit: // MicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::MicrophoneVolume(WebRtc_UWord32& volume) const +int32_t AudioDeviceWindowsCore::MicrophoneVolume(uint32_t& volume) const { { CriticalSectionScoped lock(&_critSect); @@ -1658,7 +1658,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::MicrophoneVolume(WebRtc_UWord32& volume) c EXIT_ON_ERROR(hr); // scale input volume range [0.0,1.0] to valid output range - volume = static_cast (fLevel*MAX_CORE_MICROPHONE_VOLUME); + volume = static_cast (fLevel*MAX_CORE_MICROPHONE_VOLUME); return 0; @@ -1676,7 +1676,7 @@ Exit: // how it is used today in VoE. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const +int32_t AudioDeviceWindowsCore::MaxMicrophoneVolume(uint32_t& maxVolume) const { WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -1685,7 +1685,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::MaxMicrophoneVolume(WebRtc_UWord32& maxVol return -1; } - maxVolume = static_cast (MAX_CORE_MICROPHONE_VOLUME); + maxVolume = static_cast (MAX_CORE_MICROPHONE_VOLUME); return 0; } @@ -1694,7 +1694,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::MaxMicrophoneVolume(WebRtc_UWord32& maxVol // MinMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::MinMicrophoneVolume(WebRtc_UWord32& minVolume) const +int32_t AudioDeviceWindowsCore::MinMicrophoneVolume(uint32_t& minVolume) const { if (!_microphoneIsInitialized) @@ -1702,7 +1702,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::MinMicrophoneVolume(WebRtc_UWord32& minVol return -1; } - minVolume = static_cast (MIN_CORE_MICROPHONE_VOLUME); + minVolume = static_cast (MIN_CORE_MICROPHONE_VOLUME); return 0; } @@ -1711,7 +1711,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::MinMicrophoneVolume(WebRtc_UWord32& minVol // MicrophoneVolumeStepSize // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const +int32_t AudioDeviceWindowsCore::MicrophoneVolumeStepSize(uint16_t& stepSize) const { if (!_microphoneIsInitialized) @@ -1728,7 +1728,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::MicrophoneVolumeStepSize(WebRtc_UWord16& s // PlayoutDevices // ---------------------------------------------------------------------------- -WebRtc_Word16 AudioDeviceWindowsCore::PlayoutDevices() +int16_t AudioDeviceWindowsCore::PlayoutDevices() { CriticalSectionScoped lock(&_critSect); @@ -1745,7 +1745,7 @@ WebRtc_Word16 AudioDeviceWindowsCore::PlayoutDevices() // SetPlayoutDevice I (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetPlayoutDevice(WebRtc_UWord16 index) +int32_t AudioDeviceWindowsCore::SetPlayoutDevice(uint16_t index) { if (_playIsInitialized) @@ -1799,7 +1799,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::SetPlayoutDevice(WebRtc_UWord16 index) // SetPlayoutDevice II (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType device) +int32_t AudioDeviceWindowsCore::SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType device) { if (_playIsInitialized) { @@ -1858,17 +1858,17 @@ WebRtc_Word32 AudioDeviceWindowsCore::SetPlayoutDevice(AudioDeviceModule::Window // PlayoutDeviceName // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::PlayoutDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceWindowsCore::PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { bool defaultCommunicationDevice(false); - const WebRtc_Word16 nDevices(PlayoutDevices()); // also updates the list of devices + const int16_t nDevices(PlayoutDevices()); // also updates the list of devices // Special fix for the case when the user selects '-1' as index (<=> Default Communication Device) - if (index == (WebRtc_UWord16)(-1)) + if (index == (uint16_t)(-1)) { defaultCommunicationDevice = true; index = 0; @@ -1889,7 +1889,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::PlayoutDeviceName( CriticalSectionScoped lock(&_critSect); - WebRtc_Word32 ret(-1); + int32_t ret(-1); WCHAR szDeviceName[MAX_PATH]; const int bufferLen = sizeof(szDeviceName)/sizeof(szDeviceName)[0]; @@ -1938,17 +1938,17 @@ WebRtc_Word32 AudioDeviceWindowsCore::PlayoutDeviceName( // RecordingDeviceName // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::RecordingDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceWindowsCore::RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { bool defaultCommunicationDevice(false); - const WebRtc_Word16 nDevices(RecordingDevices()); // also updates the list of devices + const int16_t nDevices(RecordingDevices()); // also updates the list of devices // Special fix for the case when the user selects '-1' as index (<=> Default Communication Device) - if (index == (WebRtc_UWord16)(-1)) + if (index == (uint16_t)(-1)) { defaultCommunicationDevice = true; index = 0; @@ -1969,7 +1969,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::RecordingDeviceName( CriticalSectionScoped lock(&_critSect); - WebRtc_Word32 ret(-1); + int32_t ret(-1); WCHAR szDeviceName[MAX_PATH]; const int bufferLen = sizeof(szDeviceName)/sizeof(szDeviceName)[0]; @@ -2018,7 +2018,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::RecordingDeviceName( // RecordingDevices // ---------------------------------------------------------------------------- -WebRtc_Word16 AudioDeviceWindowsCore::RecordingDevices() +int16_t AudioDeviceWindowsCore::RecordingDevices() { CriticalSectionScoped lock(&_critSect); @@ -2035,7 +2035,7 @@ WebRtc_Word16 AudioDeviceWindowsCore::RecordingDevices() // SetRecordingDevice I (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetRecordingDevice(WebRtc_UWord16 index) +int32_t AudioDeviceWindowsCore::SetRecordingDevice(uint16_t index) { if (_recIsInitialized) @@ -2089,7 +2089,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::SetRecordingDevice(WebRtc_UWord16 index) // SetRecordingDevice II (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetRecordingDevice(AudioDeviceModule::WindowsDeviceType device) +int32_t AudioDeviceWindowsCore::SetRecordingDevice(AudioDeviceModule::WindowsDeviceType device) { if (_recIsInitialized) { @@ -2148,13 +2148,13 @@ WebRtc_Word32 AudioDeviceWindowsCore::SetRecordingDevice(AudioDeviceModule::Wind // PlayoutIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::PlayoutIsAvailable(bool& available) +int32_t AudioDeviceWindowsCore::PlayoutIsAvailable(bool& available) { available = false; // Try to initialize the playout side - WebRtc_Word32 res = InitPlayout(); + int32_t res = InitPlayout(); // Cancel effect of initialization StopPlayout(); @@ -2171,13 +2171,13 @@ WebRtc_Word32 AudioDeviceWindowsCore::PlayoutIsAvailable(bool& available) // RecordingIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::RecordingIsAvailable(bool& available) +int32_t AudioDeviceWindowsCore::RecordingIsAvailable(bool& available) { available = false; // Try to initialize the recording side - WebRtc_Word32 res = InitRecording(); + int32_t res = InitRecording(); // Cancel effect of initialization StopRecording(); @@ -2194,7 +2194,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::RecordingIsAvailable(bool& available) // InitPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::InitPlayout() +int32_t AudioDeviceWindowsCore::InitPlayout() { CriticalSectionScoped lock(&_critSect); @@ -2396,7 +2396,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::InitPlayout() { // Update the audio buffer with the selected parameters _ptrAudioBuffer->SetPlayoutSampleRate(_playSampleRate); - _ptrAudioBuffer->SetPlayoutChannels((WebRtc_UWord8)_playChannels); + _ptrAudioBuffer->SetPlayoutChannels((uint8_t)_playChannels); } else { @@ -2452,7 +2452,7 @@ Exit: // used. Called from InitRecording(), most of which is skipped over. The DMO // handles device initialization itself. // Reference: http://msdn.microsoft.com/en-us/library/ff819492(v=vs.85).aspx -WebRtc_Word32 AudioDeviceWindowsCore::InitRecordingDMO() +int32_t AudioDeviceWindowsCore::InitRecordingDMO() { assert(_builtInAecEnabled); assert(_dmo != NULL); @@ -2536,7 +2536,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::InitRecordingDMO() // InitRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::InitRecording() +int32_t AudioDeviceWindowsCore::InitRecording() { CriticalSectionScoped lock(&_critSect); @@ -2711,7 +2711,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::InitRecording() { // Update the audio buffer with the selected parameters _ptrAudioBuffer->SetRecordingSampleRate(_recSampleRate); - _ptrAudioBuffer->SetRecordingChannels((WebRtc_UWord8)_recChannels); + _ptrAudioBuffer->SetRecordingChannels((uint8_t)_recChannels); } else { @@ -2767,7 +2767,7 @@ Exit: // StartRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::StartRecording() +int32_t AudioDeviceWindowsCore::StartRecording() { if (!_recIsInitialized) @@ -2873,9 +2873,9 @@ WebRtc_Word32 AudioDeviceWindowsCore::StartRecording() // StopRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::StopRecording() +int32_t AudioDeviceWindowsCore::StopRecording() { - WebRtc_Word32 err = 0; + int32_t err = 0; if (!_recIsInitialized) { @@ -3017,7 +3017,7 @@ bool AudioDeviceWindowsCore::PlayoutIsInitialized() const // StartPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::StartPlayout() +int32_t AudioDeviceWindowsCore::StartPlayout() { if (!_playIsInitialized) @@ -3077,7 +3077,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::StartPlayout() // StopPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::StopPlayout() +int32_t AudioDeviceWindowsCore::StopPlayout() { if (!_playIsInitialized) @@ -3161,10 +3161,10 @@ WebRtc_Word32 AudioDeviceWindowsCore::StopPlayout() // PlayoutDelay // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::PlayoutDelay(WebRtc_UWord16& delayMS) const +int32_t AudioDeviceWindowsCore::PlayoutDelay(uint16_t& delayMS) const { CriticalSectionScoped critScoped(&_critSect); - delayMS = static_cast(_sndCardPlayDelay); + delayMS = static_cast(_sndCardPlayDelay); return 0; } @@ -3172,10 +3172,10 @@ WebRtc_Word32 AudioDeviceWindowsCore::PlayoutDelay(WebRtc_UWord16& delayMS) cons // RecordingDelay // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::RecordingDelay(WebRtc_UWord16& delayMS) const +int32_t AudioDeviceWindowsCore::RecordingDelay(uint16_t& delayMS) const { CriticalSectionScoped critScoped(&_critSect); - delayMS = static_cast(_sndCardRecDelay); + delayMS = static_cast(_sndCardRecDelay); return 0; } @@ -3191,7 +3191,7 @@ bool AudioDeviceWindowsCore::Playing() const // SetPlayoutBuffer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::SetPlayoutBuffer(const AudioDeviceModule::BufferType type, WebRtc_UWord16 sizeMS) +int32_t AudioDeviceWindowsCore::SetPlayoutBuffer(const AudioDeviceModule::BufferType type, uint16_t sizeMS) { CriticalSectionScoped lock(&_critSect); @@ -3210,7 +3210,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::SetPlayoutBuffer(const AudioDeviceModule:: // PlayoutBuffer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::PlayoutBuffer(AudioDeviceModule::BufferType& type, WebRtc_UWord16& sizeMS) const +int32_t AudioDeviceWindowsCore::PlayoutBuffer(AudioDeviceModule::BufferType& type, uint16_t& sizeMS) const { CriticalSectionScoped lock(&_critSect); type = _playBufType; @@ -3222,7 +3222,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::PlayoutBuffer(AudioDeviceModule::BufferTyp else { // Use same value as for PlayoutDelay - sizeMS = static_cast(_sndCardPlayDelay); + sizeMS = static_cast(_sndCardPlayDelay); } return 0; @@ -3232,10 +3232,10 @@ WebRtc_Word32 AudioDeviceWindowsCore::PlayoutBuffer(AudioDeviceModule::BufferTyp // CPULoad // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::CPULoad(WebRtc_UWord16& load) const +int32_t AudioDeviceWindowsCore::CPULoad(uint16_t& load) const { - load = static_cast (100*_avgCPULoad); + load = static_cast (100*_avgCPULoad); return 0; } @@ -3362,7 +3362,7 @@ DWORD AudioDeviceWindowsCore::DoGetCaptureVolumeThread() { if (AGC()) { - WebRtc_UWord32 currentMicLevel = 0; + uint32_t currentMicLevel = 0; if (MicrophoneVolume(currentMicLevel) == 0) { // This doesn't set the system volume, just stores it. @@ -3411,7 +3411,7 @@ DWORD AudioDeviceWindowsCore::DoSetCaptureVolumeThread() } _Lock(); - WebRtc_UWord32 newMicLevel = _newMicLevel; + uint32_t newMicLevel = _newMicLevel; _UnLock(); if (SetMicrophoneVolume(newMicLevel) == -1) @@ -3436,7 +3436,7 @@ DWORD AudioDeviceWindowsCore::DoRenderThread() LARGE_INTEGER t1; LARGE_INTEGER t2; - WebRtc_Word32 time(0); + int32_t time(0); // Initialize COM as MTA in this thread. ScopedCOMInitializer comInit(ScopedCOMInitializer::kMTA); @@ -3586,7 +3586,7 @@ DWORD AudioDeviceWindowsCore::DoRenderThread() EXIT_ON_ERROR(hr); // Derive the amount of available space in the output buffer - WebRtc_UWord32 framesAvailable = bufferLength - padding; + uint32_t framesAvailable = bufferLength - padding; // WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "#avaliable audio frames = %u", framesAvailable); // Do we have 10 ms available in the render buffer? @@ -3598,8 +3598,8 @@ DWORD AudioDeviceWindowsCore::DoRenderThread() } // Write n*10ms buffers to the render buffer - const WebRtc_UWord32 n10msBuffers = (framesAvailable / _playBlockSize); - for (WebRtc_UWord32 n = 0; n < n10msBuffers; n++) + const uint32_t n10msBuffers = (framesAvailable / _playBlockSize); + for (uint32_t n = 0; n < n10msBuffers; n++) { // Get pointer (i.e., grab the buffer) to next space in the shared render buffer. hr = _ptrRenderClient->GetBuffer(_playBlockSize, &pData); @@ -3611,7 +3611,7 @@ DWORD AudioDeviceWindowsCore::DoRenderThread() { // Request data to be played out (#bytes = _playBlockSize*_audioFrameSize) _UnLock(); - WebRtc_Word32 nSamples = + int32_t nSamples = _ptrAudioBuffer->RequestPlayoutData(_playBlockSize); _Lock(); @@ -3630,13 +3630,13 @@ DWORD AudioDeviceWindowsCore::DoRenderThread() WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, "output state has been modified during unlocked period"); goto Exit; } - if (nSamples != static_cast(_playBlockSize)) + if (nSamples != static_cast(_playBlockSize)) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "nSamples(%d) != _playBlockSize(%d)", nSamples, _playBlockSize); } // Get the actual (stored) data - nSamples = _ptrAudioBuffer->GetPlayoutData((WebRtc_Word8*)pData); + nSamples = _ptrAudioBuffer->GetPlayoutData((int8_t*)pData); } QueryPerformanceCounter(&t2); // measure time: STOP @@ -3854,9 +3854,9 @@ DWORD AudioDeviceWindowsCore::DoCaptureThreadPollDMO() // be that ProcessOutput will try to return more than 10 ms if // we fail to call it frequently enough. assert(kSamplesProduced == static_cast(_recBlockSize)); - assert(sizeof(BYTE) == sizeof(WebRtc_Word8)); + assert(sizeof(BYTE) == sizeof(int8_t)); _ptrAudioBuffer->SetRecordedBuffer( - reinterpret_cast(data), + reinterpret_cast(data), kSamplesProduced); _ptrAudioBuffer->SetVQEData(0, 0, 0); @@ -3919,7 +3919,7 @@ DWORD AudioDeviceWindowsCore::DoCaptureThread() LARGE_INTEGER t1; LARGE_INTEGER t2; - WebRtc_Word32 time(0); + int32_t time(0); BYTE* syncBuffer = NULL; UINT32 syncBufIndex = 0; @@ -4085,11 +4085,11 @@ DWORD AudioDeviceWindowsCore::DoCaptureThread() QueryPerformanceCounter(&t1); // Get the current recording and playout delay. - WebRtc_UWord32 sndCardRecDelay = (WebRtc_UWord32) + uint32_t sndCardRecDelay = (uint32_t) (((((UINT64)t1.QuadPart * _perfCounterFactor) - recTime) / 10000) + (10*syncBufIndex) / _recBlockSize - 10); - WebRtc_UWord32 sndCardPlayDelay = - static_cast(_sndCardPlayDelay); + uint32_t sndCardPlayDelay = + static_cast(_sndCardPlayDelay); _sndCardRecDelay = sndCardRecDelay; @@ -4097,11 +4097,11 @@ DWORD AudioDeviceWindowsCore::DoCaptureThread() { if (_ptrAudioBuffer) { - _ptrAudioBuffer->SetRecordedBuffer((const WebRtc_Word8*)syncBuffer, _recBlockSize); + _ptrAudioBuffer->SetRecordedBuffer((const int8_t*)syncBuffer, _recBlockSize); _driftAccumulator += _sampleDriftAt48kHz; - const WebRtc_Word32 clockDrift = - static_cast(_driftAccumulator); + const int32_t clockDrift = + static_cast(_driftAccumulator); _driftAccumulator -= clockDrift; _ptrAudioBuffer->SetVQEData(sndCardPlayDelay, @@ -4141,7 +4141,7 @@ DWORD AudioDeviceWindowsCore::DoCaptureThread() if (_AGC) { - WebRtc_UWord32 newMicLevel = _ptrAudioBuffer->NewMicLevel(); + uint32_t newMicLevel = _ptrAudioBuffer->NewMicLevel(); if (newMicLevel != 0) { // The VQE will only deliver non-zero microphone levels when a change is needed. @@ -4411,7 +4411,7 @@ int AudioDeviceWindowsCore::SetVtI4Property(IPropertyStore* ptrPS, // such devices. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::_RefreshDeviceList(EDataFlow dir) +int32_t AudioDeviceWindowsCore::_RefreshDeviceList(EDataFlow dir) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -4454,7 +4454,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::_RefreshDeviceList(EDataFlow dir) // current list of such devices. // ---------------------------------------------------------------------------- -WebRtc_Word16 AudioDeviceWindowsCore::_DeviceListCount(EDataFlow dir) +int16_t AudioDeviceWindowsCore::_DeviceListCount(EDataFlow dir) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -4478,7 +4478,7 @@ WebRtc_Word16 AudioDeviceWindowsCore::_DeviceListCount(EDataFlow dir) return -1; } - return static_cast (count); + return static_cast (count); } // ---------------------------------------------------------------------------- @@ -4492,7 +4492,7 @@ WebRtc_Word16 AudioDeviceWindowsCore::_DeviceListCount(EDataFlow dir) // in _RefreshDeviceList(). // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::_GetListDeviceName(EDataFlow dir, int index, LPWSTR szBuffer, int bufferLen) +int32_t AudioDeviceWindowsCore::_GetListDeviceName(EDataFlow dir, int index, LPWSTR szBuffer, int bufferLen) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -4517,7 +4517,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::_GetListDeviceName(EDataFlow dir, int inde return -1; } - WebRtc_Word32 res = _GetDeviceName(pDevice, szBuffer, bufferLen); + int32_t res = _GetDeviceName(pDevice, szBuffer, bufferLen); SAFE_RELEASE(pDevice); return res; } @@ -4531,7 +4531,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::_GetListDeviceName(EDataFlow dir, int inde // Uses: _ptrEnumerator // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::_GetDefaultDeviceName(EDataFlow dir, ERole role, LPWSTR szBuffer, int bufferLen) +int32_t AudioDeviceWindowsCore::_GetDefaultDeviceName(EDataFlow dir, ERole role, LPWSTR szBuffer, int bufferLen) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -4554,7 +4554,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::_GetDefaultDeviceName(EDataFlow dir, ERole return -1; } - WebRtc_Word32 res = _GetDeviceName(pDevice, szBuffer, bufferLen); + int32_t res = _GetDeviceName(pDevice, szBuffer, bufferLen); SAFE_RELEASE(pDevice); return res; } @@ -4570,7 +4570,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::_GetDefaultDeviceName(EDataFlow dir, ERole // in _RefreshDeviceList(). // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::_GetListDeviceID(EDataFlow dir, int index, LPWSTR szBuffer, int bufferLen) +int32_t AudioDeviceWindowsCore::_GetListDeviceID(EDataFlow dir, int index, LPWSTR szBuffer, int bufferLen) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -4595,7 +4595,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::_GetListDeviceID(EDataFlow dir, int index, return -1; } - WebRtc_Word32 res = _GetDeviceID(pDevice, szBuffer, bufferLen); + int32_t res = _GetDeviceID(pDevice, szBuffer, bufferLen); SAFE_RELEASE(pDevice); return res; } @@ -4609,7 +4609,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::_GetListDeviceID(EDataFlow dir, int index, // Uses: _ptrEnumerator // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::_GetDefaultDeviceID(EDataFlow dir, ERole role, LPWSTR szBuffer, int bufferLen) +int32_t AudioDeviceWindowsCore::_GetDefaultDeviceID(EDataFlow dir, ERole role, LPWSTR szBuffer, int bufferLen) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -4632,14 +4632,14 @@ WebRtc_Word32 AudioDeviceWindowsCore::_GetDefaultDeviceID(EDataFlow dir, ERole r return -1; } - WebRtc_Word32 res = _GetDeviceID(pDevice, szBuffer, bufferLen); + int32_t res = _GetDeviceID(pDevice, szBuffer, bufferLen); SAFE_RELEASE(pDevice); return res; } -WebRtc_Word32 AudioDeviceWindowsCore::_GetDefaultDeviceIndex(EDataFlow dir, - ERole role, - int* index) +int32_t AudioDeviceWindowsCore::_GetDefaultDeviceIndex(EDataFlow dir, + ERole role, + int* index) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -4725,9 +4725,9 @@ WebRtc_Word32 AudioDeviceWindowsCore::_GetDefaultDeviceIndex(EDataFlow dir, // _GetDeviceName // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::_GetDeviceName(IMMDevice* pDevice, - LPWSTR pszBuffer, - int bufferLen) +int32_t AudioDeviceWindowsCore::_GetDeviceName(IMMDevice* pDevice, + LPWSTR pszBuffer, + int bufferLen) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -4800,7 +4800,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::_GetDeviceName(IMMDevice* pDevice, // _GetDeviceID // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::_GetDeviceID(IMMDevice* pDevice, LPWSTR pszBuffer, int bufferLen) +int32_t AudioDeviceWindowsCore::_GetDeviceID(IMMDevice* pDevice, LPWSTR pszBuffer, int bufferLen) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -4836,7 +4836,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::_GetDeviceID(IMMDevice* pDevice, LPWSTR ps // _GetDefaultDevice // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::_GetDefaultDevice(EDataFlow dir, ERole role, IMMDevice** ppDevice) +int32_t AudioDeviceWindowsCore::_GetDefaultDevice(EDataFlow dir, ERole role, IMMDevice** ppDevice) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -4861,7 +4861,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::_GetDefaultDevice(EDataFlow dir, ERole rol // _GetListDevice // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::_GetListDevice(EDataFlow dir, int index, IMMDevice** ppDevice) +int32_t AudioDeviceWindowsCore::_GetListDevice(EDataFlow dir, int index, IMMDevice** ppDevice) { HRESULT hr(S_OK); @@ -4897,7 +4897,7 @@ WebRtc_Word32 AudioDeviceWindowsCore::_GetListDevice(EDataFlow dir, int index, I // _EnumerateEndpointDevicesAll // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsCore::_EnumerateEndpointDevicesAll(EDataFlow dataFlow) const +int32_t AudioDeviceWindowsCore::_EnumerateEndpointDevicesAll(EDataFlow dataFlow) const { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); diff --git a/webrtc/modules/audio_device/win/audio_device_core_win.h b/webrtc/modules/audio_device/win/audio_device_core_win.h index 1c1c6c5976..ea28f7ced8 100644 --- a/webrtc/modules/audio_device/win/audio_device_core_win.h +++ b/webrtc/modules/audio_device/win/audio_device_core_win.h @@ -41,8 +41,8 @@ const float MAX_CORE_SPEAKER_VOLUME = 255.0f; const float MIN_CORE_SPEAKER_VOLUME = 0.0f; const float MAX_CORE_MICROPHONE_VOLUME = 255.0f; const float MIN_CORE_MICROPHONE_VOLUME = 0.0f; -const WebRtc_UWord16 CORE_SPEAKER_VOLUME_STEP_SIZE = 1; -const WebRtc_UWord16 CORE_MICROPHONE_VOLUME_STEP_SIZE = 1; +const uint16_t CORE_SPEAKER_VOLUME_STEP_SIZE = 1; +const uint16_t CORE_MICROPHONE_VOLUME_STEP_SIZE = 1; // Utility class which initializes COM in the constructor (STA or MTA), // and uninitializes COM in the destructor. @@ -83,116 +83,116 @@ class ScopedCOMInitializer { class AudioDeviceWindowsCore : public AudioDeviceGeneric { public: - AudioDeviceWindowsCore(const WebRtc_Word32 id); + AudioDeviceWindowsCore(const int32_t id); ~AudioDeviceWindowsCore(); static bool CoreAudioIsSupported(); // Retrieve the currently utilized audio layer - virtual WebRtc_Word32 ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const; + virtual int32_t ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const; // Main initializaton and termination - virtual WebRtc_Word32 Init(); - virtual WebRtc_Word32 Terminate(); + virtual int32_t Init(); + virtual int32_t Terminate(); virtual bool Initialized() const; // Device enumeration - virtual WebRtc_Word16 PlayoutDevices(); - virtual WebRtc_Word16 RecordingDevices(); - virtual WebRtc_Word32 PlayoutDeviceName( - WebRtc_UWord16 index, + virtual int16_t PlayoutDevices(); + virtual int16_t RecordingDevices(); + virtual int32_t PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); - virtual WebRtc_Word32 RecordingDeviceName( - WebRtc_UWord16 index, + virtual int32_t RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); // Device selection - virtual WebRtc_Word32 SetPlayoutDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType device); - virtual WebRtc_Word32 SetRecordingDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetRecordingDevice(AudioDeviceModule::WindowsDeviceType device); + virtual int32_t SetPlayoutDevice(uint16_t index); + virtual int32_t SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType device); + virtual int32_t SetRecordingDevice(uint16_t index); + virtual int32_t SetRecordingDevice(AudioDeviceModule::WindowsDeviceType device); // Audio transport initialization - virtual WebRtc_Word32 PlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 InitPlayout(); + virtual int32_t PlayoutIsAvailable(bool& available); + virtual int32_t InitPlayout(); virtual bool PlayoutIsInitialized() const; - virtual WebRtc_Word32 RecordingIsAvailable(bool& available); - virtual WebRtc_Word32 InitRecording(); + virtual int32_t RecordingIsAvailable(bool& available); + virtual int32_t InitRecording(); virtual bool RecordingIsInitialized() const; // Audio transport control - virtual WebRtc_Word32 StartPlayout(); - virtual WebRtc_Word32 StopPlayout(); + virtual int32_t StartPlayout(); + virtual int32_t StopPlayout(); virtual bool Playing() const; - virtual WebRtc_Word32 StartRecording(); - virtual WebRtc_Word32 StopRecording(); + virtual int32_t StartRecording(); + virtual int32_t StopRecording(); virtual bool Recording() const; // Microphone Automatic Gain Control (AGC) - virtual WebRtc_Word32 SetAGC(bool enable); + virtual int32_t SetAGC(bool enable); virtual bool AGC() const; // Volume control based on the Windows Wave API (Windows only) - virtual WebRtc_Word32 SetWaveOutVolume(WebRtc_UWord16 volumeLeft, WebRtc_UWord16 volumeRight); - virtual WebRtc_Word32 WaveOutVolume(WebRtc_UWord16& volumeLeft, WebRtc_UWord16& volumeRight) const; + virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight); + virtual int32_t WaveOutVolume(uint16_t& volumeLeft, uint16_t& volumeRight) const; // Audio mixer initialization - virtual WebRtc_Word32 SpeakerIsAvailable(bool& available); - virtual WebRtc_Word32 InitSpeaker(); + virtual int32_t SpeakerIsAvailable(bool& available); + virtual int32_t InitSpeaker(); virtual bool SpeakerIsInitialized() const; - virtual WebRtc_Word32 MicrophoneIsAvailable(bool& available); - virtual WebRtc_Word32 InitMicrophone(); + virtual int32_t MicrophoneIsAvailable(bool& available); + virtual int32_t InitMicrophone(); virtual bool MicrophoneIsInitialized() const; // Speaker volume controls - virtual WebRtc_Word32 SpeakerVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 SpeakerVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const; + virtual int32_t SpeakerVolumeIsAvailable(bool& available); + virtual int32_t SetSpeakerVolume(uint32_t volume); + virtual int32_t SpeakerVolume(uint32_t& volume) const; + virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const; + virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const; + virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const; // Microphone volume controls - virtual WebRtc_Word32 MicrophoneVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinMicrophoneVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const; + virtual int32_t MicrophoneVolumeIsAvailable(bool& available); + virtual int32_t SetMicrophoneVolume(uint32_t volume); + virtual int32_t MicrophoneVolume(uint32_t& volume) const; + virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const; + virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const; + virtual int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const; // Speaker mute control - virtual WebRtc_Word32 SpeakerMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerMute(bool enable); - virtual WebRtc_Word32 SpeakerMute(bool& enabled) const; + virtual int32_t SpeakerMuteIsAvailable(bool& available); + virtual int32_t SetSpeakerMute(bool enable); + virtual int32_t SpeakerMute(bool& enabled) const; // Microphone mute control - virtual WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneMute(bool enable); - virtual WebRtc_Word32 MicrophoneMute(bool& enabled) const; + virtual int32_t MicrophoneMuteIsAvailable(bool& available); + virtual int32_t SetMicrophoneMute(bool enable); + virtual int32_t MicrophoneMute(bool& enabled) const; // Microphone boost control - virtual WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneBoost(bool enable); - virtual WebRtc_Word32 MicrophoneBoost(bool& enabled) const; + virtual int32_t MicrophoneBoostIsAvailable(bool& available); + virtual int32_t SetMicrophoneBoost(bool enable); + virtual int32_t MicrophoneBoost(bool& enabled) const; // Stereo support - virtual WebRtc_Word32 StereoPlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoPlayout(bool enable); - virtual WebRtc_Word32 StereoPlayout(bool& enabled) const; - virtual WebRtc_Word32 StereoRecordingIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoRecording(bool enable); - virtual WebRtc_Word32 StereoRecording(bool& enabled) const; + virtual int32_t StereoPlayoutIsAvailable(bool& available); + virtual int32_t SetStereoPlayout(bool enable); + virtual int32_t StereoPlayout(bool& enabled) const; + virtual int32_t StereoRecordingIsAvailable(bool& available); + virtual int32_t SetStereoRecording(bool enable); + virtual int32_t StereoRecording(bool& enabled) const; // Delay information and control - virtual WebRtc_Word32 SetPlayoutBuffer(const AudioDeviceModule::BufferType type, WebRtc_UWord16 sizeMS); - virtual WebRtc_Word32 PlayoutBuffer(AudioDeviceModule::BufferType& type, WebRtc_UWord16& sizeMS) const; - virtual WebRtc_Word32 PlayoutDelay(WebRtc_UWord16& delayMS) const; - virtual WebRtc_Word32 RecordingDelay(WebRtc_UWord16& delayMS) const; + virtual int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type, uint16_t sizeMS); + virtual int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type, uint16_t& sizeMS) const; + virtual int32_t PlayoutDelay(uint16_t& delayMS) const; + virtual int32_t RecordingDelay(uint16_t& delayMS) const; // CPU load - virtual WebRtc_Word32 CPULoad(WebRtc_UWord16& load) const; + virtual int32_t CPULoad(uint16_t& load) const; virtual int32_t EnableBuiltInAEC(bool enable); virtual bool BuiltInAECIsEnabled() const; @@ -240,7 +240,7 @@ private: // thread functions void _UnLock() { _critSect.Leave(); }; private: - WebRtc_Word32 Id() {return _id;} + int32_t Id() {return _id;} private: int SetDMOProperties(); @@ -253,20 +253,20 @@ private: REFPROPERTYKEY key, LONG value); - WebRtc_Word32 _EnumerateEndpointDevicesAll(EDataFlow dataFlow) const; + int32_t _EnumerateEndpointDevicesAll(EDataFlow dataFlow) const; void _TraceCOMError(HRESULT hr) const; - WebRtc_Word32 _RefreshDeviceList(EDataFlow dir); - WebRtc_Word16 _DeviceListCount(EDataFlow dir); - WebRtc_Word32 _GetDefaultDeviceName(EDataFlow dir, ERole role, LPWSTR szBuffer, int bufferLen); - WebRtc_Word32 _GetListDeviceName(EDataFlow dir, int index, LPWSTR szBuffer, int bufferLen); - WebRtc_Word32 _GetDeviceName(IMMDevice* pDevice, LPWSTR pszBuffer, int bufferLen); - WebRtc_Word32 _GetListDeviceID(EDataFlow dir, int index, LPWSTR szBuffer, int bufferLen); - WebRtc_Word32 _GetDefaultDeviceID(EDataFlow dir, ERole role, LPWSTR szBuffer, int bufferLen); - WebRtc_Word32 _GetDefaultDeviceIndex(EDataFlow dir, ERole role, int* index); - WebRtc_Word32 _GetDeviceID(IMMDevice* pDevice, LPWSTR pszBuffer, int bufferLen); - WebRtc_Word32 _GetDefaultDevice(EDataFlow dir, ERole role, IMMDevice** ppDevice); - WebRtc_Word32 _GetListDevice(EDataFlow dir, int index, IMMDevice** ppDevice); + int32_t _RefreshDeviceList(EDataFlow dir); + int16_t _DeviceListCount(EDataFlow dir); + int32_t _GetDefaultDeviceName(EDataFlow dir, ERole role, LPWSTR szBuffer, int bufferLen); + int32_t _GetListDeviceName(EDataFlow dir, int index, LPWSTR szBuffer, int bufferLen); + int32_t _GetDeviceName(IMMDevice* pDevice, LPWSTR pszBuffer, int bufferLen); + int32_t _GetListDeviceID(EDataFlow dir, int index, LPWSTR szBuffer, int bufferLen); + int32_t _GetDefaultDeviceID(EDataFlow dir, ERole role, LPWSTR szBuffer, int bufferLen); + int32_t _GetDefaultDeviceIndex(EDataFlow dir, ERole role, int* index); + int32_t _GetDeviceID(IMMDevice* pDevice, LPWSTR pszBuffer, int bufferLen); + int32_t _GetDefaultDevice(EDataFlow dir, ERole role, IMMDevice** ppDevice); + int32_t _GetListDevice(EDataFlow dir, int index, IMMDevice** ppDevice); void _Get44kHzDrift(); @@ -274,14 +274,14 @@ private: // Does nothing if UNICODE is undefined. char* WideToUTF8(const TCHAR* src) const; - WebRtc_Word32 InitRecordingDMO(); + int32_t InitRecordingDMO(); private: ScopedCOMInitializer _comInit; AudioDeviceBuffer* _ptrAudioBuffer; CriticalSectionWrapper& _critSect; CriticalSectionWrapper& _volumeMutex; - WebRtc_Word32 _id; + int32_t _id; private: // MMDevice IMMDeviceEnumerator* _ptrEnumerator; @@ -320,27 +320,27 @@ private: // WASAPI HANDLE _hMmTask; UINT _playAudioFrameSize; - WebRtc_UWord32 _playSampleRate; - WebRtc_UWord32 _devicePlaySampleRate; - WebRtc_UWord32 _playBlockSize; - WebRtc_UWord32 _devicePlayBlockSize; - WebRtc_UWord32 _playChannels; - WebRtc_UWord32 _sndCardPlayDelay; + uint32_t _playSampleRate; + uint32_t _devicePlaySampleRate; + uint32_t _playBlockSize; + uint32_t _devicePlayBlockSize; + uint32_t _playChannels; + uint32_t _sndCardPlayDelay; UINT64 _writtenSamples; LONGLONG _playAcc; UINT _recAudioFrameSize; - WebRtc_UWord32 _recSampleRate; - WebRtc_UWord32 _recBlockSize; - WebRtc_UWord32 _recChannels; + uint32_t _recSampleRate; + uint32_t _recBlockSize; + uint32_t _recChannels; UINT64 _readSamples; - WebRtc_UWord32 _sndCardRecDelay; + uint32_t _sndCardRecDelay; float _sampleDriftAt48kHz; float _driftAccumulator; - WebRtc_UWord16 _recChannelsPrioList[2]; - WebRtc_UWord16 _playChannelsPrioList[2]; + uint16_t _recChannelsPrioList[2]; + uint16_t _playChannelsPrioList[2]; LARGE_INTEGER _perfCounterFreq; double _perfCounterFactor; @@ -359,21 +359,21 @@ private: bool _usingOutputDeviceIndex; AudioDeviceModule::WindowsDeviceType _inputDevice; AudioDeviceModule::WindowsDeviceType _outputDevice; - WebRtc_UWord16 _inputDeviceIndex; - WebRtc_UWord16 _outputDeviceIndex; + uint16_t _inputDeviceIndex; + uint16_t _outputDeviceIndex; bool _AGC; - WebRtc_UWord16 _playWarning; - WebRtc_UWord16 _playError; - WebRtc_UWord16 _recWarning; - WebRtc_UWord16 _recError; + uint16_t _playWarning; + uint16_t _playError; + uint16_t _recWarning; + uint16_t _recError; AudioDeviceModule::BufferType _playBufType; - WebRtc_UWord16 _playBufDelay; - WebRtc_UWord16 _playBufDelayFixed; + uint16_t _playBufDelay; + uint16_t _playBufDelayFixed; - WebRtc_UWord16 _newMicLevel; + uint16_t _newMicLevel; mutable char _str[512]; }; diff --git a/webrtc/modules/audio_device/win/audio_device_utility_win.cc b/webrtc/modules/audio_device/win/audio_device_utility_win.cc index 49fb522299..abbbc373c6 100644 --- a/webrtc/modules/audio_device/win/audio_device_utility_win.cc +++ b/webrtc/modules/audio_device/win/audio_device_utility_win.cc @@ -34,7 +34,7 @@ namespace webrtc // AudioDeviceUtilityWindows() - ctor // ---------------------------------------------------------------------------- -AudioDeviceUtilityWindows::AudioDeviceUtilityWindows(const WebRtc_Word32 id) : +AudioDeviceUtilityWindows::AudioDeviceUtilityWindows(const int32_t id) : _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _id(id), _lastError(AudioDeviceModule::kAdmErrNone) @@ -66,7 +66,7 @@ AudioDeviceUtilityWindows::~AudioDeviceUtilityWindows() // Init() // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceUtilityWindows::Init() +int32_t AudioDeviceUtilityWindows::Init() { TCHAR szOS[STRING_MAX_SIZE]; diff --git a/webrtc/modules/audio_device/win/audio_device_utility_win.h b/webrtc/modules/audio_device/win/audio_device_utility_win.h index 77b4c22d1d..b483a61d16 100644 --- a/webrtc/modules/audio_device/win/audio_device_utility_win.h +++ b/webrtc/modules/audio_device/win/audio_device_utility_win.h @@ -22,17 +22,17 @@ class CriticalSectionWrapper; class AudioDeviceUtilityWindows : public AudioDeviceUtility { public: - AudioDeviceUtilityWindows(const WebRtc_Word32 id); + AudioDeviceUtilityWindows(const int32_t id); ~AudioDeviceUtilityWindows(); - virtual WebRtc_Word32 Init(); + virtual int32_t Init(); private: BOOL GetOSDisplayString(LPTSTR pszOS); private: CriticalSectionWrapper& _critSect; - WebRtc_Word32 _id; + int32_t _id; AudioDeviceModule::ErrorCode _lastError; }; diff --git a/webrtc/modules/audio_device/win/audio_device_wave_win.cc b/webrtc/modules/audio_device/win/audio_device_wave_win.cc index 17edc7b046..9368748b91 100644 --- a/webrtc/modules/audio_device/win/audio_device_wave_win.cc +++ b/webrtc/modules/audio_device/win/audio_device_wave_win.cc @@ -45,7 +45,7 @@ namespace webrtc { // AudioDeviceWindowsWave - ctor // ---------------------------------------------------------------------------- -AudioDeviceWindowsWave::AudioDeviceWindowsWave(const WebRtc_Word32 id) : +AudioDeviceWindowsWave::AudioDeviceWindowsWave(const int32_t id) : _ptrAudioBuffer(NULL), _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _timeEvent(*EventWrapper::Create()), @@ -189,7 +189,7 @@ void AudioDeviceWindowsWave::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) // ActiveAudioLayer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const +int32_t AudioDeviceWindowsWave::ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const { audioLayer = AudioDeviceModule::kWindowsWaveAudio; return 0; @@ -199,7 +199,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::ActiveAudioLayer(AudioDeviceModule::AudioL // Init // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::Init() +int32_t AudioDeviceWindowsWave::Init() { CriticalSectionScoped lock(&_critSect); @@ -209,7 +209,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::Init() return 0; } - const WebRtc_UWord32 nowTime(AudioDeviceUtility::GetTimeInMS()); + const uint32_t nowTime(AudioDeviceUtility::GetTimeInMS()); _recordedBytes = 0; _prevRecByteCheckTime = nowTime; @@ -312,7 +312,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::Init() // Terminate // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::Terminate() +int32_t AudioDeviceWindowsWave::Terminate() { if (!_initialized) @@ -353,7 +353,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::Terminate() _critSect.Enter(); SetEvent(_hShutdownGetVolumeEvent); _critSect.Leave(); - WebRtc_Word32 ret = WaitForSingleObject(_hGetCaptureVolumeThread, 2000); + int32_t ret = WaitForSingleObject(_hGetCaptureVolumeThread, 2000); if (ret != WAIT_OBJECT_0) { // the thread did not stop as it should @@ -433,7 +433,7 @@ DWORD AudioDeviceWindowsWave::DoGetCaptureVolumeThread() if (AGC()) { - WebRtc_UWord32 currentMicLevel = 0; + uint32_t currentMicLevel = 0; if (MicrophoneVolume(currentMicLevel) == 0) { // This doesn't set the system volume, just stores it. @@ -468,7 +468,7 @@ DWORD AudioDeviceWindowsWave::DoSetCaptureVolumeThread() } _critSect.Enter(); - WebRtc_UWord32 newMicLevel = _newMicLevel; + uint32_t newMicLevel = _newMicLevel; _critSect.Leave(); if (SetMicrophoneVolume(newMicLevel) == -1) @@ -493,7 +493,7 @@ bool AudioDeviceWindowsWave::Initialized() const // SpeakerIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SpeakerIsAvailable(bool& available) +int32_t AudioDeviceWindowsWave::SpeakerIsAvailable(bool& available) { // Enumerate all avaliable speakers and make an attempt to open up the @@ -520,7 +520,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SpeakerIsAvailable(bool& available) // InitSpeaker // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::InitSpeaker() +int32_t AudioDeviceWindowsWave::InitSpeaker() { CriticalSectionScoped lock(&_critSect); @@ -558,7 +558,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::InitSpeaker() // MicrophoneIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneIsAvailable(bool& available) +int32_t AudioDeviceWindowsWave::MicrophoneIsAvailable(bool& available) { // Enumerate all avaliable microphones and make an attempt to open up the @@ -585,7 +585,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneIsAvailable(bool& available) // InitMicrophone // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::InitMicrophone() +int32_t AudioDeviceWindowsWave::InitMicrophone() { CriticalSectionScoped lock(&_critSect); @@ -616,7 +616,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::InitMicrophone() } } - WebRtc_UWord32 maxVol = 0; + uint32_t maxVol = 0; if (_mixerManager.MaxMicrophoneVolume(maxVol) == -1) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -624,7 +624,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::InitMicrophone() } _maxMicVolume = maxVol; - WebRtc_UWord32 minVol = 0; + uint32_t minVol = 0; if (_mixerManager.MinMicrophoneVolume(minVol) == -1) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, @@ -657,7 +657,7 @@ bool AudioDeviceWindowsWave::MicrophoneIsInitialized() const // SpeakerVolumeIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SpeakerVolumeIsAvailable(bool& available) +int32_t AudioDeviceWindowsWave::SpeakerVolumeIsAvailable(bool& available) { bool isAvailable(false); @@ -688,7 +688,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SpeakerVolumeIsAvailable(bool& available) // SetSpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetSpeakerVolume(WebRtc_UWord32 volume) +int32_t AudioDeviceWindowsWave::SetSpeakerVolume(uint32_t volume) { return (_mixerManager.SetSpeakerVolume(volume)); @@ -698,10 +698,10 @@ WebRtc_Word32 AudioDeviceWindowsWave::SetSpeakerVolume(WebRtc_UWord32 volume) // SpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SpeakerVolume(WebRtc_UWord32& volume) const +int32_t AudioDeviceWindowsWave::SpeakerVolume(uint32_t& volume) const { - WebRtc_UWord32 level(0); + uint32_t level(0); if (_mixerManager.SpeakerVolume(level) == -1) { @@ -729,7 +729,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SpeakerVolume(WebRtc_UWord32& volume) cons // 0x4000, 0x4FFF, and 0x43BE will all be truncated to 0x4000. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetWaveOutVolume(WebRtc_UWord16 volumeLeft, WebRtc_UWord16 volumeRight) +int32_t AudioDeviceWindowsWave::SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight) { MMRESULT res(0); @@ -793,7 +793,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SetWaveOutVolume(WebRtc_UWord16 volumeLeft // control. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::WaveOutVolume(WebRtc_UWord16& volumeLeft, WebRtc_UWord16& volumeRight) const +int32_t AudioDeviceWindowsWave::WaveOutVolume(uint16_t& volumeLeft, uint16_t& volumeRight) const { MMRESULT res(0); @@ -840,8 +840,8 @@ WebRtc_Word32 AudioDeviceWindowsWave::WaveOutVolume(WebRtc_UWord16& volumeLeft, WORD wVolumeLeft = LOWORD(dwVolume); WORD wVolumeRight = HIWORD(dwVolume); - volumeLeft = static_cast (wVolumeLeft); - volumeRight = static_cast (wVolumeRight); + volumeLeft = static_cast (wVolumeLeft); + volumeRight = static_cast (wVolumeRight); return 0; } @@ -850,10 +850,10 @@ WebRtc_Word32 AudioDeviceWindowsWave::WaveOutVolume(WebRtc_UWord16& volumeLeft, // MaxSpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const +int32_t AudioDeviceWindowsWave::MaxSpeakerVolume(uint32_t& maxVolume) const { - WebRtc_UWord32 maxVol(0); + uint32_t maxVol(0); if (_mixerManager.MaxSpeakerVolume(maxVol) == -1) { @@ -868,10 +868,10 @@ WebRtc_Word32 AudioDeviceWindowsWave::MaxSpeakerVolume(WebRtc_UWord32& maxVolume // MinSpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::MinSpeakerVolume(WebRtc_UWord32& minVolume) const +int32_t AudioDeviceWindowsWave::MinSpeakerVolume(uint32_t& minVolume) const { - WebRtc_UWord32 minVol(0); + uint32_t minVol(0); if (_mixerManager.MinSpeakerVolume(minVol) == -1) { @@ -886,10 +886,10 @@ WebRtc_Word32 AudioDeviceWindowsWave::MinSpeakerVolume(WebRtc_UWord32& minVolume // SpeakerVolumeStepSize // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const +int32_t AudioDeviceWindowsWave::SpeakerVolumeStepSize(uint16_t& stepSize) const { - WebRtc_UWord16 delta(0); + uint16_t delta(0); if (_mixerManager.SpeakerVolumeStepSize(delta) == -1) { @@ -904,7 +904,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SpeakerVolumeStepSize(WebRtc_UWord16& step // SpeakerMuteIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SpeakerMuteIsAvailable(bool& available) +int32_t AudioDeviceWindowsWave::SpeakerMuteIsAvailable(bool& available) { bool isAvailable(false); @@ -937,7 +937,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SpeakerMuteIsAvailable(bool& available) // SetSpeakerMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetSpeakerMute(bool enable) +int32_t AudioDeviceWindowsWave::SetSpeakerMute(bool enable) { return (_mixerManager.SetSpeakerMute(enable)); } @@ -946,7 +946,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SetSpeakerMute(bool enable) // SpeakerMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SpeakerMute(bool& enabled) const +int32_t AudioDeviceWindowsWave::SpeakerMute(bool& enabled) const { bool muted(0); @@ -964,7 +964,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SpeakerMute(bool& enabled) const // MicrophoneMuteIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneMuteIsAvailable(bool& available) +int32_t AudioDeviceWindowsWave::MicrophoneMuteIsAvailable(bool& available) { bool isAvailable(false); @@ -997,7 +997,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneMuteIsAvailable(bool& available) // SetMicrophoneMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetMicrophoneMute(bool enable) +int32_t AudioDeviceWindowsWave::SetMicrophoneMute(bool enable) { return (_mixerManager.SetMicrophoneMute(enable)); } @@ -1006,7 +1006,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SetMicrophoneMute(bool enable) // MicrophoneMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneMute(bool& enabled) const +int32_t AudioDeviceWindowsWave::MicrophoneMute(bool& enabled) const { bool muted(0); @@ -1024,7 +1024,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneMute(bool& enabled) const // MicrophoneBoostIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneBoostIsAvailable(bool& available) +int32_t AudioDeviceWindowsWave::MicrophoneBoostIsAvailable(bool& available) { bool isAvailable(false); @@ -1057,7 +1057,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneBoostIsAvailable(bool& available // SetMicrophoneBoost // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetMicrophoneBoost(bool enable) +int32_t AudioDeviceWindowsWave::SetMicrophoneBoost(bool enable) { return (_mixerManager.SetMicrophoneBoost(enable)); @@ -1067,7 +1067,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SetMicrophoneBoost(bool enable) // MicrophoneBoost // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneBoost(bool& enabled) const +int32_t AudioDeviceWindowsWave::MicrophoneBoost(bool& enabled) const { bool onOff(0); @@ -1085,7 +1085,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneBoost(bool& enabled) const // StereoRecordingIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::StereoRecordingIsAvailable(bool& available) +int32_t AudioDeviceWindowsWave::StereoRecordingIsAvailable(bool& available) { available = true; return 0; @@ -1095,7 +1095,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::StereoRecordingIsAvailable(bool& available // SetStereoRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetStereoRecording(bool enable) +int32_t AudioDeviceWindowsWave::SetStereoRecording(bool enable) { if (enable) @@ -1110,7 +1110,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SetStereoRecording(bool enable) // StereoRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::StereoRecording(bool& enabled) const +int32_t AudioDeviceWindowsWave::StereoRecording(bool& enabled) const { if (_recChannels == 2) @@ -1125,7 +1125,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::StereoRecording(bool& enabled) const // StereoPlayoutIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::StereoPlayoutIsAvailable(bool& available) +int32_t AudioDeviceWindowsWave::StereoPlayoutIsAvailable(bool& available) { available = true; return 0; @@ -1154,7 +1154,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::StereoPlayoutIsAvailable(bool& available) // high-order byte of channel 1. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetStereoPlayout(bool enable) +int32_t AudioDeviceWindowsWave::SetStereoPlayout(bool enable) { if (enable) @@ -1169,7 +1169,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SetStereoPlayout(bool enable) // StereoPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::StereoPlayout(bool& enabled) const +int32_t AudioDeviceWindowsWave::StereoPlayout(bool& enabled) const { if (_playChannels == 2) @@ -1184,7 +1184,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::StereoPlayout(bool& enabled) const // SetAGC // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetAGC(bool enable) +int32_t AudioDeviceWindowsWave::SetAGC(bool enable) { _AGC = enable; @@ -1205,7 +1205,7 @@ bool AudioDeviceWindowsWave::AGC() const // MicrophoneVolumeIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneVolumeIsAvailable(bool& available) +int32_t AudioDeviceWindowsWave::MicrophoneVolumeIsAvailable(bool& available) { bool isAvailable(false); @@ -1236,7 +1236,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneVolumeIsAvailable(bool& availabl // SetMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetMicrophoneVolume(WebRtc_UWord32 volume) +int32_t AudioDeviceWindowsWave::SetMicrophoneVolume(uint32_t volume) { return (_mixerManager.SetMicrophoneVolume(volume)); } @@ -1245,9 +1245,9 @@ WebRtc_Word32 AudioDeviceWindowsWave::SetMicrophoneVolume(WebRtc_UWord32 volume) // MicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneVolume(WebRtc_UWord32& volume) const +int32_t AudioDeviceWindowsWave::MicrophoneVolume(uint32_t& volume) const { - WebRtc_UWord32 level(0); + uint32_t level(0); if (_mixerManager.MicrophoneVolume(level) == -1) { @@ -1263,7 +1263,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneVolume(WebRtc_UWord32& volume) c // MaxMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const +int32_t AudioDeviceWindowsWave::MaxMicrophoneVolume(uint32_t& maxVolume) const { // _maxMicVolume can be zero in AudioMixerManager::MaxMicrophoneVolume(): // (1) API GetLineControl() returns failure at querying the max Mic level. @@ -1283,7 +1283,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::MaxMicrophoneVolume(WebRtc_UWord32& maxVol // MinMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::MinMicrophoneVolume(WebRtc_UWord32& minVolume) const +int32_t AudioDeviceWindowsWave::MinMicrophoneVolume(uint32_t& minVolume) const { minVolume = _minMicVolume; return 0; @@ -1293,10 +1293,10 @@ WebRtc_Word32 AudioDeviceWindowsWave::MinMicrophoneVolume(WebRtc_UWord32& minVol // MicrophoneVolumeStepSize // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const +int32_t AudioDeviceWindowsWave::MicrophoneVolumeStepSize(uint16_t& stepSize) const { - WebRtc_UWord16 delta(0); + uint16_t delta(0); if (_mixerManager.MicrophoneVolumeStepSize(delta) == -1) { @@ -1311,7 +1311,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::MicrophoneVolumeStepSize(WebRtc_UWord16& s // PlayoutDevices // ---------------------------------------------------------------------------- -WebRtc_Word16 AudioDeviceWindowsWave::PlayoutDevices() +int16_t AudioDeviceWindowsWave::PlayoutDevices() { return (waveOutGetNumDevs()); @@ -1321,7 +1321,7 @@ WebRtc_Word16 AudioDeviceWindowsWave::PlayoutDevices() // SetPlayoutDevice I (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetPlayoutDevice(WebRtc_UWord16 index) +int32_t AudioDeviceWindowsWave::SetPlayoutDevice(uint16_t index) { if (_playIsInitialized) @@ -1349,7 +1349,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SetPlayoutDevice(WebRtc_UWord16 index) // SetPlayoutDevice II (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType device) +int32_t AudioDeviceWindowsWave::SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType device) { if (_playIsInitialized) { @@ -1374,17 +1374,17 @@ WebRtc_Word32 AudioDeviceWindowsWave::SetPlayoutDevice(AudioDeviceModule::Window // PlayoutDeviceName // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::PlayoutDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceWindowsWave::PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { - WebRtc_UWord16 nDevices(PlayoutDevices()); + uint16_t nDevices(PlayoutDevices()); // Special fix for the case when the user asks for the name of the default device. // - if (index == (WebRtc_UWord16)(-1)) + if (index == (uint16_t)(-1)) { index = 0; } @@ -1479,17 +1479,17 @@ WebRtc_Word32 AudioDeviceWindowsWave::PlayoutDeviceName( // RecordingDeviceName // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::RecordingDeviceName( - WebRtc_UWord16 index, +int32_t AudioDeviceWindowsWave::RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { - WebRtc_UWord16 nDevices(RecordingDevices()); + uint16_t nDevices(RecordingDevices()); // Special fix for the case when the user asks for the name of the default device. // - if (index == (WebRtc_UWord16)(-1)) + if (index == (uint16_t)(-1)) { index = 0; } @@ -1584,7 +1584,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::RecordingDeviceName( // RecordingDevices // ---------------------------------------------------------------------------- -WebRtc_Word16 AudioDeviceWindowsWave::RecordingDevices() +int16_t AudioDeviceWindowsWave::RecordingDevices() { return (waveInGetNumDevs()); @@ -1594,7 +1594,7 @@ WebRtc_Word16 AudioDeviceWindowsWave::RecordingDevices() // SetRecordingDevice I (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetRecordingDevice(WebRtc_UWord16 index) +int32_t AudioDeviceWindowsWave::SetRecordingDevice(uint16_t index) { if (_recIsInitialized) @@ -1622,7 +1622,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SetRecordingDevice(WebRtc_UWord16 index) // SetRecordingDevice II (II) // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetRecordingDevice(AudioDeviceModule::WindowsDeviceType device) +int32_t AudioDeviceWindowsWave::SetRecordingDevice(AudioDeviceModule::WindowsDeviceType device) { if (device == AudioDeviceModule::kDefaultDevice) { @@ -1647,13 +1647,13 @@ WebRtc_Word32 AudioDeviceWindowsWave::SetRecordingDevice(AudioDeviceModule::Wind // PlayoutIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::PlayoutIsAvailable(bool& available) +int32_t AudioDeviceWindowsWave::PlayoutIsAvailable(bool& available) { available = false; // Try to initialize the playout side - WebRtc_Word32 res = InitPlayout(); + int32_t res = InitPlayout(); // Cancel effect of initialization StopPlayout(); @@ -1670,13 +1670,13 @@ WebRtc_Word32 AudioDeviceWindowsWave::PlayoutIsAvailable(bool& available) // RecordingIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::RecordingIsAvailable(bool& available) +int32_t AudioDeviceWindowsWave::RecordingIsAvailable(bool& available) { available = false; // Try to initialize the recording side - WebRtc_Word32 res = InitRecording(); + int32_t res = InitRecording(); // Cancel effect of initialization StopRecording(); @@ -1693,7 +1693,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::RecordingIsAvailable(bool& available) // InitPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::InitPlayout() +int32_t AudioDeviceWindowsWave::InitPlayout() { CriticalSectionScoped lock(&_critSect); @@ -1830,7 +1830,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::InitPlayout() // Prepare wave-out headers // - const WebRtc_UWord8 bytesPerSample = 2*_playChannels; + const uint8_t bytesPerSample = 2*_playChannels; for (int n = 0; n < N_BUFFERS_OUT; n++) { @@ -1889,7 +1889,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::InitPlayout() // InitRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::InitRecording() +int32_t AudioDeviceWindowsWave::InitRecording() { CriticalSectionScoped lock(&_critSect); @@ -2040,7 +2040,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::InitRecording() // StartRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::StartRecording() +int32_t AudioDeviceWindowsWave::StartRecording() { if (!_recIsInitialized) @@ -2082,7 +2082,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::StartRecording() // StopRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::StopRecording() +int32_t AudioDeviceWindowsWave::StopRecording() { CriticalSectionScoped lock(&_critSect); @@ -2191,7 +2191,7 @@ bool AudioDeviceWindowsWave::PlayoutIsInitialized() const // StartPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::StartPlayout() +int32_t AudioDeviceWindowsWave::StartPlayout() { if (!_playIsInitialized) @@ -2233,7 +2233,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::StartPlayout() // StopPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::StopPlayout() +int32_t AudioDeviceWindowsWave::StopPlayout() { CriticalSectionScoped lock(&_critSect); @@ -2306,10 +2306,10 @@ WebRtc_Word32 AudioDeviceWindowsWave::StopPlayout() // PlayoutDelay // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::PlayoutDelay(WebRtc_UWord16& delayMS) const +int32_t AudioDeviceWindowsWave::PlayoutDelay(uint16_t& delayMS) const { CriticalSectionScoped lock(&_critSect); - delayMS = (WebRtc_UWord16)_sndCardPlayDelay; + delayMS = (uint16_t)_sndCardPlayDelay; return 0; } @@ -2317,10 +2317,10 @@ WebRtc_Word32 AudioDeviceWindowsWave::PlayoutDelay(WebRtc_UWord16& delayMS) cons // RecordingDelay // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::RecordingDelay(WebRtc_UWord16& delayMS) const +int32_t AudioDeviceWindowsWave::RecordingDelay(uint16_t& delayMS) const { CriticalSectionScoped lock(&_critSect); - delayMS = (WebRtc_UWord16)_sndCardRecDelay; + delayMS = (uint16_t)_sndCardRecDelay; return 0; } @@ -2336,7 +2336,7 @@ bool AudioDeviceWindowsWave::Playing() const // SetPlayoutBuffer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::SetPlayoutBuffer(const AudioDeviceModule::BufferType type, WebRtc_UWord16 sizeMS) +int32_t AudioDeviceWindowsWave::SetPlayoutBuffer(const AudioDeviceModule::BufferType type, uint16_t sizeMS) { CriticalSectionScoped lock(&_critSect); _playBufType = type; @@ -2351,7 +2351,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::SetPlayoutBuffer(const AudioDeviceModule:: // PlayoutBuffer // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::PlayoutBuffer(AudioDeviceModule::BufferType& type, WebRtc_UWord16& sizeMS) const +int32_t AudioDeviceWindowsWave::PlayoutBuffer(AudioDeviceModule::BufferType& type, uint16_t& sizeMS) const { CriticalSectionScoped lock(&_critSect); type = _playBufType; @@ -2371,10 +2371,10 @@ WebRtc_Word32 AudioDeviceWindowsWave::PlayoutBuffer(AudioDeviceModule::BufferTyp // CPULoad // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::CPULoad(WebRtc_UWord16& load) const +int32_t AudioDeviceWindowsWave::CPULoad(uint16_t& load) const { - load = static_cast(100*_avgCPULoad); + load = static_cast(100*_avgCPULoad); return 0; } @@ -2459,7 +2459,7 @@ void AudioDeviceWindowsWave::ClearRecordingError() // InputSanityCheckAfterUnlockedPeriod // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::InputSanityCheckAfterUnlockedPeriod() const +int32_t AudioDeviceWindowsWave::InputSanityCheckAfterUnlockedPeriod() const { if (_hWaveIn == NULL) { @@ -2473,7 +2473,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::InputSanityCheckAfterUnlockedPeriod() cons // OutputSanityCheckAfterUnlockedPeriod // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::OutputSanityCheckAfterUnlockedPeriod() const +int32_t AudioDeviceWindowsWave::OutputSanityCheckAfterUnlockedPeriod() const { if (_hWaveOut == NULL) { @@ -2487,10 +2487,10 @@ WebRtc_Word32 AudioDeviceWindowsWave::OutputSanityCheckAfterUnlockedPeriod() con // EnumeratePlayoutDevices // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::EnumeratePlayoutDevices() +int32_t AudioDeviceWindowsWave::EnumeratePlayoutDevices() { - WebRtc_UWord16 nDevices(PlayoutDevices()); + uint16_t nDevices(PlayoutDevices()); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "==============================================================="); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "#output devices: %u", nDevices); @@ -2539,10 +2539,10 @@ WebRtc_Word32 AudioDeviceWindowsWave::EnumeratePlayoutDevices() // EnumerateRecordingDevices // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::EnumerateRecordingDevices() +int32_t AudioDeviceWindowsWave::EnumerateRecordingDevices() { - WebRtc_UWord16 nDevices(RecordingDevices()); + uint16_t nDevices(RecordingDevices()); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "==============================================================="); WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "#input devices: %u", nDevices); @@ -2664,7 +2664,7 @@ void AudioDeviceWindowsWave::TraceWaveOutError(MMRESULT error) const // PrepareStartPlayout // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::PrepareStartPlayout() +int32_t AudioDeviceWindowsWave::PrepareStartPlayout() { CriticalSectionScoped lock(&_critSect); @@ -2701,7 +2701,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::PrepareStartPlayout() // PrepareStartRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::PrepareStartRecording() +int32_t AudioDeviceWindowsWave::PrepareStartRecording() { CriticalSectionScoped lock(&_critSect); @@ -2733,7 +2733,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::PrepareStartRecording() for (int n = 0; n < N_BUFFERS_IN; n++) { - const WebRtc_UWord8 nBytesPerSample = 2*_recChannels; + const uint8_t nBytesPerSample = 2*_recChannels; // set up the input wave header _waveHeaderIn[n].lpData = reinterpret_cast(&_recBuffer[n]); @@ -2776,14 +2776,14 @@ WebRtc_Word32 AudioDeviceWindowsWave::PrepareStartRecording() // GetPlayoutBufferDelay // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::GetPlayoutBufferDelay(WebRtc_UWord32& writtenSamples, WebRtc_UWord32& playedSamples) +int32_t AudioDeviceWindowsWave::GetPlayoutBufferDelay(uint32_t& writtenSamples, uint32_t& playedSamples) { int i; int ms_Header; long playedDifference; int msecInPlayoutBuffer(0); // #milliseconds of audio in the playout buffer - const WebRtc_UWord16 nSamplesPerMs = (WebRtc_UWord16)(N_PLAY_SAMPLES_PER_SEC/1000); // default is 48000/1000 = 48 + const uint16_t nSamplesPerMs = (uint16_t)(N_PLAY_SAMPLES_PER_SEC/1000); // default is 48000/1000 = 48 MMRESULT res; MMTIME mmtime; @@ -3003,13 +3003,13 @@ WebRtc_Word32 AudioDeviceWindowsWave::GetPlayoutBufferDelay(WebRtc_UWord32& writ // GetRecordingBufferDelay // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::GetRecordingBufferDelay(WebRtc_UWord32& readSamples, WebRtc_UWord32& recSamples) +int32_t AudioDeviceWindowsWave::GetRecordingBufferDelay(uint32_t& readSamples, uint32_t& recSamples) { long recDifference; MMTIME mmtime; MMRESULT mmr; - const WebRtc_UWord16 nSamplesPerMs = (WebRtc_UWord16)(N_REC_SAMPLES_PER_SEC/1000); // default is 48000/1000 = 48 + const uint16_t nSamplesPerMs = (uint16_t)(N_REC_SAMPLES_PER_SEC/1000); // default is 48000/1000 = 48 // Retrieve the current input position of the given waveform-audio input device // @@ -3121,9 +3121,9 @@ bool AudioDeviceWindowsWave::ThreadFunc(void* pThis) bool AudioDeviceWindowsWave::ThreadProcess() { - WebRtc_UWord32 time(0); - WebRtc_UWord32 playDiff(0); - WebRtc_UWord32 recDiff(0); + uint32_t time(0); + uint32_t playDiff(0); + uint32_t recDiff(0); LONGLONG playTime(0); LONGLONG recTime(0); @@ -3184,7 +3184,7 @@ bool AudioDeviceWindowsWave::ThreadProcess() } if (_playing && - (playDiff > (WebRtc_UWord32)(_dTcheckPlayBufDelay - 1)) || + (playDiff > (uint32_t)(_dTcheckPlayBufDelay - 1)) || (playDiff < 0)) { Lock(); @@ -3227,8 +3227,8 @@ bool AudioDeviceWindowsWave::ThreadProcess() Lock(); if (_recording) { - WebRtc_Word32 nRecordedBytes(0); - WebRtc_UWord16 maxIter(10); + int32_t nRecordedBytes(0); + uint16_t maxIter(10); // Deliver all availiable recorded buffers and update the CPU load measurement. // We use a while loop here to compensate for the fact that the multi-media timer @@ -3285,11 +3285,11 @@ bool AudioDeviceWindowsWave::ThreadProcess() // RecProc // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::RecProc(LONGLONG& consumedTime) +int32_t AudioDeviceWindowsWave::RecProc(LONGLONG& consumedTime) { MMRESULT res; - WebRtc_UWord32 bufCount(0); - WebRtc_UWord32 nBytesRecorded(0); + uint32_t bufCount(0); + uint32_t nBytesRecorded(0); consumedTime = 0; @@ -3302,8 +3302,8 @@ WebRtc_Word32 AudioDeviceWindowsWave::RecProc(LONGLONG& consumedTime) bufCount = _recBufCount; // take mono/stereo mode into account when deriving size of a full buffer - const WebRtc_UWord16 bytesPerSample = 2*_recChannels; - const WebRtc_UWord32 fullBufferSizeInBytes = bytesPerSample * REC_BUF_SIZE_IN_SAMPLES; + const uint16_t bytesPerSample = 2*_recChannels; + const uint32_t fullBufferSizeInBytes = bytesPerSample * REC_BUF_SIZE_IN_SAMPLES; // read number of recorded bytes for the given input-buffer nBytesRecorded = _waveHeaderIn[bufCount].dwBytesRecorded; @@ -3311,14 +3311,14 @@ WebRtc_Word32 AudioDeviceWindowsWave::RecProc(LONGLONG& consumedTime) if (nBytesRecorded == fullBufferSizeInBytes || (nBytesRecorded > 0)) { - WebRtc_Word32 msecOnPlaySide; - WebRtc_Word32 msecOnRecordSide; - WebRtc_UWord32 writtenSamples; - WebRtc_UWord32 playedSamples; - WebRtc_UWord32 readSamples, recSamples; + int32_t msecOnPlaySide; + int32_t msecOnRecordSide; + uint32_t writtenSamples; + uint32_t playedSamples; + uint32_t readSamples, recSamples; bool send = true; - WebRtc_UWord32 nSamplesRecorded = (nBytesRecorded/bytesPerSample); // divide by 2 or 4 depending on mono or stereo + uint32_t nSamplesRecorded = (nBytesRecorded/bytesPerSample); // divide by 2 or 4 depending on mono or stereo if (nBytesRecorded == fullBufferSizeInBytes) { @@ -3355,7 +3355,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::RecProc(LONGLONG& consumedTime) // If we use the alternative playout delay method, skip the clock drift compensation // since it will be an unreliable estimate and might degrade AEC performance. - WebRtc_Word32 drift = (_useHeader > 0) ? 0 : GetClockDrift(playedSamples, recSamples); + int32_t drift = (_useHeader > 0) ? 0 : GetClockDrift(playedSamples, recSamples); _ptrAudioBuffer->SetVQEData(msecOnPlaySide, msecOnRecordSide, drift); @@ -3385,7 +3385,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::RecProc(LONGLONG& consumedTime) if (_AGC) { - WebRtc_UWord32 newMicLevel = _ptrAudioBuffer->NewMicLevel(); + uint32_t newMicLevel = _ptrAudioBuffer->NewMicLevel(); if (newMicLevel != 0) { // The VQE will only deliver non-zero microphone levels when a change is needed. @@ -3474,10 +3474,10 @@ WebRtc_Word32 AudioDeviceWindowsWave::RecProc(LONGLONG& consumedTime) int AudioDeviceWindowsWave::PlayProc(LONGLONG& consumedTime) { - WebRtc_Word32 remTimeMS(0); + int32_t remTimeMS(0); int8_t playBuffer[4*PLAY_BUF_SIZE_IN_SAMPLES]; - WebRtc_UWord32 writtenSamples(0); - WebRtc_UWord32 playedSamples(0); + uint32_t writtenSamples(0); + uint32_t playedSamples(0); LARGE_INTEGER t1; LARGE_INTEGER t2; @@ -3492,7 +3492,7 @@ int AudioDeviceWindowsWave::PlayProc(LONGLONG& consumedTime) // The threshold can be adaptive or fixed. The adaptive scheme is updated // also for fixed mode but the updated threshold is not utilized. // - const WebRtc_UWord16 thresholdMS = + const uint16_t thresholdMS = (_playBufType == AudioDeviceModule::kAdaptiveBufferSize) ? _playBufDelay : _playBufDelayFixed; if (remTimeMS < thresholdMS + 9) @@ -3559,7 +3559,7 @@ int AudioDeviceWindowsWave::PlayProc(LONGLONG& consumedTime) // Ensure that this callback is executed without taking the audio-thread lock. // UnLock(); - WebRtc_UWord32 nSamples = _ptrAudioBuffer->RequestPlayoutData(PLAY_BUF_SIZE_IN_SAMPLES); + uint32_t nSamples = _ptrAudioBuffer->RequestPlayoutData(PLAY_BUF_SIZE_IN_SAMPLES); Lock(); if (OutputSanityCheckAfterUnlockedPeriod() == -1) @@ -3626,7 +3626,7 @@ int AudioDeviceWindowsWave::PlayProc(LONGLONG& consumedTime) // Write // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::Write(int8_t* data, WebRtc_UWord16 nSamples) +int32_t AudioDeviceWindowsWave::Write(int8_t* data, uint16_t nSamples) { if (_hWaveOut == NULL) { @@ -3637,11 +3637,11 @@ WebRtc_Word32 AudioDeviceWindowsWave::Write(int8_t* data, WebRtc_UWord16 nSample { MMRESULT res; - const WebRtc_UWord16 bufCount(_playBufCount); + const uint16_t bufCount(_playBufCount); // Place data in the memory associated with _waveHeaderOut[bufCount] // - const WebRtc_Word16 nBytes = (2*_playChannels)*nSamples; + const int16_t nBytes = (2*_playChannels)*nSamples; memcpy(&_playBuffer[bufCount][0], &data[0], nBytes); // Send a data block to the given waveform-audio output device. @@ -3684,7 +3684,7 @@ WebRtc_Word32 AudioDeviceWindowsWave::Write(int8_t* data, WebRtc_UWord16 nSample // GetClockDrift // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::GetClockDrift(const WebRtc_UWord32 plSamp, const WebRtc_UWord32 rcSamp) +int32_t AudioDeviceWindowsWave::GetClockDrift(const uint32_t plSamp, const uint32_t rcSamp) { int drift = 0; unsigned int plSampDiff = 0, rcSampDiff = 0; @@ -3733,10 +3733,10 @@ WebRtc_Word32 AudioDeviceWindowsWave::GetClockDrift(const WebRtc_UWord32 plSamp, // MonitorRecording // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::MonitorRecording(const WebRtc_UWord32 time) +int32_t AudioDeviceWindowsWave::MonitorRecording(const uint32_t time) { - const WebRtc_UWord16 bytesPerSample = 2*_recChannels; - const WebRtc_UWord32 nRecordedSamples = _recordedBytes/bytesPerSample; + const uint16_t bytesPerSample = 2*_recChannels; + const uint32_t nRecordedSamples = _recordedBytes/bytesPerSample; if (nRecordedSamples > 5*N_REC_SAMPLES_PER_SEC) { @@ -3785,9 +3785,9 @@ WebRtc_Word32 AudioDeviceWindowsWave::MonitorRecording(const WebRtc_UWord32 time // Restart timer if needed (they seem to be messed up after a hibernate). // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioDeviceWindowsWave::RestartTimerIfNeeded(const WebRtc_UWord32 time) +int32_t AudioDeviceWindowsWave::RestartTimerIfNeeded(const uint32_t time) { - const WebRtc_UWord32 diffMS = time - _prevTimerCheckTime; + const uint32_t diffMS = time - _prevTimerCheckTime; _prevTimerCheckTime = time; if (diffMS > 7) diff --git a/webrtc/modules/audio_device/win/audio_device_wave_win.h b/webrtc/modules/audio_device/win/audio_device_wave_win.h index 7837bc63de..665f4712d4 100644 --- a/webrtc/modules/audio_device/win/audio_device_wave_win.h +++ b/webrtc/modules/audio_device/win/audio_device_wave_win.h @@ -20,19 +20,19 @@ namespace webrtc { class EventWrapper; class ThreadWrapper; -const WebRtc_UWord32 TIMER_PERIOD_MS = 2; -const WebRtc_UWord32 REC_CHECK_TIME_PERIOD_MS = 4; -const WebRtc_UWord16 REC_PUT_BACK_DELAY = 4; +const uint32_t TIMER_PERIOD_MS = 2; +const uint32_t REC_CHECK_TIME_PERIOD_MS = 4; +const uint16_t REC_PUT_BACK_DELAY = 4; -const WebRtc_UWord32 N_REC_SAMPLES_PER_SEC = 48000; -const WebRtc_UWord32 N_PLAY_SAMPLES_PER_SEC = 48000; +const uint32_t N_REC_SAMPLES_PER_SEC = 48000; +const uint32_t N_PLAY_SAMPLES_PER_SEC = 48000; -const WebRtc_UWord32 N_REC_CHANNELS = 1; // default is mono recording -const WebRtc_UWord32 N_PLAY_CHANNELS = 2; // default is stereo playout +const uint32_t N_REC_CHANNELS = 1; // default is mono recording +const uint32_t N_PLAY_CHANNELS = 2; // default is stereo playout // NOTE - CPU load will not be correct for other sizes than 10ms -const WebRtc_UWord32 REC_BUF_SIZE_IN_SAMPLES = (N_REC_SAMPLES_PER_SEC/100); -const WebRtc_UWord32 PLAY_BUF_SIZE_IN_SAMPLES = (N_PLAY_SAMPLES_PER_SEC/100); +const uint32_t REC_BUF_SIZE_IN_SAMPLES = (N_REC_SAMPLES_PER_SEC/100); +const uint32_t PLAY_BUF_SIZE_IN_SAMPLES = (N_PLAY_SAMPLES_PER_SEC/100); enum { N_BUFFERS_IN = 200 }; enum { N_BUFFERS_OUT = 200 }; @@ -40,114 +40,114 @@ enum { N_BUFFERS_OUT = 200 }; class AudioDeviceWindowsWave : public AudioDeviceGeneric { public: - AudioDeviceWindowsWave(const WebRtc_Word32 id); + AudioDeviceWindowsWave(const int32_t id); ~AudioDeviceWindowsWave(); // Retrieve the currently utilized audio layer - virtual WebRtc_Word32 ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const; + virtual int32_t ActiveAudioLayer(AudioDeviceModule::AudioLayer& audioLayer) const; // Main initializaton and termination - virtual WebRtc_Word32 Init(); - virtual WebRtc_Word32 Terminate(); + virtual int32_t Init(); + virtual int32_t Terminate(); virtual bool Initialized() const; // Device enumeration - virtual WebRtc_Word16 PlayoutDevices(); - virtual WebRtc_Word16 RecordingDevices(); - virtual WebRtc_Word32 PlayoutDeviceName( - WebRtc_UWord16 index, + virtual int16_t PlayoutDevices(); + virtual int16_t RecordingDevices(); + virtual int32_t PlayoutDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); - virtual WebRtc_Word32 RecordingDeviceName( - WebRtc_UWord16 index, + virtual int32_t RecordingDeviceName( + uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]); // Device selection - virtual WebRtc_Word32 SetPlayoutDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType device); - virtual WebRtc_Word32 SetRecordingDevice(WebRtc_UWord16 index); - virtual WebRtc_Word32 SetRecordingDevice(AudioDeviceModule::WindowsDeviceType device); + virtual int32_t SetPlayoutDevice(uint16_t index); + virtual int32_t SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType device); + virtual int32_t SetRecordingDevice(uint16_t index); + virtual int32_t SetRecordingDevice(AudioDeviceModule::WindowsDeviceType device); // Audio transport initialization - virtual WebRtc_Word32 PlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 InitPlayout(); + virtual int32_t PlayoutIsAvailable(bool& available); + virtual int32_t InitPlayout(); virtual bool PlayoutIsInitialized() const; - virtual WebRtc_Word32 RecordingIsAvailable(bool& available); - virtual WebRtc_Word32 InitRecording(); + virtual int32_t RecordingIsAvailable(bool& available); + virtual int32_t InitRecording(); virtual bool RecordingIsInitialized() const; // Audio transport control - virtual WebRtc_Word32 StartPlayout(); - virtual WebRtc_Word32 StopPlayout(); + virtual int32_t StartPlayout(); + virtual int32_t StopPlayout(); virtual bool Playing() const; - virtual WebRtc_Word32 StartRecording(); - virtual WebRtc_Word32 StopRecording(); + virtual int32_t StartRecording(); + virtual int32_t StopRecording(); virtual bool Recording() const; // Microphone Automatic Gain Control (AGC) - virtual WebRtc_Word32 SetAGC(bool enable); + virtual int32_t SetAGC(bool enable); virtual bool AGC() const; // Volume control based on the Windows Wave API (Windows only) - virtual WebRtc_Word32 SetWaveOutVolume(WebRtc_UWord16 volumeLeft, WebRtc_UWord16 volumeRight); - virtual WebRtc_Word32 WaveOutVolume(WebRtc_UWord16& volumeLeft, WebRtc_UWord16& volumeRight) const; + virtual int32_t SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight); + virtual int32_t WaveOutVolume(uint16_t& volumeLeft, uint16_t& volumeRight) const; // Audio mixer initialization - virtual WebRtc_Word32 SpeakerIsAvailable(bool& available); - virtual WebRtc_Word32 InitSpeaker(); + virtual int32_t SpeakerIsAvailable(bool& available); + virtual int32_t InitSpeaker(); virtual bool SpeakerIsInitialized() const; - virtual WebRtc_Word32 MicrophoneIsAvailable(bool& available); - virtual WebRtc_Word32 InitMicrophone(); + virtual int32_t MicrophoneIsAvailable(bool& available); + virtual int32_t InitMicrophone(); virtual bool MicrophoneIsInitialized() const; // Speaker volume controls - virtual WebRtc_Word32 SpeakerVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 SpeakerVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const; + virtual int32_t SpeakerVolumeIsAvailable(bool& available); + virtual int32_t SetSpeakerVolume(uint32_t volume); + virtual int32_t SpeakerVolume(uint32_t& volume) const; + virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const; + virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const; + virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const; // Microphone volume controls - virtual WebRtc_Word32 MicrophoneVolumeIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume); - virtual WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32& volume) const; - virtual WebRtc_Word32 MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const; - virtual WebRtc_Word32 MinMicrophoneVolume(WebRtc_UWord32& minVolume) const; - virtual WebRtc_Word32 MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const; + virtual int32_t MicrophoneVolumeIsAvailable(bool& available); + virtual int32_t SetMicrophoneVolume(uint32_t volume); + virtual int32_t MicrophoneVolume(uint32_t& volume) const; + virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const; + virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const; + virtual int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const; // Speaker mute control - virtual WebRtc_Word32 SpeakerMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetSpeakerMute(bool enable); - virtual WebRtc_Word32 SpeakerMute(bool& enabled) const; + virtual int32_t SpeakerMuteIsAvailable(bool& available); + virtual int32_t SetSpeakerMute(bool enable); + virtual int32_t SpeakerMute(bool& enabled) const; // Microphone mute control - virtual WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneMute(bool enable); - virtual WebRtc_Word32 MicrophoneMute(bool& enabled) const; + virtual int32_t MicrophoneMuteIsAvailable(bool& available); + virtual int32_t SetMicrophoneMute(bool enable); + virtual int32_t MicrophoneMute(bool& enabled) const; // Microphone boost control - virtual WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available); - virtual WebRtc_Word32 SetMicrophoneBoost(bool enable); - virtual WebRtc_Word32 MicrophoneBoost(bool& enabled) const; + virtual int32_t MicrophoneBoostIsAvailable(bool& available); + virtual int32_t SetMicrophoneBoost(bool enable); + virtual int32_t MicrophoneBoost(bool& enabled) const; // Stereo support - virtual WebRtc_Word32 StereoPlayoutIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoPlayout(bool enable); - virtual WebRtc_Word32 StereoPlayout(bool& enabled) const; - virtual WebRtc_Word32 StereoRecordingIsAvailable(bool& available); - virtual WebRtc_Word32 SetStereoRecording(bool enable); - virtual WebRtc_Word32 StereoRecording(bool& enabled) const; + virtual int32_t StereoPlayoutIsAvailable(bool& available); + virtual int32_t SetStereoPlayout(bool enable); + virtual int32_t StereoPlayout(bool& enabled) const; + virtual int32_t StereoRecordingIsAvailable(bool& available); + virtual int32_t SetStereoRecording(bool enable); + virtual int32_t StereoRecording(bool& enabled) const; // Delay information and control - virtual WebRtc_Word32 SetPlayoutBuffer(const AudioDeviceModule::BufferType type, WebRtc_UWord16 sizeMS); - virtual WebRtc_Word32 PlayoutBuffer(AudioDeviceModule::BufferType& type, WebRtc_UWord16& sizeMS) const; - virtual WebRtc_Word32 PlayoutDelay(WebRtc_UWord16& delayMS) const; - virtual WebRtc_Word32 RecordingDelay(WebRtc_UWord16& delayMS) const; + virtual int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type, uint16_t sizeMS); + virtual int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type, uint16_t& sizeMS) const; + virtual int32_t PlayoutDelay(uint16_t& delayMS) const; + virtual int32_t RecordingDelay(uint16_t& delayMS) const; // CPU load - virtual WebRtc_Word32 CPULoad(WebRtc_UWord16& load) const; + virtual int32_t CPULoad(uint16_t& load) const; public: virtual bool PlayoutWarning() const; @@ -165,36 +165,36 @@ public: private: void Lock() { _critSect.Enter(); }; void UnLock() { _critSect.Leave(); }; - WebRtc_Word32 Id() {return _id;} + int32_t Id() {return _id;} bool IsUsingOutputDeviceIndex() const {return _usingOutputDeviceIndex;} AudioDeviceModule::WindowsDeviceType OutputDevice() const {return _outputDevice;} - WebRtc_UWord16 OutputDeviceIndex() const {return _outputDeviceIndex;} + uint16_t OutputDeviceIndex() const {return _outputDeviceIndex;} bool IsUsingInputDeviceIndex() const {return _usingInputDeviceIndex;} AudioDeviceModule::WindowsDeviceType InputDevice() const {return _inputDevice;} - WebRtc_UWord16 InputDeviceIndex() const {return _inputDeviceIndex;} + uint16_t InputDeviceIndex() const {return _inputDeviceIndex;} private: - inline WebRtc_Word32 InputSanityCheckAfterUnlockedPeriod() const; - inline WebRtc_Word32 OutputSanityCheckAfterUnlockedPeriod() const; + inline int32_t InputSanityCheckAfterUnlockedPeriod() const; + inline int32_t OutputSanityCheckAfterUnlockedPeriod() const; private: - WebRtc_Word32 EnumeratePlayoutDevices(); - WebRtc_Word32 EnumerateRecordingDevices(); + int32_t EnumeratePlayoutDevices(); + int32_t EnumerateRecordingDevices(); void TraceSupportFlags(DWORD dwSupport) const; void TraceWaveInError(MMRESULT error) const; void TraceWaveOutError(MMRESULT error) const; - WebRtc_Word32 PrepareStartRecording(); - WebRtc_Word32 PrepareStartPlayout(); + int32_t PrepareStartRecording(); + int32_t PrepareStartPlayout(); - WebRtc_Word32 RecProc(LONGLONG& consumedTime); + int32_t RecProc(LONGLONG& consumedTime); int PlayProc(LONGLONG& consumedTime); - WebRtc_Word32 GetPlayoutBufferDelay(WebRtc_UWord32& writtenSamples, WebRtc_UWord32& playedSamples); - WebRtc_Word32 GetRecordingBufferDelay(WebRtc_UWord32& readSamples, WebRtc_UWord32& recSamples); - WebRtc_Word32 Write(int8_t* data, WebRtc_UWord16 nSamples); - WebRtc_Word32 GetClockDrift(const WebRtc_UWord32 plSamp, const WebRtc_UWord32 rcSamp); - WebRtc_Word32 MonitorRecording(const WebRtc_UWord32 time); - WebRtc_Word32 RestartTimerIfNeeded(const WebRtc_UWord32 time); + int32_t GetPlayoutBufferDelay(uint32_t& writtenSamples, uint32_t& playedSamples); + int32_t GetRecordingBufferDelay(uint32_t& readSamples, uint32_t& recSamples); + int32_t Write(int8_t* data, uint16_t nSamples); + int32_t GetClockDrift(const uint32_t plSamp, const uint32_t rcSamp); + int32_t MonitorRecording(const uint32_t time); + int32_t RestartTimerIfNeeded(const uint32_t time); private: static bool ThreadFunc(void*); @@ -221,11 +221,11 @@ private: HANDLE _hSetCaptureVolumeEvent; ThreadWrapper* _ptrThread; - WebRtc_UWord32 _threadID; + uint32_t _threadID; CriticalSectionWrapper& _critSectCb; - WebRtc_Word32 _id; + int32_t _id; AudioMixerManager _mixerManager; @@ -233,8 +233,8 @@ private: bool _usingOutputDeviceIndex; AudioDeviceModule::WindowsDeviceType _inputDevice; AudioDeviceModule::WindowsDeviceType _outputDevice; - WebRtc_UWord16 _inputDeviceIndex; - WebRtc_UWord16 _outputDeviceIndex; + uint16_t _inputDeviceIndex; + uint16_t _outputDeviceIndex; bool _inputDeviceIsSpecified; bool _outputDeviceIsSpecified; @@ -247,14 +247,14 @@ private: WAVEHDR _waveHeaderIn[N_BUFFERS_IN]; WAVEHDR _waveHeaderOut[N_BUFFERS_OUT]; - WebRtc_UWord8 _recChannels; - WebRtc_UWord8 _playChannels; - WebRtc_UWord16 _recBufCount; - WebRtc_UWord16 _recDelayCount; - WebRtc_UWord16 _recPutBackDelay; + uint8_t _recChannels; + uint8_t _playChannels; + uint16_t _recBufCount; + uint16_t _recDelayCount; + uint16_t _recPutBackDelay; - int8_t _recBuffer[N_BUFFERS_IN][4*REC_BUF_SIZE_IN_SAMPLES]; - int8_t _playBuffer[N_BUFFERS_OUT][4*PLAY_BUF_SIZE_IN_SAMPLES]; + int8_t _recBuffer[N_BUFFERS_IN][4*REC_BUF_SIZE_IN_SAMPLES]; + int8_t _playBuffer[N_BUFFERS_OUT][4*PLAY_BUF_SIZE_IN_SAMPLES]; AudioDeviceModule::BufferType _playBufType; @@ -271,67 +271,67 @@ private: bool _AGC; private: - WebRtc_UWord32 _prevPlayTime; - WebRtc_UWord32 _prevRecTime; - WebRtc_UWord32 _prevTimerCheckTime; + uint32_t _prevPlayTime; + uint32_t _prevRecTime; + uint32_t _prevTimerCheckTime; - WebRtc_UWord16 _playBufCount; // playout buffer index - WebRtc_UWord16 _dTcheckPlayBufDelay; // dT for check of play buffer, {2,5,10} [ms] - WebRtc_UWord16 _playBufDelay; // playback delay - WebRtc_UWord16 _playBufDelayFixed; // fixed playback delay - WebRtc_UWord16 _minPlayBufDelay; // minimum playback delay - WebRtc_UWord16 _MAX_minBuffer; // level of (adaptive) min threshold must be < _MAX_minBuffer + uint16_t _playBufCount; // playout buffer index + uint16_t _dTcheckPlayBufDelay; // dT for check of play buffer, {2,5,10} [ms] + uint16_t _playBufDelay; // playback delay + uint16_t _playBufDelayFixed; // fixed playback delay + uint16_t _minPlayBufDelay; // minimum playback delay + uint16_t _MAX_minBuffer; // level of (adaptive) min threshold must be < _MAX_minBuffer - WebRtc_Word32 _erZeroCounter; // counts "buffer-is-empty" events - WebRtc_Word32 _intro; - WebRtc_Word32 _waitCounter; + int32_t _erZeroCounter; // counts "buffer-is-empty" events + int32_t _intro; + int32_t _waitCounter; - WebRtc_UWord32 _writtenSamples; - WebRtc_UWord32 _writtenSamplesOld; - WebRtc_UWord32 _playedSamplesOld; + uint32_t _writtenSamples; + uint32_t _writtenSamplesOld; + uint32_t _playedSamplesOld; - WebRtc_UWord32 _sndCardPlayDelay; - WebRtc_UWord32 _sndCardRecDelay; + uint32_t _sndCardPlayDelay; + uint32_t _sndCardRecDelay; - WebRtc_UWord32 _plSampOld; - WebRtc_UWord32 _rcSampOld; + uint32_t _plSampOld; + uint32_t _rcSampOld; - WebRtc_UWord32 _read_samples; - WebRtc_UWord32 _read_samples_old; - WebRtc_UWord32 _rec_samples_old; + uint32_t _read_samples; + uint32_t _read_samples_old; + uint32_t _rec_samples_old; // State that detects driver problems: - WebRtc_Word32 _dc_diff_mean; - WebRtc_Word32 _dc_y_prev; - WebRtc_Word32 _dc_penalty_counter; - WebRtc_Word32 _dc_prevtime; - WebRtc_UWord32 _dc_prevplay; + int32_t _dc_diff_mean; + int32_t _dc_y_prev; + int32_t _dc_penalty_counter; + int32_t _dc_prevtime; + uint32_t _dc_prevplay; - WebRtc_UWord32 _recordedBytes; // accumulated #recorded bytes (reset periodically) - WebRtc_UWord32 _prevRecByteCheckTime; // time when we last checked the recording process + uint32_t _recordedBytes; // accumulated #recorded bytes (reset periodically) + uint32_t _prevRecByteCheckTime; // time when we last checked the recording process // CPU load measurements LARGE_INTEGER _perfFreq; LONGLONG _playAcc; // accumulated time for playout callback float _avgCPULoad; // average total (rec+play) CPU load - WebRtc_Word32 _wrapCounter; + int32_t _wrapCounter; - WebRtc_Word32 _useHeader; - WebRtc_Word16 _timesdwBytes; - WebRtc_Word32 _no_of_msecleft_warnings; - WebRtc_Word32 _writeErrors; - WebRtc_Word32 _timerFaults; - WebRtc_Word32 _timerRestartAttempts; + int32_t _useHeader; + int16_t _timesdwBytes; + int32_t _no_of_msecleft_warnings; + int32_t _writeErrors; + int32_t _timerFaults; + int32_t _timerRestartAttempts; - WebRtc_UWord16 _playWarning; - WebRtc_UWord16 _playError; - WebRtc_UWord16 _recWarning; - WebRtc_UWord16 _recError; + uint16_t _playWarning; + uint16_t _playError; + uint16_t _recWarning; + uint16_t _recError; - WebRtc_UWord32 _newMicLevel; - WebRtc_UWord32 _minMicVolume; - WebRtc_UWord32 _maxMicVolume; + uint32_t _newMicLevel; + uint32_t _minMicVolume; + uint32_t _maxMicVolume; }; } // namespace webrtc diff --git a/webrtc/modules/audio_device/win/audio_mixer_manager_win.cc b/webrtc/modules/audio_device/win/audio_mixer_manager_win.cc index a1dbcb5c3c..0c4b01e446 100644 --- a/webrtc/modules/audio_device/win/audio_mixer_manager_win.cc +++ b/webrtc/modules/audio_device/win/audio_mixer_manager_win.cc @@ -31,7 +31,7 @@ namespace webrtc { // CONSTRUCTION/DESTRUCTION // ============================================================================ -AudioMixerManager::AudioMixerManager(const WebRtc_Word32 id) : +AudioMixerManager::AudioMixerManager(const int32_t id) : _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _id(id), _inputMixerHandle(NULL), @@ -59,7 +59,7 @@ AudioMixerManager::~AudioMixerManager() // Close // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::Close() +int32_t AudioMixerManager::Close() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -83,7 +83,7 @@ WebRtc_Word32 AudioMixerManager::Close() // CloseSpeaker // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::CloseSpeaker() +int32_t AudioMixerManager::CloseSpeaker() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -106,7 +106,7 @@ WebRtc_Word32 AudioMixerManager::CloseSpeaker() // CloseMicrophone // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::CloseMicrophone() +int32_t AudioMixerManager::CloseMicrophone() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -129,7 +129,7 @@ WebRtc_Word32 AudioMixerManager::CloseMicrophone() // EnumerateAll // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::EnumerateAll() +int32_t AudioMixerManager::EnumerateAll() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -170,7 +170,7 @@ WebRtc_Word32 AudioMixerManager::EnumerateAll() // EnumerateSpeakers // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::EnumerateSpeakers() +int32_t AudioMixerManager::EnumerateSpeakers() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -254,7 +254,7 @@ WebRtc_Word32 AudioMixerManager::EnumerateSpeakers() // EnumerateMicrophones // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::EnumerateMicrophones() +int32_t AudioMixerManager::EnumerateMicrophones() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -565,7 +565,7 @@ WebRtc_Word32 AudioMixerManager::EnumerateMicrophones() // Avoids opening the mixer if valid control has not been found. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::OpenSpeaker(AudioDeviceModule::WindowsDeviceType device) +int32_t AudioMixerManager::OpenSpeaker(AudioDeviceModule::WindowsDeviceType device) { if (device == AudioDeviceModule::kDefaultDevice) { @@ -691,7 +691,7 @@ WebRtc_Word32 AudioMixerManager::OpenSpeaker(AudioDeviceModule::WindowsDeviceTyp // Avoids opening the mixer if valid control has not been found. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::OpenSpeaker(WebRtc_UWord16 index) +int32_t AudioMixerManager::OpenSpeaker(uint16_t index) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::OpenSpeaker(index=%d)", index); @@ -787,7 +787,7 @@ WebRtc_Word32 AudioMixerManager::OpenSpeaker(WebRtc_UWord16 index) // Avoids opening the mixer if valid control has not been found. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::OpenMicrophone(AudioDeviceModule::WindowsDeviceType device) +int32_t AudioMixerManager::OpenMicrophone(AudioDeviceModule::WindowsDeviceType device) { if (device == AudioDeviceModule::kDefaultDevice) { @@ -913,7 +913,7 @@ WebRtc_Word32 AudioMixerManager::OpenMicrophone(AudioDeviceModule::WindowsDevice // Avoids opening the mixer if valid control has not been found. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::OpenMicrophone(WebRtc_UWord16 index) +int32_t AudioMixerManager::OpenMicrophone(uint16_t index) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::OpenMicrophone(index=%d)", index); @@ -1028,7 +1028,7 @@ bool AudioMixerManager::MicrophoneIsInitialized() const // SetSpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::SetSpeakerVolume(WebRtc_UWord32 volume) +int32_t AudioMixerManager::SetSpeakerVolume(uint32_t volume) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::SetSpeakerVolume(volume=%u)", volume); @@ -1061,7 +1061,7 @@ WebRtc_Word32 AudioMixerManager::SetSpeakerVolume(WebRtc_UWord32 volume) // always equals MIXERCONTROL_CT_UNITS_UNSIGNED; // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::SpeakerVolume(WebRtc_UWord32& volume) const +int32_t AudioMixerManager::SpeakerVolume(uint32_t& volume) const { if (_outputMixerHandle == NULL) @@ -1093,7 +1093,7 @@ WebRtc_Word32 AudioMixerManager::SpeakerVolume(WebRtc_UWord32& volume) const // always equals MIXERCONTROL_CT_UNITS_UNSIGNED // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const +int32_t AudioMixerManager::MaxSpeakerVolume(uint32_t& maxVolume) const { if (_outputMixerHandle == NULL) @@ -1122,7 +1122,7 @@ WebRtc_Word32 AudioMixerManager::MaxSpeakerVolume(WebRtc_UWord32& maxVolume) con // MinSpeakerVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::MinSpeakerVolume(WebRtc_UWord32& minVolume) const +int32_t AudioMixerManager::MinSpeakerVolume(uint32_t& minVolume) const { if (_outputMixerHandle == NULL) @@ -1151,7 +1151,7 @@ WebRtc_Word32 AudioMixerManager::MinSpeakerVolume(WebRtc_UWord32& minVolume) con // SpeakerVolumeStepSize // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const +int32_t AudioMixerManager::SpeakerVolumeStepSize(uint16_t& stepSize) const { if (_outputMixerHandle == NULL) @@ -1170,7 +1170,7 @@ WebRtc_Word32 AudioMixerManager::SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) return -1; } - stepSize = static_cast (mixerControl.Metrics.cSteps); + stepSize = static_cast (mixerControl.Metrics.cSteps); return 0; } @@ -1179,7 +1179,7 @@ WebRtc_Word32 AudioMixerManager::SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) // SpeakerVolumeIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::SpeakerVolumeIsAvailable(bool& available) +int32_t AudioMixerManager::SpeakerVolumeIsAvailable(bool& available) { if (_outputMixerHandle == NULL) { @@ -1196,7 +1196,7 @@ WebRtc_Word32 AudioMixerManager::SpeakerVolumeIsAvailable(bool& available) // SpeakerMuteIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::SpeakerMuteIsAvailable(bool& available) +int32_t AudioMixerManager::SpeakerMuteIsAvailable(bool& available) { if (_outputMixerHandle == NULL) { @@ -1215,7 +1215,7 @@ WebRtc_Word32 AudioMixerManager::SpeakerMuteIsAvailable(bool& available) // This mute function works a master mute for the output speaker. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::SetSpeakerMute(bool enable) +int32_t AudioMixerManager::SetSpeakerMute(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::SetSpeakerMute(enable=%u)", enable); @@ -1253,7 +1253,7 @@ WebRtc_Word32 AudioMixerManager::SetSpeakerMute(bool enable) // SpeakerMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::SpeakerMute(bool& enabled) const +int32_t AudioMixerManager::SpeakerMute(bool& enabled) const { if (_outputMixerHandle == NULL) @@ -1291,7 +1291,7 @@ WebRtc_Word32 AudioMixerManager::SpeakerMute(bool& enabled) const // MicrophoneMuteIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::MicrophoneMuteIsAvailable(bool& available) +int32_t AudioMixerManager::MicrophoneMuteIsAvailable(bool& available) { if (_inputMixerHandle == NULL) { @@ -1310,7 +1310,7 @@ WebRtc_Word32 AudioMixerManager::MicrophoneMuteIsAvailable(bool& available) // This mute function works a master mute for the input microphone. // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::SetMicrophoneMute(bool enable) +int32_t AudioMixerManager::SetMicrophoneMute(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::SetMicrophoneMute(enable=%u)", enable); @@ -1348,7 +1348,7 @@ WebRtc_Word32 AudioMixerManager::SetMicrophoneMute(bool enable) // MicrophoneMute // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::MicrophoneMute(bool& enabled) const +int32_t AudioMixerManager::MicrophoneMute(bool& enabled) const { if (_inputMixerHandle == NULL) @@ -1386,7 +1386,7 @@ WebRtc_Word32 AudioMixerManager::MicrophoneMute(bool& enabled) const // MicrophoneBoostIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::MicrophoneBoostIsAvailable(bool& available) +int32_t AudioMixerManager::MicrophoneBoostIsAvailable(bool& available) { if (_inputMixerHandle == NULL) { @@ -1403,7 +1403,7 @@ WebRtc_Word32 AudioMixerManager::MicrophoneBoostIsAvailable(bool& available) // SetMicrophoneBoost // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::SetMicrophoneBoost(bool enable) +int32_t AudioMixerManager::SetMicrophoneBoost(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::SetMicrophoneBoost(enable=%u)", enable); @@ -1441,7 +1441,7 @@ WebRtc_Word32 AudioMixerManager::SetMicrophoneBoost(bool enable) // MicrophoneBoost // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::MicrophoneBoost(bool& enabled) const +int32_t AudioMixerManager::MicrophoneBoost(bool& enabled) const { if (_inputMixerHandle == NULL) @@ -1479,7 +1479,7 @@ WebRtc_Word32 AudioMixerManager::MicrophoneBoost(bool& enabled) const // MicrophoneVolumeIsAvailable // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::MicrophoneVolumeIsAvailable(bool& available) +int32_t AudioMixerManager::MicrophoneVolumeIsAvailable(bool& available) { if (_inputMixerHandle == NULL) { @@ -1496,7 +1496,7 @@ WebRtc_Word32 AudioMixerManager::MicrophoneVolumeIsAvailable(bool& available) // SetMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::SetMicrophoneVolume(WebRtc_UWord32 volume) +int32_t AudioMixerManager::SetMicrophoneVolume(uint32_t volume) { CriticalSectionScoped lock(&_critSect); @@ -1524,7 +1524,7 @@ WebRtc_Word32 AudioMixerManager::SetMicrophoneVolume(WebRtc_UWord32 volume) // MicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::MicrophoneVolume(WebRtc_UWord32& volume) const +int32_t AudioMixerManager::MicrophoneVolume(uint32_t& volume) const { CriticalSectionScoped lock(&_critSect); @@ -1554,7 +1554,7 @@ WebRtc_Word32 AudioMixerManager::MicrophoneVolume(WebRtc_UWord32& volume) const // MaxMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const +int32_t AudioMixerManager::MaxMicrophoneVolume(uint32_t& maxVolume) const { WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "%s", __FUNCTION__); @@ -1584,7 +1584,7 @@ WebRtc_Word32 AudioMixerManager::MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) // MinMicrophoneVolume // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::MinMicrophoneVolume(WebRtc_UWord32& minVolume) const +int32_t AudioMixerManager::MinMicrophoneVolume(uint32_t& minVolume) const { if (_inputMixerHandle == NULL) @@ -1613,7 +1613,7 @@ WebRtc_Word32 AudioMixerManager::MinMicrophoneVolume(WebRtc_UWord32& minVolume) // MicrophoneVolumeStepSize // ---------------------------------------------------------------------------- -WebRtc_Word32 AudioMixerManager::MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const +int32_t AudioMixerManager::MicrophoneVolumeStepSize(uint16_t& stepSize) const { if (_inputMixerHandle == NULL) @@ -1633,7 +1633,7 @@ WebRtc_Word32 AudioMixerManager::MicrophoneVolumeStepSize(WebRtc_UWord16& stepSi return -1; } - stepSize = static_cast (mixerControl.Metrics.cSteps); + stepSize = static_cast (mixerControl.Metrics.cSteps); return 0; } diff --git a/webrtc/modules/audio_device/win/audio_mixer_manager_win.h b/webrtc/modules/audio_device/win/audio_mixer_manager_win.h index da9de47d09..fc507c4c08 100644 --- a/webrtc/modules/audio_device/win/audio_mixer_manager_win.h +++ b/webrtc/modules/audio_device/win/audio_mixer_manager_win.h @@ -46,37 +46,37 @@ public: bool onOffControlIsValid; }; public: - WebRtc_Word32 EnumerateAll(); - WebRtc_Word32 EnumerateSpeakers(); - WebRtc_Word32 EnumerateMicrophones(); - WebRtc_Word32 OpenSpeaker(AudioDeviceModule::WindowsDeviceType device); - WebRtc_Word32 OpenSpeaker(WebRtc_UWord16 index); - WebRtc_Word32 OpenMicrophone(AudioDeviceModule::WindowsDeviceType device); - WebRtc_Word32 OpenMicrophone(WebRtc_UWord16 index); - WebRtc_Word32 SetSpeakerVolume(WebRtc_UWord32 volume); - WebRtc_Word32 SpeakerVolume(WebRtc_UWord32& volume) const; - WebRtc_Word32 MaxSpeakerVolume(WebRtc_UWord32& maxVolume) const; - WebRtc_Word32 MinSpeakerVolume(WebRtc_UWord32& minVolume) const; - WebRtc_Word32 SpeakerVolumeStepSize(WebRtc_UWord16& stepSize) const; - WebRtc_Word32 SpeakerVolumeIsAvailable(bool& available); - WebRtc_Word32 SpeakerMuteIsAvailable(bool& available); - WebRtc_Word32 SetSpeakerMute(bool enable); - WebRtc_Word32 SpeakerMute(bool& enabled) const; - WebRtc_Word32 MicrophoneMuteIsAvailable(bool& available); - WebRtc_Word32 SetMicrophoneMute(bool enable); - WebRtc_Word32 MicrophoneMute(bool& enabled) const; - WebRtc_Word32 MicrophoneBoostIsAvailable(bool& available); - WebRtc_Word32 SetMicrophoneBoost(bool enable); - WebRtc_Word32 MicrophoneBoost(bool& enabled) const; - WebRtc_Word32 MicrophoneVolumeIsAvailable(bool& available); - WebRtc_Word32 SetMicrophoneVolume(WebRtc_UWord32 volume); - WebRtc_Word32 MicrophoneVolume(WebRtc_UWord32& volume) const; - WebRtc_Word32 MaxMicrophoneVolume(WebRtc_UWord32& maxVolume) const; - WebRtc_Word32 MinMicrophoneVolume(WebRtc_UWord32& minVolume) const; - WebRtc_Word32 MicrophoneVolumeStepSize(WebRtc_UWord16& stepSize) const; - WebRtc_Word32 Close(); - WebRtc_Word32 CloseSpeaker(); - WebRtc_Word32 CloseMicrophone(); + int32_t EnumerateAll(); + int32_t EnumerateSpeakers(); + int32_t EnumerateMicrophones(); + int32_t OpenSpeaker(AudioDeviceModule::WindowsDeviceType device); + int32_t OpenSpeaker(uint16_t index); + int32_t OpenMicrophone(AudioDeviceModule::WindowsDeviceType device); + int32_t OpenMicrophone(uint16_t index); + int32_t SetSpeakerVolume(uint32_t volume); + int32_t SpeakerVolume(uint32_t& volume) const; + int32_t MaxSpeakerVolume(uint32_t& maxVolume) const; + int32_t MinSpeakerVolume(uint32_t& minVolume) const; + int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const; + int32_t SpeakerVolumeIsAvailable(bool& available); + int32_t SpeakerMuteIsAvailable(bool& available); + int32_t SetSpeakerMute(bool enable); + int32_t SpeakerMute(bool& enabled) const; + int32_t MicrophoneMuteIsAvailable(bool& available); + int32_t SetMicrophoneMute(bool enable); + int32_t MicrophoneMute(bool& enabled) const; + int32_t MicrophoneBoostIsAvailable(bool& available); + int32_t SetMicrophoneBoost(bool enable); + int32_t MicrophoneBoost(bool& enabled) const; + int32_t MicrophoneVolumeIsAvailable(bool& available); + int32_t SetMicrophoneVolume(uint32_t volume); + int32_t MicrophoneVolume(uint32_t& volume) const; + int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const; + int32_t MinMicrophoneVolume(uint32_t& minVolume) const; + int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const; + int32_t Close(); + int32_t CloseSpeaker(); + int32_t CloseMicrophone(); bool SpeakerIsInitialized() const; bool MicrophoneIsInitialized() const; UINT Devices() const; @@ -119,12 +119,12 @@ private: char* WideToUTF8(const TCHAR* src) const; public: - AudioMixerManager(const WebRtc_Word32 id); + AudioMixerManager(const int32_t id); ~AudioMixerManager(); private: CriticalSectionWrapper& _critSect; - WebRtc_Word32 _id; + int32_t _id; HMIXER _outputMixerHandle; UINT _outputMixerID; HMIXER _inputMixerHandle;