Moved the ringbuffer to be built using C++

webrtc/modules/audio_processing/utility/ring_buffer.cc

 /*
  *  Copyright (c) 2011 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 24 matching lines @@
 // If the region is contiguous, |data_ptr_bytes_2| will be zero.
 // If non-contiguous, |data_ptr_bytes_2| will be the size in bytes of the second
 // region. Returns room available to be read or |element_count|, whichever is
 // smaller.
 static size_t 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) {
-
   const size_t readable_elements = WebRtc_available_read(buf);
   const size_t read_elements = (readable_elements < element_count ?
       readable_elements : element_count);
   const size_t margin = buf->element_count - buf->read_pos;
 
   // Check to see if read is not contiguous.
   if (read_elements > margin) {
     // Write data in two blocks that wrap the buffer.
     *data_ptr_1 = buf->data + buf->read_pos * buf->element_size;
     *data_ptr_bytes_1 = margin * buf->element_size;
     *data_ptr_2 = buf->data;
     *data_ptr_bytes_2 = (read_elements - margin) * buf->element_size;
   } else {
     *data_ptr_1 = buf->data + buf->read_pos * buf->element_size;
     *data_ptr_bytes_1 = read_elements * buf->element_size;
     *data_ptr_2 = NULL;
     *data_ptr_bytes_2 = 0;
   }
 
   return read_elements;
 }
 
 RingBuffer* WebRtc_CreateBuffer(size_t element_count, size_t element_size) {
   RingBuffer* self = NULL;
   if (element_count == 0 || element_size == 0) {
     return NULL;
   }
 
-  self = malloc(sizeof(RingBuffer));
+  self = static_cast<RingBuffer*>(malloc(sizeof(RingBuffer)));
   if (!self) {
     return NULL;
   }
 
-  self->data = malloc(element_count * element_size);
+  self->data = static_cast<char*>(malloc(element_count * element_size));
   if (!self->data) {
     free(self);
     self = NULL;
     return NULL;
   }
 
   self->element_count = element_count;
   self->element_size = element_size;
   WebRtc_InitBuffer(self);
 
   return self;
 }
 
 void WebRtc_InitBuffer(RingBuffer* self) {
   self->read_pos = 0;
   self->write_pos = 0;
   self->rw_wrap = SAME_WRAP;
 
   // Initialize buffer to zeros
   memset(self->data, 0, self->element_count * self->element_size);
 }
 
 void WebRtc_FreeBuffer(void* handle) {
-  RingBuffer* self = (RingBuffer*)handle;
+  RingBuffer* self = static_cast<RingBuffer*>(handle);
   if (!self) {
     return;
   }
 
   free(self->data);
   free(self);
 }
 
 size_t WebRtc_ReadBuffer(RingBuffer* self,
                          void** data_ptr,
                          void* data,
                          size_t element_count) {
-
   if (self == NULL) {
     return 0;
   }
   if (data == NULL) {
     return 0;
   }
 
   {
     void* buf_ptr_1 = NULL;
     void* buf_ptr_2 = NULL;
     size_t buf_ptr_bytes_1 = 0;
     size_t buf_ptr_bytes_2 = 0;
     const size_t read_count = GetBufferReadRegions(self,
                                                    element_count,
                                                    &buf_ptr_1,
                                                    &buf_ptr_bytes_1,
                                                    &buf_ptr_2,
                                                    &buf_ptr_bytes_2);
 
     if (buf_ptr_bytes_2 > 0) {
       // We have a wrap around when reading the buffer. Copy the buffer data to
       // |data| and point to it.
       memcpy(data, buf_ptr_1, buf_ptr_bytes_1);
-      memcpy(((char*) data) + buf_ptr_bytes_1, buf_ptr_2, buf_ptr_bytes_2);
+      memcpy(static_cast<char*>(data) + buf_ptr_bytes_1, buf_ptr_2,
+             buf_ptr_bytes_2);
       buf_ptr_1 = data;
     } else if (!data_ptr) {
       // No wrap, but a memcpy was requested.
       memcpy(data, buf_ptr_1, buf_ptr_bytes_1);
     }
     if (data_ptr) {
       // |buf_ptr_1| == |data| in the case of a wrap.
       *data_ptr = buf_ptr_1;
     }
 
     // Update read position
-    WebRtc_MoveReadPtr(self, (int) read_count);
+    WebRtc_MoveReadPtr(self, static_cast<int>(read_count));
 
     return read_count;
   }
 }
 
 size_t WebRtc_WriteBuffer(RingBuffer* self,
                           const void* data,
                           size_t element_count) {
   if (!self) {
     return 0;
@@ skipping 27 matching lines @@
 }
 
 int WebRtc_MoveReadPtr(RingBuffer* self, int element_count) {
   if (!self) {
     return 0;
   }
 
   {
     // We need to be able to take care of negative changes, hence use "int"
     // instead of "size_t".
-    const int free_elements = (int) WebRtc_available_write(self);
-    const int readable_elements = (int) WebRtc_available_read(self);
-    int read_pos = (int) self->read_pos;
+    const int free_elements = static_cast<int>(WebRtc_available_write(self));
+    const int readable_elements = static_cast<int>(WebRtc_available_read(self));
+    int read_pos = static_cast<int>(self->read_pos);
 
     if (element_count > readable_elements) {
       element_count = readable_elements;
     }
     if (element_count < -free_elements) {
       element_count = -free_elements;
     }
 
     read_pos += element_count;
-    if (read_pos > (int) self->element_count) {
+    if (read_pos > static_cast<int>(self->element_count)) {
       // Buffer wrap around. Restart read position and wrap indicator.
-      read_pos -= (int) self->element_count;
+      read_pos -= static_cast<int>(self->element_count);
       self->rw_wrap = SAME_WRAP;
     }
     if (read_pos < 0) {
       // Buffer wrap around. Restart read position and wrap indicator.
-      read_pos += (int) self->element_count;
+      read_pos += static_cast<int>(self->element_count);
       self->rw_wrap = DIFF_WRAP;
     }
 
-    self->read_pos = (size_t) read_pos;
+    self->read_pos = static_cast<size_t>(read_pos);
 
     return element_count;
   }
 }
 
 size_t WebRtc_available_read(const RingBuffer* self) {
   if (!self) {
     return 0;
   }
 
   if (self->rw_wrap == SAME_WRAP) {
     return self->write_pos - self->read_pos;
   } else {
     return self->element_count - self->read_pos + self->write_pos;
   }
 }
 
 size_t WebRtc_available_write(const RingBuffer* self) {
   if (!self) {
     return 0;
   }
 
   return self->element_count - WebRtc_available_read(self);
 }