2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
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.
11 #ifndef WEBRTC_MODULES_AUDIO_PROCESSING_INCLUDE_AUDIO_PROCESSING_H_
12 #define WEBRTC_MODULES_AUDIO_PROCESSING_INCLUDE_AUDIO_PROCESSING_H_
14 #include <stddef.h> // size_t
15 #include <stdio.h> // FILE
17 #include "webrtc/common.h"
18 #include "webrtc/typedefs.h"
25 class EchoCancellation;
26 class EchoControlMobile;
30 class NoiseSuppression;
33 // Use to enable the delay correction feature. This now engages an extended
34 // filter mode in the AEC, along with robustness measures around the reported
35 // system delays. It comes with a significant increase in AEC complexity, but is
36 // much more robust to unreliable reported delays.
38 // Detailed changes to the algorithm:
39 // - The filter length is changed from 48 to 128 ms. This comes with tuning of
40 // several parameters: i) filter adaptation stepsize and error threshold;
41 // ii) non-linear processing smoothing and overdrive.
42 // - Option to ignore the reported delays on platforms which we deem
43 // sufficiently unreliable. See WEBRTC_UNTRUSTED_DELAY in echo_cancellation.c.
44 // - Faster startup times by removing the excessive "startup phase" processing
45 // of reported delays.
46 // - Much more conservative adjustments to the far-end read pointer. We smooth
47 // the delay difference more heavily, and back off from the difference more.
48 // Adjustments force a readaptation of the filter, so they should be avoided
49 // except when really necessary.
50 struct DelayCorrection {
51 DelayCorrection() : enabled(false) {}
52 explicit DelayCorrection(bool enabled) : enabled(enabled) {}
56 // Must be provided through AudioProcessing::Create(Confg&). It will have no
57 // impact if used with AudioProcessing::SetExtraOptions().
58 struct ExperimentalAgc {
59 ExperimentalAgc() : enabled(true) {}
60 explicit ExperimentalAgc(bool enabled) : enabled(enabled) {}
64 // The Audio Processing Module (APM) provides a collection of voice processing
65 // components designed for real-time communications software.
67 // APM operates on two audio streams on a frame-by-frame basis. Frames of the
68 // primary stream, on which all processing is applied, are passed to
69 // |ProcessStream()|. Frames of the reverse direction stream, which are used for
70 // analysis by some components, are passed to |AnalyzeReverseStream()|. On the
71 // client-side, this will typically be the near-end (capture) and far-end
72 // (render) streams, respectively. APM should be placed in the signal chain as
73 // close to the audio hardware abstraction layer (HAL) as possible.
75 // On the server-side, the reverse stream will normally not be used, with
76 // processing occurring on each incoming stream.
78 // Component interfaces follow a similar pattern and are accessed through
79 // corresponding getters in APM. All components are disabled at create-time,
80 // with default settings that are recommended for most situations. New settings
81 // can be applied without enabling a component. Enabling a component triggers
82 // memory allocation and initialization to allow it to start processing the
85 // Thread safety is provided with the following assumptions to reduce locking
87 // 1. The stream getters and setters are called from the same thread as
88 // ProcessStream(). More precisely, stream functions are never called
89 // concurrently with ProcessStream().
90 // 2. Parameter getters are never called concurrently with the corresponding
93 // APM accepts only 16-bit linear PCM audio data in frames of 10 ms. Multiple
94 // channels should be interleaved.
96 // Usage example, omitting error checking:
97 // AudioProcessing* apm = AudioProcessing::Create(0);
99 // apm->high_pass_filter()->Enable(true);
101 // apm->echo_cancellation()->enable_drift_compensation(false);
102 // apm->echo_cancellation()->Enable(true);
104 // apm->noise_reduction()->set_level(kHighSuppression);
105 // apm->noise_reduction()->Enable(true);
107 // apm->gain_control()->set_analog_level_limits(0, 255);
108 // apm->gain_control()->set_mode(kAdaptiveAnalog);
109 // apm->gain_control()->Enable(true);
111 // apm->voice_detection()->Enable(true);
113 // // Start a voice call...
115 // // ... Render frame arrives bound for the audio HAL ...
116 // apm->AnalyzeReverseStream(render_frame);
118 // // ... Capture frame arrives from the audio HAL ...
119 // // Call required set_stream_ functions.
120 // apm->set_stream_delay_ms(delay_ms);
121 // apm->gain_control()->set_stream_analog_level(analog_level);
123 // apm->ProcessStream(capture_frame);
125 // // Call required stream_ functions.
126 // analog_level = apm->gain_control()->stream_analog_level();
127 // has_voice = apm->stream_has_voice();
129 // // Repeate render and capture processing for the duration of the call...
130 // // Start a new call...
131 // apm->Initialize();
133 // // Close the application...
136 class AudioProcessing {
142 // Mono, keyboard mic.
144 // Left, right, keyboard mic.
148 // Creates an APM instance. Use one instance for every primary audio stream
149 // requiring processing. On the client-side, this would typically be one
150 // instance for the near-end stream, and additional instances for each far-end
151 // stream which requires processing. On the server-side, this would typically
152 // be one instance for every incoming stream.
153 static AudioProcessing* Create();
154 // Allows passing in an optional configuration at create-time.
155 static AudioProcessing* Create(const Config& config);
156 // TODO(ajm): Deprecated; remove all calls to it.
157 static AudioProcessing* Create(int id);
158 virtual ~AudioProcessing() {}
160 // Initializes internal states, while retaining all user settings. This
161 // should be called before beginning to process a new audio stream. However,
162 // it is not necessary to call before processing the first stream after
163 // creation. It is also not necessary to call if the audio parameters (sample
164 // rate and number of channels) have changed. Passing updated parameters
165 // directly to |ProcessStream()| and |AnalyzeReverseStream()| is permissible.
166 virtual int Initialize() = 0;
167 virtual int Initialize(int sample_rate_hz,
168 int reverse_sample_rate_hz,
169 int num_input_channels,
170 int num_output_channels,
171 int num_reverse_channels) = 0;
173 // Pass down additional options which don't have explicit setters. This
174 // ensures the options are applied immediately.
175 virtual void SetExtraOptions(const Config& config) = 0;
177 virtual int EnableExperimentalNs(bool enable) = 0;
178 virtual bool experimental_ns_enabled() const = 0;
180 // DEPRECATED: It is now possible to modify the sample rate directly in a call
181 // to |ProcessStream|.
182 // Sets the sample |rate| in Hz for both the primary and reverse audio
183 // streams. 8000, 16000 or 32000 Hz are permitted.
184 virtual int set_sample_rate_hz(int rate) = 0;
185 virtual int sample_rate_hz() const = 0;
186 virtual int split_sample_rate_hz() const = 0;
188 // DEPRECATED: It is now possible to modify the number of channels directly in
189 // a call to |ProcessStream|.
190 // Sets the number of channels for the primary audio stream. Input frames must
191 // contain a number of channels given by |input_channels|, while output frames
192 // will be returned with number of channels given by |output_channels|.
193 virtual int set_num_channels(int input_channels, int output_channels) = 0;
194 virtual int num_input_channels() const = 0;
195 virtual int num_output_channels() const = 0;
197 // DEPRECATED: It is now possible to modify the number of channels directly in
198 // a call to |AnalyzeReverseStream|.
199 // Sets the number of channels for the reverse audio stream. Input frames must
200 // contain a number of channels given by |channels|.
201 virtual int set_num_reverse_channels(int channels) = 0;
202 virtual int num_reverse_channels() const = 0;
204 // Set to true when the output of AudioProcessing will be muted or in some
205 // other way not used. Ideally, the captured audio would still be processed,
206 // but some components may change behavior based on this information.
208 virtual void set_output_will_be_muted(bool muted) = 0;
209 virtual bool output_will_be_muted() const = 0;
211 // Processes a 10 ms |frame| of the primary audio stream. On the client-side,
212 // this is the near-end (or captured) audio.
214 // If needed for enabled functionality, any function with the set_stream_ tag
215 // must be called prior to processing the current frame. Any getter function
216 // with the stream_ tag which is needed should be called after processing.
218 // The |sample_rate_hz_|, |num_channels_|, and |samples_per_channel_|
219 // members of |frame| must be valid. If changed from the previous call to this
220 // method, it will trigger an initialization.
221 virtual int ProcessStream(AudioFrame* frame) = 0;
223 // Accepts deinterleaved float audio with the range [-1, 1]. Each element
224 // of |data| points to a channel buffer, arranged according to
225 // |input_layout|. At output, the channels will be arranged according to
227 // TODO(ajm): Output layout conversion does not yet work.
228 virtual int ProcessStream(float* const* data,
229 int samples_per_channel,
231 ChannelLayout input_layout,
232 ChannelLayout output_layout) = 0;
234 // Analyzes a 10 ms |frame| of the reverse direction audio stream. The frame
235 // will not be modified. On the client-side, this is the far-end (or to be
238 // It is only necessary to provide this if echo processing is enabled, as the
239 // reverse stream forms the echo reference signal. It is recommended, but not
240 // necessary, to provide if gain control is enabled. On the server-side this
241 // typically will not be used. If you're not sure what to pass in here,
242 // chances are you don't need to use it.
244 // The |sample_rate_hz_|, |num_channels_|, and |samples_per_channel_|
245 // members of |frame| must be valid. |sample_rate_hz_| must correspond to
246 // |sample_rate_hz()|
248 // TODO(ajm): add const to input; requires an implementation fix.
249 virtual int AnalyzeReverseStream(AudioFrame* frame) = 0;
251 // Accepts deinterleaved float audio with the range [-1, 1]. Each element
252 // of |data| points to a channel buffer, arranged according to |layout|.
253 virtual int AnalyzeReverseStream(const float* const* data,
254 int samples_per_channel,
256 ChannelLayout layout) = 0;
258 // This must be called if and only if echo processing is enabled.
260 // Sets the |delay| in ms between AnalyzeReverseStream() receiving a far-end
261 // frame and ProcessStream() receiving a near-end frame containing the
262 // corresponding echo. On the client-side this can be expressed as
263 // delay = (t_render - t_analyze) + (t_process - t_capture)
265 // - t_analyze is the time a frame is passed to AnalyzeReverseStream() and
266 // t_render is the time the first sample of the same frame is rendered by
267 // the audio hardware.
268 // - t_capture is the time the first sample of a frame is captured by the
269 // audio hardware and t_pull is the time the same frame is passed to
271 virtual int set_stream_delay_ms(int delay) = 0;
272 virtual int stream_delay_ms() const = 0;
273 virtual bool was_stream_delay_set() const = 0;
275 // Call to signal that a key press occurred (true) or did not occur (false)
276 // with this chunk of audio.
277 virtual void set_stream_key_pressed(bool key_pressed) = 0;
278 virtual bool stream_key_pressed() const = 0;
280 // Sets a delay |offset| in ms to add to the values passed in through
281 // set_stream_delay_ms(). May be positive or negative.
283 // Note that this could cause an otherwise valid value passed to
284 // set_stream_delay_ms() to return an error.
285 virtual void set_delay_offset_ms(int offset) = 0;
286 virtual int delay_offset_ms() const = 0;
288 // Starts recording debugging information to a file specified by |filename|,
289 // a NULL-terminated string. If there is an ongoing recording, the old file
290 // will be closed, and recording will continue in the newly specified file.
291 // An already existing file will be overwritten without warning.
292 static const size_t kMaxFilenameSize = 1024;
293 virtual int StartDebugRecording(const char filename[kMaxFilenameSize]) = 0;
295 // Same as above but uses an existing file handle. Takes ownership
296 // of |handle| and closes it at StopDebugRecording().
297 virtual int StartDebugRecording(FILE* handle) = 0;
299 // Stops recording debugging information, and closes the file. Recording
300 // cannot be resumed in the same file (without overwriting it).
301 virtual int StopDebugRecording() = 0;
303 // These provide access to the component interfaces and should never return
304 // NULL. The pointers will be valid for the lifetime of the APM instance.
305 // The memory for these objects is entirely managed internally.
306 virtual EchoCancellation* echo_cancellation() const = 0;
307 virtual EchoControlMobile* echo_control_mobile() const = 0;
308 virtual GainControl* gain_control() const = 0;
309 virtual HighPassFilter* high_pass_filter() const = 0;
310 virtual LevelEstimator* level_estimator() const = 0;
311 virtual NoiseSuppression* noise_suppression() const = 0;
312 virtual VoiceDetection* voice_detection() const = 0;
315 int instant; // Instantaneous value.
316 int average; // Long-term average.
317 int maximum; // Long-term maximum.
318 int minimum; // Long-term minimum.
324 kUnspecifiedError = -1,
325 kCreationFailedError = -2,
326 kUnsupportedComponentError = -3,
327 kUnsupportedFunctionError = -4,
328 kNullPointerError = -5,
329 kBadParameterError = -6,
330 kBadSampleRateError = -7,
331 kBadDataLengthError = -8,
332 kBadNumberChannelsError = -9,
334 kStreamParameterNotSetError = -11,
335 kNotEnabledError = -12,
337 // Warnings are non-fatal.
338 // This results when a set_stream_ parameter is out of range. Processing
339 // will continue, but the parameter may have been truncated.
340 kBadStreamParameterWarning = -13
344 kSampleRate8kHz = 8000,
345 kSampleRate16kHz = 16000,
346 kSampleRate32kHz = 32000
350 // The acoustic echo cancellation (AEC) component provides better performance
351 // than AECM but also requires more processing power and is dependent on delay
352 // stability and reporting accuracy. As such it is well-suited and recommended
353 // for PC and IP phone applications.
355 // Not recommended to be enabled on the server-side.
356 class EchoCancellation {
358 // EchoCancellation and EchoControlMobile may not be enabled simultaneously.
359 // Enabling one will disable the other.
360 virtual int Enable(bool enable) = 0;
361 virtual bool is_enabled() const = 0;
363 // Differences in clock speed on the primary and reverse streams can impact
364 // the AEC performance. On the client-side, this could be seen when different
365 // render and capture devices are used, particularly with webcams.
367 // This enables a compensation mechanism, and requires that
368 // |set_device_sample_rate_hz()| and |set_stream_drift_samples()| be called.
369 virtual int enable_drift_compensation(bool enable) = 0;
370 virtual bool is_drift_compensation_enabled() const = 0;
372 // Provides the sampling rate of the audio devices. It is assumed the render
373 // and capture devices use the same nominal sample rate. Required if and only
374 // if drift compensation is enabled.
375 virtual int set_device_sample_rate_hz(int rate) = 0;
376 virtual int device_sample_rate_hz() const = 0;
378 // Sets the difference between the number of samples rendered and captured by
379 // the audio devices since the last call to |ProcessStream()|. Must be called
380 // if drift compensation is enabled, prior to |ProcessStream()|.
381 virtual void set_stream_drift_samples(int drift) = 0;
382 virtual int stream_drift_samples() const = 0;
384 enum SuppressionLevel {
386 kModerateSuppression,
390 // Sets the aggressiveness of the suppressor. A higher level trades off
391 // double-talk performance for increased echo suppression.
392 virtual int set_suppression_level(SuppressionLevel level) = 0;
393 virtual SuppressionLevel suppression_level() const = 0;
395 // Returns false if the current frame almost certainly contains no echo
396 // and true if it _might_ contain echo.
397 virtual bool stream_has_echo() const = 0;
399 // Enables the computation of various echo metrics. These are obtained
400 // through |GetMetrics()|.
401 virtual int enable_metrics(bool enable) = 0;
402 virtual bool are_metrics_enabled() const = 0;
404 // Each statistic is reported in dB.
405 // P_far: Far-end (render) signal power.
406 // P_echo: Near-end (capture) echo signal power.
407 // P_out: Signal power at the output of the AEC.
408 // P_a: Internal signal power at the point before the AEC's non-linear
412 AudioProcessing::Statistic residual_echo_return_loss;
414 // ERL = 10log_10(P_far / P_echo)
415 AudioProcessing::Statistic echo_return_loss;
417 // ERLE = 10log_10(P_echo / P_out)
418 AudioProcessing::Statistic echo_return_loss_enhancement;
420 // (Pre non-linear processing suppression) A_NLP = 10log_10(P_echo / P_a)
421 AudioProcessing::Statistic a_nlp;
424 // TODO(ajm): discuss the metrics update period.
425 virtual int GetMetrics(Metrics* metrics) = 0;
427 // Enables computation and logging of delay values. Statistics are obtained
428 // through |GetDelayMetrics()|.
429 virtual int enable_delay_logging(bool enable) = 0;
430 virtual bool is_delay_logging_enabled() const = 0;
432 // The delay metrics consists of the delay |median| and the delay standard
433 // deviation |std|. The values are averaged over the time period since the
434 // last call to |GetDelayMetrics()|.
435 virtual int GetDelayMetrics(int* median, int* std) = 0;
437 // Returns a pointer to the low level AEC component. In case of multiple
438 // channels, the pointer to the first one is returned. A NULL pointer is
439 // returned when the AEC component is disabled or has not been initialized
441 virtual struct AecCore* aec_core() const = 0;
444 virtual ~EchoCancellation() {}
447 // The acoustic echo control for mobile (AECM) component is a low complexity
448 // robust option intended for use on mobile devices.
450 // Not recommended to be enabled on the server-side.
451 class EchoControlMobile {
453 // EchoCancellation and EchoControlMobile may not be enabled simultaneously.
454 // Enabling one will disable the other.
455 virtual int Enable(bool enable) = 0;
456 virtual bool is_enabled() const = 0;
458 // Recommended settings for particular audio routes. In general, the louder
459 // the echo is expected to be, the higher this value should be set. The
460 // preferred setting may vary from device to device.
462 kQuietEarpieceOrHeadset,
469 // Sets echo control appropriate for the audio routing |mode| on the device.
470 // It can and should be updated during a call if the audio routing changes.
471 virtual int set_routing_mode(RoutingMode mode) = 0;
472 virtual RoutingMode routing_mode() const = 0;
474 // Comfort noise replaces suppressed background noise to maintain a
475 // consistent signal level.
476 virtual int enable_comfort_noise(bool enable) = 0;
477 virtual bool is_comfort_noise_enabled() const = 0;
479 // A typical use case is to initialize the component with an echo path from a
480 // previous call. The echo path is retrieved using |GetEchoPath()|, typically
481 // at the end of a call. The data can then be stored for later use as an
482 // initializer before the next call, using |SetEchoPath()|.
484 // Controlling the echo path this way requires the data |size_bytes| to match
485 // the internal echo path size. This size can be acquired using
486 // |echo_path_size_bytes()|. |SetEchoPath()| causes an entire reset, worth
487 // noting if it is to be called during an ongoing call.
489 // It is possible that version incompatibilities may result in a stored echo
490 // path of the incorrect size. In this case, the stored path should be
492 virtual int SetEchoPath(const void* echo_path, size_t size_bytes) = 0;
493 virtual int GetEchoPath(void* echo_path, size_t size_bytes) const = 0;
495 // The returned path size is guaranteed not to change for the lifetime of
497 static size_t echo_path_size_bytes();
500 virtual ~EchoControlMobile() {}
503 // The automatic gain control (AGC) component brings the signal to an
504 // appropriate range. This is done by applying a digital gain directly and, in
505 // the analog mode, prescribing an analog gain to be applied at the audio HAL.
507 // Recommended to be enabled on the client-side.
510 virtual int Enable(bool enable) = 0;
511 virtual bool is_enabled() const = 0;
513 // When an analog mode is set, this must be called prior to |ProcessStream()|
514 // to pass the current analog level from the audio HAL. Must be within the
515 // range provided to |set_analog_level_limits()|.
516 virtual int set_stream_analog_level(int level) = 0;
518 // When an analog mode is set, this should be called after |ProcessStream()|
519 // to obtain the recommended new analog level for the audio HAL. It is the
520 // users responsibility to apply this level.
521 virtual int stream_analog_level() = 0;
524 // Adaptive mode intended for use if an analog volume control is available
525 // on the capture device. It will require the user to provide coupling
526 // between the OS mixer controls and AGC through the |stream_analog_level()|
529 // It consists of an analog gain prescription for the audio device and a
530 // digital compression stage.
533 // Adaptive mode intended for situations in which an analog volume control
534 // is unavailable. It operates in a similar fashion to the adaptive analog
535 // mode, but with scaling instead applied in the digital domain. As with
536 // the analog mode, it additionally uses a digital compression stage.
539 // Fixed mode which enables only the digital compression stage also used by
540 // the two adaptive modes.
542 // It is distinguished from the adaptive modes by considering only a
543 // short time-window of the input signal. It applies a fixed gain through
544 // most of the input level range, and compresses (gradually reduces gain
545 // with increasing level) the input signal at higher levels. This mode is
546 // preferred on embedded devices where the capture signal level is
547 // predictable, so that a known gain can be applied.
551 virtual int set_mode(Mode mode) = 0;
552 virtual Mode mode() const = 0;
554 // Sets the target peak |level| (or envelope) of the AGC in dBFs (decibels
555 // from digital full-scale). The convention is to use positive values. For
556 // instance, passing in a value of 3 corresponds to -3 dBFs, or a target
557 // level 3 dB below full-scale. Limited to [0, 31].
559 // TODO(ajm): use a negative value here instead, if/when VoE will similarly
560 // update its interface.
561 virtual int set_target_level_dbfs(int level) = 0;
562 virtual int target_level_dbfs() const = 0;
564 // Sets the maximum |gain| the digital compression stage may apply, in dB. A
565 // higher number corresponds to greater compression, while a value of 0 will
566 // leave the signal uncompressed. Limited to [0, 90].
567 virtual int set_compression_gain_db(int gain) = 0;
568 virtual int compression_gain_db() const = 0;
570 // When enabled, the compression stage will hard limit the signal to the
571 // target level. Otherwise, the signal will be compressed but not limited
572 // above the target level.
573 virtual int enable_limiter(bool enable) = 0;
574 virtual bool is_limiter_enabled() const = 0;
576 // Sets the |minimum| and |maximum| analog levels of the audio capture device.
577 // Must be set if and only if an analog mode is used. Limited to [0, 65535].
578 virtual int set_analog_level_limits(int minimum,
580 virtual int analog_level_minimum() const = 0;
581 virtual int analog_level_maximum() const = 0;
583 // Returns true if the AGC has detected a saturation event (period where the
584 // signal reaches digital full-scale) in the current frame and the analog
585 // level cannot be reduced.
587 // This could be used as an indicator to reduce or disable analog mic gain at
589 virtual bool stream_is_saturated() const = 0;
592 virtual ~GainControl() {}
595 // A filtering component which removes DC offset and low-frequency noise.
596 // Recommended to be enabled on the client-side.
597 class HighPassFilter {
599 virtual int Enable(bool enable) = 0;
600 virtual bool is_enabled() const = 0;
603 virtual ~HighPassFilter() {}
606 // An estimation component used to retrieve level metrics.
607 class LevelEstimator {
609 virtual int Enable(bool enable) = 0;
610 virtual bool is_enabled() const = 0;
612 // Returns the root mean square (RMS) level in dBFs (decibels from digital
613 // full-scale), or alternately dBov. It is computed over all primary stream
614 // frames since the last call to RMS(). The returned value is positive but
615 // should be interpreted as negative. It is constrained to [0, 127].
617 // The computation follows:
618 // http://tools.ietf.org/html/draft-ietf-avtext-client-to-mixer-audio-level-05
619 // with the intent that it can provide the RTP audio level indication.
621 // Frames passed to ProcessStream() with an |_energy| of zero are considered
622 // to have been muted. The RMS of the frame will be interpreted as -127.
623 virtual int RMS() = 0;
626 virtual ~LevelEstimator() {}
629 // The noise suppression (NS) component attempts to remove noise while
630 // retaining speech. Recommended to be enabled on the client-side.
632 // Recommended to be enabled on the client-side.
633 class NoiseSuppression {
635 virtual int Enable(bool enable) = 0;
636 virtual bool is_enabled() const = 0;
638 // Determines the aggressiveness of the suppression. Increasing the level
639 // will reduce the noise level at the expense of a higher speech distortion.
647 virtual int set_level(Level level) = 0;
648 virtual Level level() const = 0;
650 // Returns the internally computed prior speech probability of current frame
651 // averaged over output channels. This is not supported in fixed point, for
652 // which |kUnsupportedFunctionError| is returned.
653 virtual float speech_probability() const = 0;
656 virtual ~NoiseSuppression() {}
659 // The voice activity detection (VAD) component analyzes the stream to
660 // determine if voice is present. A facility is also provided to pass in an
661 // external VAD decision.
663 // In addition to |stream_has_voice()| the VAD decision is provided through the
664 // |AudioFrame| passed to |ProcessStream()|. The |vad_activity_| member will be
665 // modified to reflect the current decision.
666 class VoiceDetection {
668 virtual int Enable(bool enable) = 0;
669 virtual bool is_enabled() const = 0;
671 // Returns true if voice is detected in the current frame. Should be called
672 // after |ProcessStream()|.
673 virtual bool stream_has_voice() const = 0;
675 // Some of the APM functionality requires a VAD decision. In the case that
676 // a decision is externally available for the current frame, it can be passed
677 // in here, before |ProcessStream()| is called.
679 // VoiceDetection does _not_ need to be enabled to use this. If it happens to
680 // be enabled, detection will be skipped for any frame in which an external
681 // VAD decision is provided.
682 virtual int set_stream_has_voice(bool has_voice) = 0;
684 // Specifies the likelihood that a frame will be declared to contain voice.
685 // A higher value makes it more likely that speech will not be clipped, at
686 // the expense of more noise being detected as voice.
694 virtual int set_likelihood(Likelihood likelihood) = 0;
695 virtual Likelihood likelihood() const = 0;
697 // Sets the |size| of the frames in ms on which the VAD will operate. Larger
698 // frames will improve detection accuracy, but reduce the frequency of
701 // This does not impact the size of frames passed to |ProcessStream()|.
702 virtual int set_frame_size_ms(int size) = 0;
703 virtual int frame_size_ms() const = 0;
706 virtual ~VoiceDetection() {}
708 } // namespace webrtc
710 #endif // WEBRTC_MODULES_AUDIO_PROCESSING_INCLUDE_AUDIO_PROCESSING_H_