ra8_webp.c

Go to the documentation of this file.

 
#include "ra8_webp.h"
 
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_webp_arena.h"
#include "src/webp/decode.h" /* WebPGetInfo, WebPDecodeRGBAInto (vendored libwebp) */

static const char s_ra8_webp_tag[] = "WEBP";
 
ra8_err_t ra8_webp_get_info(const uint8_t* data, size_t size, uint32_t* out_w, uint32_t* out_h)
{
  RA8_CHECK_NULL_PTR(data, s_ra8_webp_tag, "data");
  RA8_CHECK_NULL_PTR(out_w, s_ra8_webp_tag, "out_w");
  RA8_CHECK_NULL_PTR(out_h, s_ra8_webp_tag, "out_h");
  if (size == 0U) {
    ra8_log_error(s_ra8_webp_tag, "empty WebP buffer");
    return k_ra8_err_invalid_arg;
  }
 
  int w = 0;
  int h = 0;
  /* WebPGetInfo returns 0 for any invalid container or a zero/oversized
   * dimension, so on success both w and h are already in [1, WEBP_MAX_DIMENSION]
   * -- no separate non-positive check is needed (it would be dead code). */
  if (WebPGetInfo(data, size, &w, &h) == 0) {
    return k_ra8_err_validation_failed;
  }
  if (((uint32_t)w > k_ra8_webp_max_dim) || ((uint32_t)h > k_ra8_webp_max_dim)) {
    ra8_log_error(s_ra8_webp_tag, "WebP dimension exceeds cap");
    return k_ra8_err_not_supported;
  }
 
  *out_w = (uint32_t)w;
  *out_h = (uint32_t)h;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_webp_check_output(const uint8_t* data,
                                            size_t         size,
                                            size_t         out_stride,
                                            size_t         out_capacity,
                                            uint32_t*      w,
                                            uint32_t*      h)
{
  RA8_RETURN_ON_ERROR(ra8_webp_get_info(data, size, w, h), s_ra8_webp_tag, "info");
  const size_t min_stride = (size_t)*w * (size_t)k_ra8_webp_bytes_per_px;
  if ((out_stride < min_stride) || (((size_t)*h * out_stride) > out_capacity)) {
    ra8_log_error(s_ra8_webp_tag, "output buffer too small");
    return k_ra8_err_range_check_failed;
  }
  if (out_stride > (size_t)INT_MAX) {
    ra8_log_error(s_ra8_webp_tag, "output stride exceeds INT_MAX");
    return k_ra8_err_range_check_failed;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_webp_decode_impl(const uint8_t*    data,
                                           size_t            size,
                                           ra8_webp_arena_t* arena,
                                           uint8_t*          out_rgba,
                                           size_t            out_stride,
                                           size_t            out_capacity,
                                           uint32_t*         out_w,
                                           uint32_t*         out_h)
{
  uint32_t w = 0U;
  uint32_t h = 0U;
  RA8_RETURN_ON_ERROR(internal_webp_check_output(data, size, out_stride, out_capacity, &w, &h),
                      s_ra8_webp_tag,
                      "validate");
 
  ra8_webp_arena_bind(arena);
  uint8_t* const result = WebPDecodeRGBAInto(data, size, out_rgba, out_capacity, (int)out_stride);
  ra8_webp_arena_unbind();
  if (result == nullptr) {
    return k_ra8_err_validation_failed;
  }
 
  /*
   * This facade decodes a whole WebP into a caller RGBA8888 buffer. The #290
   * normalize-on-import path consumes it in the JOF tile producer
   * (apps/shared_libs/jof/src/jof_produce.c: priv_webp_transcode), which
   * bands the decoded canvas into JOF tiles so render time touches one codec
   * regardless of source. TODO(#289): the ra8_reflow / ra8_img inline raster
   * dispatch (apps/shared_libs/reflow/src/reflow_image.c) does not yet have a WebP
   * arm for the small-image (non-tiled) path -- that lands with the longstrip
   * render work; large WebP pages already normalize through the producer above.
   */
 
  if (out_w != nullptr) {
    *out_w = w;
  }
  if (out_h != nullptr) {
    *out_h = h;
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_webp_decode_rgba(const uint8_t*    data,
                               size_t            size,
                               ra8_webp_arena_t* arena,
                               uint8_t*          out_rgba,
                               size_t            out_stride,
                               size_t            out_capacity,
                               uint32_t*         out_w,
                               uint32_t*         out_h)
{
  RA8_CHECK_NULL_PTR(data, s_ra8_webp_tag, "data");
  RA8_CHECK_NULL_PTR(arena, s_ra8_webp_tag, "arena");
  RA8_CHECK_NULL_PTR(out_rgba, s_ra8_webp_tag, "out_rgba");
  return internal_webp_decode_impl(data,
                                   size,
                                   arena,
                                   out_rgba,
                                   out_stride,
                                   out_capacity,
                                   out_w,
                                   out_h);
}