Image.c File Reference

#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <SDL3_image/SDL_image.h>
#include "Image.h"
#include "Log.h"

Go to the source code of this file.

Macros
#define	_Class   _Image

Functions
Class *	_Image (void)
static void	dealloc (Object *self)
static Image *	imageWithBytes (const uint8_t *bytes, size_t length, float pixelDensity)
static Image *	imageWithData (const Data *data, float pixelDensity)
static Image *	imageWithResource (const Resource *resource, float pixelDensity)
static Image *	imageWithResourceName (const char *name, float pixelDensity)
static Image *	imageWithSurface (SDL_Surface *surface)
static Image *	imageWithSVG (const uint8_t *bytes, size_t length, float scale)
static void	initialize (Class *clazz)
static Image *	initWithBytes (Image *self, const uint8_t *bytes, size_t length, float pixelDensity)
static Image *	initWithData (Image *self, const Data *data, float pixelDensity)
static Image *	initWithResource (Image *self, const Resource *resource, float pixelDensity)
static Image *	initWithResourceName (Image *self, const char *name, float pixelDensity)
static Image *	initWithSurface (Image *self, SDL_Surface *surface)
static Image *	initWithSVG (Image *self, const uint8_t *bytes, size_t length, float scale)
static Image *	initWithSVGSize (Image *self, const uint8_t *bytes, size_t length, SDL_Size points, float pixelDensity)
static bool	isSVG (const Image *self, const uint8_t *bytes, size_t length)
static void	parseDecoration (char *name, SDL_Size *points, float *scale)
	Interprets an @ decoration in name.
static SDL_Surface *	rasterizeSVG (const uint8_t *bytes, size_t length, SDL_Size size)
	Rasterizes bytes as SVG at size pixels, or at its intrinsic size when size is zero.
static SDL_Size	size (const Image *self)
static char *	variantName (const char *name, int density)
	Composes the name of the @<density>x variant of name, e.g. foo@2x.png.

Macro Definition Documentation

_Class

#define _Class   _Image

Definition at line 27 of file Image.c.

Function Documentation

_Image()

Class * _Image

(

void

)

