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 MODULES_AUDIO_CODING_NETEQ_SYNC_BUFFER_H_ 12 #define MODULES_AUDIO_CODING_NETEQ_SYNC_BUFFER_H_ 13 14 #include <stddef.h> 15 #include <stdint.h> 16 17 #include <vector> 18 19 #include "api/audio/audio_frame.h" 20 #include "modules/audio_coding/neteq/audio_multi_vector.h" 21 #include "modules/audio_coding/neteq/audio_vector.h" 22 #include "rtc_base/buffer.h" 23 24 namespace webrtc { 25 26 class SyncBuffer : public AudioMultiVector { 27 public: SyncBuffer(size_t channels,size_t length)28 SyncBuffer(size_t channels, size_t length) 29 : AudioMultiVector(channels, length), 30 next_index_(length), 31 end_timestamp_(0), 32 dtmf_index_(0) {} 33 34 SyncBuffer(const SyncBuffer&) = delete; 35 SyncBuffer& operator=(const SyncBuffer&) = delete; 36 37 // Returns the number of samples yet to play out from the buffer. 38 size_t FutureLength() const; 39 40 // Adds the contents of `append_this` to the back of the SyncBuffer. Removes 41 // the same number of samples from the beginning of the SyncBuffer, to 42 // maintain a constant buffer size. The `next_index_` is updated to reflect 43 // the move of the beginning of "future" data. 44 void PushBack(const AudioMultiVector& append_this) override; 45 46 // Like PushBack, but reads the samples channel-interleaved from the input. 47 void PushBackInterleaved(const rtc::BufferT<int16_t>& append_this); 48 49 // Adds `length` zeros to the beginning of each channel. Removes 50 // the same number of samples from the end of the SyncBuffer, to 51 // maintain a constant buffer size. The `next_index_` is updated to reflect 52 // the move of the beginning of "future" data. 53 // Note that this operation may delete future samples that are waiting to 54 // be played. 55 void PushFrontZeros(size_t length); 56 57 // Inserts `length` zeros into each channel at index `position`. The size of 58 // the SyncBuffer is kept constant, which means that the last `length` 59 // elements in each channel will be purged. 60 virtual void InsertZerosAtIndex(size_t length, size_t position); 61 62 // Overwrites each channel in this SyncBuffer with values taken from 63 // `insert_this`. The values are taken from the beginning of `insert_this` and 64 // are inserted starting at `position`. `length` values are written into each 65 // channel. The size of the SyncBuffer is kept constant. That is, if `length` 66 // and `position` are selected such that the new data would extend beyond the 67 // end of the current SyncBuffer, the buffer is not extended. 68 // The `next_index_` is not updated. 69 virtual void ReplaceAtIndex(const AudioMultiVector& insert_this, 70 size_t length, 71 size_t position); 72 73 // Same as the above method, but where all of `insert_this` is written (with 74 // the same constraints as above, that the SyncBuffer is not extended). 75 virtual void ReplaceAtIndex(const AudioMultiVector& insert_this, 76 size_t position); 77 78 // Reads `requested_len` samples from each channel and writes them interleaved 79 // into `output`. The `next_index_` is updated to point to the sample to read 80 // next time. The AudioFrame `output` is first reset, and the `data_`, 81 // `num_channels_`, and `samples_per_channel_` fields are updated. 82 void GetNextAudioInterleaved(size_t requested_len, AudioFrame* output); 83 84 // Adds `increment` to `end_timestamp_`. 85 void IncreaseEndTimestamp(uint32_t increment); 86 87 // Flushes the buffer. The buffer will contain only zeros after the flush, and 88 // `next_index_` will point to the end, like when the buffer was first 89 // created. 90 void Flush(); 91 Channel(size_t n)92 const AudioVector& Channel(size_t n) const { return *channels_[n]; } Channel(size_t n)93 AudioVector& Channel(size_t n) { return *channels_[n]; } 94 95 // Accessors and mutators. next_index()96 size_t next_index() const { return next_index_; } 97 void set_next_index(size_t value); end_timestamp()98 uint32_t end_timestamp() const { return end_timestamp_; } set_end_timestamp(uint32_t value)99 void set_end_timestamp(uint32_t value) { end_timestamp_ = value; } dtmf_index()100 size_t dtmf_index() const { return dtmf_index_; } 101 void set_dtmf_index(size_t value); 102 103 private: 104 size_t next_index_; 105 uint32_t end_timestamp_; // The timestamp of the last sample in the buffer. 106 size_t dtmf_index_; // Index to the first non-DTMF sample in the buffer. 107 }; 108 109 } // namespace webrtc 110 #endif // MODULES_AUDIO_CODING_NETEQ_SYNC_BUFFER_H_ 111