src/third_party/webrtc/modules/audio_processing/audio_buffer.h

   1 /*
   2  *  Copyright (c) 2011 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_AUDIO_BUFFER_H_
  12 #define WEBRTC_MODULES_AUDIO_PROCESSING_AUDIO_BUFFER_H_
  13
  14 #include <vector>
  15
  16 #include "webrtc/modules/audio_processing/common.h"
  17 #include "webrtc/modules/audio_processing/include/audio_processing.h"
  18 #include "webrtc/modules/interface/module_common_types.h"
  19 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  20 #include "webrtc/system_wrappers/interface/scoped_vector.h"
  21 #include "webrtc/typedefs.h"
  22
  23 namespace webrtc {
  24
  25 class PushSincResampler;
  26 class SplitChannelBuffer;
  27
  28 struct SplitFilterStates {
  29   SplitFilterStates() {
  30     memset(analysis_filter_state1, 0, sizeof(analysis_filter_state1));
  31     memset(analysis_filter_state2, 0, sizeof(analysis_filter_state2));
  32     memset(synthesis_filter_state1, 0, sizeof(synthesis_filter_state1));
  33     memset(synthesis_filter_state2, 0, sizeof(synthesis_filter_state2));
  34   }
  35
  36   static const int kStateSize = 6;
  37   int analysis_filter_state1[kStateSize];
  38   int analysis_filter_state2[kStateSize];
  39   int synthesis_filter_state1[kStateSize];
  40   int synthesis_filter_state2[kStateSize];
  41 };
  42
  43 class AudioBuffer {
  44  public:
  45   // TODO(ajm): Switch to take ChannelLayouts.
  46   AudioBuffer(int input_samples_per_channel,
  47               int num_input_channels,
  48               int process_samples_per_channel,
  49               int num_process_channels,
  50               int output_samples_per_channel);
  51   virtual ~AudioBuffer();
  52
  53   int num_channels() const;
  54   int samples_per_channel() const;
  55   int samples_per_split_channel() const;
  56   int samples_per_keyboard_channel() const;
  57
  58   int16_t* data(int channel);
  59   const int16_t* data(int channel) const;
  60   int16_t* low_pass_split_data(int channel);
  61   const int16_t* low_pass_split_data(int channel) const;
  62   int16_t* high_pass_split_data(int channel);
  63   const int16_t* high_pass_split_data(int channel) const;
  64   const int16_t* mixed_data(int channel) const;
  65   const int16_t* mixed_low_pass_data(int channel) const;
  66   const int16_t* low_pass_reference(int channel) const;
  67   const float* keyboard_data() const;
  68
  69   SplitFilterStates* filter_states(int channel);
  70
  71   void set_activity(AudioFrame::VADActivity activity);
  72   AudioFrame::VADActivity activity() const;
  73
  74   bool is_muted() const;
  75
  76   // Use for int16 interleaved data.
  77   void DeinterleaveFrom(AudioFrame* audioFrame);
  78   void InterleaveTo(AudioFrame* audioFrame) const;
  79   // If |data_changed| is false, only the non-audio data members will be copied
  80   // to |frame|.
  81   void InterleaveTo(AudioFrame* frame, bool data_changed) const;
  82
  83   // Use for float deinterleaved data.
  84   void CopyFrom(const float* const* data,
  85                 int samples_per_channel,
  86                 AudioProcessing::ChannelLayout layout);
  87   void CopyTo(int samples_per_channel,
  88               AudioProcessing::ChannelLayout layout,
  89               float* const* data);
  90
  91   void CopyAndMix(int num_mixed_channels);
  92   void CopyAndMixLowPass(int num_mixed_channels);
  93   void CopyLowPassToReference();
  94
  95  private:
  96   // Called from DeinterleaveFrom() and CopyFrom().
  97   void InitForNewData();
  98
  99   const int input_samples_per_channel_;
 100   const int num_input_channels_;
 101   const int proc_samples_per_channel_;
 102   const int num_proc_channels_;
 103   const int output_samples_per_channel_;
 104   int samples_per_split_channel_;
 105   int num_mixed_channels_;
 106   int num_mixed_low_pass_channels_;
 107   bool reference_copied_;
 108   AudioFrame::VADActivity activity_;
 109   bool is_muted_;
 110
 111   // If non-null, use this instead of channels_->channel(0). This is an
 112   // optimization for the case num_proc_channels_ == 1 that allows us to point
 113   // to the data instead of copying it.
 114   int16_t* data_;
 115
 116   const float* keyboard_data_;
 117   scoped_ptr<ChannelBuffer<int16_t> > channels_;
 118   scoped_ptr<SplitChannelBuffer> split_channels_;
 119   scoped_ptr<SplitFilterStates[]> filter_states_;
 120   scoped_ptr<ChannelBuffer<int16_t> > mixed_channels_;
 121   scoped_ptr<ChannelBuffer<int16_t> > mixed_low_pass_channels_;
 122   scoped_ptr<ChannelBuffer<int16_t> > low_pass_reference_channels_;
 123   scoped_ptr<ChannelBuffer<float> > input_buffer_;
 124   scoped_ptr<ChannelBuffer<float> > process_buffer_;
 125   ScopedVector<PushSincResampler> input_resamplers_;
 126   ScopedVector<PushSincResampler> output_resamplers_;
 127 };
 128
 129 }  // namespace webrtc
 130
 131 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_AUDIO_BUFFER_H_