Pull out the PostFilter to its own NonlinearBeamformer API

webrtc/common_audio/channel_buffer.h

 /*
  *  Copyright (c) 2014 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 31 matching lines @@
  public:
   ChannelBuffer(size_t num_frames,
                 size_t num_channels,
                 size_t num_bands = 1)
       : data_(new T[num_frames * num_channels]()),
         channels_(new T*[num_channels * num_bands]),
         bands_(new T*[num_channels * num_bands]),
         num_frames_(num_frames),
         num_frames_per_band_(num_frames / num_bands),
         num_channels_(num_channels),
+        num_official_channels_(num_channels),
         num_bands_(num_bands) {
     for (size_t i = 0; i < num_channels_; ++i) {
       for (size_t j = 0; j < num_bands_; ++j) {
         channels_[j * num_channels_ + i] =
             &data_[i * num_frames_ + j * num_frames_per_band_];
         bands_[i * num_bands_ + j] = channels_[j * num_channels_ + i];
       }
     }
   }
 
@@ skipping 19 matching lines @@
   }
   T* const* channels(size_t band) {
     const ChannelBuffer<T>* t = this;
     return const_cast<T* const*>(t->channels(band));
   }
 
   // Returns a pointer array to the bands for a specific channel.
   // Usage:
   // bands(channel)[band][sample].
   // Where:
-  // 0 <= channel < |num_channels_|
+  // 0 <= channel < |num_official_channels_|

[peah-webrtc, 2016/06/01 14:51:01]

This seems very confusing to me. What is the difference between
num_official_channels and num_channels?

Could you please explain further why this change in ChannelBuffer is needed?

[aluebs-webrtc, 2016/06/01 22:13:20]

It is needed to change the number of channels of a ChannelBuffer dynamically.
The num_channels is the actual space in memory and the num_official_channels is
the one surfaced to the users of ChannelBuffer.

[peah-webrtc, 2016/06/08 12:04:55]

I still don't see why this change is here. But I'll post the question in the
latest patch instead.

[aluebs-webrtc, 2016/06/09 02:11:46]

Acknowledged.

   // 0 <= band < |num_bands_|
   // 0 <= sample < |num_frames_per_band_|
   const T* const* bands(size_t channel) const {
-    RTC_DCHECK_LT(channel, num_channels_);
+    RTC_DCHECK_LT(channel, num_official_channels_);
     RTC_DCHECK_GE(channel, 0u);
     return &bands_[channel * num_bands_];
   }
   T* const* bands(size_t channel) {
     const ChannelBuffer<T>* t = this;
     return const_cast<T* const*>(t->bands(channel));
   }
 
   // Sets the |slice| pointers to the |start_frame| position for each channel.
   // Returns |slice| for convenience.
   const T* const* Slice(T** slice, size_t start_frame) const {
     RTC_DCHECK_LT(start_frame, num_frames_);
-    for (size_t i = 0; i < num_channels_; ++i)
+    for (size_t i = 0; i < num_official_channels_; ++i)
       slice[i] = &channels_[i][start_frame];
     return slice;
   }
   T** Slice(T** slice, size_t start_frame) {
     const ChannelBuffer<T>* t = this;
     return const_cast<T**>(t->Slice(slice, start_frame));
   }
 
   size_t num_frames() const { return num_frames_; }
   size_t num_frames_per_band() const { return num_frames_per_band_; }
-  size_t num_channels() const { return num_channels_; }
+  size_t num_channels() const { return num_official_channels_; }
   size_t num_bands() const { return num_bands_; }
   size_t size() const {return num_frames_ * num_channels_; }
 
+  void set_num_channels(size_t num_channels) {
+    RTC_DCHECK_LE(num_channels, num_channels_);
+    num_official_channels_ = num_channels;
+  }
+
   void SetDataForTesting(const T* data, size_t size) {
     RTC_CHECK_EQ(size, this->size());
     memcpy(data_.get(), data, size * sizeof(*data));
   }
 
  private:
   std::unique_ptr<T[]> data_;
   std::unique_ptr<T* []> channels_;
   std::unique_ptr<T* []> bands_;
   const size_t num_frames_;
   const size_t num_frames_per_band_;
+  // Number of channels the internal buffer holds.
   const size_t num_channels_;
+  // Number of channels the user sees.
+  size_t num_official_channels_;
   const size_t num_bands_;
 };
 
 // One int16_t and one float ChannelBuffer that are kept in sync. The sync is
 // broken when someone requests write access to either ChannelBuffer, and
 // reestablished when someone requests the outdated ChannelBuffer. It is
 // therefore safe to use the return value of ibuf_const() and fbuf_const()
 // until the next call to ibuf() or fbuf(), and the return value of ibuf() and
 // fbuf() until the next call to any of the other functions.
 class IFChannelBuffer {
  public:
   IFChannelBuffer(size_t num_frames, size_t num_channels, size_t num_bands = 1);
 
   ChannelBuffer<int16_t>* ibuf();
   ChannelBuffer<float>* fbuf();
   const ChannelBuffer<int16_t>* ibuf_const() const;
   const ChannelBuffer<float>* fbuf_const() const;
 
   size_t num_frames() const { return ibuf_.num_frames(); }
   size_t num_frames_per_band() const { return ibuf_.num_frames_per_band(); }
-  size_t num_channels() const { return ibuf_.num_channels(); }
+  size_t num_channels() const {
+    return std::min(ibuf_.num_channels(), fbuf_.num_channels());
+  }
+  void set_num_channels(size_t num_channels) {
+    ibuf_.set_num_channels(num_channels);
+    fbuf_.set_num_channels(num_channels);
+  }
   size_t num_bands() const { return ibuf_.num_bands(); }
 
  private:
   void RefreshF() const;
   void RefreshI() const;
 
   mutable bool ivalid_;
   mutable ChannelBuffer<int16_t> ibuf_;
   mutable bool fvalid_;
   mutable ChannelBuffer<float> fbuf_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_CHANNEL_BUFFER_H_