rsys

commit d561824f1b4f60e9a765c2bba396de74e446d4c0
parent 698959233eb56ca2f15f880ea9e5bcd52aeed9c4
Author: vaplv <vincent.forest@meso-star.com>
Date:   Fri, 31 Mar 2017 14:42:57 +0200

Add binary serialization of PPM images

Diffstat:
M
src/image.c
 | 
80
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------
M
src/image.h
 | 
4
+++-
M
src/test_image.c
 | 
267
+++++++++++++++++++++++++++++++++++++++++++++----------------------------------

3 files changed, 216 insertions(+), 135 deletions(-)
diff --git a/src/image.c b/src/image.c
@@ -64,7 +64,8 @@ parser_next_token(struct parser* parser)
 static INLINE res_T
 parse_ppm_id(const char* str, enum ppm_id* id)
 {
-  ASSERT(str && id);
+  ASSERT(id);
+  if(!str) return RES_BAD_ARG;
   if(!strcmp(str, "P3")) {
     *id = P3;
   } else if(!strcmp(str, "P6")) {
@@ -128,6 +129,46 @@ parse_bin_pixels
   return (n == fread(buffer, size, n, parser->stream)) ? RES_OK : RES_BAD_ARG;
 }
 
+static res_T
+write_bin_ppm(const struct image* img, FILE* stream)
+{
+  size_t y;
+  ASSERT(img && stream);
+
+  FOR_EACH(y, 0, img->height) {
+    const char* row = img->pixels + y * img->pitch;
+    size_t n;
+    n = fwrite(row, sizeof_image_format(img->format), img->width, stream);
+    if(n < img->width) return RES_IO_ERR;
+  }
+  return RES_OK;
+}
+
+static res_T
+write_raw_ppm(const struct image* img, FILE* stream)
+{
+  size_t x, y;
+  ASSERT(img && stream);
+
+  FOR_EACH(y, 0, img->height) {
+    const char* row = img->pixels + y * img->pitch;
+    FOR_EACH(x, 0, img->width) {
+      const char* pixel = row + x * sizeof_image_format(img->format);
+      switch(img->format) {
+        case IMAGE_RGB8:
+          fprintf(stream, "%u %u %u\n", SPLIT3((uint8_t*)pixel));
+          break;
+        case IMAGE_RGB16:
+          fprintf(stream, "%u %u %u\n", SPLIT3(((uint16_t*)pixel)));
+          break;
+        default: FATAL("Unreachable code.\n"); break;
+      }
+    }
+  }
+  return RES_OK;
+}
+
+
 /*******************************************************************************
  * Exported functions
  ******************************************************************************/
@@ -157,7 +198,7 @@ image_setup
    const size_t height,
    const size_t pitch,
    const enum image_format format,
-   char* pixels)
+   const char* pixels)
 {
   size_t size;
   char* buffer = NULL;
@@ -274,7 +315,10 @@ error:
 }
 
 res_T
-image_write_ppm(const struct image* img, const char* filename)
+image_write_ppm
+  (const struct image* img,
+   const int binary,
+   const char* filename)
 {
   FILE* stream = NULL;
   res_T res = RES_OK;
@@ -290,7 +334,7 @@ image_write_ppm(const struct image* img, const char* filename)
     goto error;
   }
 
-  res = image_write_ppm_stream(img, stream);
+  res = image_write_ppm_stream(img, binary, stream);
   if(res != RES_OK) goto error;
 
 exit:
@@ -301,9 +345,11 @@ error:
 }
 
 res_T
