Removes unused APIs from the ADM (part II)

webrtc/modules/audio_device/audio_device_impl.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 618 matching lines @@
 
   if (_ptrAudioDevice->MinSpeakerVolume(minVol) == -1) {
     return -1;
   }
 
   *minVolume = minVol;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
-//  SpeakerVolumeStepSize
-// ----------------------------------------------------------------------------
-
-int32_t AudioDeviceModuleImpl::SpeakerVolumeStepSize(uint16_t* stepSize) const {
-  LOG(INFO) << __FUNCTION__;
-  CHECK_INITIALIZED();
-
-  uint16_t delta(0);
-
-  if (_ptrAudioDevice->SpeakerVolumeStepSize(delta) == -1) {
-    LOG(LERROR) << "failed to retrieve the speaker-volume step size";
-    return -1;
-  }
-
-  *stepSize = delta;
-  LOG(INFO) << "output: " << *stepSize;
-  return (0);
-}
-
-// ----------------------------------------------------------------------------
 //  SpeakerMuteIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SpeakerMuteIsAvailable(bool* available) {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool isAvailable(0);
 
   if (_ptrAudioDevice->SpeakerMuteIsAvailable(isAvailable) == -1) {
@@ skipping 76 matching lines @@
   if (_ptrAudioDevice->MicrophoneMute(muted) == -1) {
     return -1;
   }
 
   *enabled = muted;
   LOG(INFO) << "output: " << muted;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
-//  MicrophoneBoostIsAvailable
-// ----------------------------------------------------------------------------
-
-int32_t AudioDeviceModuleImpl::MicrophoneBoostIsAvailable(bool* available) {
-  LOG(INFO) << __FUNCTION__;
-  CHECK_INITIALIZED();
-
-  bool isAvailable(0);
-
-  if (_ptrAudioDevice->MicrophoneBoostIsAvailable(isAvailable) == -1) {
-    return -1;
-  }
-
-  *available = isAvailable;
-  LOG(INFO) << "output: " << isAvailable;
-  return (0);
-}
-
-// ----------------------------------------------------------------------------
-//  SetMicrophoneBoost
-// ----------------------------------------------------------------------------
-
-int32_t AudioDeviceModuleImpl::SetMicrophoneBoost(bool enable) {
-  LOG(INFO) << __FUNCTION__ << "(" << enable << ")";
-  CHECK_INITIALIZED();
-  return (_ptrAudioDevice->SetMicrophoneBoost(enable));
-}
-
-// ----------------------------------------------------------------------------
-//  MicrophoneBoost
-// ----------------------------------------------------------------------------
-
-int32_t AudioDeviceModuleImpl::MicrophoneBoost(bool* enabled) const {
-  LOG(INFO) << __FUNCTION__;
-  CHECK_INITIALIZED();
-
-  bool onOff(false);
-
-  if (_ptrAudioDevice->MicrophoneBoost(onOff) == -1) {
-    return -1;
-  }
-
-  *enabled = onOff;
-  LOG(INFO) << "output: " << onOff;
-  return (0);
-}
-
-// ----------------------------------------------------------------------------
 //  MicrophoneVolumeIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::MicrophoneVolumeIsAvailable(bool* available) {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool isAvailable(0);
 
   if (_ptrAudioDevice->MicrophoneVolumeIsAvailable(isAvailable) == -1) {
@@ skipping 301 matching lines @@
 
   if (_ptrAudioDevice->MinMicrophoneVolume(minVol) == -1) {
     return -1;
   }
 
   *minVolume = minVol;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
-//  MicrophoneVolumeStepSize
-// ----------------------------------------------------------------------------
-
-int32_t AudioDeviceModuleImpl::MicrophoneVolumeStepSize(
-    uint16_t* stepSize) const {
-  LOG(INFO) << __FUNCTION__;
-  CHECK_INITIALIZED();
-
-  uint16_t delta(0);
-
-  if (_ptrAudioDevice->MicrophoneVolumeStepSize(delta) == -1) {
-    return -1;
-  }
-
-  *stepSize = delta;
-  LOG(INFO) << "output: " << *stepSize;
-  return (0);
-}
-
-// ----------------------------------------------------------------------------
 //  PlayoutDevices
 // ----------------------------------------------------------------------------
 
 int16_t AudioDeviceModuleImpl::PlayoutDevices() {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint16_t nPlayoutDevices = _ptrAudioDevice->PlayoutDevices();
   LOG(INFO) << "output: " << nPlayoutDevices;
   return ((int16_t)(nPlayoutDevices));
@@ skipping 272 matching lines @@
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::RegisterAudioCallback(
     AudioTransport* audioCallback) {
   LOG(INFO) << __FUNCTION__;
   rtc::CritScope lock(&_critSectAudioCb);
   return _audioDeviceBuffer.RegisterAudioCallback(audioCallback);
 }
 
 // ----------------------------------------------------------------------------
-//  StartRawInputFileRecording
-// ----------------------------------------------------------------------------
-
-int32_t AudioDeviceModuleImpl::StartRawInputFileRecording(
-    const char pcmFileNameUTF8[kAdmMaxFileNameSize]) {
-  LOG(INFO) << __FUNCTION__;
-  CHECK_INITIALIZED();
-
-  if (NULL == pcmFileNameUTF8) {
-    return -1;
-  }
-
-  return (_audioDeviceBuffer.StartInputFileRecording(pcmFileNameUTF8));
-}
-
-// ----------------------------------------------------------------------------
-//  StopRawInputFileRecording
-// ----------------------------------------------------------------------------
-
-int32_t AudioDeviceModuleImpl::StopRawInputFileRecording() {
-  LOG(INFO) << __FUNCTION__;
-  CHECK_INITIALIZED();
-
-  return (_audioDeviceBuffer.StopInputFileRecording());
-}
-
-// ----------------------------------------------------------------------------
-//  StartRawOutputFileRecording
-// ----------------------------------------------------------------------------
-
-int32_t AudioDeviceModuleImpl::StartRawOutputFileRecording(
-    const char pcmFileNameUTF8[kAdmMaxFileNameSize]) {
-  LOG(INFO) << __FUNCTION__;
-  CHECK_INITIALIZED();
-
-  if (NULL == pcmFileNameUTF8) {
-    return -1;
-  }
-
-  return (_audioDeviceBuffer.StartOutputFileRecording(pcmFileNameUTF8));
-}
-
-// ----------------------------------------------------------------------------
-//  StopRawOutputFileRecording
-// ----------------------------------------------------------------------------
-
-int32_t AudioDeviceModuleImpl::StopRawOutputFileRecording() {
-  LOG(INFO) << __FUNCTION__;
-  CHECK_INITIALIZED();
-
-  return (_audioDeviceBuffer.StopOutputFileRecording());
-}
-
-// ----------------------------------------------------------------------------
-//  SetPlayoutBuffer
-// ----------------------------------------------------------------------------
-
-int32_t AudioDeviceModuleImpl::SetPlayoutBuffer(const BufferType type,
-                                                uint16_t sizeMS) {
-  if (type == kFixedBufferSize) {
-    LOG(INFO) << __FUNCTION__ << "(fixed buffer, " << sizeMS << "ms)";
-  } else if (type == kAdaptiveBufferSize) {
-    LOG(INFO) << __FUNCTION__ << "(adaptive buffer, " << sizeMS << "ms)";
-  } else {
-    LOG(INFO) << __FUNCTION__ << "(?, " << sizeMS << "ms)";
-  }
-  CHECK_INITIALIZED();
-
-  if (_ptrAudioDevice->PlayoutIsInitialized()) {
-    LOG(LERROR) << "unable to modify the playout buffer while playing side is "
-                   "initialized";
-    return -1;
-  }
-
-  int32_t ret(0);
-
-  if (kFixedBufferSize == type) {
-    if (sizeMS < kAdmMinPlayoutBufferSizeMs ||
-        sizeMS > kAdmMaxPlayoutBufferSizeMs) {
-      LOG(LERROR) << "size parameter is out of range";
-      return -1;
-    }
-  }
-
-  if ((ret = _ptrAudioDevice->SetPlayoutBuffer(type, sizeMS)) == -1) {
-    LOG(LERROR) << "failed to set the playout buffer (error: " << LastError()
-                << ")";
-  }
-
-  return ret;
-}
-
-// ----------------------------------------------------------------------------
-//  PlayoutBuffer
-// ----------------------------------------------------------------------------
-
-int32_t AudioDeviceModuleImpl::PlayoutBuffer(BufferType* type,
-                                             uint16_t* sizeMS) const {
-  LOG(INFO) << __FUNCTION__;
-  CHECK_INITIALIZED();
-
-  BufferType bufType;
-  uint16_t size(0);
-
-  if (_ptrAudioDevice->PlayoutBuffer(bufType, size) == -1) {
-    LOG(LERROR) << "failed to retrieve the buffer type and size";
-    return -1;
-  }
-
-  *type = bufType;
-  *sizeMS = size;
-
-  LOG(INFO) << "output: type = " << *type << ", sizeMS = " << *sizeMS;
-  return (0);
-}
-
-// ----------------------------------------------------------------------------
 //  PlayoutDelay
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::PlayoutDelay(uint16_t* delayMS) const {
   CHECK_INITIALIZED();
 
   uint16_t delay(0);
 
   if (_ptrAudioDevice->PlayoutDelay(delay) == -1) {
     LOG(LERROR) << "failed to retrieve the playout delay";
@@ skipping 18 matching lines @@
     LOG(LERROR) << "failed to retrieve the recording delay";
     return -1;
   }
 
   *delayMS = delay;
   LOG(INFO) << "output: " << *delayMS;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
-//  CPULoad
-// ----------------------------------------------------------------------------
-
-int32_t AudioDeviceModuleImpl::CPULoad(uint16_t* load) const {
-  LOG(INFO) << __FUNCTION__;
-  CHECK_INITIALIZED();
-
-  uint16_t cpuLoad(0);
-
-  if (_ptrAudioDevice->CPULoad(cpuLoad) == -1) {
-    LOG(LERROR) << "failed to retrieve the CPU load";
-    return -1;
-  }
-
-  *load = cpuLoad;
-  LOG(INFO) << "output: " << *load;
-  return (0);
-}
-
-// ----------------------------------------------------------------------------
 //  SetRecordingSampleRate
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetRecordingSampleRate(
     const uint32_t samplesPerSec) {
   LOG(INFO) << __FUNCTION__ << "(" << samplesPerSec << ")";
   CHECK_INITIALIZED();
 
   if (_ptrAudioDevice->SetRecordingSampleRate(samplesPerSec) != 0) {
     return -1;
@@ skipping 54 matching lines @@
     LOG(LERROR) << "failed to retrieve the sample rate";
     return -1;
   }
 
   *samplesPerSec = sampleRate;
   LOG(INFO) << "output: " << *samplesPerSec;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
-//  ResetAudioDevice
-// ----------------------------------------------------------------------------
-
-int32_t AudioDeviceModuleImpl::ResetAudioDevice() {
-  LOG(INFO) << __FUNCTION__;
-  FATAL() << "Should never be called";
-  return -1;
-}
-
-// ----------------------------------------------------------------------------
 //  SetLoudspeakerStatus
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetLoudspeakerStatus(bool enable) {
   LOG(INFO) << __FUNCTION__ << "(" << enable << ")";
   CHECK_INITIALIZED();
 
   if (_ptrAudioDevice->SetLoudspeakerStatus(enable) != 0) {
     return -1;
   }
@@ skipping 99 matching lines @@
 //  PlatformAudioLayer
 // ----------------------------------------------------------------------------
 
 AudioDeviceModule::AudioLayer AudioDeviceModuleImpl::PlatformAudioLayer()
     const {
   LOG(INFO) << __FUNCTION__;
   return _platformAudioLayer;
 }
 
 }  // namespace webrtc