vdr-plugin-softhdcuvid/ringbuffer.c

///
/// @file ringbuffer.c  @brief Ringbuffer module
///
/// Copyright (c) 2009, 2011, 2014  by Johns.  All Rights Reserved.
///
/// Contributor(s):
///
/// License: AGPLv3
///
/// This program is free software: you can redistribute it and/or modify
/// it under the terms of the GNU Affero General Public License as
/// published by the Free Software Foundation, either version 3 of the
/// License.
///
/// This program is distributed in the hope that it will be useful,
/// but WITHOUT ANY WARRANTY; without even the implied warranty of
/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
/// GNU Affero General Public License for more details.
///
/// $Id: c9497b197ce7e7a6ba397944edc7ccb161152efd $
//////////////////////////////////////////////////////////////////////////////

///
/// @defgroup Ringbuffer The ring buffer module.
///
/// Lock free ring buffer with only one writer and one reader.
///

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "iatomic.h"
#include "ringbuffer.h"

    /// ring buffer structure
struct _ring_buffer_
{
    char *Buffer;                       ///< ring buffer data
    const char *BufferEnd;              ///< end of buffer
    size_t Size;                        ///< bytes in buffer (for faster calc)

    const char *ReadPointer;            ///< only used by reader
    char *WritePointer;                 ///< only used by writer

    /// The only thing modified by both
    atomic_t Filled;                    ///< how many of the buffer is used
};

/**
**	Reset ring buffer pointers.
**
**	@param rb	Ring buffer to reset read/write pointers.
*/
void RingBufferReset(RingBuffer * rb)
{
    rb->ReadPointer = rb->Buffer;
    rb->WritePointer = rb->Buffer;
    atomic_set(&rb->Filled, 0);
}

/**
**	Allocate a new ring buffer.
**
**	@param size	Size of the ring buffer.
**
**	@returns	Allocated ring buffer, must be freed with
**			RingBufferDel(), NULL for out of memory.
*/
RingBuffer *RingBufferNew(size_t size)
{
    RingBuffer *rb;

    if (!(rb = malloc(sizeof(*rb)))) {  // allocate structure
        return rb;
    }
    if (!(rb->Buffer = malloc(size))) { // allocate buffer
        free(rb);
        return NULL;
    }

    rb->Size = size;
    rb->BufferEnd = rb->Buffer + size;
    RingBufferReset(rb);

    return rb;
}

/**
**	Free an allocated ring buffer.
*/
void RingBufferDel(RingBuffer * rb)
{
    free(rb->Buffer);
    free(rb);
}

/**
**	Advance write pointer in ring buffer.
**
**	@param rb	Ring buffer to advance write pointer.
**	@param cnt	Number of bytes to be adavanced.
**
**	@returns	Number of bytes that could be advanced in ring buffer.
*/
size_t RingBufferWriteAdvance(RingBuffer * rb, size_t cnt)
{
    size_t n;

    n = rb->Size - atomic_read(&rb->Filled);
    if (cnt > n) {                      // not enough space
        cnt = n;
    }
    //
    //  Hitting end of buffer?
    //
    n = rb->BufferEnd - rb->WritePointer;
    if (n > cnt) {                      // don't cross the end
        rb->WritePointer += cnt;
    } else {                            // reached or cross the end
        rb->WritePointer = rb->Buffer;
        if (n < cnt) {
            n = cnt - n;
            rb->WritePointer += n;
        }
    }

    //
    //  Only atomic modification!
    //
    atomic_add(cnt, &rb->Filled);
    return cnt;
}

/**
**	Write to a ring buffer.
**
**	@param rb	Ring buffer to write to.
**	@param buf	Buffer of @p cnt bytes.
**	@param cnt	Number of bytes in buffer.
**
**	@returns	The number of bytes that could be placed in the ring
**			buffer.
*/
size_t RingBufferWrite(RingBuffer * rb, const void *buf, size_t cnt)
{
    size_t n;

    n = rb->Size - atomic_read(&rb->Filled);
    if (cnt > n) {                      // not enough space
        cnt = n;
    }
    //
    //  Hitting end of buffer?
    //
    n = rb->BufferEnd - rb->WritePointer;
    if (n > cnt) {                      // don't cross the end
        memcpy(rb->WritePointer, buf, cnt);
        rb->WritePointer += cnt;
    } else {                            // reached or cross the end
        memcpy(rb->WritePointer, buf, n);
        rb->WritePointer = rb->Buffer;
        if (n < cnt) {
            buf += n;
            n = cnt - n;
            memcpy(rb->WritePointer, buf, n);
            rb->WritePointer += n;
        }
    }

    //
    //  Only atomic modification!
    //
    atomic_add(cnt, &rb->Filled);
    return cnt;
}