-image_write_ppm_stream(const struct image* img, FILE* stream)
+image_write_ppm_stream
+  (const struct image* img,
+   const int bin,
+   FILE* stream)
 {
-  size_t x, y;
   res_T res = RES_OK;
 
   if(!img || !stream) {
@@ -311,28 +357,20 @@ image_write_ppm_stream(const struct image* img, FILE* stream)
     goto error;
   }
 
-  fprintf(stream, "P3 %lu %lu\n", img->width, img->height);
+  fprintf(stream, "%s %lu %lu\n", bin ? "P6" : "P3", img->width, img->height);
   switch(img->format) { /* Write Max val */
     case IMAGE_RGB8: fprintf(stream, "255\n"); break;
     case IMAGE_RGB16: fprintf(stream, "65535\n"); break;
     default: FATAL("Unreachable code.\n"); break;
   }
 
-  FOR_EACH(y, 0, img->height) {
-    const char* row = img->pixels + y * img->pitch;
-    FOR_EACH(x, 0, img->width) {
-      const char* pixel = row + x * sizeof_image_format(img->format);
-      switch(img->format) {
-        case IMAGE_RGB8:
-          fprintf(stream, "%u %u %u\n", SPLIT3((uint8_t*)pixel));
-          break;
-        case IMAGE_RGB16:
-          fprintf(stream, "%u %u %u\n", SPLIT3(((uint16_t*)pixel)));
-          break;
-        default: FATAL("Unreachable code.\n"); break;
-      }
-    }
+  if(bin) {
+    res = write_bin_ppm(img, stream);
+  } else {
+    res = write_raw_ppm(img, stream);
   }
+  if(res != RES_OK) goto error;
+
 
 exit:
   return res;
diff --git a/src/image.h b/src/image.h
@@ -64,7 +64,7 @@ image_setup
    const size_t height,
    const size_t pitch,
    const enum image_format format,
-   char* pixels); /* May be NULL */
+   const char* pixels); /* May be NULL */
 
 RSYS_API res_T
 image_read_ppm
@@ -79,11 +79,13 @@ image_read_ppm_stream
 RSYS_API res_T
 image_write_ppm
   (const struct image* image,
+   const int binary,
    const char* filename);
 
 RSYS_API res_T
 image_write_ppm_stream
   (const struct image* image,
+   const int binary,
    FILE* stream);
 
 RSYS_API res_T
diff --git a/src/test_image.c b/src/test_image.c
@@ -20,6 +20,7 @@
 #define WIDTH 64
 #define HEIGHT 32
 
+
 static void
 check_image
   (const struct image* img,
@@ -58,29 +59,117 @@ check_image
   }
 }
 
