• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
12 #include "webrtc/modules/audio_device/audio_device_config.h"
13 #include "webrtc/modules/audio_device/audio_device_impl.h"
14 #include "webrtc/system_wrappers/interface/ref_count.h"
15 
16 #include <assert.h>
17 #include <string.h>
18 
19 #if defined(_WIN32)
20     #include "audio_device_utility_win.h"
21     #include "audio_device_wave_win.h"
22  #if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
23     #include "audio_device_core_win.h"
24  #endif
25 #elif defined(WEBRTC_ANDROID)
26     #include <stdlib.h>
27     #include "audio_device_utility_android.h"
28     #include "webrtc/modules/audio_device/android/audio_device_template.h"
29     #include "webrtc/modules/audio_device/android/audio_record_jni.h"
30     #include "webrtc/modules/audio_device/android/audio_track_jni.h"
31     #include "webrtc/modules/audio_device/android/opensles_input.h"
32     #include "webrtc/modules/audio_device/android/opensles_output.h"
33 #elif defined(WEBRTC_LINUX)
34     #include "audio_device_utility_linux.h"
35  #if defined(LINUX_ALSA)
36     #include "audio_device_alsa_linux.h"
37  #endif
38  #if defined(LINUX_PULSE)
39     #include "audio_device_pulse_linux.h"
40  #endif
41 #elif defined(WEBRTC_IOS)
42     #include "audio_device_utility_ios.h"
43     #include "audio_device_ios.h"
44 #elif defined(WEBRTC_MAC)
45     #include "audio_device_utility_mac.h"
46     #include "audio_device_mac.h"
47 #endif
48 
49 #if defined(WEBRTC_DUMMY_FILE_DEVICES)
50 #include "webrtc/modules/audio_device/dummy/file_audio_device_factory.h"
51 #endif
52 
53 #include "webrtc/modules/audio_device/dummy/audio_device_dummy.h"
54 #include "webrtc/modules/audio_device/dummy/audio_device_utility_dummy.h"
55 #include "webrtc/modules/audio_device/dummy/file_audio_device.h"
56 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
57 #include "webrtc/system_wrappers/interface/trace.h"
58 
59 #define CHECK_INITIALIZED()         \
60 {                                   \
61     if (!_initialized) {            \
62         return -1;                  \
63     };                              \
64 }
65 
66 #define CHECK_INITIALIZED_BOOL()    \
67 {                                   \
68     if (!_initialized) {            \
69         return false;               \
70     };                              \
71 }
72 
73 namespace webrtc
74 {
75 
CreateAudioDeviceModule(int32_t id,AudioDeviceModule::AudioLayer audioLayer)76 AudioDeviceModule* CreateAudioDeviceModule(
77     int32_t id, AudioDeviceModule::AudioLayer audioLayer) {
78   return AudioDeviceModuleImpl::Create(id, audioLayer);
79 }
80 
81 
82 // ============================================================================
83 //                                   Static methods
84 // ============================================================================
85 
86 // ----------------------------------------------------------------------------
87 //  AudioDeviceModule::Create()
88 // ----------------------------------------------------------------------------
89 
Create(const int32_t id,const AudioLayer audioLayer)90 AudioDeviceModule* AudioDeviceModuleImpl::Create(const int32_t id,
91                                                  const AudioLayer audioLayer)
92 {
93 
94     // Create the generic ref counted (platform independent) implementation.
95     RefCountImpl<AudioDeviceModuleImpl>* audioDevice =
96         new RefCountImpl<AudioDeviceModuleImpl>(id, audioLayer);
97 
98     // Ensure that the current platform is supported.
99     if (audioDevice->CheckPlatform() == -1)
100     {
101         delete audioDevice;
102         return NULL;
103     }
104 
105     // Create the platform-dependent implementation.
106     if (audioDevice->CreatePlatformSpecificObjects() == -1)
107     {
108         delete audioDevice;
109         return NULL;
110     }
111 
112     // Ensure that the generic audio buffer can communicate with the
113     // platform-specific parts.
114     if (audioDevice->AttachAudioBuffer() == -1)
115     {
116         delete audioDevice;
117         return NULL;
118     }
119 
120     WebRtcSpl_Init();
121 
122     return audioDevice;
123 }
124 
125 // ============================================================================
126 //                            Construction & Destruction
127 // ============================================================================
128 
129 // ----------------------------------------------------------------------------
130 //  AudioDeviceModuleImpl - ctor
131 // ----------------------------------------------------------------------------
132 
AudioDeviceModuleImpl(const int32_t id,const AudioLayer audioLayer)133 AudioDeviceModuleImpl::AudioDeviceModuleImpl(const int32_t id, const AudioLayer audioLayer) :
134     _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
135     _critSectEventCb(*CriticalSectionWrapper::CreateCriticalSection()),
136     _critSectAudioCb(*CriticalSectionWrapper::CreateCriticalSection()),
137     _ptrCbAudioDeviceObserver(NULL),
138     _ptrAudioDeviceUtility(NULL),
139     _ptrAudioDevice(NULL),
140     _id(id),
141     _platformAudioLayer(audioLayer),
142     _lastProcessTime(AudioDeviceUtility::GetTimeInMS()),
143     _platformType(kPlatformNotSupported),
144     _initialized(false),
145     _lastError(kAdmErrNone)
146 {
147     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id, "%s created", __FUNCTION__);
148 }
149 
150 // ----------------------------------------------------------------------------
151 //  CheckPlatform
152 // ----------------------------------------------------------------------------
153 
CheckPlatform()154 int32_t AudioDeviceModuleImpl::CheckPlatform()
155 {
156     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__);
157 
158     // Ensure that the current platform is supported
159     //
160     PlatformType platform(kPlatformNotSupported);
161 
162 #if defined(_WIN32)
163     platform = kPlatformWin32;
164     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "current platform is WIN32");
165 #elif defined(WEBRTC_ANDROID)
166     platform = kPlatformAndroid;
167     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "current platform is ANDROID");
168 #elif defined(WEBRTC_LINUX)
169     platform = kPlatformLinux;
170     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "current platform is LINUX");
171 #elif defined(WEBRTC_IOS)
172     platform = kPlatformIOS;
173     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "current platform is IOS");
174 #elif defined(WEBRTC_MAC)
175     platform = kPlatformMac;
176     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "current platform is MAC");
177 #endif
178 
179     if (platform == kPlatformNotSupported)
180     {
181         WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, "current platform is not supported => this module will self destruct!");
182         return -1;
183     }
184 
185     // Store valid output results
186     //
187     _platformType = platform;
188 
189     return 0;
190 }
191 
192 
193 // ----------------------------------------------------------------------------
194 //  CreatePlatformSpecificObjects
195 // ----------------------------------------------------------------------------
196 
CreatePlatformSpecificObjects()197 int32_t AudioDeviceModuleImpl::CreatePlatformSpecificObjects()
198 {
199     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__);
200 
201     AudioDeviceGeneric* ptrAudioDevice(NULL);
202     AudioDeviceUtility* ptrAudioDeviceUtility(NULL);
203 
204 #if defined(WEBRTC_DUMMY_AUDIO_BUILD)
205     ptrAudioDevice = new AudioDeviceDummy(Id());
206     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Dummy Audio APIs will be utilized");
207 
208     if (ptrAudioDevice != NULL)
209     {
210         ptrAudioDeviceUtility = new AudioDeviceUtilityDummy(Id());
211     }
212 #elif defined(WEBRTC_DUMMY_FILE_DEVICES)
213     ptrAudioDevice = FileAudioDeviceFactory::CreateFileAudioDevice(Id());
214     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
215                  "Will use file-playing dummy device.");
216     if (ptrAudioDevice != NULL)
217     {
218         ptrAudioDeviceUtility = new AudioDeviceUtilityDummy(Id());
219     }
220 #else
221     const AudioLayer audioLayer(PlatformAudioLayer());
222 
223     // Create the *Windows* implementation of the Audio Device
224     //
225 #if defined(_WIN32)
226     if ((audioLayer == kWindowsWaveAudio)
227 #if !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
228         // Wave audio is default if Core audio is not supported in this build
229         || (audioLayer == kPlatformDefaultAudio)
230 #endif
231         )
232     {
233         // create *Windows Wave Audio* implementation
234         ptrAudioDevice = new AudioDeviceWindowsWave(Id());
235         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Windows Wave APIs will be utilized");
236     }
237 #if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
238     if ((audioLayer == kWindowsCoreAudio) ||
239         (audioLayer == kPlatformDefaultAudio)
240         )
241     {
242         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "attempting to use the Windows Core Audio APIs...");
243 
244         if (AudioDeviceWindowsCore::CoreAudioIsSupported())
245         {
246             // create *Windows Core Audio* implementation
247             ptrAudioDevice = new AudioDeviceWindowsCore(Id());
248             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Windows Core Audio APIs will be utilized");
249         }
250         else
251         {
252             // create *Windows Wave Audio* implementation
253             ptrAudioDevice = new AudioDeviceWindowsWave(Id());
254             if (ptrAudioDevice != NULL)
255             {
256                 // Core Audio was not supported => revert to Windows Wave instead
257                 _platformAudioLayer = kWindowsWaveAudio;  // modify the state set at construction
258                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "Windows Core Audio is *not* supported => Wave APIs will be utilized instead");
259             }
260         }
261     }
262 #endif // defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
263     if (ptrAudioDevice != NULL)
264     {
265         // Create the Windows implementation of the Device Utility.
266         // This class is independent of the selected audio layer
267         // for Windows.
268         //
269         ptrAudioDeviceUtility = new AudioDeviceUtilityWindows(Id());
270     }
271 #endif  // #if defined(_WIN32)
272 
273     // Create the *Android OpenSLES* implementation of the Audio Device
274     //
275 #if defined(WEBRTC_ANDROID)
276     if (audioLayer == kPlatformDefaultAudio)
277     {
278         // AudioRecordJni provides hardware AEC and OpenSlesOutput low latency.
279 #if defined(WEBRTC_ANDROID_OPENSLES)
280         ptrAudioDevice = new AudioDeviceTemplate<OpenSlesInput, OpenSlesOutput>(Id());
281         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
282                      "Android OpenSLES Audio APIs will be utilized");
283 #else
284         ptrAudioDevice = new AudioDeviceTemplate<AudioRecordJni, AudioTrackJni>(Id());
285         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
286                      "Android JNI Audio APIs will be utilized");
287 #endif
288     }
289 
290     if (ptrAudioDevice != NULL)
291     {
292         // Create the Android implementation of the Device Utility.
293         ptrAudioDeviceUtility = new AudioDeviceUtilityAndroid(Id());
294     }
295     // END #if defined(WEBRTC_ANDROID)
296 
297     // Create the *Linux* implementation of the Audio Device
298     //
299 #elif defined(WEBRTC_LINUX)
300     if ((audioLayer == kLinuxPulseAudio) || (audioLayer == kPlatformDefaultAudio))
301     {
302 #if defined(LINUX_PULSE)
303         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "attempting to use the Linux PulseAudio APIs...");
304 
305         // create *Linux PulseAudio* implementation
306         AudioDeviceLinuxPulse* pulseDevice = new AudioDeviceLinuxPulse(Id());
307         if (pulseDevice->Init() != -1)
308         {
309             ptrAudioDevice = pulseDevice;
310             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Linux PulseAudio APIs will be utilized");
311         }
312         else
313         {
314             delete pulseDevice;
315 #endif
316 #if defined(LINUX_ALSA)
317             // create *Linux ALSA Audio* implementation
318             ptrAudioDevice = new AudioDeviceLinuxALSA(Id());
319             if (ptrAudioDevice != NULL)
320             {
321                 // Pulse Audio was not supported => revert to ALSA instead
322                 _platformAudioLayer = kLinuxAlsaAudio;  // modify the state set at construction
323                 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "Linux PulseAudio is *not* supported => ALSA APIs will be utilized instead");
324             }
325 #endif
326 #if defined(LINUX_PULSE)
327         }
328 #endif
329     }
330     else if (audioLayer == kLinuxAlsaAudio)
331     {
332 #if defined(LINUX_ALSA)
333         // create *Linux ALSA Audio* implementation
334         ptrAudioDevice = new AudioDeviceLinuxALSA(Id());
335         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Linux ALSA APIs will be utilized");
336 #endif
337     }
338 
339     if (ptrAudioDevice != NULL)
340     {
341         // Create the Linux implementation of the Device Utility.
342         // This class is independent of the selected audio layer
343         // for Linux.
344         //
345         ptrAudioDeviceUtility = new AudioDeviceUtilityLinux(Id());
346     }
347 #endif  // #if defined(WEBRTC_LINUX)
348 
349     // Create the *iPhone* implementation of the Audio Device
350     //
351 #if defined(WEBRTC_IOS)
352     if (audioLayer == kPlatformDefaultAudio)
353     {
354         // Create iOS Audio Device implementation.
355         ptrAudioDevice = new AudioDeviceIOS(Id());
356         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "iPhone Audio APIs will be utilized");
357     }
358 
359     if (ptrAudioDevice != NULL)
360     {
361         // Create iOS Device Utility implementation.
362         ptrAudioDeviceUtility = new AudioDeviceUtilityIOS(Id());
363     }
364     // END #if defined(WEBRTC_IOS)
365 
366     // Create the *Mac* implementation of the Audio Device
367     //
368 #elif defined(WEBRTC_MAC)
369     if (audioLayer == kPlatformDefaultAudio)
370     {
371         // Create *Mac Audio* implementation
372         ptrAudioDevice = new AudioDeviceMac(Id());
373         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Mac OS X Audio APIs will be utilized");
374     }
375 
376     if (ptrAudioDevice != NULL)
377     {
378         // Create the Mac implementation of the Device Utility.
379         ptrAudioDeviceUtility = new AudioDeviceUtilityMac(Id());
380     }
381 #endif  // WEBRTC_MAC
382 
383     // Create the *Dummy* implementation of the Audio Device
384     // Available for all platforms
385     //
386     if (audioLayer == kDummyAudio)
387     {
388         // Create *Dummy Audio* implementation
389         assert(!ptrAudioDevice);
390         ptrAudioDevice = new AudioDeviceDummy(Id());
391         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Dummy Audio APIs will be utilized");
392 
393         if (ptrAudioDevice != NULL)
394         {
395             ptrAudioDeviceUtility = new AudioDeviceUtilityDummy(Id());
396         }
397     }
398 #endif  // if defined(WEBRTC_DUMMY_AUDIO_BUILD)
399 
400     if (ptrAudioDevice == NULL)
401     {
402         WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, "unable to create the platform specific audio device implementation");
403         return -1;
404     }
405 
406     if (ptrAudioDeviceUtility == NULL)
407     {
408         WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, "unable to create the platform specific audio device utility");
409         return -1;
410     }
411 
412     // Store valid output pointers
413     //
414     _ptrAudioDevice = ptrAudioDevice;
415     _ptrAudioDeviceUtility = ptrAudioDeviceUtility;
416 
417     return 0;
418 }
419 
420 // ----------------------------------------------------------------------------
421 //  AttachAudioBuffer
422 //
423 //  Install "bridge" between the platform implemetation and the generic
424 //  implementation. The "child" shall set the native sampling rate and the
425 //  number of channels in this function call.
426 // ----------------------------------------------------------------------------
427 
AttachAudioBuffer()428 int32_t AudioDeviceModuleImpl::AttachAudioBuffer()
429 {
430     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__);
431 
432     _audioDeviceBuffer.SetId(_id);
433     _ptrAudioDevice->AttachAudioBuffer(&_audioDeviceBuffer);
434     return 0;
435 }
436 
437 // ----------------------------------------------------------------------------
438 //  ~AudioDeviceModuleImpl - dtor
439 // ----------------------------------------------------------------------------
440 
~AudioDeviceModuleImpl()441 AudioDeviceModuleImpl::~AudioDeviceModuleImpl()
442 {
443     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s destroyed", __FUNCTION__);
444 
445     if (_ptrAudioDevice)
446     {
447         delete _ptrAudioDevice;
448         _ptrAudioDevice = NULL;
449     }
450 
451     if (_ptrAudioDeviceUtility)
452     {
453         delete _ptrAudioDeviceUtility;
454         _ptrAudioDeviceUtility = NULL;
455     }
456 
457     delete &_critSect;
458     delete &_critSectEventCb;
459     delete &_critSectAudioCb;
460 }
461 
462 // ============================================================================
463 //                                  Module
464 // ============================================================================
465 
466 // ----------------------------------------------------------------------------
467 //  Module::ChangeUniqueId
468 // ----------------------------------------------------------------------------
469 
ChangeUniqueId(const int32_t id)470 int32_t AudioDeviceModuleImpl::ChangeUniqueId(const int32_t id)
471 {
472     _id = id;
473     return 0;
474 }
475 
476 // ----------------------------------------------------------------------------
477 //  Module::TimeUntilNextProcess
478 //
479 //  Returns the number of milliseconds until the module want a worker thread
480 //  to call Process().
481 // ----------------------------------------------------------------------------
482 
TimeUntilNextProcess()483 int32_t AudioDeviceModuleImpl::TimeUntilNextProcess()
484 {
485     uint32_t now = AudioDeviceUtility::GetTimeInMS();
486     int32_t deltaProcess = kAdmMaxIdleTimeProcess - (now - _lastProcessTime);
487     return (deltaProcess);
488 }
489 
490 // ----------------------------------------------------------------------------
491 //  Module::Process
492 //
493 //  Check for posted error and warning reports. Generate callbacks if
494 //  new reports exists.
495 // ----------------------------------------------------------------------------
496 
Process()497 int32_t AudioDeviceModuleImpl::Process()
498 {
499 
500     _lastProcessTime = AudioDeviceUtility::GetTimeInMS();
501 
502     // kPlayoutWarning
503     if (_ptrAudioDevice->PlayoutWarning())
504     {
505         CriticalSectionScoped lock(&_critSectEventCb);
506         if (_ptrCbAudioDeviceObserver)
507         {
508             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "=> OnWarningIsReported(kPlayoutWarning)");
509             _ptrCbAudioDeviceObserver->OnWarningIsReported(AudioDeviceObserver::kPlayoutWarning);
510         }
511         _ptrAudioDevice->ClearPlayoutWarning();
512     }
513 
514     // kPlayoutError
515     if (_ptrAudioDevice->PlayoutError())
516     {
517         CriticalSectionScoped lock(&_critSectEventCb);
518         if (_ptrCbAudioDeviceObserver)
519         {
520             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "=> OnErrorIsReported(kPlayoutError)");
521             _ptrCbAudioDeviceObserver->OnErrorIsReported(AudioDeviceObserver::kPlayoutError);
522         }
523         _ptrAudioDevice->ClearPlayoutError();
524     }
525 
526     // kRecordingWarning
527     if (_ptrAudioDevice->RecordingWarning())
528     {
529         CriticalSectionScoped lock(&_critSectEventCb);
530         if (_ptrCbAudioDeviceObserver)
531         {
532             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "=> OnWarningIsReported(kRecordingWarning)");
533             _ptrCbAudioDeviceObserver->OnWarningIsReported(AudioDeviceObserver::kRecordingWarning);
534         }
535         _ptrAudioDevice->ClearRecordingWarning();
536     }
537 
538     // kRecordingError
539     if (_ptrAudioDevice->RecordingError())
540     {
541         CriticalSectionScoped lock(&_critSectEventCb);
542         if (_ptrCbAudioDeviceObserver)
543         {
544             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "=> OnErrorIsReported(kRecordingError)");
545             _ptrCbAudioDeviceObserver->OnErrorIsReported(AudioDeviceObserver::kRecordingError);
546         }
547         _ptrAudioDevice->ClearRecordingError();
548     }
549 
550     return 0;
551 }
552 
553 // ============================================================================
554 //                                    Public API
555 // ============================================================================
556 
557 // ----------------------------------------------------------------------------
558 //  ActiveAudioLayer
559 // ----------------------------------------------------------------------------
560 
ActiveAudioLayer(AudioLayer * audioLayer) const561 int32_t AudioDeviceModuleImpl::ActiveAudioLayer(AudioLayer* audioLayer) const
562 {
563 
564     AudioLayer activeAudio;
565 
566     if (_ptrAudioDevice->ActiveAudioLayer(activeAudio) == -1)
567     {
568         return -1;
569     }
570 
571     *audioLayer = activeAudio;
572 
573     if (*audioLayer == AudioDeviceModule::kWindowsWaveAudio)
574     {
575         WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: kWindowsWaveAudio");
576     }
577     else if (*audioLayer == AudioDeviceModule::kWindowsCoreAudio)
578     {
579         WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: kWindowsCoreAudio");
580     }
581     else if (*audioLayer == AudioDeviceModule::kLinuxAlsaAudio)
582     {
583         WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: kLinuxAlsaAudio");
584     }
585     else
586     {
587         WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: NOT_SUPPORTED");
588     }
589 
590     return 0;
591 }
592 
593 // ----------------------------------------------------------------------------
594 //  LastError
595 // ----------------------------------------------------------------------------
596 
LastError() const597 AudioDeviceModule::ErrorCode AudioDeviceModuleImpl::LastError() const
598 {
599     return _lastError;
600 }
601 
602 // ----------------------------------------------------------------------------
603 //  Init
604 // ----------------------------------------------------------------------------
605 
Init()606 int32_t AudioDeviceModuleImpl::Init()
607 {
608 
609     if (_initialized)
610         return 0;
611 
612     if (!_ptrAudioDeviceUtility)
613         return -1;
614 
615     if (!_ptrAudioDevice)
616         return -1;
617 
618     _ptrAudioDeviceUtility->Init();
619 
620     if (_ptrAudioDevice->Init() == -1)
621     {
622         return -1;
623     }
624 
625     _initialized = true;
626     return 0;
627 }
628 
629 // ----------------------------------------------------------------------------
630 //  Terminate
631 // ----------------------------------------------------------------------------
632 
Terminate()633 int32_t AudioDeviceModuleImpl::Terminate()
634 {
635 
636     if (!_initialized)
637         return 0;
638 
639     if (_ptrAudioDevice->Terminate() == -1)
640     {
641         return -1;
642     }
643 
644     _initialized = false;
645     return 0;
646 }
647 
648 // ----------------------------------------------------------------------------
649 //  Initialized
650 // ----------------------------------------------------------------------------
651 
Initialized() const652 bool AudioDeviceModuleImpl::Initialized() const
653 {
654 
655     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: %d", _initialized);
656     return (_initialized);
657 }
658 
659 // ----------------------------------------------------------------------------
660 //  InitSpeaker
661 // ----------------------------------------------------------------------------
662 
InitSpeaker()663 int32_t AudioDeviceModuleImpl::InitSpeaker()
664 {
665     CHECK_INITIALIZED();
666     return (_ptrAudioDevice->InitSpeaker());
667 }
668 
669 // ----------------------------------------------------------------------------
670 //  InitMicrophone
671 // ----------------------------------------------------------------------------
672 
InitMicrophone()673 int32_t AudioDeviceModuleImpl::InitMicrophone()
674 {
675     CHECK_INITIALIZED();
676     return (_ptrAudioDevice->InitMicrophone());
677 }
678 
679 // ----------------------------------------------------------------------------
680 //  SpeakerVolumeIsAvailable
681 // ----------------------------------------------------------------------------
682 
SpeakerVolumeIsAvailable(bool * available)683 int32_t AudioDeviceModuleImpl::SpeakerVolumeIsAvailable(bool* available)
684 {
685     CHECK_INITIALIZED();
686 
687     bool isAvailable(0);
688 
689     if (_ptrAudioDevice->SpeakerVolumeIsAvailable(isAvailable) == -1)
690     {
691         return -1;
692     }
693 
694     *available = isAvailable;
695 
696     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: available=%d", *available);
697     return (0);
698 }
699 
700 // ----------------------------------------------------------------------------
701 //  SetSpeakerVolume
702 // ----------------------------------------------------------------------------
703 
SetSpeakerVolume(uint32_t volume)704 int32_t AudioDeviceModuleImpl::SetSpeakerVolume(uint32_t volume)
705 {
706     CHECK_INITIALIZED();
707     return (_ptrAudioDevice->SetSpeakerVolume(volume));
708 }
709 
710 // ----------------------------------------------------------------------------
711 //  SpeakerVolume
712 // ----------------------------------------------------------------------------
713 
SpeakerVolume(uint32_t * volume) const714 int32_t AudioDeviceModuleImpl::SpeakerVolume(uint32_t* volume) const
715 {
716     CHECK_INITIALIZED();
717 
718     uint32_t level(0);
719 
720     if (_ptrAudioDevice->SpeakerVolume(level) == -1)
721     {
722         return -1;
723     }
724 
725     *volume = level;
726 
727     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: volume=%u", *volume);
728     return (0);
729 }
730 
731 // ----------------------------------------------------------------------------
732 //  SetWaveOutVolume
733 // ----------------------------------------------------------------------------
734 
SetWaveOutVolume(uint16_t volumeLeft,uint16_t volumeRight)735 int32_t AudioDeviceModuleImpl::SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight)
736 {
737     CHECK_INITIALIZED();
738     return (_ptrAudioDevice->SetWaveOutVolume(volumeLeft, volumeRight));
739 }
740 
741 // ----------------------------------------------------------------------------
742 //  WaveOutVolume
743 // ----------------------------------------------------------------------------
744 
WaveOutVolume(uint16_t * volumeLeft,uint16_t * volumeRight) const745 int32_t AudioDeviceModuleImpl::WaveOutVolume(uint16_t* volumeLeft, uint16_t* volumeRight) const
746 {
747     CHECK_INITIALIZED();
748 
749     uint16_t volLeft(0);
750     uint16_t volRight(0);
751 
752     if (_ptrAudioDevice->WaveOutVolume(volLeft, volRight) == -1)
753     {
754         return -1;
755     }
756 
757     *volumeLeft = volLeft;
758     *volumeRight = volRight;
759 
760     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "outputs: volumeLeft=%u, volumeRight=%u",
761         *volumeLeft, *volumeRight);
762 
763     return (0);
764 }
765 
766 // ----------------------------------------------------------------------------
767 //  SpeakerIsInitialized
768 // ----------------------------------------------------------------------------
769 
SpeakerIsInitialized() const770 bool AudioDeviceModuleImpl::SpeakerIsInitialized() const
771 {
772     CHECK_INITIALIZED_BOOL();
773 
774     bool isInitialized = _ptrAudioDevice->SpeakerIsInitialized();
775 
776     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: %d", isInitialized);
777     return (isInitialized);
778 }
779 
780 // ----------------------------------------------------------------------------
781 //  MicrophoneIsInitialized
782 // ----------------------------------------------------------------------------
783 
MicrophoneIsInitialized() const784 bool AudioDeviceModuleImpl::MicrophoneIsInitialized() const
785 {
786     CHECK_INITIALIZED_BOOL();
787 
788     bool isInitialized = _ptrAudioDevice->MicrophoneIsInitialized();
789 
790     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: %d", isInitialized);
791     return (isInitialized);
792 }
793 
794 // ----------------------------------------------------------------------------
795 //  MaxSpeakerVolume
796 // ----------------------------------------------------------------------------
797 
MaxSpeakerVolume(uint32_t * maxVolume) const798 int32_t AudioDeviceModuleImpl::MaxSpeakerVolume(uint32_t* maxVolume) const
799 {
800     CHECK_INITIALIZED();
801 
802     uint32_t maxVol(0);
803 
804     if (_ptrAudioDevice->MaxSpeakerVolume(maxVol) == -1)
805     {
806         return -1;
807     }
808 
809     *maxVolume = maxVol;
810 
811     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: maxVolume=%d", *maxVolume);
812     return (0);
813 }
814 
815 // ----------------------------------------------------------------------------
816 //  MinSpeakerVolume
817 // ----------------------------------------------------------------------------
818 
MinSpeakerVolume(uint32_t * minVolume) const819 int32_t AudioDeviceModuleImpl::MinSpeakerVolume(uint32_t* minVolume) const
820 {
821     CHECK_INITIALIZED();
822 
823     uint32_t minVol(0);
824 
825     if (_ptrAudioDevice->MinSpeakerVolume(minVol) == -1)
826     {
827         return -1;
828     }
829 
830     *minVolume = minVol;
831 
832     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: minVolume=%u", *minVolume);
833     return (0);
834 }
835 
836 // ----------------------------------------------------------------------------
837 //  SpeakerVolumeStepSize
838 // ----------------------------------------------------------------------------
839 
SpeakerVolumeStepSize(uint16_t * stepSize) const840 int32_t AudioDeviceModuleImpl::SpeakerVolumeStepSize(uint16_t* stepSize) const
841 {
842     CHECK_INITIALIZED();
843 
844     uint16_t delta(0);
845 
846     if (_ptrAudioDevice->SpeakerVolumeStepSize(delta) == -1)
847     {
848         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to retrieve the speaker-volume step size");
849         return -1;
850     }
851 
852     *stepSize = delta;
853 
854     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: stepSize=%u", *stepSize);
855     return (0);
856 }
857 
858 // ----------------------------------------------------------------------------
859 //  SpeakerMuteIsAvailable
860 // ----------------------------------------------------------------------------
861 
SpeakerMuteIsAvailable(bool * available)862 int32_t AudioDeviceModuleImpl::SpeakerMuteIsAvailable(bool* available)
863 {
864     CHECK_INITIALIZED();
865 
866     bool isAvailable(0);
867 
868     if (_ptrAudioDevice->SpeakerMuteIsAvailable(isAvailable) == -1)
869     {
870         return -1;
871     }
872 
873     *available = isAvailable;
874 
875     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: available=%d", *available);
876     return (0);
877 }
878 
879 // ----------------------------------------------------------------------------
880 //  SetSpeakerMute
881 // ----------------------------------------------------------------------------
882 
SetSpeakerMute(bool enable)883 int32_t AudioDeviceModuleImpl::SetSpeakerMute(bool enable)
884 {
885     CHECK_INITIALIZED();
886     return (_ptrAudioDevice->SetSpeakerMute(enable));
887 }
888 
889 // ----------------------------------------------------------------------------
890 //  SpeakerMute
891 // ----------------------------------------------------------------------------
892 
SpeakerMute(bool * enabled) const893 int32_t AudioDeviceModuleImpl::SpeakerMute(bool* enabled) const
894 {
895     CHECK_INITIALIZED();
896 
897     bool muted(false);
898 
899     if (_ptrAudioDevice->SpeakerMute(muted) == -1)
900     {
901         return -1;
902     }
903 
904     *enabled = muted;
905 
906     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: enabled=%u", *enabled);
907     return (0);
908 }
909 
910 // ----------------------------------------------------------------------------
911 //  MicrophoneMuteIsAvailable
912 // ----------------------------------------------------------------------------
913 
MicrophoneMuteIsAvailable(bool * available)914 int32_t AudioDeviceModuleImpl::MicrophoneMuteIsAvailable(bool* available)
915 {
916     CHECK_INITIALIZED();
917 
918     bool isAvailable(0);
919 
920     if (_ptrAudioDevice->MicrophoneMuteIsAvailable(isAvailable) == -1)
921     {
922         return -1;
923     }
924 
925     *available = isAvailable;
926 
927     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: available=%d", *available);
928     return (0);
929 }
930 
931 // ----------------------------------------------------------------------------
932 //  SetMicrophoneMute
933 // ----------------------------------------------------------------------------
934 
SetMicrophoneMute(bool enable)935 int32_t AudioDeviceModuleImpl::SetMicrophoneMute(bool enable)
936 {
937     CHECK_INITIALIZED();
938     return (_ptrAudioDevice->SetMicrophoneMute(enable));
939 }
940 
941 // ----------------------------------------------------------------------------
942 //  MicrophoneMute
943 // ----------------------------------------------------------------------------
944 
MicrophoneMute(bool * enabled) const945 int32_t AudioDeviceModuleImpl::MicrophoneMute(bool* enabled) const
946 {
947     CHECK_INITIALIZED();
948 
949     bool muted(false);
950 
951     if (_ptrAudioDevice->MicrophoneMute(muted) == -1)
952     {
953         return -1;
954     }
955 
956     *enabled = muted;
957 
958     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: enabled=%u", *enabled);
959     return (0);
960 }
961 
962 // ----------------------------------------------------------------------------
963 //  MicrophoneBoostIsAvailable
964 // ----------------------------------------------------------------------------
965 
MicrophoneBoostIsAvailable(bool * available)966 int32_t AudioDeviceModuleImpl::MicrophoneBoostIsAvailable(bool* available)
967 {
968     CHECK_INITIALIZED();
969 
970     bool isAvailable(0);
971 
972     if (_ptrAudioDevice->MicrophoneBoostIsAvailable(isAvailable) == -1)
973     {
974         return -1;
975     }
976 
977     *available = isAvailable;
978 
979     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: available=%d", *available);
980     return (0);
981 }
982 
983 // ----------------------------------------------------------------------------
984 //  SetMicrophoneBoost
985 // ----------------------------------------------------------------------------
986 
SetMicrophoneBoost(bool enable)987 int32_t AudioDeviceModuleImpl::SetMicrophoneBoost(bool enable)
988 {
989     CHECK_INITIALIZED();
990     return (_ptrAudioDevice->SetMicrophoneBoost(enable));
991 }
992 
993 // ----------------------------------------------------------------------------
994 //  MicrophoneBoost
995 // ----------------------------------------------------------------------------
996 
MicrophoneBoost(bool * enabled) const997 int32_t AudioDeviceModuleImpl::MicrophoneBoost(bool* enabled) const
998 {
999     CHECK_INITIALIZED();
1000 
1001     bool onOff(false);
1002 
1003     if (_ptrAudioDevice->MicrophoneBoost(onOff) == -1)
1004     {
1005         return -1;
1006     }
1007 
1008     *enabled = onOff;
1009 
1010     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: enabled=%u", *enabled);
1011     return (0);
1012 }
1013 
1014 // ----------------------------------------------------------------------------
1015 //  MicrophoneVolumeIsAvailable
1016 // ----------------------------------------------------------------------------
1017 
MicrophoneVolumeIsAvailable(bool * available)1018 int32_t AudioDeviceModuleImpl::MicrophoneVolumeIsAvailable(bool* available)
1019 {
1020     CHECK_INITIALIZED();
1021 
1022     bool isAvailable(0);
1023 
1024     if (_ptrAudioDevice->MicrophoneVolumeIsAvailable(isAvailable) == -1)
1025     {
1026         return -1;
1027     }
1028 
1029     *available = isAvailable;
1030 
1031     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: available=%d", *available);
1032     return (0);
1033 }
1034 
1035 // ----------------------------------------------------------------------------
1036 //  SetMicrophoneVolume
1037 // ----------------------------------------------------------------------------
1038 
SetMicrophoneVolume(uint32_t volume)1039 int32_t AudioDeviceModuleImpl::SetMicrophoneVolume(uint32_t volume)
1040 {
1041     CHECK_INITIALIZED();
1042     return (_ptrAudioDevice->SetMicrophoneVolume(volume));
1043 }
1044 
1045 // ----------------------------------------------------------------------------
1046 //  MicrophoneVolume
1047 // ----------------------------------------------------------------------------
1048 
MicrophoneVolume(uint32_t * volume) const1049 int32_t AudioDeviceModuleImpl::MicrophoneVolume(uint32_t* volume) const
1050 {
1051     WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "%s", __FUNCTION__);
1052     CHECK_INITIALIZED();
1053 
1054     uint32_t level(0);
1055 
1056     if (_ptrAudioDevice->MicrophoneVolume(level) == -1)
1057     {
1058         return -1;
1059     }
1060 
1061     *volume = level;
1062 
1063     WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "output: volume=%u", *volume);
1064     return (0);
1065 }
1066 
1067 // ----------------------------------------------------------------------------
1068 //  StereoRecordingIsAvailable
1069 // ----------------------------------------------------------------------------
1070 
StereoRecordingIsAvailable(bool * available) const1071 int32_t AudioDeviceModuleImpl::StereoRecordingIsAvailable(bool* available) const
1072 {
1073     CHECK_INITIALIZED();
1074 
1075     bool isAvailable(0);
1076 
1077     if (_ptrAudioDevice->StereoRecordingIsAvailable(isAvailable) == -1)
1078     {
1079         return -1;
1080     }
1081 
1082     *available = isAvailable;
1083 
1084     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: available=%d", *available);
1085     return (0);
1086 }
1087 
1088 // ----------------------------------------------------------------------------
1089 //  SetStereoRecording
1090 // ----------------------------------------------------------------------------
1091 
SetStereoRecording(bool enable)1092 int32_t AudioDeviceModuleImpl::SetStereoRecording(bool enable)
1093 {
1094     CHECK_INITIALIZED();
1095 
1096     if (_ptrAudioDevice->RecordingIsInitialized())
1097     {
1098         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "recording in stereo is not supported");
1099         return -1;
1100     }
1101 
1102     if (_ptrAudioDevice->SetStereoRecording(enable) == -1)
1103     {
1104         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to enable stereo recording");
1105         return -1;
1106     }
1107 
1108     int8_t nChannels(1);
1109     if (enable)
1110     {
1111         nChannels = 2;
1112     }
1113     _audioDeviceBuffer.SetRecordingChannels(nChannels);
1114 
1115     return 0;
1116 }
1117 
1118 // ----------------------------------------------------------------------------
1119 //  StereoRecording
1120 // ----------------------------------------------------------------------------
1121 
StereoRecording(bool * enabled) const1122 int32_t AudioDeviceModuleImpl::StereoRecording(bool* enabled) const
1123 {
1124     CHECK_INITIALIZED();
1125 
1126     bool stereo(false);
1127 
1128     if (_ptrAudioDevice->StereoRecording(stereo) == -1)
1129     {
1130         return -1;
1131     }
1132 
1133     *enabled = stereo;
1134 
1135     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: enabled=%u", *enabled);
1136     return (0);
1137 }
1138 
1139 // ----------------------------------------------------------------------------
1140 //  SetRecordingChannel
1141 // ----------------------------------------------------------------------------
1142 
SetRecordingChannel(const ChannelType channel)1143 int32_t AudioDeviceModuleImpl::SetRecordingChannel(const ChannelType channel)
1144 {
1145     if (channel == kChannelBoth)
1146     {
1147     }
1148     else if (channel == kChannelLeft)
1149     {
1150     }
1151     else
1152     {
1153     }
1154     CHECK_INITIALIZED();
1155 
1156     bool stereo(false);
1157 
1158     if (_ptrAudioDevice->StereoRecording(stereo) == -1)
1159     {
1160         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "recording in stereo is not supported");
1161         return -1;
1162     }
1163 
1164     return (_audioDeviceBuffer.SetRecordingChannel(channel));
1165 }
1166 
1167 // ----------------------------------------------------------------------------
1168 //  RecordingChannel
1169 // ----------------------------------------------------------------------------
1170 
RecordingChannel(ChannelType * channel) const1171 int32_t AudioDeviceModuleImpl::RecordingChannel(ChannelType* channel) const
1172 {
1173     CHECK_INITIALIZED();
1174 
1175     ChannelType chType;
1176 
1177     if (_audioDeviceBuffer.RecordingChannel(chType) == -1)
1178     {
1179         return -1;
1180     }
1181 
1182     *channel = chType;
1183 
1184     if (*channel == kChannelBoth)
1185     {
1186     }
1187     else if (*channel == kChannelLeft)
1188     {
1189     }
1190     else
1191     {
1192     }
1193 
1194     return (0);
1195 }
1196 
1197 // ----------------------------------------------------------------------------
1198 //  StereoPlayoutIsAvailable
1199 // ----------------------------------------------------------------------------
1200 
StereoPlayoutIsAvailable(bool * available) const1201 int32_t AudioDeviceModuleImpl::StereoPlayoutIsAvailable(bool* available) const
1202 {
1203     CHECK_INITIALIZED();
1204 
1205     bool isAvailable(0);
1206 
1207     if (_ptrAudioDevice->StereoPlayoutIsAvailable(isAvailable) == -1)
1208     {
1209         return -1;
1210     }
1211 
1212     *available = isAvailable;
1213 
1214     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: available=%d", *available);
1215     return (0);
1216 }
1217 
1218 // ----------------------------------------------------------------------------
1219 //  SetStereoPlayout
1220 // ----------------------------------------------------------------------------
1221 
SetStereoPlayout(bool enable)1222 int32_t AudioDeviceModuleImpl::SetStereoPlayout(bool enable)
1223 {
1224     CHECK_INITIALIZED();
1225 
1226     if (_ptrAudioDevice->PlayoutIsInitialized())
1227     {
1228         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "unable to set stereo mode while playing side is initialized");
1229         return -1;
1230     }
1231 
1232     if (_ptrAudioDevice->SetStereoPlayout(enable))
1233     {
1234         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "stereo playout is not supported");
1235         return -1;
1236     }
1237 
1238     int8_t nChannels(1);
1239     if (enable)
1240     {
1241         nChannels = 2;
1242     }
1243     _audioDeviceBuffer.SetPlayoutChannels(nChannels);
1244 
1245     return 0;
1246 }
1247 
1248 // ----------------------------------------------------------------------------
1249 //  StereoPlayout
1250 // ----------------------------------------------------------------------------
1251 
StereoPlayout(bool * enabled) const1252 int32_t AudioDeviceModuleImpl::StereoPlayout(bool* enabled) const
1253 {
1254     CHECK_INITIALIZED();
1255 
1256     bool stereo(false);
1257 
1258     if (_ptrAudioDevice->StereoPlayout(stereo) == -1)
1259     {
1260         return -1;
1261     }
1262 
1263    *enabled = stereo;
1264 
1265    WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: enabled=%u", *enabled);
1266    return (0);
1267 }
1268 
1269 // ----------------------------------------------------------------------------
1270 //  SetAGC
1271 // ----------------------------------------------------------------------------
1272 
SetAGC(bool enable)1273 int32_t AudioDeviceModuleImpl::SetAGC(bool enable)
1274 {
1275     CHECK_INITIALIZED();
1276     return (_ptrAudioDevice->SetAGC(enable));
1277 }
1278 
1279 // ----------------------------------------------------------------------------
1280 //  AGC
1281 // ----------------------------------------------------------------------------
1282 
AGC() const1283 bool AudioDeviceModuleImpl::AGC() const
1284 {
1285     CHECK_INITIALIZED_BOOL();
1286     return (_ptrAudioDevice->AGC());
1287 }
1288 
1289 // ----------------------------------------------------------------------------
1290 //  PlayoutIsAvailable
1291 // ----------------------------------------------------------------------------
1292 
PlayoutIsAvailable(bool * available)1293 int32_t AudioDeviceModuleImpl::PlayoutIsAvailable(bool* available)
1294 {
1295     CHECK_INITIALIZED();
1296 
1297     bool isAvailable(0);
1298 
1299     if (_ptrAudioDevice->PlayoutIsAvailable(isAvailable) == -1)
1300     {
1301         return -1;
1302     }
1303 
1304     *available = isAvailable;
1305 
1306     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: available=%d", *available);
1307     return (0);
1308 }
1309 
1310 // ----------------------------------------------------------------------------
1311 //  RecordingIsAvailable
1312 // ----------------------------------------------------------------------------
1313 
RecordingIsAvailable(bool * available)1314 int32_t AudioDeviceModuleImpl::RecordingIsAvailable(bool* available)
1315 {
1316     CHECK_INITIALIZED();
1317 
1318     bool isAvailable(0);
1319 
1320     if (_ptrAudioDevice->RecordingIsAvailable(isAvailable) == -1)
1321     {
1322         return -1;
1323     }
1324 
1325     *available = isAvailable;
1326 
1327     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: available=%d", *available);
1328     return (0);
1329 }
1330 
1331 // ----------------------------------------------------------------------------
1332 //  MaxMicrophoneVolume
1333 // ----------------------------------------------------------------------------
1334 
MaxMicrophoneVolume(uint32_t * maxVolume) const1335 int32_t AudioDeviceModuleImpl::MaxMicrophoneVolume(uint32_t* maxVolume) const
1336 {
1337     WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "%s", __FUNCTION__);
1338     CHECK_INITIALIZED();
1339 
1340     uint32_t maxVol(0);
1341 
1342     if (_ptrAudioDevice->MaxMicrophoneVolume(maxVol) == -1)
1343     {
1344         return -1;
1345     }
1346 
1347     *maxVolume = maxVol;
1348 
1349     WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "output: maxVolume=%d", *maxVolume);
1350     return (0);
1351 }
1352 
1353 // ----------------------------------------------------------------------------
1354 //  MinMicrophoneVolume
1355 // ----------------------------------------------------------------------------
1356 
MinMicrophoneVolume(uint32_t * minVolume) const1357 int32_t AudioDeviceModuleImpl::MinMicrophoneVolume(uint32_t* minVolume) const
1358 {
1359     CHECK_INITIALIZED();
1360 
1361     uint32_t minVol(0);
1362 
1363     if (_ptrAudioDevice->MinMicrophoneVolume(minVol) == -1)
1364     {
1365         return -1;
1366     }
1367 
1368     *minVolume = minVol;
1369 
1370     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: minVolume=%u", *minVolume);
1371     return (0);
1372 }
1373 
1374 // ----------------------------------------------------------------------------
1375 //  MicrophoneVolumeStepSize
1376 // ----------------------------------------------------------------------------
1377 
MicrophoneVolumeStepSize(uint16_t * stepSize) const1378 int32_t AudioDeviceModuleImpl::MicrophoneVolumeStepSize(uint16_t* stepSize) const
1379 {
1380     CHECK_INITIALIZED();
1381 
1382     uint16_t delta(0);
1383 
1384     if (_ptrAudioDevice->MicrophoneVolumeStepSize(delta) == -1)
1385     {
1386         return -1;
1387     }
1388 
1389     *stepSize = delta;
1390 
1391     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: stepSize=%u", *stepSize);
1392     return (0);
1393 }
1394 
1395 // ----------------------------------------------------------------------------
1396 //  PlayoutDevices
1397 // ----------------------------------------------------------------------------
1398 
PlayoutDevices()1399 int16_t AudioDeviceModuleImpl::PlayoutDevices()
1400 {
1401     CHECK_INITIALIZED();
1402 
1403     uint16_t nPlayoutDevices = _ptrAudioDevice->PlayoutDevices();
1404 
1405     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: #playout devices=%d", nPlayoutDevices);
1406     return ((int16_t)(nPlayoutDevices));
1407 }
1408 
1409 // ----------------------------------------------------------------------------
1410 //  SetPlayoutDevice I (II)
1411 // ----------------------------------------------------------------------------
1412 
SetPlayoutDevice(uint16_t index)1413 int32_t AudioDeviceModuleImpl::SetPlayoutDevice(uint16_t index)
1414 {
1415     CHECK_INITIALIZED();
1416     return (_ptrAudioDevice->SetPlayoutDevice(index));
1417 }
1418 
1419 // ----------------------------------------------------------------------------
1420 //  SetPlayoutDevice II (II)
1421 // ----------------------------------------------------------------------------
1422 
SetPlayoutDevice(WindowsDeviceType device)1423 int32_t AudioDeviceModuleImpl::SetPlayoutDevice(WindowsDeviceType device)
1424 {
1425     if (device == kDefaultDevice)
1426     {
1427     }
1428     else
1429     {
1430     }
1431     CHECK_INITIALIZED();
1432 
1433     return (_ptrAudioDevice->SetPlayoutDevice(device));
1434 }
1435 
1436 // ----------------------------------------------------------------------------
1437 //  PlayoutDeviceName
1438 // ----------------------------------------------------------------------------
1439 
PlayoutDeviceName(uint16_t index,char name[kAdmMaxDeviceNameSize],char guid[kAdmMaxGuidSize])1440 int32_t AudioDeviceModuleImpl::PlayoutDeviceName(
1441     uint16_t index,
1442     char name[kAdmMaxDeviceNameSize],
1443     char guid[kAdmMaxGuidSize])
1444 {
1445     CHECK_INITIALIZED();
1446 
1447     if (name == NULL)
1448     {
1449         _lastError = kAdmErrArgument;
1450         return -1;
1451     }
1452 
1453     if (_ptrAudioDevice->PlayoutDeviceName(index, name, guid) == -1)
1454     {
1455         return -1;
1456     }
1457 
1458     if (name != NULL)
1459     {
1460         WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: name=%s", name);
1461     }
1462     if (guid != NULL)
1463     {
1464         WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: guid=%s", guid);
1465     }
1466 
1467     return (0);
1468 }
1469 
1470 // ----------------------------------------------------------------------------
1471 //  RecordingDeviceName
1472 // ----------------------------------------------------------------------------
1473 
RecordingDeviceName(uint16_t index,char name[kAdmMaxDeviceNameSize],char guid[kAdmMaxGuidSize])1474 int32_t AudioDeviceModuleImpl::RecordingDeviceName(
1475     uint16_t index,
1476     char name[kAdmMaxDeviceNameSize],
1477     char guid[kAdmMaxGuidSize])
1478 {
1479     CHECK_INITIALIZED();
1480 
1481     if (name == NULL)
1482     {
1483         _lastError = kAdmErrArgument;
1484         return -1;
1485     }
1486 
1487     if (_ptrAudioDevice->RecordingDeviceName(index, name, guid) == -1)
1488     {
1489         return -1;
1490     }
1491 
1492     if (name != NULL)
1493     {
1494         WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: name=%s", name);
1495     }
1496     if (guid != NULL)
1497     {
1498         WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: guid=%s", guid);
1499     }
1500 
1501     return (0);
1502 }
1503 
1504 // ----------------------------------------------------------------------------
1505 //  RecordingDevices
1506 // ----------------------------------------------------------------------------
1507 
RecordingDevices()1508 int16_t AudioDeviceModuleImpl::RecordingDevices()
1509 {
1510     CHECK_INITIALIZED();
1511 
1512     uint16_t nRecordingDevices = _ptrAudioDevice->RecordingDevices();
1513 
1514     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id,
1515                  "output: #recording devices=%d", nRecordingDevices);
1516     return ((int16_t)nRecordingDevices);
1517 }
1518 
1519 // ----------------------------------------------------------------------------
1520 //  SetRecordingDevice I (II)
1521 // ----------------------------------------------------------------------------
1522 
SetRecordingDevice(uint16_t index)1523 int32_t AudioDeviceModuleImpl::SetRecordingDevice(uint16_t index)
1524 {
1525     CHECK_INITIALIZED();
1526     return (_ptrAudioDevice->SetRecordingDevice(index));
1527 }
1528 
1529 // ----------------------------------------------------------------------------
1530 //  SetRecordingDevice II (II)
1531 // ----------------------------------------------------------------------------
1532 
SetRecordingDevice(WindowsDeviceType device)1533 int32_t AudioDeviceModuleImpl::SetRecordingDevice(WindowsDeviceType device)
1534 {
1535     if (device == kDefaultDevice)
1536     {
1537     }
1538     else
1539     {
1540     }
1541     CHECK_INITIALIZED();
1542 
1543     return (_ptrAudioDevice->SetRecordingDevice(device));
1544 }
1545 
1546 // ----------------------------------------------------------------------------
1547 //  InitPlayout
1548 // ----------------------------------------------------------------------------
1549 
InitPlayout()1550 int32_t AudioDeviceModuleImpl::InitPlayout()
1551 {
1552     CHECK_INITIALIZED();
1553     _audioDeviceBuffer.InitPlayout();
1554     return (_ptrAudioDevice->InitPlayout());
1555 }
1556 
1557 // ----------------------------------------------------------------------------
1558 //  InitRecording
1559 // ----------------------------------------------------------------------------
1560 
InitRecording()1561 int32_t AudioDeviceModuleImpl::InitRecording()
1562 {
1563     CHECK_INITIALIZED();
1564     _audioDeviceBuffer.InitRecording();
1565     return (_ptrAudioDevice->InitRecording());
1566 }
1567 
1568 // ----------------------------------------------------------------------------
1569 //  PlayoutIsInitialized
1570 // ----------------------------------------------------------------------------
1571 
PlayoutIsInitialized() const1572 bool AudioDeviceModuleImpl::PlayoutIsInitialized() const
1573 {
1574     CHECK_INITIALIZED_BOOL();
1575     return (_ptrAudioDevice->PlayoutIsInitialized());
1576 }
1577 
1578 // ----------------------------------------------------------------------------
1579 //  RecordingIsInitialized
1580 // ----------------------------------------------------------------------------
1581 
RecordingIsInitialized() const1582 bool AudioDeviceModuleImpl::RecordingIsInitialized() const
1583 {
1584     CHECK_INITIALIZED_BOOL();
1585     return (_ptrAudioDevice->RecordingIsInitialized());
1586 }
1587 
1588 // ----------------------------------------------------------------------------
1589 //  StartPlayout
1590 // ----------------------------------------------------------------------------
1591 
StartPlayout()1592 int32_t AudioDeviceModuleImpl::StartPlayout()
1593 {
1594     CHECK_INITIALIZED();
1595     return (_ptrAudioDevice->StartPlayout());
1596 }
1597 
1598 // ----------------------------------------------------------------------------
1599 //  StopPlayout
1600 // ----------------------------------------------------------------------------
1601 
StopPlayout()1602 int32_t AudioDeviceModuleImpl::StopPlayout()
1603 {
1604     CHECK_INITIALIZED();
1605     return (_ptrAudioDevice->StopPlayout());
1606 }
1607 
1608 // ----------------------------------------------------------------------------
1609 //  Playing
1610 // ----------------------------------------------------------------------------
1611 
Playing() const1612 bool AudioDeviceModuleImpl::Playing() const
1613 {
1614     CHECK_INITIALIZED_BOOL();
1615     return (_ptrAudioDevice->Playing());
1616 }
1617 
1618 // ----------------------------------------------------------------------------
1619 //  StartRecording
1620 // ----------------------------------------------------------------------------
1621 
StartRecording()1622 int32_t AudioDeviceModuleImpl::StartRecording()
1623 {
1624     CHECK_INITIALIZED();
1625     return (_ptrAudioDevice->StartRecording());
1626 }
1627 // ----------------------------------------------------------------------------
1628 //  StopRecording
1629 // ----------------------------------------------------------------------------
1630 
StopRecording()1631 int32_t AudioDeviceModuleImpl::StopRecording()
1632 {
1633     CHECK_INITIALIZED();
1634     return (_ptrAudioDevice->StopRecording());
1635 }
1636 
1637 // ----------------------------------------------------------------------------
1638 //  Recording
1639 // ----------------------------------------------------------------------------
1640 
Recording() const1641 bool AudioDeviceModuleImpl::Recording() const
1642 {
1643     CHECK_INITIALIZED_BOOL();
1644     return (_ptrAudioDevice->Recording());
1645 }
1646 
1647 // ----------------------------------------------------------------------------
1648 //  RegisterEventObserver
1649 // ----------------------------------------------------------------------------
1650 
RegisterEventObserver(AudioDeviceObserver * eventCallback)1651 int32_t AudioDeviceModuleImpl::RegisterEventObserver(AudioDeviceObserver* eventCallback)
1652 {
1653 
1654     CriticalSectionScoped lock(&_critSectEventCb);
1655     _ptrCbAudioDeviceObserver = eventCallback;
1656 
1657     return 0;
1658 }
1659 
1660 // ----------------------------------------------------------------------------
1661 //  RegisterAudioCallback
1662 // ----------------------------------------------------------------------------
1663 
RegisterAudioCallback(AudioTransport * audioCallback)1664 int32_t AudioDeviceModuleImpl::RegisterAudioCallback(AudioTransport* audioCallback)
1665 {
1666 
1667     CriticalSectionScoped lock(&_critSectAudioCb);
1668     _audioDeviceBuffer.RegisterAudioCallback(audioCallback);
1669 
1670     return 0;
1671 }
1672 
1673 // ----------------------------------------------------------------------------
1674 //  StartRawInputFileRecording
1675 // ----------------------------------------------------------------------------
1676 
StartRawInputFileRecording(const char pcmFileNameUTF8[kAdmMaxFileNameSize])1677 int32_t AudioDeviceModuleImpl::StartRawInputFileRecording(
1678     const char pcmFileNameUTF8[kAdmMaxFileNameSize])
1679 {
1680     CHECK_INITIALIZED();
1681 
1682     if (NULL == pcmFileNameUTF8)
1683     {
1684         return -1;
1685     }
1686 
1687     return (_audioDeviceBuffer.StartInputFileRecording(pcmFileNameUTF8));
1688 }
1689 
1690 // ----------------------------------------------------------------------------
1691 //  StopRawInputFileRecording
1692 // ----------------------------------------------------------------------------
1693 
StopRawInputFileRecording()1694 int32_t AudioDeviceModuleImpl::StopRawInputFileRecording()
1695 {
1696     CHECK_INITIALIZED();
1697 
1698     return (_audioDeviceBuffer.StopInputFileRecording());
1699 }
1700 
1701 // ----------------------------------------------------------------------------
1702 //  StartRawOutputFileRecording
1703 // ----------------------------------------------------------------------------
1704 
StartRawOutputFileRecording(const char pcmFileNameUTF8[kAdmMaxFileNameSize])1705 int32_t AudioDeviceModuleImpl::StartRawOutputFileRecording(
1706     const char pcmFileNameUTF8[kAdmMaxFileNameSize])
1707 {
1708     CHECK_INITIALIZED();
1709 
1710     if (NULL == pcmFileNameUTF8)
1711     {
1712         return -1;
1713     }
1714 
1715     return (_audioDeviceBuffer.StartOutputFileRecording(pcmFileNameUTF8));
1716 }
1717 
1718 // ----------------------------------------------------------------------------
1719 //  StopRawOutputFileRecording
1720 // ----------------------------------------------------------------------------
1721 
StopRawOutputFileRecording()1722 int32_t AudioDeviceModuleImpl::StopRawOutputFileRecording()
1723 {
1724     CHECK_INITIALIZED();
1725 
1726     return (_audioDeviceBuffer.StopOutputFileRecording());
1727 }
1728 
1729 // ----------------------------------------------------------------------------
1730 //  SetPlayoutBuffer
1731 // ----------------------------------------------------------------------------
1732 
SetPlayoutBuffer(const BufferType type,uint16_t sizeMS)1733 int32_t AudioDeviceModuleImpl::SetPlayoutBuffer(const BufferType type, uint16_t sizeMS)
1734 {
1735     CHECK_INITIALIZED();
1736 
1737     if (_ptrAudioDevice->PlayoutIsInitialized())
1738     {
1739         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "unable to modify the playout buffer while playing side is initialized");
1740         return -1;
1741     }
1742 
1743     int32_t ret(0);
1744 
1745     if (kFixedBufferSize == type)
1746     {
1747         if (sizeMS < kAdmMinPlayoutBufferSizeMs || sizeMS > kAdmMaxPlayoutBufferSizeMs)
1748         {
1749             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "size parameter is out of range");
1750             return -1;
1751         }
1752     }
1753 
1754     if ((ret = _ptrAudioDevice->SetPlayoutBuffer(type, sizeMS)) == -1)
1755     {
1756         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to set the playout buffer (error: %d)", LastError());
1757     }
1758 
1759     return ret;
1760 }
1761 
1762 // ----------------------------------------------------------------------------
1763 //  PlayoutBuffer
1764 // ----------------------------------------------------------------------------
1765 
PlayoutBuffer(BufferType * type,uint16_t * sizeMS) const1766 int32_t AudioDeviceModuleImpl::PlayoutBuffer(BufferType* type, uint16_t* sizeMS) const
1767 {
1768     CHECK_INITIALIZED();
1769 
1770     BufferType bufType;
1771     uint16_t size(0);
1772 
1773     if (_ptrAudioDevice->PlayoutBuffer(bufType, size) == -1)
1774     {
1775         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to retrieve the buffer type and size");
1776         return -1;
1777     }
1778 
1779     *type = bufType;
1780     *sizeMS = size;
1781 
1782     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: type=%u, sizeMS=%u", *type, *sizeMS);
1783     return (0);
1784 }
1785 
1786 // ----------------------------------------------------------------------------
1787 //  PlayoutDelay
1788 // ----------------------------------------------------------------------------
1789 
PlayoutDelay(uint16_t * delayMS) const1790 int32_t AudioDeviceModuleImpl::PlayoutDelay(uint16_t* delayMS) const
1791 {
1792     WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "%s", __FUNCTION__);
1793     CHECK_INITIALIZED();
1794 
1795     uint16_t delay(0);
1796 
1797     if (_ptrAudioDevice->PlayoutDelay(delay) == -1)
1798     {
1799         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to retrieve the playout delay");
1800         return -1;
1801     }
1802 
1803     *delayMS = delay;
1804 
1805     WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "output: delayMS=%u", *delayMS);
1806     return (0);
1807 }
1808 
1809 // ----------------------------------------------------------------------------
1810 //  RecordingDelay
1811 // ----------------------------------------------------------------------------
1812 
RecordingDelay(uint16_t * delayMS) const1813 int32_t AudioDeviceModuleImpl::RecordingDelay(uint16_t* delayMS) const
1814 {
1815     WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "%s", __FUNCTION__);
1816     CHECK_INITIALIZED();
1817 
1818     uint16_t delay(0);
1819 
1820     if (_ptrAudioDevice->RecordingDelay(delay) == -1)
1821     {
1822         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to retrieve the recording delay");
1823         return -1;
1824     }
1825 
1826     *delayMS = delay;
1827 
1828     WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "output: delayMS=%u", *delayMS);
1829     return (0);
1830 }
1831 
1832 // ----------------------------------------------------------------------------
1833 //  CPULoad
1834 // ----------------------------------------------------------------------------
1835 
CPULoad(uint16_t * load) const1836 int32_t AudioDeviceModuleImpl::CPULoad(uint16_t* load) const
1837 {
1838     CHECK_INITIALIZED();
1839 
1840     uint16_t cpuLoad(0);
1841 
1842     if (_ptrAudioDevice->CPULoad(cpuLoad) == -1)
1843     {
1844         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to retrieve the CPU load");
1845         return -1;
1846     }
1847 
1848     *load = cpuLoad;
1849 
1850     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: load=%u", *load);
1851     return (0);
1852 }
1853 
1854 // ----------------------------------------------------------------------------
1855 //  SetRecordingSampleRate
1856 // ----------------------------------------------------------------------------
1857 
SetRecordingSampleRate(const uint32_t samplesPerSec)1858 int32_t AudioDeviceModuleImpl::SetRecordingSampleRate(const uint32_t samplesPerSec)
1859 {
1860     CHECK_INITIALIZED();
1861 
1862     if (_ptrAudioDevice->SetRecordingSampleRate(samplesPerSec) != 0)
1863     {
1864         return -1;
1865     }
1866 
1867     return (0);
1868 }
1869 
1870 // ----------------------------------------------------------------------------
1871 //  RecordingSampleRate
1872 // ----------------------------------------------------------------------------
1873 
RecordingSampleRate(uint32_t * samplesPerSec) const1874 int32_t AudioDeviceModuleImpl::RecordingSampleRate(uint32_t* samplesPerSec) const
1875 {
1876     CHECK_INITIALIZED();
1877 
1878     int32_t sampleRate = _audioDeviceBuffer.RecordingSampleRate();
1879 
1880     if (sampleRate == -1)
1881     {
1882         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to retrieve the sample rate");
1883         return -1;
1884     }
1885 
1886     *samplesPerSec = sampleRate;
1887 
1888     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: samplesPerSec=%u", *samplesPerSec);
1889     return (0);
1890 }
1891 
1892 // ----------------------------------------------------------------------------
1893 //  SetPlayoutSampleRate
1894 // ----------------------------------------------------------------------------
1895 
SetPlayoutSampleRate(const uint32_t samplesPerSec)1896 int32_t AudioDeviceModuleImpl::SetPlayoutSampleRate(const uint32_t samplesPerSec)
1897 {
1898     CHECK_INITIALIZED();
1899 
1900     if (_ptrAudioDevice->SetPlayoutSampleRate(samplesPerSec) != 0)
1901     {
1902         return -1;
1903     }
1904 
1905     return (0);
1906 }
1907 
1908 // ----------------------------------------------------------------------------
1909 //  PlayoutSampleRate
1910 // ----------------------------------------------------------------------------
1911 
PlayoutSampleRate(uint32_t * samplesPerSec) const1912 int32_t AudioDeviceModuleImpl::PlayoutSampleRate(uint32_t* samplesPerSec) const
1913 {
1914     CHECK_INITIALIZED();
1915 
1916     int32_t sampleRate = _audioDeviceBuffer.PlayoutSampleRate();
1917 
1918     if (sampleRate == -1)
1919     {
1920         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "failed to retrieve the sample rate");
1921         return -1;
1922     }
1923 
1924     *samplesPerSec = sampleRate;
1925 
1926     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id, "output: samplesPerSec=%u", *samplesPerSec);
1927     return (0);
1928 }
1929 
1930 // ----------------------------------------------------------------------------
1931 //  ResetAudioDevice
1932 // ----------------------------------------------------------------------------
1933 
ResetAudioDevice()1934 int32_t AudioDeviceModuleImpl::ResetAudioDevice()
1935 {
1936     CHECK_INITIALIZED();
1937 
1938 
1939     if (_ptrAudioDevice->ResetAudioDevice() == -1)
1940     {
1941         return -1;
1942     }
1943 
1944     return (0);
1945 }
1946 
1947 // ----------------------------------------------------------------------------
1948 //  SetLoudspeakerStatus
1949 // ----------------------------------------------------------------------------
1950 
SetLoudspeakerStatus(bool enable)1951 int32_t AudioDeviceModuleImpl::SetLoudspeakerStatus(bool enable)
1952 {
1953     CHECK_INITIALIZED();
1954 
1955     if (_ptrAudioDevice->SetLoudspeakerStatus(enable) != 0)
1956     {
1957         return -1;
1958     }
1959 
1960     return 0;
1961 }
1962 
1963 // ----------------------------------------------------------------------------
1964 //  GetLoudspeakerStatus
1965 // ----------------------------------------------------------------------------
1966 
GetLoudspeakerStatus(bool * enabled) const1967 int32_t AudioDeviceModuleImpl::GetLoudspeakerStatus(bool* enabled) const
1968 {
1969     CHECK_INITIALIZED();
1970 
1971     if (_ptrAudioDevice->GetLoudspeakerStatus(*enabled) != 0)
1972     {
1973         return -1;
1974     }
1975 
1976     return 0;
1977 }
1978 
EnableBuiltInAEC(bool enable)1979 int32_t AudioDeviceModuleImpl::EnableBuiltInAEC(bool enable)
1980 {
1981     CHECK_INITIALIZED();
1982 
1983     return _ptrAudioDevice->EnableBuiltInAEC(enable);
1984 }
1985 
BuiltInAECIsEnabled() const1986 bool AudioDeviceModuleImpl::BuiltInAECIsEnabled() const
1987 {
1988     CHECK_INITIALIZED_BOOL();
1989 
1990     return _ptrAudioDevice->BuiltInAECIsEnabled();
1991 }
1992 
1993 // ============================================================================
1994 //                                 Private Methods
1995 // ============================================================================
1996 
1997 // ----------------------------------------------------------------------------
1998 //  Platform
1999 // ----------------------------------------------------------------------------
2000 
Platform() const2001 AudioDeviceModuleImpl::PlatformType AudioDeviceModuleImpl::Platform() const
2002 {
2003     return _platformType;
2004 }
2005 
2006 // ----------------------------------------------------------------------------
2007 //  PlatformAudioLayer
2008 // ----------------------------------------------------------------------------
2009 
PlatformAudioLayer() const2010 AudioDeviceModule::AudioLayer AudioDeviceModuleImpl::PlatformAudioLayer() const
2011 {
2012 
2013     switch (_platformAudioLayer)
2014     {
2015     case kPlatformDefaultAudio:
2016         WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id,
2017                      "output: kPlatformDefaultAudio");
2018         break;
2019     case kWindowsWaveAudio:
2020         WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id,
2021                      "output: kWindowsWaveAudio");
2022         break;
2023     case kWindowsCoreAudio:
2024         WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id,
2025                      "output: kWindowsCoreAudio");
2026         break;
2027     case kLinuxAlsaAudio:
2028         WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id,
2029                      "output: kLinuxAlsaAudio");
2030         break;
2031     case kDummyAudio:
2032         WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, _id,
2033                      "output: kDummyAudio");
2034         break;
2035     default:
2036         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
2037                      "output: INVALID");
2038         break;
2039     }
2040 
2041     return _platformAudioLayer;
2042 }
2043 
2044 }  // namespace webrtc
2045