Definition at line 452 of file Image.c.

                    {
  static Class *clazz;
  static Once once;
 
  do_once(&once, {
    clazz = _initialize(&(const ClassDef) {
      .name = "Image",
      .superclass = _Object(),
      .instanceSize = sizeof(Image),
      .interfaceSize = sizeof(ImageInterface),
      .initialize = initialize,
    });
  });
 
  return clazz;
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 35 of file Image.c.

                                  {
 
  Image *this = (Image *) self;
 
  SDL_DestroySurface(this->surface);
 
  super(Object, self, dealloc);
}

imageWithBytes()

static Image * imageWithBytes ( const uint8_t *  bytes, size_t  length, float  pixelDensity  )

static

Definition at line 50 of file Image.c.

                                                                                      {
  return $(alloc(Image), initWithBytes, bytes, length, pixelDensity);
}

imageWithData()

static Image * imageWithData ( const Data *  data, float  pixelDensity  )

static

Definition at line 58 of file Image.c.

                                                                  {
  return $(alloc(Image), initWithData, data, pixelDensity);
}

imageWithResource()

static Image * imageWithResource ( const Resource *  resource, float  pixelDensity  )

static

Definition at line 66 of file Image.c.

                                                                              {
  return $(alloc(Image), initWithResource, resource, pixelDensity);
}

imageWithResourceName()

static Image * imageWithResourceName ( const char *  name, float  pixelDensity  )

static

Definition at line 74 of file Image.c.

                                                                          {
  return $(alloc(Image), initWithResourceName, name, pixelDensity);
}

imageWithSurface()

static Image * imageWithSurface ( SDL_Surface *  surface )

static

Definition at line 82 of file Image.c.

                                                     {
  return $(alloc(Image), initWithSurface, surface);
}

imageWithSVG()

static Image * imageWithSVG ( const uint8_t *  bytes, size_t  length, float  scale  )

static

Definition at line 90 of file Image.c.

                                                                             {
  return $(alloc(Image), initWithSVG, bytes, length, scale);
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 428 of file Image.c.

                                     {
 
  ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
 
  ((ImageInterface *) clazz->interface)->imageWithBytes = imageWithBytes;
  ((ImageInterface *) clazz->interface)->imageWithData = imageWithData;
  ((ImageInterface *) clazz->interface)->imageWithResource = imageWithResource;
  ((ImageInterface *) clazz->interface)->imageWithResourceName = imageWithResourceName;
  ((ImageInterface *) clazz->interface)->imageWithSurface = imageWithSurface;
  ((ImageInterface *) clazz->interface)->imageWithSVG = imageWithSVG;
  ((ImageInterface *) clazz->interface)->initWithBytes = initWithBytes;
  ((ImageInterface *) clazz->interface)->initWithData = initWithData;
  ((ImageInterface *) clazz->interface)->initWithResource = initWithResource;
  ((ImageInterface *) clazz->interface)->initWithResourceName = initWithResourceName;
  ((ImageInterface *) clazz->interface)->initWithSurface = initWithSurface;
  ((ImageInterface *) clazz->interface)->initWithSVG = initWithSVG;
  ((ImageInterface *) clazz->interface)->initWithSVGSize = initWithSVGSize;
  ((ImageInterface *) clazz->interface)->size = size;
}

initWithBytes()

static Image * initWithBytes ( Image *  self, const uint8_t *  bytes, size_t  length, float  pixelDensity  )

static

Definition at line 118 of file Image.c.

                                                                                                  {
 
  if (isSVG(self, bytes, length)) {
    return $(self, initWithSVG, bytes, length, pixelDensity);
  }
 
  SDL_IOStream *stream = SDL_IOFromConstMem(bytes, (int) length);
  if (stream) {
    SDL_Surface *surface = IMG_LoadTyped_IO(stream, 0, self->type);
    if (surface) {
      self = $(self, initWithSurface, surface);
      SDL_DestroySurface(surface);
    } else {
      self = release(self);
    }
    SDL_CloseIO(stream);
  } else {
    self = release(self);
  }
 
  return self;
}

initWithData()

static Image * initWithData ( Image *  self, const Data *  data, float  pixelDensity  )

static

Definition at line 145 of file Image.c.

                                                                              {
 
  if (data) {
    self = $(self, initWithBytes, data->bytes, data->length, pixelDensity);
  } else {
    self = release(self);
  }
 
  return self;
}

initWithResource()

static Image * initWithResource ( Image *  self, const Resource *  resource, float  pixelDensity  )

static

Definition at line 160 of file Image.c.

                                                                                          {
 
  if (resource) {
    self->type = strrchr(resource->name, '.') ? strrchr(resource->name, '.') + 1 : NULL;
    self = $(self, initWithData, resource->data, pixelDensity);
  } else {
    self = release(self);
  }
 
  return self;
}

initWithResourceName()

static Image * initWithResourceName ( Image *  self, const char *  name, float  pixelDensity  )

static

Definition at line 244 of file Image.c.

                                                                                      {
 
  assert(name);
 
  char *resourceName = strdup(name);
  assert(resourceName);
 
  SDL_Size points;
  float scale;
 
  parseDecoration(resourceName, &points, &scale);
 
  Resource *resource = NULL;
 
  const char *extension = strrchr(resourceName, '.');
 
  // an undecorated raster name prefers the variant matching the display, as @2x assets are
  // chosen; a vector needs no variant, rasterizing to the density in initWithBytes instead
  if (points.w == 0 && scale == 0.f && !(extension && SDL_strcasecmp(extension, ".svg") == 0)) {
 
    const int density = (int) SDL_roundf(pixelDensity);
    if (density > 1) {
 
      char *variant = variantName(resourceName, density);
      if (variant) {
 
        resource = $$(Resource, resourceWithName, variant);
        if (resource) {
          scale = (float) density;
        }
 
        free(variant);
      }
    }
  }
 
  if (resource == NULL) {
    resource = $$(Resource, resourceWithName, resourceName);
  }
 
  free(resourceName);
 
  if (resource == NULL) {
    return release(self);
  }
 
  if (points.w && points.h && resource->data &&
      isSVG(self, resource->data->bytes, resource->data->length)) {
    self = $(self, initWithSVGSize, resource->data->bytes, resource->data->length, points,
                  pixelDensity);
  } else {
    self = $(self, initWithResource, resource, pixelDensity);
 
    if (self && scale > 0.f) {
      self->scale = scale;
    }
  }
 
  release(resource);
 
  return self;
}

initWithSurface()

static Image * initWithSurface ( Image *  self, SDL_Surface *  surface  )

static

Definition at line 391 of file Image.c.

                                                                 {
 
  self = (Image *) super(Object, self, init);
  if (self) {
    self->scale = 1.f;
 
    if (surface) {
      if (surface->format != SDL_PIXELFORMAT_RGBA32) {
        self->surface = SDL_ConvertSurface(surface, SDL_PIXELFORMAT_RGBA32);
      } else {
        self->surface = surface;
        self->surface->refcount++;
      }
 
      assert(self->surface);
    }
  }
 
  return self;
}

initWithSVG()

static Image * initWithSVG ( Image *  self, const uint8_t *  bytes, size_t  length, float  scale  )

static

Definition at line 327 of file Image.c.

                                                                                         {
 
  scale = scale > 0.f ? scale : 1.f;
 
  SDL_Surface *surface = rasterizeSVG(bytes, length, MakeSize(0, 0));
 
  if (surface && scale != 1.f) {
    const SDL_Size size = MakeSize(
      (int) SDL_roundf(surface->w * scale),
      (int) SDL_roundf(surface->h * scale)
    );
 
    SDL_DestroySurface(surface);
    surface = rasterizeSVG(bytes, length, size);
  }
 
  if (surface) {
    self = $(self, initWithSurface, surface);
    SDL_DestroySurface(surface);
 
    if (self) {
      self->type = "svg";
      self->scale = scale;
    }
  } else {
    MVC_LogWarn("%s\n", SDL_GetError());
    self = release(self);
  }
 
  return self;
}

initWithSVGSize()

static Image * initWithSVGSize ( Image *  self, const uint8_t *  bytes, size_t  length, SDL_Size  points, float  pixelDensity  )

static

Definition at line 363 of file Image.c.

                                                                                                                     {
 
  const SDL_Size pixels = MakeSize(
    (int) SDL_roundf(points.w * pixelDensity),
    (int) SDL_roundf(points.h * pixelDensity)
  );
 
  SDL_Surface *surface = rasterizeSVG(bytes, length, pixels);
  if (surface) {
    self = $(self, initWithSurface, surface);
    SDL_DestroySurface(surface);
 
    if (self) {
      self->type = "svg";
      self->scale = pixelDensity;
    }
  } else {
    MVC_LogWarn("%s\n", SDL_GetError());
    self = release(self);
  }
 
  return self;
}

isSVG()

static bool isSVG ( const Image *  self, const uint8_t *  bytes, size_t  length  )

static

Returns

True if bytes are an SVG document, by declared type or by sniffing.

Definition at line 97 of file Image.c.

                                                                          {
 
  if (self->type && SDL_strcasecmp(self->type, "svg") == 0) {
    return true;
  }
 
  bool svg = false;
 
  SDL_IOStream *stream = SDL_IOFromConstMem(bytes, (int) length);
  if (stream) {
    svg = IMG_isSVG(stream);
    SDL_CloseIO(stream);
  }
 
  return svg;
}

parseDecoration()

static void parseDecoration ( char *  name, SDL_Size *  points, float *  scale  )

static

Interprets an @ decoration in name.

Where the decoration sits says what it is. name.svg@<width>x<height> trails the whole reference and requests a size in points: it is a rasterization request, so it is stripped, and name.svg is what loads. name@<scale>x.ext sits inside the name, before the extension, and declares how many pixels per point a raster carries, following Apple; a file is named that way on disk, so it is left alone and loaded verbatim.

Parameters

name	The resource name, edited in place.
points	Receives the requested size, or zero.
scale	Receives the declared pixels per point, or zero.

Definition at line 183 of file Image.c.

                                                                        {
 
  *points = MakeSize(0, 0);
  *scale = 0.f;
 
  char *at = strrchr(name, '@');
  if (at == NULL) {
    return;
  }
 
  char excess;
  int w, h;
 
  const char *extension = strrchr(name, '.');
 
  if (extension && at > extension) {
 
    if (sscanf(at + 1, "%dx%d%c", &w, &h, &excess) == 2 && w > 0 && h > 0) {
      *points = MakeSize(w, h);
      *at = '\0';
    }
 
    return;
  }
 
  const size_t length = (extension ? (size_t) (extension - at) : strlen(at)) - 1;
 
  char decoration[32];
  if (length == 0 || length >= sizeof(decoration)) {
    return;
  }
 
  memcpy(decoration, at + 1, length);
  decoration[length] = '\0';
 
  if (sscanf(decoration, "%dx%c", &w, &excess) == 1 && w > 0) {
    *scale = (float) w;
  }
}

rasterizeSVG()

static SDL_Surface * rasterizeSVG ( const uint8_t *  bytes, size_t  length, SDL_Size  size  )

static

Rasterizes bytes as SVG at size pixels, or at its intrinsic size when size is zero.

Definition at line 310 of file Image.c.

                                                                                     {
 
  SDL_Surface *surface = NULL;
 
  SDL_IOStream *stream = SDL_IOFromConstMem(bytes, (int) length);
  if (stream) {
    surface = IMG_LoadSizedSVG_IO(stream, size.w, size.h);
    SDL_CloseIO(stream);
  }
 
  return surface;
}

size()

static SDL_Size size ( const Image *  self )

static

Definition at line 416 of file Image.c.

                                        {
  return MakeSize(
    (int) SDL_roundf(self->surface->w / self->scale),
    (int) SDL_roundf(self->surface->h / self->scale)
  );
}

variantName()

static char * variantName ( const char *  name, int  density  )

static

Composes the name of the @<density>x variant of name, e.g. foo@2x.png.

Returns

The variant name, to be freed by the caller, or NULL on error.

Definition at line 227 of file Image.c.

                                                        {
 
  const char *extension = strrchr(name, '.');
  const int stem = extension ? (int) (extension - name) : (int) strlen(name);
 
  char *variant = NULL;
  if (SDL_asprintf(&variant, "%.*s@%dx%s", stem, name, density, extension ?: "") < 0) {
    return NULL;
  }
 
  return variant;
}