+static void
+check
+  (const char* pixels,
+   const size_t width,
+   const size_t height,
+   const enum image_format fmt,
+   struct mem_allocator* allocator)
+{
+  struct image img;
+  size_t pitch;
+  FILE* fp;
+
+  CHECK(image_init(NULL, NULL), RES_BAD_ARG);
+  CHECK(image_init(allocator, NULL), RES_BAD_ARG);
+  CHECK(image_init(NULL, &img), RES_OK);
+  CHECK(image_release(NULL), RES_BAD_ARG);
+  CHECK(image_release(&img), RES_OK);
+  CHECK(image_init(allocator, &img), RES_OK);
+
+  pitch = width * sizeof_image_format(fmt);
+
+  CHECK(image_setup(NULL, 0, 0, 0, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(&img, 0, 0, 0, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(NULL, width, 0, 0, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(&img, width, 0, 0, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(NULL, 0, height, 0, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(&img, 0, height, 0, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(NULL, width, height, 0, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(&img, width, height, 0, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(NULL, 0, 0, pitch, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(&img, 0, 0, pitch, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(NULL, width, 0, pitch, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(&img, width, 0, pitch, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(NULL, 0, height, pitch, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(&img, 0, height, pitch, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(NULL, width, height, pitch, fmt, NULL), RES_BAD_ARG);
+  CHECK(image_setup(&img, width, height, pitch, fmt, NULL), RES_OK);
+  CHECK(image_setup(NULL, 0, 0, 0, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(&img, 0, 0, 0, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(NULL, width, 0, 0, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(&img, width, 0, 0, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(NULL, 0, height, 0, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(&img, 0, height, 0, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(NULL, width, height, 0, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(&img, width, height, 0, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(NULL, 0, 0, pitch, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(&img, 0, 0, pitch, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(NULL, width, 0, pitch, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(&img, width, 0, pitch, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(NULL, 0, height, pitch, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(&img, 0, height, pitch, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(NULL, width, height, pitch, fmt, pixels), RES_BAD_ARG);
+  CHECK(image_setup(&img, width, height, pitch, fmt, pixels), RES_OK);
+
+  fp = tmpfile();
+  NCHECK(fp, NULL);
+
+  CHECK(image_write_ppm_stream(NULL, 0, NULL), RES_BAD_ARG);
+  CHECK(image_write_ppm_stream(&img, 0, NULL), RES_BAD_ARG);
+  CHECK(image_write_ppm_stream(NULL, 0, fp), RES_BAD_ARG);
+  CHECK(image_write_ppm_stream(&img, 0, fp), RES_OK);
+
+  CHECK(image_read_ppm_stream(NULL, NULL), RES_BAD_ARG);
+  CHECK(image_read_ppm_stream(&img, NULL), RES_BAD_ARG);
+  CHECK(image_read_ppm_stream(NULL, fp), RES_BAD_ARG);
+  CHECK(image_read_ppm_stream(&img, fp), RES_BAD_ARG);
+  rewind(fp);
+  CHECK(image_read_ppm_stream(&img, fp), RES_OK);
+  check_image(&img, pixels, width, height, fmt);
+
+  rewind(fp);
+  CHECK(image_write_ppm_stream(&img, 1, fp), RES_OK);
+  rewind(fp);
+  CHECK(image_read_ppm_stream(&img, fp), RES_OK);
+  check_image(&img, pixels, width, height, fmt);
+
+  CHECK(image_write_ppm_stream(&img, 1, stdout), RES_OK);
+
+  CHECK(image_release(&img), RES_OK);
+
+  fclose(fp);
+}
+
 int
 main(int argc, char** argv)
 {
-  unsigned char lut[4][4][3] = {
-    {{0xFF,0xFF,0x00}, {0xFF,0x00,0x00 }, {0xFF,0x00,0x00}, { 0xFF,0xFF,0x00}},
-    {{0xFF,0xFF,0xFF}, {0x00,0x00,0x00 }, {0x00,0x00,0x00}, { 0xFF,0xFF,0xFF}},
-    {{0x00,0xFF,0x00}, {0x00,0xFF,0xFF }, {0x00,0xFF,0xFF}, { 0x00,0xFF,0x00}},
-    {{0x00,0x00,0xFF}, {0xFF,0x00,0xFF }, {0xFF,0x00,0xFF}, { 0x00,0x00,0xFF}}
+  uint8_t lut8[4][4][3] = {
+    {{0xFF,0xFF,0x00}, {0xFF,0x00,0x00}, {0xFF,0x00,0x00}, {0xFF,0xFF,0x00}},
+    {{0xFF,0xFF,0xFF}, {0x00,0x00,0x00}, {0x00,0x00,0x00}, {0xFF,0xFF,0xFF}},
+    {{0x00,0xFF,0x00}, {0x00,0xFF,0xFF}, {0x00,0xFF,0xFF}, {0x00,0xFF,0x00}},
+    {{0x00,0x00,0xFF}, {0xFF,0x00,0xFF}, {0xFF,0x00,0xFF}, {0x00,0x00,0xFF}}
+  };
+  uint16_t lut16[4][4][3] = {
+    { {0x0000,0x0000,0xFFFF}, {0xFFFF,0x0000,0xFFFF},
+      {0xFFFF,0x0000,0xFFFF}, {0x0000,0x0000,0xFFFF} },
+    { {0x0000,0xFFFF,0x0000}, {0x0000,0xFFFF,0xFFFF},
+      {0x0000,0xFFFF,0xFFFF}, {0x0000,0xFFFF,0x0000} },
+    { {0xFFFF,0xFFFF,0xFFFF}, {0x0000,0x0000,0x0000},
+      {0x0000,0x0000,0x0000}, {0xFFFF,0xFFFF,0xFFFF} },
+    { {0xFFFF,0xFFFF,0x0000}, {0xFFFF,0x0000,0x0000},
+      {0xFFFF,0x0000,0x0000}, {0xFFFF,0xFFFF,0x0000} }
   };
   struct mem_allocator allocator;
-  struct image img;
-  unsigned char* pixels;
-  size_t pitch;
+  char* pixels;
   FILE* fp;
   int x, y, i = 0;
   (void)argc, (void)argv;
 
   CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
 
-  fp = tmpfile();
-  NCHECK(fp, NULL);
-
-  pixels = MEM_ALLOC(&allocator, WIDTH*HEIGHT*3);
+  pixels = MEM_ALLOC(&allocator, WIDTH*sizeof_image_format(IMAGE_RGB8)*HEIGHT);
   NCHECK(pixels, NULL);
 
   i = 0;
@@ -89,113 +178,65 @@ main(int argc, char** argv)
     int j = ((x/32) & 1) + ((y/16)&1) * 2;
     int k = ((x/8) & 1) + ((y/8)&1) * 2;
 
-    pixels[i++] = lut[j][k][0];
-    pixels[i++] = lut[j][k][1];
-    pixels[i++] = lut[j][k][2];
+    ((uint8_t*)pixels)[i++] = lut8[j][k][0];
+    ((uint8_t*)pixels)[i++] = lut8[j][k][1];
+    ((uint8_t*)pixels)[i++] = lut8[j][k][2];
   }}
 
-  CHECK(image_ppm_write_stream(NULL, 0, 0, 0, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, 0, 0, 0, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, WIDTH, 0, 0, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, WIDTH, 0, 0, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, 0, HEIGHT, 0, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, 0, HEIGHT, 0, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, WIDTH, HEIGHT, 0, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, WIDTH, HEIGHT, 0, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, 0, 0, 3, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, 0, 0, 3, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, WIDTH, 0, 3, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, WIDTH, 0, 3, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, 0, HEIGHT, 3, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, 0, HEIGHT, 3, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, WIDTH, HEIGHT, 3, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, WIDTH, HEIGHT, 3, NULL), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, 0, 0, 0, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, 0, 0, 0, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, WIDTH, 0, 0, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, WIDTH, 0, 0, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, 0, HEIGHT, 0, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, 0, HEIGHT, 0, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, WIDTH, HEIGHT, 0, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, WIDTH, HEIGHT, 0, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, 0, 0, 3, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, 0, 0, 3, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, WIDTH, 0, 3, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, WIDTH, 0, 3, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, 0, HEIGHT, 3, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, 0, HEIGHT, 3, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(NULL, WIDTH, HEIGHT, 3, pixels), RES_BAD_ARG);
-  CHECK(image_ppm_write_stream(fp, WIDTH, HEIGHT, 3, pixels), RES_OK);
-  rewind(fp);
-
-  CHECK(image_init(NULL, NULL), RES_BAD_ARG);
-  CHECK(image_init(&allocator, NULL), RES_BAD_ARG);
-  CHECK(image_init(NULL, &img), RES_OK);
-  CHECK(image_release(NULL), RES_BAD_ARG);
-  CHECK(image_release(&img), RES_OK);
-  CHECK(image_init(&allocator, &img), RES_OK);
-
-  pitch = WIDTH * sizeof_image_format(IMAGE_RGB8);
-  #define SETUP image_setup
-  CHECK(SETUP(NULL, 0, 0, 0, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(&img, 0, 0, 0, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(NULL, WIDTH, 0, 0, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(&img, WIDTH, 0, 0, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(NULL, 0, HEIGHT, 0, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(&img, 0, HEIGHT, 0, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(NULL, WIDTH, HEIGHT, 0, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(&img, WIDTH, HEIGHT, 0, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(NULL, 0, 0, pitch, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(&img, 0, 0, pitch, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(NULL, WIDTH, 0, pitch, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(&img, WIDTH, 0, pitch, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(NULL, 0, HEIGHT, pitch, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(&img, 0, HEIGHT, pitch, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(NULL, WIDTH, HEIGHT, pitch, IMAGE_RGB8, NULL), RES_BAD_ARG);
-  CHECK(SETUP(&img, WIDTH, HEIGHT, pitch, IMAGE_RGB8, NULL), RES_OK);
-  CHECK(SETUP(NULL, 0, 0, 0, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(&img, 0, 0, 0, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(NULL, WIDTH, 0, 0, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(&img, WIDTH, 0, 0, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(NULL, 0, HEIGHT, 0, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(&img, 0, HEIGHT, 0, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(NULL, WIDTH, HEIGHT, 0, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(&img, WIDTH, HEIGHT, 0, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(NULL, 0, 0, pitch, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(&img, 0, 0, pitch, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(NULL, WIDTH, 0, pitch, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(&img, WIDTH, 0, pitch, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(NULL, 0, HEIGHT, pitch, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(&img, 0, HEIGHT, pitch, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(NULL, WIDTH, HEIGHT, pitch, IMAGE_RGB8, (char*)pixels), RES_BAD_ARG);
-  CHECK(SETUP(&img, WIDTH, HEIGHT, pitch, IMAGE_RGB8, (char*)pixels), RES_OK);
-  #undef SETUP
-
-  CHECK(image_release(&img), RES_OK);
-  CHECK(image_init(&allocator, &img), RES_OK);
-
-  CHECK(image_read_ppm_stream(NULL, NULL), RES_BAD_ARG);
-  CHECK(image_read_ppm_stream(&img, NULL), RES_BAD_ARG);
-  CHECK(image_read_ppm_stream(NULL, fp), RES_BAD_ARG);
-  CHECK(image_read_ppm_stream(&img, fp), RES_OK);
-
-  check_image(&img, (char*)pixels, WIDTH, HEIGHT, IMAGE_RGB8);
-
-  rewind(fp);
-  CHECK(image_write_ppm_stream(NULL, NULL), RES_BAD_ARG);
-  CHECK(image_write_ppm_stream(&img, NULL), RES_BAD_ARG);
-  CHECK(image_write_ppm_stream(NULL, fp), RES_BAD_ARG);
-  CHECK(image_write_ppm_stream(&img, fp), RES_OK);
-  CHECK(image_read_ppm_stream(&img, fp), RES_BAD_ARG);
+  fp = tmpfile();
+  NCHECK(fp, NULL);
+  #define WRITE image_ppm_write_stream
+  CHECK(WRITE(NULL, 0, 0, 0, NULL), RES_BAD_ARG);
+  CHECK(WRITE(fp, 0, 0, 0, NULL), RES_BAD_ARG);
+  CHECK(WRITE(NULL, WIDTH, 0, 0, NULL), RES_BAD_ARG);
+  CHECK(WRITE(fp, WIDTH, 0, 0, NULL), RES_BAD_ARG);
+  CHECK(WRITE(NULL, 0, HEIGHT, 0, NULL), RES_BAD_ARG);
+  CHECK(WRITE(fp, 0, HEIGHT, 0, NULL), RES_BAD_ARG);
+  CHECK(WRITE(NULL, WIDTH, HEIGHT, 0, NULL), RES_BAD_ARG);
+  CHECK(WRITE(fp, WIDTH, HEIGHT, 0, NULL), RES_BAD_ARG);
+  CHECK(WRITE(NULL, 0, 0, 3, NULL), RES_BAD_ARG);
+  CHECK(WRITE(fp, 0, 0, 3, NULL), RES_BAD_ARG);
+  CHECK(WRITE(NULL, WIDTH, 0, 3, NULL), RES_BAD_ARG);
+  CHECK(WRITE(fp, WIDTH, 0, 3, NULL), RES_BAD_ARG);
+  CHECK(WRITE(NULL, 0, HEIGHT, 3, NULL), RES_BAD_ARG);
+  CHECK(WRITE(fp, 0, HEIGHT, 3, NULL), RES_BAD_ARG);
+  CHECK(WRITE(NULL, WIDTH, HEIGHT, 3, NULL), RES_BAD_ARG);
+  CHECK(WRITE(fp, WIDTH, HEIGHT, 3, NULL), RES_BAD_ARG);
+  CHECK(WRITE(NULL, 0, 0, 0, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(fp, 0, 0, 0, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(NULL, WIDTH, 0, 0, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(fp, WIDTH, 0, 0, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(NULL, 0, HEIGHT, 0, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(fp, 0, HEIGHT, 0, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(NULL, WIDTH, HEIGHT, 0, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(fp, WIDTH, HEIGHT, 0, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(NULL, 0, 0, 3, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(fp, 0, 0, 3, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(NULL, WIDTH, 0, 3, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(fp, WIDTH, 0, 3, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(NULL, 0, HEIGHT, 3, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(fp, 0, HEIGHT, 3, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(NULL, WIDTH, HEIGHT, 3, (unsigned char*)pixels), RES_BAD_ARG);
+  CHECK(WRITE(fp, WIDTH, HEIGHT, 3, (unsigned char*)pixels), RES_OK);
+  #undef WRITE
   rewind(fp);
-  CHECK(image_write_ppm_stream(&img, fp), RES_OK);
-  check_image(&img, (char*)pixels, WIDTH, HEIGHT, IMAGE_RGB8);
 
-  CHECK(image_write_ppm_stream(&img, stdout), RES_OK);
+  check(pixels, WIDTH, HEIGHT, IMAGE_RGB8, &allocator);
+  MEM_RM(&allocator, pixels);
 
-  CHECK(image_release(&img), RES_OK);
+  pixels = MEM_ALLOC(&allocator, WIDTH*sizeof_image_format(IMAGE_RGB16)*HEIGHT);
+  NCHECK(pixels, NULL);
 
-  fclose(fp);
+  i = 0;
+  FOR_EACH(y, 0, HEIGHT) {
+  FOR_EACH(x, 0, WIDTH) {
+    int j = ((x/32) & 1) + ((y/16)&1) * 2;
+    int k = ((x/8) & 1) + ((y/8)&1) * 2;
+    ((uint16_t*)pixels)[i++] = lut16[j][k][0];
+    ((uint16_t*)pixels)[i++] = lut16[j][k][1];
+    ((uint16_t*)pixels)[i++] = lut16[j][k][2];
+  }}
+  check(pixels, WIDTH, HEIGHT, IMAGE_RGB16, &allocator);
   MEM_RM(&allocator, pixels);
 
   check_memory_allocator(&allocator);