Remove no-op and unused methods from AudioCodingModule

webrtc/modules/audio_coding/main/interface/audio_coding_module.h

 /*
  *  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 176 matching lines @@
   //   true if the parameters are valid,
   //   false if any parameter is not valid.
   //
   static bool IsCodecValid(const CodecInst& codec);
 
   ///////////////////////////////////////////////////////////////////////////
   //   Sender
   //
 
   ///////////////////////////////////////////////////////////////////////////
-  // int32_t ResetEncoder()
-  // This API resets the states of encoder. All the encoder settings, such as
-  // send-codec or VAD/DTX, will be preserved.
-  //
-  // Return value:
-  //   -1 if failed to initialize,
-  //    0 if succeeded.
-  //
-  virtual int32_t ResetEncoder() = 0;
-
-  ///////////////////////////////////////////////////////////////////////////
   // int32_t RegisterSendCodec()
   // Registers a codec, specified by |send_codec|, as sending codec.
   // This API can be called multiple of times to register Codec. The last codec
   // registered overwrites the previous ones.
   // The API can also be used to change payload type for CNG and RED, which are
   // registered by default to default payload types.
   // Note that registering CNG and RED won't overwrite speech codecs.
   // This API can be called to set/change the send payload-type, frame-size
   // or encoding rate (if applicable for the codec).
   //
@@ skipping 37 matching lines @@
   // int32_t SendFrequency()
   // Get the sampling frequency of the current encoder in Hertz.
   //
   // Return value:
   //   positive; sampling frequency [Hz] of the current encoder.
   //   -1 if an error has happened.
   //
   virtual int32_t SendFrequency() const = 0;
 
   ///////////////////////////////////////////////////////////////////////////
-  // int32_t Bitrate()
-  // Get encoding bit-rate in bits per second.
-  //
-  // Return value:
-  //   positive; encoding rate in bits/sec,
-  //   -1 if an error is happened.
-  //
-  virtual int32_t SendBitrate() const = 0;
-
-  ///////////////////////////////////////////////////////////////////////////
   // Sets the bitrate to the specified value in bits/sec. If the value is not
   // supported by the codec, it will choose another appropriate value.
   virtual void SetBitRate(int bitrate_bps) = 0;
 
-  ///////////////////////////////////////////////////////////////////////////
-  // int32_t SetReceivedEstimatedBandwidth()
-  // Set available bandwidth [bits/sec] of the up-link channel.
-  // This information is used for traffic shaping, and is currently only
-  // supported if iSAC is the send codec.
-  //
-  // Input:
-  //   -bw                 : bandwidth in bits/sec estimated for
-  //                         up-link.
-  // Return value
-  //   -1 if error occurred in setting the bandwidth,
-  //    0 bandwidth is set successfully.
-  //
-  // TODO(henrik.lundin) Unused. Remove?
-  virtual int32_t SetReceivedEstimatedBandwidth(
-      const int32_t bw) = 0;
-
-  ///////////////////////////////////////////////////////////////////////////
   // int32_t RegisterTransportCallback()
   // Register a transport callback which will be called to deliver
   // the encoded buffers whenever Process() is called and a
   // bit-stream is ready.
   //
   // Input:
   //   -transport          : pointer to the callback class
   //                         transport->SendData() is called whenever
   //                         Process() is called and bit-stream is ready
   //                         to deliver.
@@ skipping 152 matching lines @@
   //   -vad_mode            : is set to the current aggressiveness of VAD.
   //
   // Return value:
   //   -1 if fails to retrieve the setting of DTX/VAD,
   //    0 if succeeded.
   //
   virtual int32_t VAD(bool* dtx_enabled, bool* vad_enabled,
                             ACMVADMode* vad_mode) const = 0;
 
   ///////////////////////////////////////////////////////////////////////////
-  // int32_t ReplaceInternalDTXWithWebRtc()
-  // Used to replace codec internal DTX scheme with WebRtc.
-  //
-  // Input:
-  //   -use_webrtc_dtx     : if false (default) the codec built-in DTX/VAD
-  //                         scheme is used, otherwise the internal DTX is
-  //                         replaced with WebRtc DTX/VAD.
-  //
-  // Return value:
-  //   -1 if failed to replace codec internal DTX with WebRtc,
-  //    0 if succeeded.
-  //
-  virtual int32_t ReplaceInternalDTXWithWebRtc(
-      const bool use_webrtc_dtx = false) = 0;
-
-  ///////////////////////////////////////////////////////////////////////////
-  // int32_t IsInternalDTXReplacedWithWebRtc()
-  // Get status if the codec internal DTX is replaced with WebRtc DTX.
-  // This should always be true if codec does not have an internal DTX.
-  //
-  // Output:
-  //   -uses_webrtc_dtx    : is set to true if the codec internal DTX is
-  //                         replaced with WebRtc DTX/VAD, otherwise it is set
-  //                         to false.
-  //
-  // Return value:
-  //   -1 if failed to determine if codec internal DTX is replaced with WebRtc,
-  //    0 if succeeded.
-  //
-  virtual int32_t IsInternalDTXReplacedWithWebRtc(
-      bool* uses_webrtc_dtx) = 0;
-
-  ///////////////////////////////////////////////////////////////////////////
   // int32_t RegisterVADCallback()
   // Call this method to register a callback function which is called
   // any time that ACM encounters an empty frame. That is a frame which is
   // recognized inactive. Depending on the codec WebRtc VAD or internal codec
   // VAD is employed to identify a frame as active/inactive.
   //
   // Input:
   //   -vad_callback        : pointer to a callback function.
   //
   // Return value:
@@ skipping 15 matching lines @@
   // For instance, all registered codecs are deleted and have to be
   // registered again.
   //
   // Return value:
   //   -1 if failed to initialize,
   //    0 if succeeded.
   //
   virtual int32_t InitializeReceiver() = 0;
 
   ///////////////////////////////////////////////////////////////////////////
-  // int32_t ResetDecoder()
-  // This API resets the states of decoders. ACM will not lose any
-  // decoder-related settings, such as registered codecs.
-  //
-  // Return value:
-  //   -1 if failed to initialize,
-  //    0 if succeeded.
-  //
-  virtual int32_t ResetDecoder() = 0;
-
-  ///////////////////////////////////////////////////////////////////////////
   // int32_t ReceiveFrequency()
   // Get sampling frequency of the last received payload.
   //
   // Return value:
   //   non-negative the sampling frequency in Hertz.
   //   -1 if an error has occurred.
   //
   virtual int32_t ReceiveFrequency() const = 0;
 
   ///////////////////////////////////////////////////////////////////////////
@@ skipping 174 matching lines @@
   //   -timestamp          : a reference to a uint32_t to receive the
   //                         timestamp.
   // Return value:
   //    0 if the output is a correct timestamp.
   //   -1 if failed to output the correct timestamp.
   //
   // TODO(tlegrand): Change function to return the timestamp.
   virtual int32_t PlayoutTimestamp(uint32_t* timestamp) = 0;
 
   ///////////////////////////////////////////////////////////////////////////
-  // int32_t DecoderEstimatedBandwidth()
-  // Get the estimate of the Bandwidth, in bits/second, based on the incoming
-  // stream. This API is useful in one-way communication scenarios, where
-  // the bandwidth information is sent in an out-of-band fashion.
-  // Currently only supported if iSAC is registered as a receiver.
-  //
-  // Return value:
-  //   >0 bandwidth in bits/second.
-  //   -1 if failed to get a bandwidth estimate.
-  //
-  virtual int32_t DecoderEstimatedBandwidth() const = 0;
-
-  ///////////////////////////////////////////////////////////////////////////
   // int32_t SetPlayoutMode()
   // Call this API to set the playout mode. Playout mode could be optimized
   // for i) voice, ii) FAX or iii) streaming. In Voice mode, NetEQ is
   // optimized to deliver highest audio quality while maintaining a minimum
   // delay. In FAX mode, NetEQ is optimized to have few delay changes as
   // possible and maintain a constant delay, perhaps large relative to voice
   // mode, to avoid PLC. In streaming mode, we tolerate a little more delay
   // to achieve better jitter robustness.
   //
   // Input:
@@ skipping 78 matching lines @@
   // Input:
   //   -max_payload_len_bytes : maximum payload size in bytes.
   //
   // Return value:
   //   -1 if failed to set the maximum  payload-size.
   //    0 if the given length is set successfully.
   //
   virtual int SetISACMaxPayloadSize(int max_payload_len_bytes) = 0;
 
   ///////////////////////////////////////////////////////////////////////////
-  // int32_t ConfigISACBandwidthEstimator()
-  // Call this function to configure the bandwidth estimator of ISAC.
-  // During the adaptation of bit-rate, iSAC automatically adjusts the
-  // frame-size (either 30 or 60 ms) to save on RTP header. The initial
-  // frame-size can be specified by the first argument. The configuration also
-  // regards the initial estimate of bandwidths. The estimator starts from
-  // this point and converges to the actual bottleneck. This is given by the
-  // second parameter. Furthermore, it is also possible to control the
-  // adaptation of frame-size. This is specified by the last parameter.
-  //
-  // Input:
-  //   -init_frame_size_ms : initial frame-size in milliseconds. For iSAC-wb
-  //                         30 ms and 60 ms (default) are acceptable values,
-  //                         and for iSAC-swb 30 ms is the only acceptable
-  //                         value. Zero indicates default value.
-  //   -init_rate_bps      : initial estimate of the bandwidth. Values
-  //                         between 10000 and 58000 are acceptable.
-  //   -enforce_srame_size : if true, the frame-size will not be adapted.
-  //
-  // Return value:
-  //   -1 if failed to configure the bandwidth estimator,
-  //    0 if the configuration was successfully applied.
-  //
-  virtual int32_t ConfigISACBandwidthEstimator(
-      int init_frame_size_ms,
-      int init_rate_bps,
-      bool enforce_frame_size = false) = 0;
-
-  ///////////////////////////////////////////////////////////////////////////
   // int SetOpusApplication()
   // Sets the intended application if current send codec is Opus. Opus uses this
   // to optimize the encoding for applications like VOIP and music. Currently,
   // two modes are supported: kVoip and kAudio.
   //
   // Input:
   //   - application            : intended application.
   //
   // Return value:
   //   -1 if current send codec is not Opus or error occurred in setting the
@@ skipping 275 matching lines @@
   virtual std::vector<uint16_t> GetNackList(int round_trip_time_ms) const = 0;
 
   // Returns the timing statistics for calls to Get10MsAudio.
   virtual void GetDecodingCallStatistics(
       AudioDecodingCallStats* call_stats) const = 0;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_CODING_MAIN_INTERFACE_AUDIO_CODING_MODULE_H_