ra8_viewer_ppm.c

Go to the documentation of this file.

 
#include <errno.h>
#include <fcntl.h>
#include <stddef.h>
#include <stdint.h>
#include <unistd.h>
 
#include "ra8_err.h"
#include "ra8_viewer_reader.h"
#include "ra8_viewer_reader_internal.h"
 
#ifndef O_CLOEXEC
#define O_CLOEXEC (0)
#endif

typedef enum : uint8_t {
  k_rgb565_r_shift  = 11U, 
  k_rgb565_g_shift  = 5U,  
  k_rgb565_r5_drop  = 3U,  
  k_rgb565_g6_drop  = 2U,  
  k_rgb565_r5_fill  = 2U,  
  k_rgb565_g6_fill  = 4U,  
  k_rgb565_hi_shift = 8U,  
} ra8_viewer_rgb565_shift_t;

typedef enum : uint32_t {
  k_rgb565_r5_mask = 0x1FU, 
  k_rgb565_g6_mask = 0x3FU, 
  k_rgb565_b5_mask = 0x1FU, 
} ra8_viewer_rgb565_mask_t;

typedef enum : uint8_t {
  k_ppm_channels = 3U, 
  k_ppm_idx_r    = 0U, 
  k_ppm_idx_g    = 1U, 
  k_ppm_idx_b    = 2U, 
} ra8_viewer_ppm_t;

typedef enum : uint16_t {
  k_ppm_u32_digits    = 10U,   
  k_ppm_decimal_radix = 10U,   
  k_ppm_header_bytes  = 32U,   
  k_ppm_chunk_pixels  = 1024U, 
  k_ppm_file_mode     = 0666,  
  k_ppm_chunk_bytes = k_ppm_chunk_pixels * k_ppm_channels,
} ra8_viewer_ppm_io_t;
 
uint16_t ra8_viewer_pack565(uint8_t rr, uint8_t gg, uint8_t bb)
{
  const uint16_t r5 = (uint16_t)(rr >> (uint16_t)k_rgb565_r5_drop);
  const uint16_t g6 = (uint16_t)(gg >> (uint16_t)k_rgb565_g6_drop);
  const uint16_t b5 = (uint16_t)(bb >> (uint16_t)k_rgb565_r5_drop);
  return (uint16_t)((r5 << (uint16_t)k_rgb565_r_shift) | (g6 << (uint16_t)k_rgb565_g_shift) | b5);
}
 
uint16_t ra8_viewer_pack565_le_pair(uint8_t lo, uint8_t hi)
{
  return (uint16_t)((uint16_t)lo | ((uint16_t)hi << (uint16_t)k_rgb565_hi_shift));
}

RA8_INTERNAL static void internal_unpack565(uint16_t px, uint8_t rgb[k_ppm_channels])
{
  const uint32_t r5 = ((uint32_t)px >> (uint32_t)k_rgb565_r_shift) & (uint32_t)k_rgb565_r5_mask;
  const uint32_t g6 = ((uint32_t)px >> (uint32_t)k_rgb565_g_shift) & (uint32_t)k_rgb565_g6_mask;
  const uint32_t b5 = (uint32_t)px & (uint32_t)k_rgb565_b5_mask;
 
  rgb[k_ppm_idx_r] =
    (uint8_t)((r5 << (uint32_t)k_rgb565_r5_drop) | (r5 >> (uint32_t)k_rgb565_r5_fill));
  rgb[k_ppm_idx_g] =
    (uint8_t)((g6 << (uint32_t)k_rgb565_g6_drop) | (g6 >> (uint32_t)k_rgb565_g6_fill));
  rgb[k_ppm_idx_b] =
    (uint8_t)((b5 << (uint32_t)k_rgb565_r5_drop) | (b5 >> (uint32_t)k_rgb565_r5_fill));
}

RA8_INTERNAL static bool internal_write_all(int fd, const uint8_t* bytes, size_t length)
{
  size_t offset = 0U;
  while (offset < length) {
    const ssize_t written = write(fd, &bytes[offset], length - offset);
    if ((written < 0) && (errno == EINTR)) {
      continue;
    }
    if (written <= 0) {
      return false;
    }
    offset += (size_t)written;
  }
  return true;
}

RA8_INTERNAL static size_t
internal_append_u32(char out[k_ppm_header_bytes], size_t offset, uint32_t value)
{
  char   reverse[k_ppm_u32_digits];
  size_t digits = 0U;
  do {
    reverse[digits] = (char)('0' + (value % (uint32_t)k_ppm_decimal_radix));
    ++digits;
    value /= (uint32_t)k_ppm_decimal_radix;
  } while (value != 0U);
  while (digits > 0U) {
    --digits;
    out[offset] = reverse[digits];
    ++offset;
  }
  return offset;
}

RA8_INTERNAL static size_t
internal_ppm_header(char out[k_ppm_header_bytes], uint32_t width, uint32_t height)
{
  size_t offset = 0U;
  out[offset++] = 'P';
  out[offset++] = '6';
  out[offset++] = '\n';
  offset        = internal_append_u32(out, offset, width);
  out[offset++] = ' ';
  offset        = internal_append_u32(out, offset, height);
  out[offset++] = '\n';
  out[offset++] = '2';
  out[offset++] = '5';
  out[offset++] = '5';
  out[offset++] = '\n';
  return offset;
}
 
ra8_err_t ra8_viewer_write_ppm565(const uint16_t* px, uint32_t w, uint32_t h, const char* path)
{
  if ((px == nullptr) || (path == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if ((w == 0U) || (h == 0U)) {
    return k_ra8_err_invalid_size;
  }
  if ((size_t)w > (SIZE_MAX / (size_t)h)) {
    return k_ra8_err_invalid_size;
  }
  const int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, k_ppm_file_mode);
  if (fd < 0) {
    return k_ra8_err_not_found;
  }
  char         header[k_ppm_header_bytes];
  const size_t header_bytes = internal_ppm_header(header, w, h);
  bool         ok           = internal_write_all(fd, (const uint8_t*)header, header_bytes);
  const size_t pixels       = (size_t)w * (size_t)h;
  uint8_t      chunk[k_ppm_chunk_bytes];
  size_t       consumed = 0U;
  while (ok && (consumed < pixels)) {
    size_t batch = pixels - consumed;
    if (batch > (size_t)k_ppm_chunk_pixels) {
      batch = (size_t)k_ppm_chunk_pixels;
    }
    for (size_t i = 0U; i < batch; ++i) {
      internal_unpack565(px[consumed + i], &chunk[i * (size_t)k_ppm_channels]);
    }
    ok = internal_write_all(fd, chunk, batch * (size_t)k_ppm_channels);
    consumed += batch;
  }
  const int closed = close(fd);
  return (ok && (closed == 0)) ? k_ra8_ok : k_ra8_err_not_found;
}
 
ra8_err_t ra8_viewer_dump_ppm(const ra8_viewer_reader_t* r, const char* path)
{
  if ((r == nullptr) || (path == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  return ra8_viewer_write_ppm565(r->fb,
                                 (uint32_t)k_ra8_viewer_fb_width,
                                 (uint32_t)k_ra8_viewer_fb_height,
                                 path);
}