ra8_rabook_raster.c

Go to the documentation of this file.

 
#include "ra8_rabook_raster.h"
 
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_img_arena.h"
#include "ra8_rabook_gray4.h"
#include "ra8_webp.h"
#include "stb_image.h"

typedef enum : uint16_t {
  k_raster_webp_signature_size = 12U,  
  k_raster_webp_form_offset    = 8U,   
  k_raster_webp_bytes_per_px   = 4U,   
  k_raster_luma_r              = 77U,  
  k_raster_luma_g              = 150U, 
  k_raster_luma_b              = 29U,  
  k_raster_luma_shift          = 8U,   
} ra8_rabook_raster_consts_t;

RA8_INTERNAL static bool internal_is_webp(const uint8_t* source, size_t source_size)
{
  static const uint8_t k_riff[] = {'R', 'I', 'F', 'F'};
  static const uint8_t k_webp[] = {'W', 'E', 'B', 'P'};
  if (source_size < (size_t)k_raster_webp_signature_size) {
    return false;
  }
  if (memcmp(source, k_riff, sizeof k_riff) != 0) {
    return false;
  }
  return memcmp(&source[k_raster_webp_form_offset], k_webp, sizeof k_webp) == 0;
}

RA8_INTERNAL static void internal_rgba_to_gray(uint8_t* rgba, uint32_t pixels)
{
  for (uint32_t i = 0U; i < pixels; ++i) {
    const size_t   p = (size_t)i * (size_t)k_raster_webp_bytes_per_px;
    const uint32_t y = ((uint32_t)rgba[p] * (uint32_t)k_raster_luma_r) +
                       ((uint32_t)rgba[p + 1U] * (uint32_t)k_raster_luma_g) +
                       ((uint32_t)rgba[p + 2U] * (uint32_t)k_raster_luma_b);
    rgba[i]          = (uint8_t)(y >> k_raster_luma_shift);
  }
}

RA8_INTERNAL static void internal_output_dims(uint16_t  source_width,
                                              uint16_t  source_height,
                                              uint16_t  max_edge,
                                              uint16_t* out_width,
                                              uint16_t* out_height)
{
  if (max_edge == 0U) {
    *out_width  = source_width;
    *out_height = source_height;
    return;
  }
  ra8_rabook_gray4_output_dims(source_width, source_height, max_edge, out_width, out_height);
}

RA8_INTERNAL static ra8_err_t internal_scale(const uint8_t*                 source_gray,
                                             uint16_t                       source_width,
                                             uint16_t                       source_height,
                                             uint16_t                       out_width,
                                             uint16_t                       out_height,
                                             ra8_rabook_raster_workspace_t* workspace,
                                             const uint8_t**                out_gray)
{
  if (source_width == out_width) {
    if (source_height == out_height) {
      *out_gray = source_gray;
      return k_ra8_ok;
    }
  }
  const uint32_t pixels = (uint32_t)out_width * (uint32_t)out_height;
  if (workspace->gray == nullptr) {
    return k_ra8_err_no_mem;
  }
  if ((size_t)pixels > workspace->gray_cap) {
    return k_ra8_err_no_mem;
  }
  const ra8_err_t rc = ra8_rabook_gray4_downscale(source_gray,
                                                  source_width,
                                                  source_height,
                                                  workspace->gray,
                                                  out_width,
                                                  out_height);
  if (rc == k_ra8_ok) {
    *out_gray = workspace->gray;
  }
  return rc;
}

RA8_INTERNAL static ra8_err_t internal_encode(const uint8_t* gray,
                                              uint16_t       width,
                                              uint16_t       height,
                                              uint8_t        pixel_format,
                                              uint8_t*       encoded,
                                              size_t         encoded_cap,
                                              uint32_t*      out_size)
{
  const uint32_t bounded_cap = (encoded_cap > UINT32_MAX) ? UINT32_MAX : (uint32_t)encoded_cap;
  if (pixel_format == (uint8_t)k_book_pixfmt_gray8) {
    return ra8_rabook_gray8_encode(gray, width, height, encoded, bounded_cap, out_size);
  }
  return ra8_rabook_gray4_encode(gray, width, height, encoded, bounded_cap, out_size);
}

