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#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_MAIN_SOURCE_AUDIO_PROCESSING_IMPL_H_
12#define WEBRTC_MODULES_AUDIO_PROCESSING_MAIN_SOURCE_AUDIO_PROCESSING_IMPL_H_
13
14#include "webrtc/modules/audio_processing/include/audio_processing.h"
15
16#include <list>
17#include <string>
18
19#include "webrtc/system_wrappers/interface/scoped_ptr.h"
20
21namespace webrtc {
22
23class AudioBuffer;
24class CriticalSectionWrapper;
25class EchoCancellationImpl;
26class EchoControlMobileImpl;
27class FileWrapper;
28class GainControlImpl;
29class HighPassFilterImpl;
30class LevelEstimatorImpl;
31class NoiseSuppressionImpl;
32class ProcessingComponent;
33class VoiceDetectionImpl;
34
35#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
36namespace audioproc {
37
38class Event;
39
40}  // namespace audioproc
41#endif
42
43class AudioRate {
44 public:
45  explicit AudioRate(int sample_rate_hz)
46      : rate_(sample_rate_hz),
47        samples_per_channel_(AudioProcessing::kChunkSizeMs * rate_ / 1000) {}
48  virtual ~AudioRate() {}
49
50  void set(int rate) {
51    rate_ = rate;
52    samples_per_channel_ = AudioProcessing::kChunkSizeMs * rate_ / 1000;
53  }
54
55  int rate() const { return rate_; }
56  int samples_per_channel() const { return samples_per_channel_; }
57
58 private:
59  int rate_;
60  int samples_per_channel_;
61};
62
63class AudioFormat : public AudioRate {
64 public:
65  AudioFormat(int sample_rate_hz, int num_channels)
66      : AudioRate(sample_rate_hz),
67        num_channels_(num_channels) {}
68  virtual ~AudioFormat() {}
69
70  void set(int rate, int num_channels) {
71    AudioRate::set(rate);
72    num_channels_ = num_channels;
73  }
74
75  int num_channels() const { return num_channels_; }
76
77 private:
78  int num_channels_;
79};
80
81class AudioProcessingImpl : public AudioProcessing {
82 public:
83  explicit AudioProcessingImpl(const Config& config);
84  virtual ~AudioProcessingImpl();
85
86  // AudioProcessing methods.
87  virtual int Initialize() OVERRIDE;
88  virtual int Initialize(int input_sample_rate_hz,
89                         int output_sample_rate_hz,
90                         int reverse_sample_rate_hz,
91                         ChannelLayout input_layout,
92                         ChannelLayout output_layout,
93                         ChannelLayout reverse_layout) OVERRIDE;
94  virtual void SetExtraOptions(const Config& config) OVERRIDE;
95  virtual int EnableExperimentalNs(bool enable) OVERRIDE;
96  virtual bool experimental_ns_enabled() const OVERRIDE {
97    return false;
98  }
99  virtual int set_sample_rate_hz(int rate) OVERRIDE;
100  virtual int input_sample_rate_hz() const OVERRIDE;
101  virtual int sample_rate_hz() const OVERRIDE;
102  virtual int proc_sample_rate_hz() const OVERRIDE;
103  virtual int proc_split_sample_rate_hz() const OVERRIDE;
104  virtual int num_input_channels() const OVERRIDE;
105  virtual int num_output_channels() const OVERRIDE;
106  virtual int num_reverse_channels() const OVERRIDE;
107  virtual void set_output_will_be_muted(bool muted) OVERRIDE;
108  virtual bool output_will_be_muted() const OVERRIDE;
109  virtual int ProcessStream(AudioFrame* frame) OVERRIDE;
110  virtual int ProcessStream(const float* const* src,
111                            int samples_per_channel,
112                            int input_sample_rate_hz,
113                            ChannelLayout input_layout,
114                            int output_sample_rate_hz,
115                            ChannelLayout output_layout,
116                            float* const* dest) OVERRIDE;
117  virtual int AnalyzeReverseStream(AudioFrame* frame) OVERRIDE;
118  virtual int AnalyzeReverseStream(const float* const* data,
119                                   int samples_per_channel,
120                                   int sample_rate_hz,
121                                   ChannelLayout layout) OVERRIDE;
122  virtual int set_stream_delay_ms(int delay) OVERRIDE;
123  virtual int stream_delay_ms() const OVERRIDE;
124  virtual bool was_stream_delay_set() const OVERRIDE;
125  virtual void set_delay_offset_ms(int offset) OVERRIDE;
126  virtual int delay_offset_ms() const OVERRIDE;
127  virtual void set_stream_key_pressed(bool key_pressed) OVERRIDE;
128  virtual bool stream_key_pressed() const OVERRIDE;
129  virtual int StartDebugRecording(
130      const char filename[kMaxFilenameSize]) OVERRIDE;
131  virtual int StartDebugRecording(FILE* handle) OVERRIDE;
132  virtual int StopDebugRecording() OVERRIDE;
133  virtual EchoCancellation* echo_cancellation() const OVERRIDE;
134  virtual EchoControlMobile* echo_control_mobile() const OVERRIDE;
135  virtual GainControl* gain_control() const OVERRIDE;
136  virtual HighPassFilter* high_pass_filter() const OVERRIDE;
137  virtual LevelEstimator* level_estimator() const OVERRIDE;
138  virtual NoiseSuppression* noise_suppression() const OVERRIDE;
139  virtual VoiceDetection* voice_detection() const OVERRIDE;
140
141 protected:
142  // Overridden in a mock.
143  virtual int InitializeLocked();
144
145 private:
146  int InitializeLocked(int input_sample_rate_hz,
147                       int output_sample_rate_hz,
148                       int reverse_sample_rate_hz,
149                       int num_input_channels,
150                       int num_output_channels,
151                       int num_reverse_channels);
152  int MaybeInitializeLocked(int input_sample_rate_hz,
153                            int output_sample_rate_hz,
154                            int reverse_sample_rate_hz,
155                            int num_input_channels,
156                            int num_output_channels,
157                            int num_reverse_channels);
158  int ProcessStreamLocked();
159  int AnalyzeReverseStreamLocked();
160
161  bool is_data_processed() const;
162  bool output_copy_needed(bool is_data_processed) const;
163  bool synthesis_needed(bool is_data_processed) const;
164  bool analysis_needed(bool is_data_processed) const;
165
166  EchoCancellationImpl* echo_cancellation_;
167  EchoControlMobileImpl* echo_control_mobile_;
168  GainControlImpl* gain_control_;
169  HighPassFilterImpl* high_pass_filter_;
170  LevelEstimatorImpl* level_estimator_;
171  NoiseSuppressionImpl* noise_suppression_;
172  VoiceDetectionImpl* voice_detection_;
173
174  std::list<ProcessingComponent*> component_list_;
175  CriticalSectionWrapper* crit_;
176  scoped_ptr<AudioBuffer> render_audio_;
177  scoped_ptr<AudioBuffer> capture_audio_;
178#ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
179  // TODO(andrew): make this more graceful. Ideally we would split this stuff
180  // out into a separate class with an "enabled" and "disabled" implementation.
181  int WriteMessageToDebugFile();
182  int WriteInitMessage();
183  scoped_ptr<FileWrapper> debug_file_;
184  scoped_ptr<audioproc::Event> event_msg_;  // Protobuf message.
185  std::string event_str_;  // Memory for protobuf serialization.
186#endif
187
188  AudioFormat fwd_in_format_;
189  AudioFormat fwd_proc_format_;
190  AudioRate fwd_out_format_;
191  AudioFormat rev_in_format_;
192  AudioFormat rev_proc_format_;
193  int split_rate_;
194
195  int stream_delay_ms_;
196  int delay_offset_ms_;
197  bool was_stream_delay_set_;
198
199  bool output_will_be_muted_;
200
201  bool key_pressed_;
202};
203
204}  // namespace webrtc
205
206#endif  // WEBRTC_MODULES_AUDIO_PROCESSING_MAIN_SOURCE_AUDIO_PROCESSING_IMPL_H_
207