1/*
2 *  Copyright (c) 2014 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_CHANNEL_BUFFER_H_
12#define WEBRTC_MODULES_AUDIO_PROCESSING_CHANNEL_BUFFER_H_
13
14#include <string.h>
15
16#include "webrtc/base/checks.h"
17#include "webrtc/base/scoped_ptr.h"
18#include "webrtc/common_audio/include/audio_util.h"
19#include "webrtc/test/testsupport/gtest_prod_util.h"
20
21namespace webrtc {
22
23// Helper to encapsulate a contiguous data buffer, full or split into frequency
24// bands, with access to a pointer arrays of the deinterleaved channels and
25// bands. The buffer is zero initialized at creation.
26//
27// The buffer structure is showed below for a 2 channel and 2 bands case:
28//
29// |data_|:
30// { [ --- b1ch1 --- ] [ --- b2ch1 --- ] [ --- b1ch2 --- ] [ --- b2ch2 --- ] }
31//
32// The pointer arrays for the same example are as follows:
33//
34// |channels_|:
35// { [ b1ch1* ] [ b1ch2* ] [ b2ch1* ] [ b2ch2* ] }
36//
37// |bands_|:
38// { [ b1ch1* ] [ b2ch1* ] [ b1ch2* ] [ b2ch2* ] }
39template <typename T>
40class ChannelBuffer {
41 public:
42  ChannelBuffer(size_t num_frames,
43                size_t num_channels,
44                size_t num_bands = 1)
45      : data_(new T[num_frames * num_channels]()),
46        channels_(new T*[num_channels * num_bands]),
47        bands_(new T*[num_channels * num_bands]),
48        num_frames_(num_frames),
49        num_frames_per_band_(num_frames / num_bands),
50        num_channels_(num_channels),
51        num_bands_(num_bands) {
52    for (size_t i = 0; i < num_channels_; ++i) {
53      for (size_t j = 0; j < num_bands_; ++j) {
54        channels_[j * num_channels_ + i] =
55            &data_[i * num_frames_ + j * num_frames_per_band_];
56        bands_[i * num_bands_ + j] = channels_[j * num_channels_ + i];
57      }
58    }
59  }
60
61  // Returns a pointer array to the full-band channels (or lower band channels).
62  // Usage:
63  // channels()[channel][sample].
64  // Where:
65  // 0 <= channel < |num_channels_|
66  // 0 <= sample < |num_frames_|
67  T* const* channels() { return channels(0); }
68  const T* const* channels() const { return channels(0); }
69
70  // Returns a pointer array to the channels for a specific band.
71  // Usage:
72  // channels(band)[channel][sample].
73  // Where:
74  // 0 <= band < |num_bands_|
75  // 0 <= channel < |num_channels_|
76  // 0 <= sample < |num_frames_per_band_|
77  const T* const* channels(size_t band) const {
78    RTC_DCHECK_LT(band, num_bands_);
79    return &channels_[band * num_channels_];
80  }
81  T* const* channels(size_t band) {
82    const ChannelBuffer<T>* t = this;
83    return const_cast<T* const*>(t->channels(band));
84  }
85
86  // Returns a pointer array to the bands for a specific channel.
87  // Usage:
88  // bands(channel)[band][sample].
89  // Where:
90  // 0 <= channel < |num_channels_|
91  // 0 <= band < |num_bands_|
92  // 0 <= sample < |num_frames_per_band_|
93  const T* const* bands(size_t channel) const {
94    RTC_DCHECK_LT(channel, num_channels_);
95    RTC_DCHECK_GE(channel, 0u);
96    return &bands_[channel * num_bands_];
97  }
98  T* const* bands(size_t channel) {
99    const ChannelBuffer<T>* t = this;
100    return const_cast<T* const*>(t->bands(channel));
101  }
102
103  // Sets the |slice| pointers to the |start_frame| position for each channel.
104  // Returns |slice| for convenience.
105  const T* const* Slice(T** slice, size_t start_frame) const {
106    RTC_DCHECK_LT(start_frame, num_frames_);
107    for (size_t i = 0; i < num_channels_; ++i)
108      slice[i] = &channels_[i][start_frame];
109    return slice;
110  }
111  T** Slice(T** slice, size_t start_frame) {
112    const ChannelBuffer<T>* t = this;
113    return const_cast<T**>(t->Slice(slice, start_frame));
114  }
115
116  size_t num_frames() const { return num_frames_; }
117  size_t num_frames_per_band() const { return num_frames_per_band_; }
118  size_t num_channels() const { return num_channels_; }
119  size_t num_bands() const { return num_bands_; }
120  size_t size() const {return num_frames_ * num_channels_; }
121
122  void SetDataForTesting(const T* data, size_t size) {
123    RTC_CHECK_EQ(size, this->size());
124    memcpy(data_.get(), data, size * sizeof(*data));
125  }
126
127 private:
128  rtc::scoped_ptr<T[]> data_;
129  rtc::scoped_ptr<T* []> channels_;
130  rtc::scoped_ptr<T* []> bands_;
131  const size_t num_frames_;
132  const size_t num_frames_per_band_;
133  const size_t num_channels_;
134  const size_t num_bands_;
135};
136
137// One int16_t and one float ChannelBuffer that are kept in sync. The sync is
138// broken when someone requests write access to either ChannelBuffer, and
139// reestablished when someone requests the outdated ChannelBuffer. It is
140// therefore safe to use the return value of ibuf_const() and fbuf_const()
141// until the next call to ibuf() or fbuf(), and the return value of ibuf() and
142// fbuf() until the next call to any of the other functions.
143class IFChannelBuffer {
144 public:
145  IFChannelBuffer(size_t num_frames, size_t num_channels, size_t num_bands = 1);
146
147  ChannelBuffer<int16_t>* ibuf();
148  ChannelBuffer<float>* fbuf();
149  const ChannelBuffer<int16_t>* ibuf_const() const;
150  const ChannelBuffer<float>* fbuf_const() const;
151
152  size_t num_frames() const { return ibuf_.num_frames(); }
153  size_t num_frames_per_band() const { return ibuf_.num_frames_per_band(); }
154  size_t num_channels() const { return ibuf_.num_channels(); }
155  size_t num_bands() const { return ibuf_.num_bands(); }
156
157 private:
158  void RefreshF() const;
159  void RefreshI() const;
160
161  mutable bool ivalid_;
162  mutable ChannelBuffer<int16_t> ibuf_;
163  mutable bool fvalid_;
164  mutable ChannelBuffer<float> fbuf_;
165};
166
167}  // namespace webrtc
168
169#endif  // WEBRTC_MODULES_AUDIO_PROCESSING_CHANNEL_BUFFER_H_
170