RA8_INTERNAL static ra8_err_t internal_decode_webp(const uint8_t*                 source,
                                                   size_t                         source_size,
                                                   ra8_rabook_raster_workspace_t* workspace,
                                                   const uint8_t**                out_gray,
                                                   uint16_t*                      out_width,
                                                   uint16_t*                      out_height)
{
  uint32_t  width  = 0U;
  uint32_t  height = 0U;
  ra8_err_t rc     = ra8_webp_get_info(source, source_size, &width, &height);
  if (rc != k_ra8_ok) {
    return rc;
  }
  if (width > UINT16_MAX) {
    return k_ra8_err_invalid_size;
  }
  if (height > UINT16_MAX) {
    return k_ra8_err_invalid_size;
  }
  const uint64_t frame_size =
    (uint64_t)width * (uint64_t)height * (uint64_t)k_raster_webp_bytes_per_px;
  if (workspace->webp_arena == nullptr) {
    return k_ra8_err_no_mem;
  }
  if (workspace->rgba == nullptr) {
    return k_ra8_err_no_mem;
  }
  if (frame_size > (uint64_t)workspace->rgba_cap) {
    return k_ra8_err_no_mem;
  }
  rc = ra8_webp_decode_rgba(source,
                            source_size,
                            workspace->webp_arena,
                            workspace->rgba,
                            (size_t)width * (size_t)k_raster_webp_bytes_per_px,
                            (size_t)frame_size,
                            nullptr,
                            nullptr);
  if (rc != k_ra8_ok) {
    return rc;
  }
  const uint32_t pixels = width * height;
  internal_rgba_to_gray(workspace->rgba, pixels);
  *out_gray   = workspace->rgba;
  *out_width  = (uint16_t)width;
  *out_height = (uint16_t)height;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_decode_stb(const uint8_t*                 source,
                                                  size_t                         source_size,
                                                  ra8_rabook_raster_workspace_t* workspace,
                                                  uint8_t**                      out_gray,
                                                  uint16_t*                      out_width,
                                                  uint16_t*                      out_height)
{
  if (source_size > (size_t)INT_MAX) {
    return k_ra8_err_invalid_size;
  }
  if (workspace->stb_arena == nullptr) {
    return k_ra8_err_no_mem;
  }
  int width      = 0;
  int height     = 0;
  int components = 0;
  ra8_img_arena_bind(workspace->stb_arena);
  uint8_t* pixels = stbi_load_from_memory(source, /* alloc-allow: caller-bound ra8_img_arena */
                                          (int)source_size,
                                          &width,
                                          &height,
                                          &components,
                                          1);
  if (pixels == nullptr) {
    ra8_img_arena_unbind();
    return k_ra8_err_validation_failed;
  }
  bool dimensions_valid = width > 0;
  if (height <= 0) {
    dimensions_valid = false;
  }
  if (width > (int)UINT16_MAX) {
    dimensions_valid = false;
  }
  if (height > (int)UINT16_MAX) {
    dimensions_valid = false;
  }
  if (!dimensions_valid) {
    stbi_image_free(pixels); /* alloc-allow: caller-bound ra8_img_arena */
    ra8_img_arena_unbind();
    return k_ra8_err_invalid_size;
  }
  *out_gray   = pixels;
  *out_width  = (uint16_t)width;
  *out_height = (uint16_t)height;
  return k_ra8_ok;
}

typedef struct internal_decoded_raster_t {
  const uint8_t* gray;       
  uint8_t*       stb_pixels; 
  uint16_t       width;      
  uint16_t       height;     
  bool           webp;       
} internal_decoded_raster_t;

RA8_INTERNAL
static ra8_err_t internal_decode_source(const uint8_t*                 source,
                                        size_t                         source_size,
                                        ra8_rabook_raster_workspace_t* workspace,
                                        internal_decoded_raster_t*     decoded)
{
  decoded->webp          = internal_is_webp(source, source_size);
  const ra8_err_t result = decoded->webp ? internal_decode_webp(source,
                                                                source_size,
                                                                workspace,
                                                                &decoded->gray,
                                                                &decoded->width,
                                                                &decoded->height)
                                         : internal_decode_stb(source,
                                                               source_size,
                                                               workspace,
                                                               &decoded->stb_pixels,
                                                               &decoded->width,
                                                               &decoded->height);
  if (!decoded->webp) {
    decoded->gray = decoded->stb_pixels;
  }
  return result;
}

RA8_INTERNAL
static ra8_err_t internal_encode_source(const uint8_t*                 source,
                                        size_t                         source_size,
                                        uint16_t                       max_edge,
                                        uint8_t                        pixel_format,
                                        ra8_rabook_raster_workspace_t* workspace,
                                        uint8_t*                       encoded,
                                        size_t                         encoded_cap,
                                        ra8_rabook_raster_result_t*    result)
{
  internal_decoded_raster_t decoded = {};
  ra8_err_t                 rc = internal_decode_source(source, source_size, workspace, &decoded);
  if (rc != k_ra8_ok) {
    return rc;
  }
  uint16_t out_width  = 0U;
  uint16_t out_height = 0U;
  internal_output_dims(decoded.width, decoded.height, max_edge, &out_width, &out_height);
  const uint8_t* scaled = nullptr;
  rc                    = internal_scale(decoded.gray,
                                         decoded.width,
                                         decoded.height,
                                         out_width,
                                         out_height,
                                         workspace,
                                         &scaled);
  if (rc == k_ra8_ok) {
    rc = internal_encode(scaled,
                         out_width,
                         out_height,
                         pixel_format,
                         encoded,
                         encoded_cap,
                         &result->encoded_size);
  }
  if (!decoded.webp) {
    stbi_image_free(decoded.stb_pixels); /* alloc-allow: caller-bound ra8_img_arena */
    ra8_img_arena_unbind();
  }
  if (rc != k_ra8_ok) {
    *result = (ra8_rabook_raster_result_t){0};
    return rc;
  }
  result->width        = out_width;
  result->height       = out_height;
  result->pixel_format = pixel_format;
  return k_ra8_ok;
}
 
ra8_err_t ra8_rabook_raster_encode(const uint8_t*                 source,
                                   size_t                         source_size,
                                   uint16_t                       max_edge,
                                   uint8_t                        pixel_format,
                                   ra8_rabook_raster_workspace_t* workspace,
                                   uint8_t*                       encoded,
                                   size_t                         encoded_cap,
                                   ra8_rabook_raster_result_t*    result)
{
  if (source == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (workspace == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (encoded == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (result == nullptr) {
    return k_ra8_err_null_ptr;
  }
  *result = (ra8_rabook_raster_result_t){0};
  if (source_size == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (pixel_format != (uint8_t)k_book_pixfmt_gray4) {
    if (pixel_format != (uint8_t)k_book_pixfmt_gray8) {
      return k_ra8_err_invalid_arg;
    }
  }
 
  return internal_encode_source(source,
                                source_size,
                                max_edge,
                                pixel_format,
                                workspace,
                                encoded,
                                encoded_cap,
                                result);
}