/**
**	Get write pointer and free bytes at this position of ring buffer.
**
**	@param rb	Ring buffer to write to.
**	@param[out] wp	Write pointer is placed here
**
**	@returns	The number of bytes that could be placed in the ring
**			buffer at the write pointer.
*/
size_t RingBufferGetWritePointer(RingBuffer * rb, void **wp)
{
    size_t n;
    size_t cnt;

    //  Total free bytes available in ring buffer
    cnt = rb->Size - atomic_read(&rb->Filled);

    *wp = rb->WritePointer;

    //
    //  Hitting end of buffer?
    //
    n = rb->BufferEnd - rb->WritePointer;
    if (n <= cnt) {                     // reached or cross the end
        return n;
    }
    return cnt;
}

/**
**	Advance read pointer in ring buffer.
**
**	@param rb	Ring buffer to advance read pointer.
**	@param cnt	Number of bytes to be advanced.
**
**	@returns	Number of bytes that could be advanced in ring buffer.
*/
size_t RingBufferReadAdvance(RingBuffer * rb, size_t cnt)
{
    size_t n;

    n = atomic_read(&rb->Filled);
    if (cnt > n) {                      // not enough filled
        cnt = n;
    }
    //
    //  Hitting end of buffer?
    //
    n = rb->BufferEnd - rb->ReadPointer;
    if (n > cnt) {                      // don't cross the end
        rb->ReadPointer += cnt;
    } else {                            // reached or cross the end
        rb->ReadPointer = rb->Buffer;
        if (n < cnt) {
            n = cnt - n;
            rb->ReadPointer += n;
        }
    }

    //
    //  Only atomic modification!
    //
    atomic_sub(cnt, &rb->Filled);
    return cnt;
}

/**
**	Read from a ring buffer.
**
**	@param rb	Ring buffer to read from.
**	@param buf	Buffer of @p cnt bytes.
**	@param cnt	Number of bytes to be read.
**
**	@returns	Number of bytes that could be read from ring buffer.
*/
size_t RingBufferRead(RingBuffer * rb, void *buf, size_t cnt)
{
    size_t n;

    n = atomic_read(&rb->Filled);
    if (cnt > n) {                      // not enough filled
        cnt = n;
    }
    //
    //  Hitting end of buffer?
    //
    n = rb->BufferEnd - rb->ReadPointer;
    if (n > cnt) {                      // don't cross the end
        memcpy(buf, rb->ReadPointer, cnt);
        rb->ReadPointer += cnt;
    } else {                            // reached or cross the end
        memcpy(buf, rb->ReadPointer, n);
        rb->ReadPointer = rb->Buffer;
        if (n < cnt) {
            buf += n;
            n = cnt - n;
            memcpy(buf, rb->ReadPointer, n);
            rb->ReadPointer += n;
        }
    }

    //
    //  Only atomic modification!
    //
    atomic_sub(cnt, &rb->Filled);
    return cnt;
}

/**
**	Get read pointer and used bytes at this position of ring buffer.
**
**	@param rb	Ring buffer to read from.
**	@param[out] rp	Read pointer is placed here
**
**	@returns	The number of bytes that could be read from the ring
**			buffer at the read pointer.
*/
size_t RingBufferGetReadPointer(RingBuffer * rb, const void **rp)
{
    size_t n;
    size_t cnt;

    //  Total used bytes in ring buffer
    cnt = atomic_read(&rb->Filled);

    *rp = rb->ReadPointer;

    //
    //  Hitting end of buffer?
    //
    n = rb->BufferEnd - rb->ReadPointer;
    if (n <= cnt) {                     // reached or cross the end
        return n;
    }
    return cnt;
}

/**
**	Get free bytes in ring buffer.
**
**	@param rb	Ring buffer.
**
**	@returns	Number of bytes free in buffer.
*/
size_t RingBufferFreeBytes(RingBuffer * rb)
{
    return rb->Size - atomic_read(&rb->Filled);
}

/**
**	Get used bytes in ring buffer.
**
**	@param rb	Ring buffer.
**
**	@returns	Number of bytes used in buffer.
*/
size_t RingBufferUsedBytes(RingBuffer * rb)
{
    return atomic_read(&rb->Filled);
}