emu_view_tile.c

Go to the documentation of this file.

 
#include "emu_view.h"
#include "emu_view_tile_internal.h"

RA8_INTERNAL static size_t
internal_row_offset(const emu_presentation_workspace_t* presentation, uint16_t x, uint16_t y)
{
  return (((size_t)y * presentation->composite_width) + x) * sizeof(uint16_t);
}

typedef struct {
  uint16_t x;      
  uint16_t y;      
  uint16_t width;  
  uint16_t height; 
} tile_destination_t;

RA8_INTERNAL static bool internal_write_rows(emu_presentation_workspace_t* presentation,
                                             const uint16_t*               pixels,
                                             const tile_destination_t*     destination)
{
  for (uint16_t row = 0U; row < destination->height; row++) {
    if (!emu_presentation_write(
          presentation,
          internal_row_offset(presentation, destination->x, (uint16_t)(destination->y + row)),
          &pixels[(size_t)row * destination->width],
          (size_t)destination->width * sizeof(uint16_t))) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL static tile_destination_t
internal_tile_destination(const emu_presentation_workspace_t* presentation,
                          uint16_t                            source_x,
                          uint16_t                            source_y,
                          uint16_t                            width,
                          uint16_t                            height)
{
  tile_destination_t destination = {.x = source_x, .y = source_y, .width = width, .height = height};
  if ((presentation->rotate_deg == (uint32_t)k_rotate_90) ||
      (presentation->rotate_deg == (uint32_t)k_rotate_270)) {
    destination.width  = height;
    destination.height = width;
  }
  if (presentation->rotate_deg == (uint32_t)k_rotate_90) {
    destination.x = (uint16_t)(presentation->panel_height - source_y - height);
    destination.y = source_x;
  } else if (presentation->rotate_deg == (uint32_t)k_rotate_180) {
    destination.x = (uint16_t)(presentation->panel_width - source_x - width);
    destination.y = (uint16_t)(presentation->panel_height - source_y - height);
  } else if (presentation->rotate_deg == (uint32_t)k_rotate_270) {
    destination.x = source_y;
    destination.y = (uint16_t)(presentation->panel_width - source_x - width);
  }
  return destination;
}

RA8_INTERNAL static void internal_rotate_tile(const emu_presentation_workspace_t* presentation,
                                              const uint16_t*                     source,
                                              uint16_t*                           rotated,
                                              uint16_t                            width,
                                              uint16_t                            height,
                                              uint16_t                            output_width)
{
  for (uint16_t y = 0U; y < height; y++) {
    for (uint16_t x = 0U; x < width; x++) {
      /* The caller rejects 0 degrees, so 270 is the remaining default. */
      uint16_t destination_x = y;
      uint16_t destination_y = (uint16_t)(width - 1U - x);
      if (presentation->rotate_deg == (uint32_t)k_rotate_90) {
        destination_x = (uint16_t)(height - 1U - y);
        destination_y = x;
      } else if (presentation->rotate_deg == (uint32_t)k_rotate_180) {
        destination_x = (uint16_t)(width - 1U - x);
        destination_y = (uint16_t)(height - 1U - y);
      } else {
        /* 270 degrees: the seeded destination above already describes it. */
      }
      rotated[((size_t)destination_y * output_width) + destination_x] =
        source[((size_t)y * width) + x];
    }
  }
}
 
bool priv_emu_view_tile_write(emu_presentation_workspace_t* presentation,
                              const uint16_t*               source,
                              uint16_t                      source_x,
                              uint16_t                      source_y,
                              uint16_t                      width,
                              uint16_t                      height)
{
  if ((presentation == nullptr) || (source == nullptr) || (width == 0U) || (height == 0U) ||
      ((size_t)source_x + width > presentation->panel_width) ||
      ((size_t)source_y + height > presentation->panel_height)) {
    return false;
  }
  if (presentation->rotate_deg == 0U) {
    const tile_destination_t destination = {.x      = source_x,
                                            .y      = source_y,
                                            .width  = width,
                                            .height = height};
    return internal_write_rows(presentation, source, &destination);
  }
  const size_t max_tile_width  = (presentation->panel_width < k_emu_presentation_tile_px)
                                   ? presentation->panel_width
                                   : k_emu_presentation_tile_px;
  const size_t max_tile_height = (presentation->panel_height < k_emu_presentation_tile_px)
                                   ? presentation->panel_height
                                   : k_emu_presentation_tile_px;
  /* Same borrowed scratch, second half: the rotation destination. Alignment to
   * alignof(uint16_t) is a checked precondition of emu_presentation_open().
   * Only the rotating path needs scratch; the workspace documents it as borrowed
   * "or nullptr", so refuse rather than rotate into nothing. */
  uint16_t* const pixels = presentation->scratch;
  if (pixels == nullptr) {
    return false;
  }
  uint16_t* const          rotated = &pixels[max_tile_width * max_tile_height];
  const tile_destination_t destination =
    internal_tile_destination(presentation, source_x, source_y, width, height);
  internal_rotate_tile(presentation, source, rotated, width, height, destination.width);
  return internal_write_rows(presentation, rotated, &destination);
}