circular_buffer.c

#include "circular_buffer.h"

int init_circular_buffer(CircularBuffer *buffer, int segment_duration, 
                        int sample_rate, int channels, int bits_per_sample)
{
    buffer->segment_duration = segment_duration;
    buffer->segment_size = segment_duration * sample_rate * channels * bits_per_sample / 8;
    buffer->buffer_size = 10; // Store 10 segments (enough for our needs)
    buffer->head = 0;
    buffer->tail = 0;
    buffer->count = 0;

    // Allocate memory for segment pointers
    buffer->segments = (char **)malloc(buffer->buffer_size * sizeof(char *));
    if (!buffer->segments)
    {
        fprintf(stderr, "ERROR: Cannot allocate memory for segment pointers\n");
        return -1;
    }

    // Allocate memory for each segment
    for (int i = 0; i < buffer->buffer_size; i++)
    {
        buffer->segments[i] = (char *)malloc(buffer->segment_size);
        if (!buffer->segments[i])
        {
            fprintf(stderr, "ERROR: Cannot allocate memory for segment %d\n", i);
            // Free already allocated memory
            for (int j = 0; j < i; j++)
            {
                free(buffer->segments[j]);
            }
            free(buffer->segments);
            return -1;
        }
        memset(buffer->segments[i], 0, buffer->segment_size); // Initialize with silence
    }

    return 0;
}

void free_circular_buffer(CircularBuffer *buffer)
{
    if (buffer->segments)
    {
        for (int i = 0; i < buffer->buffer_size; i++)
        {
            if (buffer->segments[i])
            {
                free(buffer->segments[i]);
            }
        }
        free(buffer->segments);
    }
    buffer->segments = NULL;
    buffer->count = 0;
    buffer->head = 0;
    buffer->tail = 0;
}

int push_segment(CircularBuffer *buffer, char *data)
{
    if (buffer->count == buffer->buffer_size)
    {
        // Buffer is full, overwrite oldest segment
        buffer->tail = (buffer->tail + 1) % buffer->buffer_size;
        buffer->count--;
    }

    // Copy data to buffer
    memcpy(buffer->segments[buffer->head], data, buffer->segment_size);
    buffer->head = (buffer->head + 1) % buffer->buffer_size;
    buffer->count++;

    return 0;
}

char *get_segment(CircularBuffer *buffer, int index)
{
    if (index < 0 || index >= buffer->count)
    {
        return NULL;
    }

    int actual_index = (buffer->tail + index) % buffer->buffer_size;
    return buffer->segments[actual_index];
}

int pop_segment(CircularBuffer *buffer)
{
    if (buffer->count == 0)
    {
        return -1; // Buffer is empty
    }

    buffer->tail = (buffer->tail + 1) % buffer->buffer_size;
    buffer->count--;

    return 0;
}

int is_buffer_full(CircularBuffer *buffer)
{
    return buffer->count == buffer->buffer_size;
}

int is_buffer_empty(CircularBuffer *buffer)
{
    return buffer->count == 0;
}