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 // A ring buffer to hold arbitrary data. Provides no thread safety. Unless
12 // otherwise specified, functions return 0 on success and -1 on error.
13
14 #include "webrtc/modules/audio_processing/utility/ring_buffer.h"
15
16 #include <stddef.h> // size_t
17 #include <stdlib.h>
18 #include <string.h>
19
20 enum Wrap {
21 SAME_WRAP,
22 DIFF_WRAP
23 };
24
25 struct RingBuffer {
26 size_t read_pos;
27 size_t write_pos;
28 size_t element_count;
29 size_t element_size;
30 enum Wrap rw_wrap;
31 char* data;
32 };
33
34 // Get address of region(s) from which we can read data.
35 // If the region is contiguous, |data_ptr_bytes_2| will be zero.
36 // If non-contiguous, |data_ptr_bytes_2| will be the size in bytes of the second
37 // region. Returns room available to be read or |element_count|, whichever is
38 // smaller.
GetBufferReadRegions(RingBuffer * buf,size_t element_count,void ** data_ptr_1,size_t * data_ptr_bytes_1,void ** data_ptr_2,size_t * data_ptr_bytes_2)39 static size_t GetBufferReadRegions(RingBuffer* buf,
40 size_t element_count,
41 void** data_ptr_1,
42 size_t* data_ptr_bytes_1,
43 void** data_ptr_2,
44 size_t* data_ptr_bytes_2) {
45
46 const size_t readable_elements = WebRtc_available_read(buf);
47 const size_t read_elements = (readable_elements < element_count ?
48 readable_elements : element_count);
49 const size_t margin = buf->element_count - buf->read_pos;
50
51 // Check to see if read is not contiguous.
52 if (read_elements > margin) {
53 // Write data in two blocks that wrap the buffer.
54 *data_ptr_1 = buf->data + buf->read_pos * buf->element_size;
55 *data_ptr_bytes_1 = margin * buf->element_size;
56 *data_ptr_2 = buf->data;
57 *data_ptr_bytes_2 = (read_elements - margin) * buf->element_size;
58 } else {
59 *data_ptr_1 = buf->data + buf->read_pos * buf->element_size;
60 *data_ptr_bytes_1 = read_elements * buf->element_size;
61 *data_ptr_2 = NULL;
62 *data_ptr_bytes_2 = 0;
63 }
64
65 return read_elements;
66 }
67
WebRtc_CreateBuffer(size_t element_count,size_t element_size)68 RingBuffer* WebRtc_CreateBuffer(size_t element_count, size_t element_size) {
69 RingBuffer* self = NULL;
70 if (element_count == 0 || element_size == 0) {
71 return NULL;
72 }
73
74 self = malloc(sizeof(RingBuffer));
75 if (!self) {
76 return NULL;
77 }
78
79 self->data = malloc(element_count * element_size);
80 if (!self->data) {
81 free(self);
82 self = NULL;
83 return NULL;
84 }
85
86 self->element_count = element_count;
87 self->element_size = element_size;
88
89 return self;
90 }
91
WebRtc_InitBuffer(RingBuffer * self)92 int WebRtc_InitBuffer(RingBuffer* self) {
93 if (!self) {
94 return -1;
95 }
96
97 self->read_pos = 0;
98 self->write_pos = 0;
99 self->rw_wrap = SAME_WRAP;
100
101 // Initialize buffer to zeros
102 memset(self->data, 0, self->element_count * self->element_size);
103
104 return 0;
105 }
106
WebRtc_FreeBuffer(void * handle)107 void WebRtc_FreeBuffer(void* handle) {
108 RingBuffer* self = (RingBuffer*)handle;
109 if (!self) {
110 return;
111 }
112
113 free(self->data);
114 free(self);
115 }
116
WebRtc_ReadBuffer(RingBuffer * self,void ** data_ptr,void * data,size_t element_count)117 size_t WebRtc_ReadBuffer(RingBuffer* self,
118 void** data_ptr,
119 void* data,
120 size_t element_count) {
121
122 if (self == NULL) {
123 return 0;
124 }
125 if (data == NULL) {
126 return 0;
127 }
128
129 {
130 void* buf_ptr_1 = NULL;
131 void* buf_ptr_2 = NULL;
132 size_t buf_ptr_bytes_1 = 0;
133 size_t buf_ptr_bytes_2 = 0;
134 const size_t read_count = GetBufferReadRegions(self,
135 element_count,
136 &buf_ptr_1,
137 &buf_ptr_bytes_1,
138 &buf_ptr_2,
139 &buf_ptr_bytes_2);
140
141 if (buf_ptr_bytes_2 > 0) {
142 // We have a wrap around when reading the buffer. Copy the buffer data to
143 // |data| and point to it.
144 memcpy(data, buf_ptr_1, buf_ptr_bytes_1);
145 memcpy(((char*) data) + buf_ptr_bytes_1, buf_ptr_2, buf_ptr_bytes_2);
146 buf_ptr_1 = data;
147 } else if (!data_ptr) {
148 // No wrap, but a memcpy was requested.
149 memcpy(data, buf_ptr_1, buf_ptr_bytes_1);
150 }
151 if (data_ptr) {
152 // |buf_ptr_1| == |data| in the case of a wrap.
153 *data_ptr = buf_ptr_1;
154 }
155
156 // Update read position
157 WebRtc_MoveReadPtr(self, (int) read_count);
158
159 return read_count;
160 }
161 }
162
WebRtc_WriteBuffer(RingBuffer * self,const void * data,size_t element_count)163 size_t WebRtc_WriteBuffer(RingBuffer* self,
164 const void* data,
165 size_t element_count) {
166 if (!self) {
167 return 0;
168 }
169 if (!data) {
170 return 0;
171 }
172
173 {
174 const size_t free_elements = WebRtc_available_write(self);
175 const size_t write_elements = (free_elements < element_count ? free_elements
176 : element_count);
177 size_t n = write_elements;
178 const size_t margin = self->element_count - self->write_pos;
179
180 if (write_elements > margin) {
181 // Buffer wrap around when writing.
182 memcpy(self->data + self->write_pos * self->element_size,
183 data, margin * self->element_size);
184 self->write_pos = 0;
185 n -= margin;
186 self->rw_wrap = DIFF_WRAP;
187 }
188 memcpy(self->data + self->write_pos * self->element_size,
189 ((const char*) data) + ((write_elements - n) * self->element_size),
190 n * self->element_size);
191 self->write_pos += n;
192
193 return write_elements;
194 }
195 }
196
WebRtc_MoveReadPtr(RingBuffer * self,int element_count)197 int WebRtc_MoveReadPtr(RingBuffer* self, int element_count) {
198 if (!self) {
199 return 0;
200 }
201
202 {
203 // We need to be able to take care of negative changes, hence use "int"
204 // instead of "size_t".
205 const int free_elements = (int) WebRtc_available_write(self);
206 const int readable_elements = (int) WebRtc_available_read(self);
207 int read_pos = (int) self->read_pos;
208
209 if (element_count > readable_elements) {
210 element_count = readable_elements;
211 }
212 if (element_count < -free_elements) {
213 element_count = -free_elements;
214 }
215
216 read_pos += element_count;
217 if (read_pos > (int) self->element_count) {
218 // Buffer wrap around. Restart read position and wrap indicator.
219 read_pos -= (int) self->element_count;
220 self->rw_wrap = SAME_WRAP;
221 }
222 if (read_pos < 0) {
223 // Buffer wrap around. Restart read position and wrap indicator.
224 read_pos += (int) self->element_count;
225 self->rw_wrap = DIFF_WRAP;
226 }
227
228 self->read_pos = (size_t) read_pos;
229
230 return element_count;
231 }
232 }
233
WebRtc_available_read(const RingBuffer * self)234 size_t WebRtc_available_read(const RingBuffer* self) {
235 if (!self) {
236 return 0;
237 }
238
239 if (self->rw_wrap == SAME_WRAP) {
240 return self->write_pos - self->read_pos;
241 } else {
242 return self->element_count - self->read_pos + self->write_pos;
243 }
244 }
245
WebRtc_available_write(const RingBuffer * self)246 size_t WebRtc_available_write(const RingBuffer* self) {
247 if (!self) {
248 return 0;
249 }
250
251 return self->element_count - WebRtc_available_read(self);
252 }
253