Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/RingBuffer/BUILD

@@ -0,0 +1,21 @@
+
+objc_library(
+    name = "RingBuffer",
+    enable_modules = True,
+    module_name = "RingBuffer",
+    srcs = glob([
+        "Sources/*.m",
+    ]),
+    hdrs = glob([
+        "PublicHeaders/**/*.h",
+    ]),
+    includes = [
+        "PublicHeaders",
+    ],
+    sdk_frameworks = [
+      "Foundation",
+    ],
+    visibility = [
+        "//visibility:public",
+    ],
+)

submodules/RingBuffer/PublicHeaders/RingBuffer/RingBuffer.h

@@ -0,0 +1,140 @@
+#import <Foundation/Foundation.h>
+
+#include <string.h>
+#include <assert.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+    typedef struct {
+        void             *buffer;
+        int32_t           length;
+        int32_t           tail;
+        int32_t           head;
+        int32_t  fillCount;
+    } TPCircularBuffer;
+    
+    /*!
+     * Initialise buffer
+     *
+     *  Note that the length is advisory only: Because of the way the
+     *  memory mirroring technique works, the true buffer length will
+     *  be multiples of the device page size (e.g. 4096 bytes)
+     *
+     *  If you intend to use the AudioBufferList utilities, you should
+     *  always allocate a bit more space than you need for pure audio
+     *  data, so there's room for the metadata. How much extra is required
+     *  depends on how many AudioBufferList structures are used, which is
+     *  a function of how many audio frames each buffer holds. A good rule
+     *  of thumb is to add 15%, or at least another 2048 bytes or so.
+     *
+     * @param buffer Circular buffer
+     * @param length Length of buffer
+     */
+    bool TPCircularBufferInit(TPCircularBuffer *buffer, int32_t length);
+    bool _TPCircularBufferInit(TPCircularBuffer *buffer, int32_t length, size_t structSize);
+    
+    /*!
+     * Cleanup buffer
+     *
+     *  Releases buffer resources.
+     */
+    void  TPCircularBufferCleanup(TPCircularBuffer *buffer);
+    
+    /*!
+     * Clear buffer
+     *
+     *  Resets buffer to original, empty state.
+     *
+     *  This is safe for use by consumer while producer is accessing
+     *  buffer.
+     */
+    void  TPCircularBufferClear(TPCircularBuffer *buffer);
+    
+    // Reading (consuming)
+    
+    /*!
+     * Access end of buffer
+     *
+     *  This gives you a pointer to the end of the buffer, ready
+     *  for reading, and the number of available bytes to read.
+     *
+     * @param buffer Circular buffer
+     * @param availableBytes On output, the number of bytes ready for reading
+     * @return Pointer to the first bytes ready for reading, or NULL if buffer is empty
+     */
+    static __inline__ __attribute__((always_inline)) void* TPCircularBufferTail(TPCircularBuffer *buffer, int32_t* availableBytes) {
+        *availableBytes = buffer->fillCount;
+        if ( *availableBytes == 0 ) return NULL;
+        return (void*)((char*)buffer->buffer + buffer->tail);
+    }
+    
+    /*!
+     * Consume bytes in buffer
+     *
+     *  This frees up the just-read bytes, ready for writing again.
+     *
+     * @param buffer Circular buffer
+     * @param amount Number of bytes to consume
+     */
+    static __inline__ __attribute__((always_inline)) void TPCircularBufferConsume(TPCircularBuffer *buffer, int32_t amount) {
+        buffer->tail = (buffer->tail + amount) % buffer->length;
+        buffer->fillCount -= amount;
+        assert(buffer->fillCount >= 0);
+    }
+    
+    /*!
+     * Access front of buffer
+     *
+     *  This gives you a pointer to the front of the buffer, ready
+     *  for writing, and the number of available bytes to write.
+     *
+     * @param buffer Circular buffer
+     * @param availableBytes On output, the number of bytes ready for writing
+     * @return Pointer to the first bytes ready for writing, or NULL if buffer is full
+     */
+    static __inline__ __attribute__((always_inline)) void* TPCircularBufferHead(TPCircularBuffer *buffer, int32_t* availableBytes) {
+        *availableBytes = (buffer->length - buffer->fillCount);
+        if ( *availableBytes == 0 ) return NULL;
+        return (void*)((char*)buffer->buffer + buffer->head);
+    }
+    
+    // Writing (producing)
+    
+    /*!
+     * Produce bytes in buffer
+     *
+     *  This marks the given section of the buffer ready for reading.
+     *
+     * @param buffer Circular buffer
+     * @param amount Number of bytes to produce
+     */
+    static __inline__ __attribute__((always_inline)) void TPCircularBufferProduce(TPCircularBuffer *buffer, int32_t amount) {
+        buffer->head = (buffer->head + amount) % buffer->length;
+        buffer->fillCount += amount;
+        assert(buffer->fillCount <= buffer->length);
+    }
+    
+    /*!
+     * Helper routine to copy bytes to buffer
+     *
+     *  This copies the given bytes to the buffer, and marks them ready for reading.
+     *
+     * @param buffer Circular buffer
+     * @param src Source buffer
+     * @param len Number of bytes in source buffer
+     * @return true if bytes copied, false if there was insufficient space
+     */
+    static __inline__ __attribute__((always_inline)) bool TPCircularBufferProduceBytes(TPCircularBuffer *buffer, const void* src, int32_t len) {
+        int32_t space;
+        void *ptr = TPCircularBufferHead(buffer, &space);
+        if ( space < len ) return false;
+        memcpy(ptr, src, len);
+        TPCircularBufferProduce(buffer, len);
+        return true;
+    }
+#ifdef __cplusplus
+}
+#endif
+

