Home | History | Annotate | Download | only in audio_processing 
      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 
     21 namespace webrtc {
     22 
     23 class AudioBuffer;
     24 class CriticalSectionWrapper;
     25 class EchoCancellationImpl;
     26 class EchoControlMobileImpl;
     27 class FileWrapper;
     28 class GainControlImpl;
     29 class HighPassFilterImpl;
     30 class LevelEstimatorImpl;
     31 class NoiseSuppressionImpl;
     32 class ProcessingComponent;
     33 class VoiceDetectionImpl;
     34 
     35 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
     36 namespace audioproc {
     37 
     38 class Event;
     39 
     40 }  // namespace audioproc
     41 #endif
     42 
     43 class 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 
     63 class 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 
     81 class 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