• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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