submodules/RingBuffer/Sources/RingBuffer.m

@@ -0,0 +1,121 @@
+#import <RingBuffer/RingBuffer.h>
+
+#include <mach/mach.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define reportResult(result,operation) (_reportResult((result),(operation),strrchr(__FILE__, '/')+1,__LINE__))
+static inline bool _reportResult(kern_return_t result, const char *operation, const char* file, int line) {
+    if ( result != ERR_SUCCESS ) {
+        printf("%s:%d: %s: %s\n", file, line, operation, mach_error_string(result));
+        return false;
+    }
+    return true;
+}
+
+bool TPCircularBufferInit(TPCircularBuffer *buffer, int32_t length) {
+    return _TPCircularBufferInit(buffer, length, sizeof(TPCircularBuffer));
+}
+
+bool _TPCircularBufferInit(TPCircularBuffer *buffer, int32_t length, size_t structSize) {
+    
+    assert(length > 0);
+    
+    if ( structSize != sizeof(TPCircularBuffer) ) {
+        fprintf(stderr, "TPCircularBuffer: Header version mismatch. Check for old versions of TPCircularBuffer in your project\n");
+        abort();
+    }
+    
+    // Keep trying until we get our buffer, needed to handle race conditions
+    int retries = 3;
+    while ( true ) {
+        
+        buffer->length = (int32_t)round_page(length);    // We need whole page sizes
+        
+        // Temporarily allocate twice the length, so we have the contiguous address space to
+        // support a second instance of the buffer directly after
+        vm_address_t bufferAddress;
+        kern_return_t result = vm_allocate(mach_task_self(),
+                                           &bufferAddress,
+                                           buffer->length * 2,
+                                           VM_FLAGS_ANYWHERE); // allocate anywhere it'll fit
+        if ( result != ERR_SUCCESS ) {
+            if ( retries-- == 0 ) {
+                reportResult(result, "Buffer allocation");
+                return false;
+            }
+            // Try again if we fail
+            continue;
+        }
+        
+        // Now replace the second half of the allocation with a virtual copy of the first half. Deallocate the second half...
+        result = vm_deallocate(mach_task_self(),
+                               bufferAddress + buffer->length,
+                               buffer->length);
+        if ( result != ERR_SUCCESS ) {
+            if ( retries-- == 0 ) {
+                reportResult(result, "Buffer deallocation");
+                return false;
+            }
+            // If this fails somehow, deallocate the whole region and try again
+            vm_deallocate(mach_task_self(), bufferAddress, buffer->length);
+            continue;
+        }
+        
+        // Re-map the buffer to the address space immediately after the buffer
+        vm_address_t virtualAddress = bufferAddress + buffer->length;
+        vm_prot_t cur_prot, max_prot;
+        result = vm_remap(mach_task_self(),
+                          &virtualAddress,   // mirror target
+                          buffer->length,    // size of mirror
+                          0,                 // auto alignment
+                          0,                 // force remapping to virtualAddress
+                          mach_task_self(),  // same task
+                          bufferAddress,     // mirror source
+                          0,                 // MAP READ-WRITE, NOT COPY
+                          &cur_prot,         // unused protection struct
+                          &max_prot,         // unused protection struct
+                          VM_INHERIT_DEFAULT);
+        if ( result != ERR_SUCCESS ) {
+            if ( retries-- == 0 ) {
+                reportResult(result, "Remap buffer memory");
+                return false;
+            }
+            // If this remap failed, we hit a race condition, so deallocate and try again
+            vm_deallocate(mach_task_self(), bufferAddress, buffer->length);
+            continue;
+        }
+        
+        if ( virtualAddress != bufferAddress+buffer->length ) {
+            // If the memory is not contiguous, clean up both allocated buffers and try again
+            if ( retries-- == 0 ) {
+                printf("Couldn't map buffer memory to end of buffer\n");
+                return false;
+            }
+            
+            vm_deallocate(mach_task_self(), virtualAddress, buffer->length);
+            vm_deallocate(mach_task_self(), bufferAddress, buffer->length);
+            continue;
+        }
+        
+        buffer->buffer = (void*)bufferAddress;
+        buffer->fillCount = 0;
+        buffer->head = buffer->tail = 0;
+        
+        return true;
+    }
+    return false;
+}
+
+void TPCircularBufferCleanup(TPCircularBuffer *buffer) {
+    vm_deallocate(mach_task_self(), (vm_address_t)buffer->buffer, buffer->length * 2);
+    memset(buffer, 0, sizeof(TPCircularBuffer));
+}
+
+void TPCircularBufferClear(TPCircularBuffer *buffer) {
+    int32_t fillCount;
+    if ( TPCircularBufferTail(buffer, &fillCount) ) {
+        TPCircularBufferConsume(buffer, fillCount);
+    }
+}
+