X-Git-Url: http://mj.ucw.cz/gitweb/?a=blobdiff_plain;ds=inline;f=images%2Fimage.c;h=e6111ab8e995d98819f090bfc45cc854266ff0e6;hb=0e5c5828c3f3e1abd14bd012827e6b467075290b;hp=4fb349dee5696df4598b88863e19be8b0993fa19;hpb=966305189fb3c543170117da57f110a8e9851ac2;p=libucw.git

diff --git a/images/image.c b/images/image.c
index 4fb349de..e6111ab8 100644
--- a/images/image.c
+++ b/images/image.c
@@ -12,46 +12,15 @@
 #include "lib/lib.h"
 #include "lib/mempool.h"
 #include "images/images.h"
-#include <string.h>
-
-#define MAX_IMAGE_SIZE (1 << 30)
+#include "images/error.h"
+#include "images/color.h"
 
-void
-image_thread_init(struct image_thread *it)
-{
-  DBG("image_thread_init()");
-  bzero(it, sizeof(*it));
-  it->pool = mp_new(1024);
-}
-
-void
-image_thread_cleanup(struct image_thread *it)
-{
-  DBG("image_thread_cleanup()");
-  mp_delete(it->pool);
-}
-
-void
-image_thread_err_format(struct image_thread *it, uns code, char *msg, ...)
-{
-  va_list args;
-  va_start(args, msg);
-  it->err_code = code;
-  it->err_msg = mp_vprintf(it->pool, msg, args);
-  va_end(args);
-}
+#include <string.h>
 
