ra8_webp_arena.c

Go to the documentation of this file.

 
#include "ra8_webp_arena.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>

typedef enum : uint32_t {
  k_ra8_webp_align      = 16U, 
  k_ra8_webp_align_mask = 15U, 
} ra8_webp_arena_consts_t;

static ra8_webp_arena_t* s_arena = nullptr;
 
void ra8_webp_arena_bind(ra8_webp_arena_t* arena)
{
  s_arena = arena;
  if (arena != nullptr) {
    arena->offset = 0U;
    arena->live   = 0U;
  }
}
 
void ra8_webp_arena_unbind(void)
{
  s_arena = nullptr;
}
 
void* ra8_webp_arena_malloc(size_t n)
{
  ra8_webp_arena_t* const a = s_arena;
  if (a == nullptr) {
    return nullptr;
  }
  /* Reject requests too large to ever fit; this also prevents the alignment
   * round-up below from overflowing. */
  if (n > a->cap) {
    return nullptr;
  }
  const size_t aligned = (n + (size_t)k_ra8_webp_align_mask) & ~(size_t)k_ra8_webp_align_mask;
  if (aligned > (a->cap - a->offset)) {
    return nullptr;
  }
  void* const block = &a->base[a->offset];
  a->offset += aligned;
  a->live += 1U;
  return block;
}
 
void* ra8_webp_arena_calloc(size_t nmemb, size_t size)
{
  /* Guard the product against size_t overflow before allocating (libwebp
   * checks this too, but the arena must be safe on its own). */
  if ((size != 0U) && (nmemb > (SIZE_MAX / size))) {
    return nullptr;
  }
  const size_t total = nmemb * size;
  void* const  block = ra8_webp_arena_malloc(total);
  if (block == nullptr) {
    return nullptr;
  }
  if (total > 0U) {
    memset(block, 0, total);
  }
  return block;
}
 
void ra8_webp_arena_free(void* p)
{
  ra8_webp_arena_t* const a = s_arena;
  if ((p == nullptr) || (a == nullptr)) {
    return;
  }
  if (a->live > 0U) {
    a->live -= 1U;
  }
  if (a->live == 0U) {
    a->offset = 0U;
  }
}