ringbuffer.c

 
#include <freerdp/config.h>
 
#include <freerdp/utils/ringbuffer.h>
 
#include <stdlib.h>
#include <string.h>
#include <winpr/assert.h>
 
#include <winpr/crt.h>
#include <freerdp/log.h>
 
#ifdef WITH_DEBUG_RINGBUFFER
#define TAG FREERDP_TAG("utils.ringbuffer")
 
#define DEBUG_RINGBUFFER(...) WLog_DBG(TAG, __VA_ARGS__)
#else
#define DEBUG_RINGBUFFER(...) \
  do                        \
  {                         \
  } while (0)
#endif
 
BOOL ringbuffer_init(RingBuffer* ringbuffer, size_t initialSize)
{
  WINPR_ASSERT(ringbuffer);
  ringbuffer->buffer = malloc(initialSize);
 
  if (!ringbuffer->buffer)
    return FALSE;
 
  ringbuffer->readPtr = ringbuffer->writePtr = 0;
  ringbuffer->initialSize = ringbuffer->size = ringbuffer->freeSize = initialSize;
  DEBUG_RINGBUFFER("ringbuffer_init(%p)", (void*)rb);
  return TRUE;
}
 
size_t ringbuffer_used(const RingBuffer* ringbuffer)
{
  WINPR_ASSERT(ringbuffer);
  return ringbuffer->size - ringbuffer->freeSize;
}
 
size_t ringbuffer_capacity(const RingBuffer* ringbuffer)
{
  WINPR_ASSERT(ringbuffer);
  return ringbuffer->size;
}
 
void ringbuffer_destroy(RingBuffer* ringbuffer)
{
  DEBUG_RINGBUFFER("ringbuffer_destroy(%p)", (void*)ringbuffer);
  if (!ringbuffer)
    return;
 
  free(ringbuffer->buffer);
  ringbuffer->buffer = nullptr;
}
 
static BOOL ringbuffer_realloc(RingBuffer* ringbuffer, size_t targetSize)
{
  WINPR_ASSERT(ringbuffer);
  BYTE* newData = nullptr;
  DEBUG_RINGBUFFER("ringbuffer_realloc(%p): targetSize: %" PRIdz "", (void*)rb, targetSize);
 
  if (ringbuffer->writePtr == ringbuffer->readPtr)
  {
    /* when no size is used we can realloc() and set the heads at the
     * beginning of the buffer
     */
    newData = (BYTE*)realloc(ringbuffer->buffer, targetSize);
 
    if (!newData)
      return FALSE;
 
    ringbuffer->readPtr = ringbuffer->writePtr = 0;
    ringbuffer->buffer = newData;
  }
  else if ((ringbuffer->writePtr >= ringbuffer->readPtr) && (ringbuffer->writePtr < targetSize))
  {
    /* we reallocate only if we're in that case, realloc don't touch read
     * and write heads
     *
     *        readPtr              writePtr
     *              |              |
     *              v              v
     * [............|XXXXXXXXXXXXXX|..........]
     */
    newData = (BYTE*)realloc(ringbuffer->buffer, targetSize);
 
    if (!newData)
      return FALSE;
 
    ringbuffer->buffer = newData;
  }
  else
  {
    /* in case of malloc the read head is moved at the beginning of the new buffer
     * and the write head is set accordingly
     */
    newData = (BYTE*)malloc(targetSize);
 
    if (!newData)
      return FALSE;
 
    if (ringbuffer->readPtr < ringbuffer->writePtr)
    {
      /*        readPtr              writePtr
       *              |              |
       *              v              v
       * [............|XXXXXXXXXXXXXX|..........]
       */
      memcpy(newData, ringbuffer->buffer + ringbuffer->readPtr, ringbuffer_used(ringbuffer));
    }
    else
    {
      /*        writePtr             readPtr
       *              |              |
       *              v              v
       * [XXXXXXXXXXXX|..............|XXXXXXXXXX]
       */
      BYTE* dst = newData;
      memcpy(dst, ringbuffer->buffer + ringbuffer->readPtr,
             ringbuffer->size - ringbuffer->readPtr);
      dst += (ringbuffer->size - ringbuffer->readPtr);
 
      if (ringbuffer->writePtr)
        memcpy(dst, ringbuffer->buffer, ringbuffer->writePtr);
    }
 
    ringbuffer->writePtr = ringbuffer->size - ringbuffer->freeSize;
    ringbuffer->readPtr = 0;
    free(ringbuffer->buffer);
    ringbuffer->buffer = newData;
  }
 
  ringbuffer->freeSize += (targetSize - ringbuffer->size);
  ringbuffer->size = targetSize;
  return TRUE;
}
 