-struct image *
-image_new(struct image_thread *it, uns cols, uns rows, uns flags, struct mempool *pool)
+static inline uns
+flags_to_pixel_size(uns flags)
 {
-  DBG("image_new(cols=%u rows=%u flags=0x%x pool=%p)", cols, rows, flags, pool);
-  if (cols >= 0x10000 || rows >= 0x10000)
-    {
-      image_thread_err(it, IMAGE_ERR_INVALID_DIMENSIONS, "Image dimension(s) too large");
-      return NULL;
-    }
-  struct image *img;
-  uns pixel_size, row_size, image_size, align;
+  uns pixel_size;
   switch (flags & IMAGE_COLOR_SPACE)
     {
       case COLOR_SPACE_GRAYSCALE:
@@ -65,6 +34,22 @@ image_new(struct image_thread *it, uns cols, uns rows, uns flags, struct mempool
     }
   if (flags & IMAGE_ALPHA)
     pixel_size++;
+  return pixel_size;
+}
+
+struct image *
+image_new(struct image_context *ctx, uns cols, uns rows, uns flags, struct mempool *pool)
+{
+  DBG("image_new(cols=%u rows=%u flags=0x%x pool=%p)", cols, rows, flags, pool);
+  flags &= IMAGE_NEW_FLAGS;
+  if (unlikely(!image_dimensions_valid(cols, rows)))
+    {
+      IMAGE_ERROR(ctx, IMAGE_ERROR_INVALID_DIMENSIONS, "Invalid image dimensions (%ux%u)", cols, rows);
+      return NULL;
+    }
+  struct image *img;
+  uns pixel_size, row_pixels_size, row_size, align;
+  pixel_size = flags_to_pixel_size(flags);
   switch (pixel_size)
     {
       case 1:
@@ -80,67 +65,70 @@ image_new(struct image_thread *it, uns cols, uns rows, uns flags, struct mempool
 	ASSERT(0);
     }
   if (flags & IMAGE_SSE_ALIGNED)
-    align = MAX(16, sizeof(uns));
+    align = IMAGE_SSE_ALIGN_SIZE;
   else if (flags & IMAGE_PIXELS_ALIGNED)
     align = pixel_size;
   else
     align = 1;
-  row_size = cols * pixel_size;
-  row_size = ALIGN(row_size, align);
-  u64 image_size_64 = row_size * rows;
-  if (image_size_64 > MAX_IMAGE_SIZE)
+  row_pixels_size = cols * pixel_size;
+  row_size = ALIGN(row_pixels_size, align);
+  u64 image_size_64 = (u64)row_size * rows;
+  u64 bytes_64 = image_size_64 + (sizeof(struct image) + IMAGE_SSE_ALIGN_SIZE - 1 + sizeof(uns));
+  if (unlikely(bytes_64 > image_max_bytes))
     {
-      image_thread_err(it, IMAGE_ERR_INVALID_DIMENSIONS, "Image does not fit in memory");
+      IMAGE_ERROR(ctx, IMAGE_ERROR_INVALID_DIMENSIONS, "Image does not fit in memory");
       return NULL;
     }
-  if (!(image_size = image_size_64))
+  if (pool)
+    img = mp_alloc(pool, bytes_64);
+  else
     {
-      image_thread_err(it, IMAGE_ERR_INVALID_DIMENSIONS, "Zero dimension(s)");
-      return NULL;
+      img = xmalloc(bytes_64);
+      flags |= IMAGE_NEED_DESTROY;
     }
-  uns size = sizeof(struct image) + image_size + MAX(16, sizeof(uns)) - 1 + sizeof(uns);
-  img = pool ? mp_alloc(pool, size) : xmalloc(size);
   bzero(img, sizeof(struct image));
   byte *p = (byte *)img + sizeof(struct image);
-  img->pixels = ALIGN_PTR(p, MAX(16, sizeof(uns)));
+  img->pixels = ALIGN_PTR(p, IMAGE_SSE_ALIGN_SIZE);
   img->flags = flags;
   img->pixel_size = pixel_size;
   img->cols = cols;
   img->rows = rows;
   img->row_size = row_size;
-  img->image_size = image_size;
+  img->row_pixels_size = row_pixels_size;
+  img->image_size = image_size_64;
   DBG("img=%p flags=0x%x pixel_size=%u row_size=%u image_size=%u pixels=%p",
     img, img->flags, img->pixel_size, img->row_size, img->image_size, img->pixels);
   return img;
 }
 
 struct image *
-image_clone(struct image_thread *it, struct image *src, uns flags, struct mempool *pool)
+image_clone(struct image_context *ctx, struct image *src, uns flags, struct mempool *pool)
 {
   DBG("image_clone(src=%p flags=0x%x pool=%p)", src, src->flags, pool);
   struct image *img;
-  flags &= ~IMAGE_CHANNELS_FORMAT;
+  flags &= IMAGE_NEW_FLAGS & ~IMAGE_CHANNELS_FORMAT;
   flags |= src->flags & IMAGE_CHANNELS_FORMAT;
-  if (!(img = image_new(it, src->cols, src->rows, flags, pool)))
+  if (!(img = image_new(ctx, src->cols, src->rows, flags, pool)))
     return NULL;
   if (img->image_size)
     {
-      if (src->pixel_size != img->pixel_size)
+      if (src->pixel_size != img->pixel_size) /* conversion between aligned and unaligned RGB */
         {
-	  struct image *sec_img = src;
+#	  define IMAGE_WALK_PREFIX(x) walk_##x
 #         define IMAGE_WALK_INLINE
+#	  define IMAGE_WALK_IMAGE img
+#	  define IMAGE_WALK_SEC_IMAGE src
 #         define IMAGE_WALK_DOUBLE
-#         define IMAGE_WALK_DO_STEP do{ *(u32 *)pos = *(u32 *)sec_pos; }while(0)
+#         define IMAGE_WALK_DO_STEP do{ walk_pos[0] = walk_sec_pos[0]; walk_pos[1] = walk_sec_pos[1]; walk_pos[2] = walk_sec_pos[2]; }while(0)
 #         include "images/image-walk.h"
 	}
-      else if (src->row_size != img->row_size)
+      else if (src->row_size != img->row_size || ((img->flags | src->flags) & IMAGE_GAPS_PROTECTED))
         {
           byte *s = src->pixels;
           byte *d = img->pixels;
-          uns bytes = src->cols * img->pixel_size;
 	  for (uns row = src->rows; row--; )
             {
-	      memcpy(d, s, bytes);
+	      memcpy(d, s, src->row_pixels_size);
 	      d += img->row_size;
 	      s += src->row_size;
 	    }
@@ -152,22 +140,68 @@ image_clone(struct image_thread *it, struct image *src, uns flags, struct mempoo
 }
 
 void
-image_destroy(struct image_thread *it UNUSED, struct image *img)
+image_destroy(struct image *img)
 {
   DBG("image_destroy(img=%p)", img);
-  xfree((byte *)img);
+  if (img->flags & IMAGE_NEED_DESTROY)
+    xfree(img);
 }
 
 void
-image_clear(struct image_thread *it UNUSED, struct image *img)
+image_clear(struct image_context *ctx UNUSED, struct image *img)
 {
   DBG("image_clear(img=%p)", img);
   if (img->image_size)
-    bzero(img->pixels, img->image_size);
+    if (img->flags & IMAGE_GAPS_PROTECTED)
+      {
+        byte *p = img->pixels;
+        uns bytes = img->cols * img->pixel_size;
+	for (uns row = img->rows; row--; p += img->row_size)
+	  bzero(p, bytes);
+      }
+    else
+      bzero(img->pixels, img->image_size);
+}
+
+struct image *
+image_init_matrix(struct image_context *ctx, struct image *img, byte *pixels, uns cols, uns rows, uns row_size, uns flags)
+{
+  DBG("image_init_matrix(img=%p pixels=%p cols=%u rows=%u row_size=%u flags=0x%x)", img, pixels, cols, rows, row_size, flags);
+  if (unlikely(!image_dimensions_valid(cols, rows)))
+    {
+      IMAGE_ERROR(ctx, IMAGE_ERROR_INVALID_DIMENSIONS, "Invalid image dimensions (%ux%u)", cols, rows);
+      return NULL;
+    }
+  img->pixels = pixels;
+  img->cols = cols;
+  img->rows = rows;
+  img->pixel_size = flags_to_pixel_size(flags);
+  img->row_size = row_size;
+  img->row_pixels_size = cols * img->pixel_size;
+  img->image_size = rows * row_size;
+  img->flags = flags & (IMAGE_NEW_FLAGS | IMAGE_GAPS_PROTECTED);
+  return img;
+}
+
+struct image *
+image_init_subimage(struct image_context *ctx UNUSED, struct image *img, struct image *src, uns left, uns top, uns cols, uns rows)
+{
+  DBG("image_init_subimage(img=%p src=%p left=%u top=%u cols=%u rows=%u)", img, src, left, top, cols, rows);
+  ASSERT(left + cols <= src->cols && top + rows <= src->rows);
+  img->pixels = src->pixels + left * src->pixel_size + top * src->row_size;
+  img->cols = cols;
+  img->rows = rows;
+  img->pixel_size = src->pixel_size;
+  img->row_size = src->row_size;
+  img->row_pixels_size = cols * src->pixel_size;
+  img->image_size = src->row_size * rows;
+  img->flags = src->flags & IMAGE_NEW_FLAGS;
+  img->flags |= IMAGE_GAPS_PROTECTED;
+  return img;
 }
 
 byte *
-color_space_to_name(enum color_space cs)
+color_space_to_name(uns cs)
 {
   return image_channels_format_to_name(cs);
 }
@@ -204,8 +238,8 @@ image_name_to_channels_format(byte *name)
   if (!strcasecmp(name, "rgb"))
     return COLOR_SPACE_RGB;
   if (!strcasecmp(name, "rgbalpha"))
-    return COLOR_SPACE_RGB + IMAGE_ALPHA;
+    return COLOR_SPACE_RGB | IMAGE_ALPHA;
   if (!strcasecmp(name, "rgba"))
-    return COLOR_SPACE_RGB + IMAGE_ALPHA;
+    return COLOR_SPACE_RGB | IMAGE_ALPHA;
   return 0;
 }