BOOL ringbuffer_write(RingBuffer* ringbuffer, const BYTE* ptr, size_t sz)
{
  size_t toWrite = 0;
  size_t remaining = 0;
 
  WINPR_ASSERT(ringbuffer);
  DEBUG_RINGBUFFER("ringbuffer_write(%p): sz: %" PRIdz "", (void*)rb, sz);
 
  if ((ringbuffer->freeSize <= sz) && !ringbuffer_realloc(ringbuffer, ringbuffer->size + sz))
    return FALSE;
 
  /*  the write could be split in two
   *    readHead        writeHead
   *      |               |
   *      v               v
   * [    ################        ]
   */
  toWrite = sz;
  remaining = sz;
 
  if (ringbuffer->size - ringbuffer->writePtr < sz)
    toWrite = ringbuffer->size - ringbuffer->writePtr;
 
  if (toWrite)
  {
    memcpy(ringbuffer->buffer + ringbuffer->writePtr, ptr, toWrite);
    remaining -= toWrite;
    ptr += toWrite;
  }
 
  if (remaining)
    memcpy(ringbuffer->buffer, ptr, remaining);
 
  ringbuffer->writePtr = (ringbuffer->writePtr + sz) % ringbuffer->size;
  ringbuffer->freeSize -= sz;
  return TRUE;
}
 
BYTE* ringbuffer_ensure_linear_write(RingBuffer* ringbuffer, size_t sz)
{
  DEBUG_RINGBUFFER("ringbuffer_ensure_linear_write(%p): sz: %" PRIdz "", (void*)rb, sz);
 
  WINPR_ASSERT(ringbuffer);
  if (ringbuffer->freeSize < sz)
  {
    if (!ringbuffer_realloc(ringbuffer, ringbuffer->size + sz - ringbuffer->freeSize + 32))
      return nullptr;
  }
 
  if (ringbuffer->writePtr == ringbuffer->readPtr)
  {
    ringbuffer->writePtr = ringbuffer->readPtr = 0;
  }
 
  if (ringbuffer->writePtr + sz < ringbuffer->size)
    return ringbuffer->buffer + ringbuffer->writePtr;
 
  /*
   * to add:             .......
   * [          XXXXXXXXX  ]
   *
   * result:
   * [XXXXXXXXX.......     ]
   */
  memmove(ringbuffer->buffer, ringbuffer->buffer + ringbuffer->readPtr,
          ringbuffer->writePtr - ringbuffer->readPtr);
  ringbuffer->readPtr = 0;
  ringbuffer->writePtr = ringbuffer->size - ringbuffer->freeSize;
  return ringbuffer->buffer + ringbuffer->writePtr;
}
 
BOOL ringbuffer_commit_written_bytes(RingBuffer* ringbuffer, size_t sz)
{
  DEBUG_RINGBUFFER("ringbuffer_commit_written_bytes(%p): sz: %" PRIdz "", (void*)rb, sz);
 
  WINPR_ASSERT(ringbuffer);
  if (sz < 1)
    return TRUE;
 
  if (ringbuffer->writePtr + sz > ringbuffer->size)
    return FALSE;
 
  ringbuffer->writePtr = (ringbuffer->writePtr + sz) % ringbuffer->size;
  ringbuffer->freeSize -= sz;
  return TRUE;
}
 
int ringbuffer_peek(const RingBuffer* ringbuffer, DataChunk chunks[2], size_t sz)
{
  size_t remaining = sz;
  size_t toRead = 0;
  int chunkIndex = 0;
  int status = 0;
  DEBUG_RINGBUFFER("ringbuffer_peek(%p): sz: %" PRIdz "", (const void*)rb, sz);
 
  WINPR_ASSERT(ringbuffer);
  if (sz < 1)
    return 0;
 
  if ((ringbuffer->size - ringbuffer->freeSize) < sz)
    remaining = ringbuffer->size - ringbuffer->freeSize;
 
  toRead = remaining;
 
  if ((ringbuffer->readPtr + remaining) > ringbuffer->size)
    toRead = ringbuffer->size - ringbuffer->readPtr;
 
  if (toRead)
  {
    chunks[0].data = ringbuffer->buffer + ringbuffer->readPtr;
    chunks[0].size = toRead;
    remaining -= toRead;
    chunkIndex++;
    status++;
  }
 
  if (remaining)
  {
    chunks[chunkIndex].data = ringbuffer->buffer;
    chunks[chunkIndex].size = remaining;
    status++;
  }
 
  return status;
}
 
void ringbuffer_commit_read_bytes(RingBuffer* ringbuffer, size_t sz)
{
  DEBUG_RINGBUFFER("ringbuffer_commit_read_bytes(%p): sz: %" PRIdz "", (void*)ringbuffer, sz);
 
  WINPR_ASSERT(ringbuffer);
  if (sz < 1)
    return;
 
  WINPR_ASSERT(ringbuffer->size - ringbuffer->freeSize >= sz);
  ringbuffer->readPtr = (ringbuffer->readPtr + sz) % ringbuffer->size;
  ringbuffer->freeSize += sz;
 
  /* when we reach a reasonable free size, we can go back to the original size */
  if ((ringbuffer->size != ringbuffer->initialSize) &&
      (ringbuffer_used(ringbuffer) < ringbuffer->initialSize / 2))
    ringbuffer_realloc(ringbuffer, ringbuffer->initialSize);
}