// This program is free software: you can use, modify and/or redistribute it
// under the terms of the simplified BSD License. You should have received a
// copy of this license along this program. If not, see
// <http://www.opensource.org/licenses/bsd-license.html>.
//
// Copyright 2012 Enric Meinhardt-Llopis <enric.meinhardt@cmla.ens-cachan.fr>
// All rights reserved.
// IIO: a library for reading small images {{{1
//
// Goal: load an image (of unknown format) from a given FILE*
//
// Technique: read the first few bytes of the file to identify the format, and
// call the appropriate image library (lipng, lipjpeg, libtiff, etc). For
// simple, uncompressed formats, write the loading code by hand. For formats
// having a library with a nice API, call the library functions. For other or
// unrecognized formats use an external program (convert, anytopnm,
// gm convert...) to convert them into a readable format. If anything else
// fails, assume that the image is in headings+raw format, and try to extract
// its dimensions and headings using some heuristics (file name containing
// "%dx%d", headings containing ascii numbers, etc.)
//
// Difficulties: most image libraries expect to be fed a whole file, not a
// beheaded file. Thus, some hackery is necessary.
//
//
// Copyright 2012 Enric Meinhardt-Llopis <enric.meinhardt@cmla.ens-cachan.fr>
//
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "iio.h" // only for IIO_MAX_DIMENSION
#ifdef I_CAN_HAS_LIBPNG
// ugly "feature" in png.h forces this header to be included first
#include <png.h>
#endif
// #defines {{{1
//
// configuration
//
#if _POSIX_C_SOURCE >= 200809L
#define I_CAN_HAS_FMEMOPEN 1
#endif
#if _POSIX_C_SOURCE >= 200112L
#define I_CAN_HAS_MKSTEMP 1
#endif
//
// enum-like, only used internally
//
#define IIO_TYPE_INT8 1
#define IIO_TYPE_UINT8 2
#define IIO_TYPE_INT16 3
#define IIO_TYPE_UINT16 4
#define IIO_TYPE_INT32 5
#define IIO_TYPE_UINT32 6
#define IIO_TYPE_FLOAT 7
#define IIO_TYPE_DOUBLE 8
#define IIO_TYPE_LONGDOUBLE 9
#define IIO_TYPE_INT64 10
#define IIO_TYPE_UINT64 11
#define IIO_TYPE_HALF 12
#define IIO_TYPE_UINT1 13
#define IIO_TYPE_UINT2 14
#define IIO_TYPE_UINT4 15
#define IIO_TYPE_CHAR 16
#define IIO_TYPE_SHORT 17
#define IIO_TYPE_INT 18
#define IIO_TYPE_LONG 19
#define IIO_TYPE_LONGLONG 20
#define IIO_FORMAT_WHATEVER 0
#define IIO_FORMAT_QNM 1
#define IIO_FORMAT_PNG 2
#define IIO_FORMAT_JPEG 3
#define IIO_FORMAT_TIFF 4
#define IIO_FORMAT_RIM 5
#define IIO_FORMAT_BMP 6
#define IIO_FORMAT_EXR 7
#define IIO_FORMAT_JP2 8
#define IIO_FORMAT_VTK 9
#define IIO_FORMAT_CIMG 10
#define IIO_FORMAT_PAU 11
#define IIO_FORMAT_DICOM 12
#define IIO_FORMAT_PFM 13
#define IIO_FORMAT_NIFTI 14
#define IIO_FORMAT_PCX 15
#define IIO_FORMAT_GIF 16
#define IIO_FORMAT_XPM 17
#define IIO_FORMAT_RAFA 18
#define IIO_FORMAT_FLO 19
#define IIO_FORMAT_JUV 20
#define IIO_FORMAT_LUM 21
#define IIO_FORMAT_PCM 22
#define IIO_FORMAT_UNRECOGNIZED (-1)
//
// sugar
//
#define FORI(n) for(int i=0;i<(int)(n);i++)
#define FORJ(n) for(int j=0;j<(int)(n);j++)
#define FORK(n) for(int k=0;k<(int)(n);k++)
#define FORL(n) for(int l=0;l<(int)(n);l++)
#ifdef IIO_SHOW_DEBUG_MESSAGES
#define IIO_DEBUG(...) do {\
fprintf(stderr,"DEBUG(%s:%d:%s): ",__FILE__,__LINE__,__PRETTY_FUNCTION__);\
fprintf(stderr,__VA_ARGS__);} while(0)
#else //IIO_SHOW_DEBUG_MESSAGES
#define IIO_DEBUG(...) do { ; } while(0) /* no-res */
#endif //IIO_SHOW_DEBUG_MESSAGES
//
// hacks
//
#ifndef __attribute__
#ifndef __GNUC__
#define __attribute__(x) /*NOTHING*/
#endif
#endif
// typedefs {{{1
typedef long long longong;
typedef long double longdouble;
// utility functions {{{1
static bool
checkbounds (int a, int x, int b)
{
return a <= x && x < b;
}
#ifndef IIO_ABORT_ON_ERROR
// NOTE: libpng has a nasty "feature" whereby you have to include libpng.h
// before setjmp.h if you want to use both. This induces the following
// hackery:
#ifndef I_CAN_HAS_LIBPNG
#include <setjmp.h>
#endif //I_CAN_HAS_LIBPNG
static jmp_buf global_jump_buffer;
#endif //IIO_ABORT_ON_ERROR
//#include <errno.h> // only for errno
#include <ctype.h> // for isspace
#include <math.h> // for floorf
#include <stdlib.h>
#ifdef I_CAN_HAS_LINUX
#include <unistd.h>
static const char *emptystring = "";
static const char *
myname (void)
{
#define n 0x29a
static char buf[n];
pid_t p = getpid ();
snprintf (buf, n, "/proc/%d/cmdline", p);
FILE *f = fopen (buf, "r");
if (!f)
return emptystring;
int c, i = 0;
while ((c = fgetc (f)) != EOF && i < n)
{
#undef n
buf[i] = c ? c : ' ';
i += 1;
}
if (i)
buf[i - 1] = '\0';
fclose (f);
return buf;
}
#else
static const char *
myname (void)
{
return "";
}
#endif //I_CAN_HAS_LINUX
//static int iio_single_jmpstuff(bool setup, bool do_return)
//{
// if (setup) {
//}
static void error (const char *fmt, ...)
__attribute__ ((noreturn, format (printf, 1, 2)));
static void
error (const char *fmt, ...)
{
va_list argp;
fprintf (stderr, "\nERROR(\"%s\"): ", myname ());
va_start (argp, fmt);
vfprintf (stderr, fmt, argp);
va_end (argp);
fprintf (stderr, "\n\n");
fflush (NULL);
// if (global_hack_to_never_fail)
// {
// IIO_DEBUG("now wave a dead chicken and press enter\n");
// getchar();
// return;
// }
// exit(43);
#ifndef IIO_ABORT_ON_ERROR
longjmp (global_jump_buffer, 1);
//iio_single_jmpstuff(true, false);
#else //IIO_ABORT_ON_ERROR
#ifdef NDEBUG
exit (-1);
#else //NDEBUG
//print_trace(stderr);
exit (*(int *) 0x43);
#endif //NDEBUG
#endif //IIO_ABORT_ON_ERROR
}
static void *
xmalloc (size_t size)
{
if (size == 0)
error ("xmalloc: zero size");
void *new = malloc (size);
if (!new)
{
double sm = size / (0x100000 * 1.0);
error ("xmalloc: out of memory when requesting " "%zu bytes (%gMB)", //:\"%s\"",
size, sm); //, strerror(errno));
}
return new;
}
static void *
xrealloc (void *p, size_t s)
{
void *r = realloc (p, s);
if (!r)
error ("realloc failed");
return r;
}
static void
xfree (void *p)
{
if (!p)
error ("thou shalt not free a null pointer!");
free (p);
}
static const
char *global_variable_containing_the_name_of_the_last_opened_file = NULL;
static FILE *
xfopen (const char *s, const char *p)
{
global_variable_containing_the_name_of_the_last_opened_file = NULL;
FILE *f;
if (!s)
error ("trying to open a file with NULL name");
if (0 == strcmp ("-", s))
{
if (0 == strcmp ("w", p))
return stdout;
else if (0 == strcmp ("r", p))
return stdin;
else
error ("unknown fopen mode \"%s\"", p);
}
if (0 == strcmp ("--", s) && 0 == strcmp ("w", p))
return stderr;
f = fopen (s, p);
if (f == NULL)
error ("can not open file \"%s\" in mode \"%s\"", // (%s)",
s, p); //, strerror(errno));
//global_variable_containing_the_name_of_the_last_opened_file = (char*)s;
global_variable_containing_the_name_of_the_last_opened_file = s;
return f;
}
static void
xfclose (FILE * f)
{
global_variable_containing_the_name_of_the_last_opened_file = NULL;
if (f != stdout && f != stdin && f != stderr)
{
int r = fclose (f);
if (r)
error ("fclose error"); // \"%s\"", strerror(errno));
}
}
static int
pilla_caracter_segur (FILE * f)
{
int c = getc (f);
if (EOF == c)
error ("input file ended before expected");
//IIO_DEBUG("pcs = '%c'\n", c);
return c;
}
static void
menja_espais (FILE * f)
{
//IIO_DEBUG("inside menja espais\n");
int c;
do
c = pilla_caracter_segur (f);
while (isspace (c));
ungetc (c, f);
}
static void
menja_linia (FILE * f)
{
//IIO_DEBUG("inside menja linia\n");
while (pilla_caracter_segur (f) != '\n')
;
}
static void
menja_espais_i_comentaris (FILE * f)
{
//IIO_DEBUG("inside menja espais i comentaris\n");
int c, comment_char = '#';
menja_espais (f);
while (1)
{
c = pilla_caracter_segur (f);
if (c == comment_char)
{
menja_linia (f);
menja_espais (f);
}
else
ungetc (c, f);
if (c == comment_char)
break;
}
}
// struct iio_image { ... }; {{{1
// This struct is used for exchanging image information between internal
// functions. It could be safely eliminated, and this information be passed as
// five or six variables.
struct iio_image
{
int dimension; // 1, 2, 3 or 4
int sizes[IIO_MAX_DIMENSION];
int pixel_dimension;
int type; // IIO_TYPE_*
int meta; // IIO_META_*
int format; // IIO_FORMAT_*
bool contiguous_data;
bool caca[3];
void *data;
};
// struct iio_image management {{{1
// TODO: reduce the silly number of constructors to 1
static void
iio_image_assert_struct_consistency (struct iio_image *x)
{
assert (x->dimension > 0);
assert (x->dimension <= IIO_MAX_DIMENSION);
FORI (x->dimension) assert (x->sizes[i] > 0);
assert (x->pixel_dimension > 0);
switch (x->type)
{
case IIO_TYPE_INT8:
case IIO_TYPE_UINT8:
case IIO_TYPE_INT16:
case IIO_TYPE_UINT16:
case IIO_TYPE_INT32:
case IIO_TYPE_UINT32:
case IIO_TYPE_FLOAT:
case IIO_TYPE_DOUBLE:
case IIO_TYPE_LONGDOUBLE:
case IIO_TYPE_INT64:
case IIO_TYPE_UINT64:
case IIO_TYPE_HALF:
case IIO_TYPE_CHAR:
case IIO_TYPE_SHORT:
case IIO_TYPE_INT:
case IIO_TYPE_LONG:
case IIO_TYPE_LONGLONG:
break;
default:
assert (false);
}
//if (x->contiguous_data)
// assert(x->data == (void*)(x+1));
}
// API
static size_t
iio_type_size (int type)
{
switch (type)
{
case IIO_TYPE_INT8:
return 1;
case IIO_TYPE_UINT8:
return 1;
case IIO_TYPE_INT16:
return 2;
case IIO_TYPE_UINT16:
return 2;
case IIO_TYPE_INT32:
return 4;
case IIO_TYPE_UINT32:
return 4;
case IIO_TYPE_INT64:
return 8;
case IIO_TYPE_UINT64:
return 8;
case IIO_TYPE_CHAR:
return sizeof (char); // 1
case IIO_TYPE_SHORT:
return sizeof (short);
case IIO_TYPE_INT:
return sizeof (int);
case IIO_TYPE_LONG:
return sizeof (long);
case IIO_TYPE_LONGLONG:
return sizeof (long long);
case IIO_TYPE_FLOAT:
return sizeof (float);
case IIO_TYPE_DOUBLE:
return sizeof (double);
case IIO_TYPE_LONGDOUBLE:
return sizeof (long double);
case IIO_TYPE_HALF:
return sizeof (float) / 2;
default:
error ("unrecognized type %d", type);
}
}
// XXX TODO FIXME: this is architecture dependent!
// this function actually requires A LOT of magic to be portable
static int
normalize_type (int type_in)
{
int type_out;
switch (type_in)
{
case IIO_TYPE_CHAR:
type_out = IIO_TYPE_UINT8;
break;
case IIO_TYPE_SHORT:
type_out = IIO_TYPE_INT16;
break;
case IIO_TYPE_INT:
type_out = IIO_TYPE_UINT32;
break;
default:
type_out = type_in;
break;
}
if (type_out != type_in)
{
// the following assertion fails on many architectures
assert (iio_type_size (type_in) == iio_type_size (type_out));
}
return type_out;
}
// internal API
static int
iio_type_id (size_t sample_size, bool ieeefp_sample, bool signed_sample)
{
if (ieeefp_sample)
{
if (signed_sample)
error ("signed floats are a no-no!");
switch (sample_size)
{
case sizeof (float):
return IIO_TYPE_FLOAT;
case sizeof (double):
return IIO_TYPE_DOUBLE;
case sizeof (long double):
return IIO_TYPE_LONGDOUBLE;
case sizeof (float) / 2:
return IIO_TYPE_HALF;
default:
error ("bad float size %zu", sample_size);
}
}
else
{
switch (sample_size)
{
case 1:
return signed_sample ? IIO_TYPE_INT8 : IIO_TYPE_UINT8;
case 2:
return signed_sample ? IIO_TYPE_INT16 : IIO_TYPE_UINT16;
case 4:
return signed_sample ? IIO_TYPE_INT32 : IIO_TYPE_UINT32;
case 8:
return signed_sample ? IIO_TYPE_INT64 : IIO_TYPE_UINT64;
default:
error ("bad integral size %zu", sample_size);
}
}
}
// internal API
static void
iio_type_unid (int *size, bool * ieefp, bool * signedness, int type)
{
int t = normalize_type (type);
*size = iio_type_size (t);
*ieefp = (t == IIO_TYPE_HALF || t == IIO_TYPE_FLOAT
|| t == IIO_TYPE_DOUBLE || t == IIO_TYPE_LONGDOUBLE);
*signedness = (t == IIO_TYPE_INT8 || t == IIO_TYPE_INT16
|| t == IIO_TYPE_INT32 || t == IIO_TYPE_INT64);
}
// internal API
static int
iio_image_number_of_elements (struct iio_image *x)
{
iio_image_assert_struct_consistency (x);
int r = 1;
FORI (x->dimension) r *= x->sizes[i];
return r;
}
// internal API
static int
iio_image_number_of_samples (struct iio_image *x)
{
return iio_image_number_of_elements (x) * x->pixel_dimension;
}
// internal API
static int
iio_image_data_size (struct iio_image *x)
{
return iio_type_size (x->type) * iio_image_number_of_samples (x);
}
// internal API
static bool
iio_image_sample_integerP (struct iio_image *x)
{
if (false
|| x->type == IIO_TYPE_HALF
|| x->type == IIO_TYPE_FLOAT
|| x->type == IIO_TYPE_DOUBLE || x->type == IIO_TYPE_LONGDOUBLE)
return false;
else
return true;
}
// internal API
static size_t
iio_image_sample_size (struct iio_image *x)
{
return iio_type_size (x->type);
}
static const char *
iio_strtyp (int type)
{
#define M(t) case IIO_TYPE_ ## t: return #t
switch (type)
{
M (INT8);
M (UINT8);
M (INT16);
M (UINT16);
M (INT32);
M (UINT32);
M (INT64);
M (UINT64);
M (FLOAT);
M (DOUBLE);
M (LONGDOUBLE);
M (HALF);
M (UINT1);
M (UINT2);
M (UINT4);
M (CHAR);
M (SHORT);
M (INT);
M (LONG);
M (LONGLONG);
default:
return "unrecognized";
}
#undef M
}
static const char *
iio_strfmt (int format)
{
#define M(f) case IIO_FORMAT_ ## f: return #f
switch (format)
{
M (WHATEVER);
M (QNM);
M (PNG);
M (JPEG);
M (TIFF);
M (RIM);
M (BMP);
M (EXR);
M (JP2);
M (VTK);
M (CIMG);
M (PAU);
M (DICOM);
M (PFM);
M (NIFTI);
M (PCX);
M (GIF);
M (XPM);
M (RAFA);
M (UNRECOGNIZED);
default:
error ("caca de la grossa");
}
#undef M
}
static void
iio_print_image_info (FILE * f, struct iio_image *x)
{
fprintf (f, "iio_print_image_info %p\n", (void *) x);
fprintf (f, "dimension = %d\n", x->dimension);
int *s = x->sizes;
switch (x->dimension)
{
case 1:
fprintf (f, "size = %d\n", s[0]);
break;
case 2:
fprintf (f, "sizes = %dx%d\n", s[0], s[1]);
break;
case 3:
fprintf (f, "sizes = %dx%dx%d\n", s[0], s[1], s[2]);
break;
case 4:
fprintf (f, "sizes = %dx%dx%dx%d\n", s[0], s[1], s[2], s[3]);
break;
default:
error ("unsupported dimension %d", x->dimension);
}
fprintf (f, "pixel_dimension = %d\n", x->pixel_dimension);
fprintf (f, "type = %s\n", iio_strtyp (x->type));
//fprintf(f, "format = %d\n", x->format);
//fprintf(f, "meta = %d\n", x->meta);
//fprintf(f, "contiguous_data = %d\n", x->contiguous_data);
fprintf (f, "data = %p\n", (void *) x->data);
}
//static void fill_canonic_type_descriptors(struct iio_image *x, int type)
//{
// bool s; int i; int f;
// switch(type) {
// case IIO_TYPE_INT8: s=true; i=1; f=0; break;
// case IIO_TYPE_INT16: s=true; i=2; f=0; break;
// case IIO_TYPE_INT32: s=true; i=4; f=0; break;
// case IIO_TYPE_INT64: s=true; i=4; f=0; break;
// case IIO_TYPE_UINT8: s=false; i=1; f=0; break;
// case IIO_TYPE_UINT16: s=false; i=2; f=0; break;
// case IIO_TYPE_UINT32: s=false; i=4; f=0; break;
// case IIO_TYPE_UINT64: s=false; i=8; f=0; break;
// case IIO_TYPE_FLOAT: s=false; i=0; f=4; break;
// case IIO_TYPE_DOUBLE: s=false; i=0; f=8; break;
// case IIO_TYPE_HALF: s=false; i=0; f=2; break;
// default: error("unrecognized type %d", type);
// }
// x->signedness = s;
// x->integer_size = i;
// x->float_size = f;
//}
//static size_t typesize(int type)
//{
// switch(type) {
// case IIO_TYPE_CHAR: return sizeof(char);
// case IIO_TYPE_SHORT: return sizeof(short);
// case IIO_TYPE_INT: return sizeof(int);
// case IIO_TYPE_LONG: return sizeof(long);
// case IIO_TYPE_FLOAT: return sizeof(float);
// case IIO_TYPE_DOUBLE: return sizeof(double);
// default: return -1;
// }
//}
static void
fill_struct_2d (struct iio_image *x, int w, int h, int pd, int type,
void *data)
{
x->dimension = 2;
x->type = type;
x->pixel_dimension = pd;
x->data = data;
x->sizes[0] = w;
x->sizes[1] = h;
}
static void
iio_image_fill (struct iio_image *x,
int dimension, int *sizes, int type, int pixel_dimension)
{
x->dimension = dimension;
FORI (dimension) x->sizes[i] = sizes[i];
x->type = type;
x->pixel_dimension = pixel_dimension;
x->data = NULL;
x->format = -1;
x->meta = -1;
x->contiguous_data = false;
}
static void
iio_wrap_image_struct_around_data (struct iio_image *x,
int dimension, int *sizes,
int pixel_dimension, int type, void *data)
{
assert (dimension < IIO_MAX_DIMENSION);
x->dimension = dimension;
FORI (x->dimension) x->sizes[i] = sizes[i];
x->pixel_dimension = pixel_dimension;
x->type = type;
x->data = data;
x->contiguous_data = false;
x->meta = -42;
x->format = -42;
}
static void
iio_image_build_independent (struct iio_image *x,
int dimension, int *sizes, int type,
int pixel_dimension)
{
assert (dimension > 0);
assert (dimension <= 4);
assert (pixel_dimension > 0);
iio_image_fill (x, dimension, sizes, type, pixel_dimension);
size_t datalength = 1;
FORI (dimension) datalength *= sizes[i];
size_t datasize = datalength * iio_type_size (type) * pixel_dimension;
x->data = xmalloc (datasize);
}
// low-level API: constructor
static struct iio_image *
iio_image_build_contiguous (int dimension, int *sizes,
int type, int pixel_dimension, void *data)
{
assert (!data);
assert (dimension > 0);
assert (dimension <= 4);
assert (pixel_dimension > 0);
size_t datalength = 1;
FORI (dimension) datalength *= sizes[i];
size_t datasize = datalength * iio_type_size (type) * pixel_dimension;
struct iio_image *r = xmalloc (datasize + sizeof *r);
iio_image_fill (r, dimension, sizes, type, pixel_dimension);
r->data = sizeof *r + (char *) r;
r->contiguous_data = true;
return r;
}
// low-level API: queries
static int
iio_image_get_dimension (struct iio_image *x)
{
return x->dimension;
}
static int *
iio_image_get_sizes (struct iio_image *x)
{
return x->sizes;
}
static int
iio_image_get_type (struct iio_image *x)
{
return x->type;
}
static int
iio_image_get_pixel_dimension (struct iio_image *x)
{
return x->pixel_dimension;
}
static int
iio_image_get_meta (struct iio_image *x)
{
return x->meta;
}
//int iio_image_get_layout(struct iio_image *x) { return x->layout; }
static int
iio_image_get_format (struct iio_image *x)
{
return x->format;
}
static void *
iio_image_get_data (struct iio_image *x)
{
return x->data;
}
// data conversion {{{1
#define T0(x) ((x)>0?(x):0)
#define T8(x) ((x)>0?((x)<0xff?(x):0xff):0)
#define T6(x) ((x)>0?((x)<0xffff?(x):0xffff):0)
#define CC(a,b) (77*(a)+(b)) // hash number of a conversion pair
#define I8 IIO_TYPE_INT8
#define U8 IIO_TYPE_UINT8
#define I6 IIO_TYPE_INT16
#define U6 IIO_TYPE_UINT16
#define I2 IIO_TYPE_INT32
#define U2 IIO_TYPE_UINT32
#define I4 IIO_TYPE_INT64
#define U4 IIO_TYPE_UINT64
#define F4 IIO_TYPE_FLOAT
#define F8 IIO_TYPE_DOUBLE
#define F6 IIO_TYPE_LONGDOUBLE
static void
convert_datum (void *dest, void *src, int dest_fmt, int src_fmt)
{
// NOTE: verify that this switch is optimized outside of the loop in
// which it is contained. Otherwise, produce some self-modifying code
// here.
switch (CC (dest_fmt, src_fmt))
{
// change of sign (lossless, but changes interpretation)
case CC (I8, U8):
*(int8_t *) dest = *(uint8_t *) src;
break;
case CC (I6, U6):
*(int16_t *) dest = *(uint16_t *) src;
break;
case CC (I2, U2):
*(int32_t *) dest = *(uint32_t *) src;
break;
case CC (U8, I8):
*(uint8_t *) dest = *(int8_t *) src;
break;
case CC (U6, I6):
*(uint16_t *) dest = *(int16_t *) src;
break;
case CC (U2, I2):
*(uint32_t *) dest = *(int32_t *) src;
break;
// different size signed integers (3 lossy, 3 lossless)
case CC (I8, I6):
*(int8_t *) dest = *(int16_t *) src;
break; //iw810
case CC (I8, I2):
*(int8_t *) dest = *(int32_t *) src;
break; //iw810
case CC (I6, I2):
*(int16_t *) dest = *(int32_t *) src;
break; //iw810
case CC (I6, I8):
*(int16_t *) dest = *(int8_t *) src;
break;
case CC (I2, I8):
*(int32_t *) dest = *(int8_t *) src;
break;
case CC (I2, I6):
*(int32_t *) dest = *(int16_t *) src;
break;
// different size unsigned integers (3 lossy, 3 lossless)
case CC (U8, U6):
*(uint8_t *) dest = *(uint16_t *) src;
break; //iw810
case CC (U8, U2):
*(uint8_t *) dest = *(uint32_t *) src;
break; //iw810
case CC (U6, U2):
*(uint16_t *) dest = *(uint32_t *) src;
break; //iw810
case CC (U6, U8):
*(uint16_t *) dest = *(uint8_t *) src;
break;
case CC (U2, U8):
*(uint32_t *) dest = *(uint8_t *) src;
break;
case CC (U2, U6):
*(uint32_t *) dest = *(uint16_t *) src;
break;
// diferent size mixed integers, make signed (3 lossy, 3 lossless)
case CC (I8, U6):
*(int8_t *) dest = *(uint16_t *) src;
break; //iw810
case CC (I8, U2):
*(int8_t *) dest = *(uint32_t *) src;
break; //iw810
case CC (I6, U2):
*(int16_t *) dest = *(uint32_t *) src;
break; //iw810
case CC (I6, U8):
*(int16_t *) dest = *(uint8_t *) src;
break;
case CC (I2, U8):
*(int32_t *) dest = *(uint8_t *) src;
break;
case CC (I2, U6):
*(int32_t *) dest = *(uint16_t *) src;
break;
// diferent size mixed integers, make unsigned (3 lossy, 3 lossless)
case CC (U8, I6):
*(uint8_t *) dest = *(int16_t *) src;
break; //iw810
case CC (U8, I2):
*(uint8_t *) dest = *(int32_t *) src;
break; //iw810
case CC (U6, I2):
*(uint16_t *) dest = *(int32_t *) src;
break; //iw810
case CC (U6, I8):
*(uint16_t *) dest = *(int8_t *) src;
break;
case CC (U2, I8):
*(uint32_t *) dest = *(int8_t *) src;
break;
case CC (U2, I6):
*(uint32_t *) dest = *(int16_t *) src;
break;
// from float (typically lossy, except for small integers)
case CC (I8, F4):
*(int8_t *) dest = *(float *) src;
break; //iw810
case CC (I6, F4):
*(int16_t *) dest = *(float *) src;
break; //iw810
case CC (I2, F4):
*(int32_t *) dest = *(float *) src;
break;
case CC (I8, F8):
*(int8_t *) dest = *(double *) src;
break; //iw810
case CC (I6, F8):
*(int16_t *) dest = *(double *) src;
break; //iw810
case CC (I2, F8):
*(int32_t *) dest = *(double *) src;
break; //iw810
case CC (U8, F4):
*(uint8_t *) dest = T8 (0.5 + *(float *) src);
break; //iw810
case CC (U6, F4):
*(uint16_t *) dest = T6 (0.5 + *(float *) src);
break; //iw810
case CC (U2, F4):
*(uint32_t *) dest = *(float *) src;
break;
case CC (U8, F8):
*(uint8_t *) dest = T8 (0.5 + *(double *) src);
break; //iw810
case CC (U6, F8):
*(uint16_t *) dest = T6 (0.5 + *(double *) src);
break; //iw810
case CC (U2, F8):
*(uint32_t *) dest = *(double *) src;
break; //iw810
// to float (typically lossless, except for large integers)
case CC (F4, I8):
*(float *) dest = *(int8_t *) src;
break;
case CC (F4, I6):
*(float *) dest = *(int16_t *) src;
break;
case CC (F4, I2):
*(float *) dest = *(int32_t *) src;
break; //iw810
case CC (F8, I8):
*(double *) dest = *(int8_t *) src;
break;
case CC (F8, I6):
*(double *) dest = *(int16_t *) src;
break;
case CC (F8, I2):
*(double *) dest = *(int32_t *) src;
break;
case CC (F4, U8):
*(float *) dest = *(uint8_t *) src;
break;
case CC (F4, U6):
*(float *) dest = *(uint16_t *) src;
break;
case CC (F4, U2):
*(float *) dest = *(uint32_t *) src;
break; //iw810
case CC (F8, U8):
*(double *) dest = *(uint8_t *) src;
break;
case CC (F8, U6):
*(double *) dest = *(uint16_t *) src;
break;
case CC (F8, U2):
*(double *) dest = *(uint32_t *) src;
break;
#ifdef I_CAN_HAS_INT64
// to int64_t and uint64_t
case CC (I4, I8):
*(int64_t *) dest = *(int8_t *) src;
break;
case CC (I4, I6):
*(int64_t *) dest = *(int16_t *) src;
break;
case CC (I4, I2):
*(int64_t *) dest = *(int32_t *) src;
break;
case CC (I4, U8):
*(int64_t *) dest = *(uint8_t *) src;
break;
case CC (I4, U6):
*(int64_t *) dest = *(uint16_t *) src;
break;
case CC (I4, U2):
*(int64_t *) dest = *(uint32_t *) src;
break;
case CC (I4, F4):
*(int64_t *) dest = *(float *) src;
break;
case CC (I4, F8):
*(int64_t *) dest = *(double *) src;
break;
case CC (U4, I8):
*(uint64_t *) dest = *(int8_t *) src;
break;
case CC (U4, I6):
*(uint64_t *) dest = *(int16_t *) src;
break;
case CC (U4, I2):
*(uint64_t *) dest = *(int32_t *) src;
break;
case CC (U4, U8):
*(uint64_t *) dest = *(uint8_t *) src;
break;
case CC (U4, U6):
*(uint64_t *) dest = *(uint16_t *) src;
break;
case CC (U4, U2):
*(uint64_t *) dest = *(uint32_t *) src;
break;
case CC (U4, F4):
*(uint64_t *) dest = *(float *) src;
break;
case CC (U4, F8):
*(uint64_t *) dest = *(double *) src;
break;
// from int64_t and uint64_t
case CC (I8, I4):
*(int8_t *) dest = *(int64_t *) src;
break;
case CC (I6, I4):
*(int16_t *) dest = *(int64_t *) src;
break;
case CC (I2, I4):
*(int32_t *) dest = *(int64_t *) src;
break;
case CC (U8, I4):
*(uint8_t *) dest = *(int64_t *) src;
break;
case CC (U6, I4):
*(uint16_t *) dest = *(int64_t *) src;
break;
case CC (U2, I4):
*(uint32_t *) dest = *(int64_t *) src;
break;
case CC (F4, I4):
*(float *) dest = *(int64_t *) src;
break;
case CC (F8, I4):
*(double *) dest = *(int64_t *) src;
break;
case CC (I8, U4):
*(int8_t *) dest = *(uint64_t *) src;
break;
case CC (I6, U4):
*(int16_t *) dest = *(uint64_t *) src;
break;
case CC (I2, U4):
*(int32_t *) dest = *(uint64_t *) src;
break;
case CC (U8, U4):
*(uint8_t *) dest = *(uint64_t *) src;
break;
case CC (U6, U4):
*(uint16_t *) dest = *(uint64_t *) src;
break;
case CC (U2, U4):
*(uint32_t *) dest = *(uint64_t *) src;
break;
case CC (F4, U4):
*(float *) dest = *(uint64_t *) src;
break;
case CC (F8, U4):
*(double *) dest = *(uint64_t *) src;
break;
#endif //I_CAN_HAS_INT64
#ifdef I_CAN_HAS_LONGDOUBLE
// to longdouble
case CC (F6, I8):
*(longdouble *) dest = *(int8_t *) src;
break;
case CC (F6, I6):
*(longdouble *) dest = *(int16_t *) src;
break;
case CC (F6, I2):
*(longdouble *) dest = *(int32_t *) src;
break;
case CC (F6, U8):
*(longdouble *) dest = *(uint8_t *) src;
break;
case CC (F6, U6):
*(longdouble *) dest = *(uint16_t *) src;
break;
case CC (F6, U2):
*(longdouble *) dest = *(uint32_t *) src;
break;
case CC (F6, F4):
*(longdouble *) dest = *(float *) src;
break;
case CC (F6, F8):
*(longdouble *) dest = *(double *) src;
break;
// from longdouble
case CC (I8, F6):
*(int8_t *) dest = *(longdouble *) src;
break;
case CC (I6, F6):
*(int16_t *) dest = *(longdouble *) src;
break;
case CC (I2, F6):
*(int32_t *) dest = *(longdouble *) src;
break;
case CC (U8, F6):
*(uint8_t *) dest = T8 (0.5 + *(longdouble *) src);
break;
case CC (U6, F6):
*(uint16_t *) dest = T6 (0.5 + *(longdouble *) src);
break;
case CC (U2, F6):
*(uint32_t *) dest = *(longdouble *) src;
break;
case CC (F4, F6):
*(float *) dest = *(longdouble *) src;
break;
case CC (F8, F6):
*(double *) dest = *(longdouble *) src;
break;
#ifdef I_CAN_HAS_INT64 //(nested)
case CC (F6, I4):
*(longdouble *) dest = *(int64_t *) src;
break;
case CC (F6, U4):
*(longdouble *) dest = *(uint64_t *) src;
break;
case CC (I4, F6):
*(int64_t *) dest = *(longdouble *) src;
break;
case CC (U4, F6):
*(uint64_t *) dest = *(longdouble *) src;
break;
#endif //I_CAN_HAS_INT64 (nested)
#endif //I_CAN_HAS_LONGDOUBLE
default:
error ("bad conversion from %d to %d", src_fmt, dest_fmt);
}
}
#undef CC
#undef I8
#undef U8
#undef I6
#undef U6
#undef I2
#undef U2
#undef F4
#undef F8
#undef F6
static void *
convert_data (void *src, int n, int dest_fmt, int src_fmt)
{
if (src_fmt == IIO_TYPE_FLOAT)
IIO_DEBUG ("first float sample = %g\n", *(float *) src);
size_t src_width = iio_type_size (src_fmt);
size_t dest_width = iio_type_size (dest_fmt);
IIO_DEBUG ("converting %d samples from %s to %s\n", n, iio_strtyp (src_fmt),
iio_strtyp (dest_fmt));
IIO_DEBUG ("src width = %zu\n", src_width);
IIO_DEBUG ("dest width = %zu\n", dest_width);
char *r = xmalloc (n * dest_width);
// NOTE: the switch inside "convert_datum" should be optimized
// outside of this loop
FORI (n)
{
void *to = i * dest_width + r;
void *from = i * src_width + (char *) src;
convert_datum (to, from, dest_fmt, src_fmt);
}
xfree (src);
if (dest_fmt == IIO_TYPE_INT16)
IIO_DEBUG ("first short sample = %d\n", *(int16_t *) r);
return r;
}
static void
unpack_nibbles_to_bytes (uint8_t out[2], uint8_t in)
{
out[1] = (in & 0x0f); //0b00001111
out[0] = (in & 0xf0) >> 4; //0b11110000
}
static void
unpack_couples_to_bytes (uint8_t out[4], uint8_t in)
{
out[3] = (in & 0x03); //0b00000011
out[2] = (in & 0x0c) >> 2; //0b00001100
out[1] = (in & 0x30) >> 4; //0b00110000
out[0] = (in & 0xc0) >> 6; //0b11000000
}
static void
unpack_bits_to_bytes (uint8_t out[8], uint8_t in)
{
out[7] = (in & 1) ? 1 : 0;
out[6] = (in & 2) ? 1 : 0;
out[5] = (in & 4) ? 1 : 0;
out[4] = (in & 8) ? 1 : 0;
out[3] = (in & 16) ? 1 : 0;
out[2] = (in & 32) ? 1 : 0;
out[1] = (in & 64) ? 1 : 0;
out[0] = (in & 128) ? 1 : 0;
}
static void
unpack_to_bytes_here (uint8_t * dest, uint8_t * src, int n, int bits)
{
fprintf (stderr, "unpacking %d bytes %d-fold\n", n, bits);
assert (bits == 1 || bits == 2 || bits == 4);
size_t unpack_factor = 8 / bits;
switch (bits)
{
case 1:
FORI (n) unpack_bits_to_bytes (dest + 8 * i, src[i]);
break;
case 2:
FORI (n) unpack_couples_to_bytes (dest + 4 * i, src[i]);
break;
case 4:
FORI (n) unpack_nibbles_to_bytes (dest + 2 * i, src[i]);
break;
default:
error ("very strange error");
}
}
//static uint8_t *unpack_to_bytes(uint8_t *s, int n, int src_bits)
//{
// assert(src_bits==1 || src_bits==2 || src_bits==4);
// size_t unpack_factor = 8 / src_bits;
// uint8_t *r = xmalloc(n * unpack_factor);
// switch(src_bits) {
// case 1: FORI(n) unpack_bits_to_bytes(r + 8*i, s[i]); break;
// case 2: FORI(n) unpack_couples_to_bytes(r + 4*i, s[i]); break;
// case 4: FORI(n) unpack_nibbles_to_bytes(r + 2*i, s[i]); break;
// default: error("very strange error");
// }
// xfree(s);
// return r;
//}
static void
iio_convert_samples (struct iio_image *x, int desired_type)
{
assert (!x->contiguous_data);
int source_type = normalize_type (x->type);
if (source_type == desired_type)
return;
IIO_DEBUG ("converting from %s to %s\n", iio_strtyp (x->type),
iio_strtyp (desired_type));
int n = iio_image_number_of_samples (x);
x->data = convert_data (x->data, n, desired_type, source_type);
x->type = desired_type;
}
static void
iio_hacky_colorize (struct iio_image *x, int pd)
{
assert (!x->contiguous_data);
if (x->pixel_dimension != 1)
error ("please, do not colorize color stuff");
int source_type = normalize_type (x->type);
int n = iio_image_number_of_elements (x);
int ss = iio_image_sample_size (x);
void *rdata = xmalloc (n * ss * pd);
char *data_dest = rdata;
char *data_src = x->data;
FORI (n)
FORJ (pd) memcpy (data_dest + (pd * i + j) * ss, data_src + i * ss, ss);
xfree (x->data);
x->data = rdata;
x->pixel_dimension = pd;
}
// uncolorize
static void
iio_hacky_uncolorize (struct iio_image *x)
{
assert (!x->contiguous_data);
if (x->pixel_dimension != 3)
error ("please, do not uncolorize non-color stuff");
assert (x->pixel_dimension == 3);
int source_type = normalize_type (x->type);
int n = iio_image_number_of_elements (x);
switch (source_type)
{
case IIO_TYPE_UINT8:
{
uint8_t (*xd)[3] = x->data;
uint8_t *r = xmalloc (n * sizeof *r);
FORI (n) r[i] = .299 * xd[i][0] + .587 * xd[i][1] + .114 * xd[i][2];
xfree (x->data);
x->data = r;
}
break;
case IIO_TYPE_FLOAT:
{
float (*xd)[3] = x->data;
float *r = xmalloc (n * sizeof *r);
FORI (n) r[i] = .299 * xd[i][0] + .587 * xd[i][1] + .114 * xd[i][2];
xfree (x->data);
x->data = r;
}
break;
default:
error ("uncolorize type not supported");
}
x->pixel_dimension = 1;
}
// uncolorize
static void
iio_hacky_uncolorizea (struct iio_image *x)
{
assert (!x->contiguous_data);
if (x->pixel_dimension != 4)
error ("please, do not uncolorizea non-colora stuff");
assert (x->pixel_dimension == 4);
int source_type = normalize_type (x->type);
int n = iio_image_number_of_elements (x);
switch (source_type)
{
case IIO_TYPE_UINT8:
{
uint8_t (*xd)[4] = x->data;
uint8_t *r = xmalloc (n * sizeof *r);
FORI (n) r[i] = .299 * xd[i][0] + .587 * xd[i][1] + .114 * xd[i][2];
xfree (x->data);
x->data = r;
}
break;
case IIO_TYPE_FLOAT:
{
float (*xd)[4] = x->data;
float *r = xmalloc (n * sizeof *r);
FORI (n) r[i] = .299 * xd[i][0] + .587 * xd[i][1] + .114 * xd[i][2];
xfree (x->data);
x->data = r;
}
break;
default:
error ("uncolorizea type not supported");
}
x->pixel_dimension = 1;
}
// (minimal) image processing using the iio_image {{{1
//TODO: remove this section
// whatever
// get/set pixel {{{2
// the "getpixel" function can be used also as a setpixel
static void *
iio_getpixel (struct iio_image *x, int *p)
{
FORI (x->dimension) if (!checkbounds (0, p[i], x->sizes[i]))
return NULL;
int n = iio_image_sample_size (x);
char *r = x->data;
switch (x->dimension)
{
case 1:
return n * p[0] + r;
case 2:
return n * p[0] + x->sizes[0] * p[1] + r;
case 3:
return n * p[0] + x->sizes[0] * (p[1] + x->sizes[1] * p[2]) + r;
default:
error ("getpixel not yet for dimension %d", x->dimension);
}
}
static void *
iio_getsample (struct iio_image *x, int *p, int c)
{
if (!checkbounds (0, c, x->pixel_dimension))
return NULL;
void *pixel = iio_getpixel (x, p);
int n = iio_image_sample_size (x);
return c * n + (char *) pixel;
}
// crop/slice/select {{{2
// To CROP an image means building an image with a "rectangular" subset of its
// numbers As particular cases it contains taking a slice from a video, or a
// color channel. It does not change the signature.
// signs equals 1.
static void
iio_general_crop (struct iio_image *x, int *corner, int *sizes,
int firstchan, int lastchan)
{
// silently ignores out of range bounds
int newsizes[x->dimension];
}
// rotate/deinterlace {{{2
// To TRANSPOSE an image means building an image with the same numbers in
// different order. As particular it contains rotation, (de)interlacing, etc.
static void
iio_general_transposition (struct iio_image *x, int c[2])
{
}
// ntiply/colorize {{{2
// to NTIPLY an image means building an image where some numbers are repeated
// As particular cases it contains zooming in an image (with nearest neighbor
// interpolation), or colorizing a gray image.
static void
iio_general_ntiply (struct iio_image *x, int *factors, int pfac)
{
// too complicated for now...
}
// normalize signature {{{2
static void
iio_general_normalize_signature (struct iio_image *x)
{
}
// general memory and file utilities {{{1
// Input: a partially read stream "f"
// (of which "bufn" bytes are already read into "buf")
//
// Output: a malloc'd block with the whole file content
//
// Implementation: re-invent the wheel
static void *
load_rest_of_file (long *on, FILE * f, void *buf, size_t bufn)
{
size_t n = bufn, ntop = n + 0x3000;
char *t = xmalloc (ntop);
if (!t)
error ("out of mem (%zu) while loading file", ntop);
memcpy (t, buf, bufn);
while (1)
{
if (n >= ntop)
{
ntop = 1000 + 2 * (ntop + 1);
t = xrealloc (t, ntop);
if (!t)
error ("out of mem (%zu) loading file", ntop);
}
int r = fgetc (f);
if (r == EOF)
break;
t[n] = r; //iw810
n += 1;
}
*on = n;
return t;
}
// Input: a pointer to raw data
//
// Output: the name of a temporary file containing the data
//
// Implementation: re-invent the wheel
static char *
put_data_into_temporary_file (void *filedata, size_t filesize)
{
#ifdef I_CAN_HAS_MKSTEMP
static char filename[] = "/tmp/iio_temporal_file_XXXXXX\0";
int r = mkstemp (filename);
if (r == -1)
error ("caca [pditf]");
#else
// WARNING XXX XXX XXX ERROR FIXME TODO WARNING:
// this function is not reentrant
static char buf[L_tmpnam + 1];
//
// from TMPNAM(3):
//
//The tmpnam() function returns a pointer to a string that is a
//valid filename, and such that a file with this name did not exist
//at some point in time, so that naive programmers may think it a
//suitable name for a temporary file.
//
char *filename = tmpnam (buf);
// MULTIPLE RACE CONDITIONS HERE
#endif
FILE *f = xfopen (filename, "w");
int cx = fwrite (filedata, filesize, 1, f);
if (cx != 1)
error ("fwrite to temporary file failed");
xfclose (f);
return filename;
}
static void
delete_temporary_file (char *filename)
{
#ifdef NDEBUG
remove (filename);
#else
//IIO_DEBUG("WARNING: kept temporary file %s around\n", filename);
fprintf (stderr, "WARNING: kept temporary file %s around\n", filename);
#endif
}
// Allows read access to memory via a FILE*
// Always returns a valid FILE*
static FILE *
iio_fmemopen (void *data, size_t size)
{
#ifdef I_CAN_HAS_FMEMOPEN // GNU case
FILE *r = fmemopen (data, size, "r");
if (!r)
error ("fmemopen failed");
return r;
#elif I_CAN_HAS_FUNOPEN // BSD case
error ("implement fmemopen using funopen here");
#else // portable case
FILE *f = tmpfile ();
if (!f)
error ("tmpfile failed");
int cx = fwrite (data, size, 1, f);
if (cx != 1)
error ("fwrite failed");
rewind (f);
return f;
#endif // I_CAN_HAS_...
}
// beautiful hack follows
static void *
matrix_build (int w, int h, size_t n)
{
size_t p = sizeof (void *);
char *r = xmalloc (h * p + w * h * n);
for (int i = 0; i < h; i++)
*(void **) (r + i * p) = r + h * p + i * w * n;
return r;
}
static void *
wrap_2dmatrix_around_data (void *x, int w, int h, size_t s)
{
void *r = matrix_build (w, h, s);
char *y = h * sizeof (void *) + (char *) r;
memcpy (y, x, w * h * s);
xfree (x);
return r;
}
static int
atoin (char *s)
{
int r = 0;
while (isdigit (*s))
{
r *= 10;
r += *s - '0';
s += 1;
}
return r;
}
// heurística per trobar les dimensions a partir del nom
static bool
find_dimensions_in_string_2d (int out[2], char *s)
{
// preprocessem el text per trobar-ne els dígits
int n = strlen (s), nnums = 0, numbegs[n];
for (int i = 1; i < n; i++)
if (isdigit (s[i]) && !isdigit (s[i - 1]))
numbegs[nnums++] = i;
if (nnums < 2)
return false;
// si el text conté algun parell "%dx%d", retornem el primer parell
for (int i = 1; i < nnums; i++)
if (tolower (s[numbegs[i] - 1]) == 'x')
{
out[0] = atoin (s + numbegs[i - 1]);
out[1] = atoin (s + numbegs[i]);
return true;
}
// altrament, cerquem els dos primers números
out[0] = atoin (s + numbegs[0]);
out[1] = atoin (s + numbegs[1]);
return true;
}
static bool
find_dimensions_in_string_3d (int out[3], char *s)
{
// preprocessem el text per trobar-ne els dígits
int n = strlen (s), nnums = 0, numbegs[n];
for (int i = 1; i < n; i++)
if (isdigit (s[i]) && !isdigit (s[i - 1]))
numbegs[nnums++] = i;
if (nnums < 3)
return false;
// si el text conté algun trio "%dx%dx%d", retornem el primer trio
for (int i = 2; i < nnums; i++)
if (tolower (s[numbegs[i] - 1]) == 'x'
&& tolower (s[numbegs[i - 1] - 1]) == 'x')
{
out[0] = atoin (s + numbegs[i - 2]);
out[1] = atoin (s + numbegs[i - 1]);
out[2] = atoin (s + numbegs[i]);
return true;
}
// altrament, cerquem els dos primers números
out[0] = atoin (s + numbegs[0]);
out[1] = atoin (s + numbegs[1]);
out[2] = atoin (s + numbegs[2]);
return true;
}
static void
break_pixels (void *broken, void *clear, int ss, int n, int pd)
{
char *to = broken;
char *from = clear;
FORI (n) FORL (pd) FORK (ss)
to[(n * l + i) * ss + k] = from[(pd * i + l) * ss + k];
}
static void
recover_broken_pixels (void *c, void *b, int ss, int n, int pd)
{
char *to = c;
char *from = b;
FORL (pd) FORI (n) FORK (ss)
to[(pd * i + l) * ss + k] = from[(n * l + i) * ss + k];
}
// todo make this function more general, or a front-end to a general
// "data trasposition" routine
static void
break_pixels_float (float *broken, float *clear, int n, int pd)
{
//fprintf(stderr, "breaking %d %d-dimensional vectors\n", n, pd);
FORI (n) FORL (pd) broken[n * l + i] = clear[pd * i + l];
}
static void
recover_broken_pixels_float (float *clear, float *broken, int n, int pd)
{
//fprintf(stderr, "unbreaking %d %d-dimensional vectors\n", n, pd);
FORL (pd) FORI (n) clear[pd * i + l] = broken[n * l + i];
}
// individual format readers {{{1
// PNG reader {{{2
static void
swap_two_bytes (char *here)
{
char tmp = here[0];
here[0] = here[1];
here[1] = tmp;
}
#ifdef I_CAN_HAS_LIBPNG
//#include <png.h>
#include <limits.h> // for CHAR_BIT only
static int
read_beheaded_png (struct iio_image *x, FILE * f, char *header, int nheader)
{
// TODO: reorder this mess
png_structp pp = png_create_read_struct (PNG_LIBPNG_VER_STRING, 0, 0, 0);
if (!pp)
error ("png_create_read_struct fail");
png_infop pi = png_create_info_struct (pp);
if (!pi)
error ("png_create_info_struct fail");
if (setjmp (png_jmpbuf (pp)))
error ("png error");
png_init_io (pp, f);
png_set_sig_bytes (pp, nheader);
int transforms = PNG_TRANSFORM_IDENTITY
| PNG_TRANSFORM_PACKING | PNG_TRANSFORM_EXPAND;
png_read_png (pp, pi, transforms, NULL);
png_uint_32 w, h;
int channels, rowbytes;
int depth, color, interl, compr, filt;
w = png_get_image_width (pp, pi);
h = png_get_image_height (pp, pi);
//png_get_IHDR(pp, pi, &w, &h, &depth, &color, &interl, &compr, &filt);
channels = png_get_channels (pp, pi);
rowbytes = png_get_rowbytes (pp, pi);
depth = png_get_bit_depth (pp, pi);
color = png_get_color_type (pp, pi);
IIO_DEBUG ("png get width = %d\n", (int) w);
IIO_DEBUG ("png get height = %d\n", (int) h);
IIO_DEBUG ("png get channels = %d\n", channels);
IIO_DEBUG ("png get rowbytes = %d\n", rowbytes);
IIO_DEBUG ("png get depth = %d\n", depth);
IIO_DEBUG ("png get color = %d\n", color);
//IIO_DEBUG("png ihdr width = %d\n", (int)w);
//IIO_DEBUG("png ihdr height = %d\n", (int)h);
//IIO_DEBUG("png ihdr depth = %d\n", depth);
//IIO_DEBUG("png ihdr color = %d\n", color);
//IIO_DEBUG("png ihdr interl = %d\n", interl);
//IIO_DEBUG("png ihdr compr = %d\n", compr);
//IIO_DEBUG("png ihdr filt = %d\n", filt);
//IIO_DEBUG("png channels = %d\n", channels);
//IIO_DEBUG("png rowbytes = %d\n", rowbytes);
//assert(rowbytes == ceil((channels * (int)w * depth)/CHAR_BIT));
//if (depth == 16) png_set_swap(pp); (does not seem to work)
int sizes[2] = { w, h };
png_bytepp rows = png_get_rows (pp, pi);
x->format = IIO_FORMAT_PNG;
x->meta = -42;
switch (depth)
{
case 1:
case 8:
IIO_DEBUG ("first byte = %d\n", (int) rows[0][0]);
iio_image_build_independent (x, 2, sizes, IIO_TYPE_CHAR, channels);
FORJ (h) FORI (w) FORL (channels)
{
char *data = x->data;
png_byte *b = rows[j] + i * channels + l;
data[(i + j * w) * channels + l] = *b;
}
x->type = IIO_TYPE_CHAR;
break;
case 16:
iio_image_build_independent (x, 2, sizes, IIO_TYPE_UINT16, channels);
FORJ (h) FORI (w) FORL (channels)
{
uint16_t *data = x->data;
png_byte *b = rows[j] + 2 * (i * channels + l);
swap_two_bytes ((char *) b);
uint16_t *tb = (uint16_t *) b;
data[(i + j * w) * channels + l] = *tb;
}
x->type = IIO_TYPE_UINT16;
break;
default:
error ("unsuported bit depth %d", depth);
}
//FORJ(h) FORIk
//png_destroy_read_struct(&pp, &pi, &pe);
png_destroy_read_struct (&pp, &pi, NULL);
return 0;
}
#endif //I_CAN_HAS_LIBPNG
// JPEG reader {{{2
#ifdef I_CAN_HAS_LIBJPEG
#include <jpeglib.h>
static int
read_whole_jpeg (struct iio_image *x, FILE * f)
{
// allocate and initialize a JPEG decompression object
struct jpeg_decompress_struct cinfo[1];
struct jpeg_error_mgr jerr[1];
cinfo->err = jpeg_std_error (jerr);
jpeg_create_decompress (cinfo);
// specify the source of the compressed data
jpeg_stdio_src (cinfo, f);
// obtain image info
jpeg_read_header (cinfo, 1);
int size[2], depth;
size[0] = cinfo->image_width;
size[1] = cinfo->image_height;
depth = cinfo->num_components;
IIO_DEBUG ("jpeg header widht = %d\n", size[0]);
IIO_DEBUG ("jpeg header height = %d\n", size[1]);
IIO_DEBUG ("jpeg header colordepth = %d\n", depth);
iio_image_build_independent (x, 2, size, IIO_TYPE_CHAR, depth);
// set parameters for decompression
// cinfo->do_fancy_upsampling = 0;
// colorspace selection, etc
// start decompress
jpeg_start_decompress (cinfo);
assert (size[0] == (int) cinfo->output_width);
assert (size[1] == (int) cinfo->output_height);
assert (depth == cinfo->out_color_components);
assert (cinfo->output_components == cinfo->out_color_components);
// read scanlines
FORI (size[1])
{
void *wheretoputit = i * depth * size[0] + (char *) x->data;
//FORJ(size[0]*depth) ((char*)wheretoputit)[j] = 6;
JSAMPROW scanline[1] = { wheretoputit };
int r = jpeg_read_scanlines (cinfo, scanline, 1);
//IIO_DEBUG("read %dth scanline (r=%d) {%d}\n", i, r, (int)sizeof(JSAMPLE));
if (1 != r)
error ("failed to rean jpeg scanline %d", i);
}
// finish decompress
jpeg_finish_decompress (cinfo);
// release the JPEG decompression object
jpeg_destroy_decompress (cinfo);
return 0;
}
static int
read_beheaded_jpeg (struct iio_image *x,
FILE * fin, char *header, int nheader)
{
long filesize;
// TODO: if "f" is rewindable, rewind it!
void *filedata = load_rest_of_file (&filesize, fin, header, nheader);
FILE *f = iio_fmemopen (filedata, filesize);
int r = read_whole_jpeg (x, f);
if (r)
error ("read whole jpeg returned %d", r);
fclose (f);
xfree (filedata);
return 0;
}
#endif //I_CAN_HAS_LIBJPEG
// TIFF reader {{{2
#ifdef I_CAN_HAS_LIBTIFF
#include <tiffio.h>
static int
read_whole_tiff (struct iio_image *x, const char *filename)
{
// tries to read data in the correct format (via scanlines)
// if it fails, it tries to read ABGR data
TIFF *tif = TIFFOpen (filename, "r");
if (!tif)
error ("could not open TIFF file \"%s\"", filename);
uint32_t w, h;
uint16_t spp, bps, fmt;
int r = 0, fmt_iio = -1;
r += TIFFGetField (tif, TIFFTAG_IMAGEWIDTH, &w);
IIO_DEBUG ("tiff get field width %d (r=%d)\n", (int) w, r);
r += TIFFGetField (tif, TIFFTAG_IMAGELENGTH, &h);
IIO_DEBUG ("tiff get field length %d (r=%d)\n", (int) h, r);
if (r != 2)
error ("can not read tiff of unknown size");
r = TIFFGetField (tif, TIFFTAG_SAMPLESPERPIXEL, &spp);
if (!r)
spp = 1;
if (r)
IIO_DEBUG ("tiff get field spp %d (r=%d)\n", spp, r);
r = TIFFGetField (tif, TIFFTAG_BITSPERSAMPLE, &bps);
if (!r)
bps = 1;
if (r)
IIO_DEBUG ("tiff get field bps %d (r=%d)\n", bps, r);
r = TIFFGetField (tif, TIFFTAG_SAMPLEFORMAT, &fmt);
if (!r)
fmt = SAMPLEFORMAT_UINT;
if (r)
IIO_DEBUG ("tiff get field fmt %d (r=%d)\n", fmt, r);
//if (r != 5) error("some tiff getfield failed (r=%d)", r);
// TODO: consider the missing cases (run through PerlMagick's format database)
IIO_DEBUG ("fmt = %d\n", fmt);
// set appropriate size and type flags
if (fmt == SAMPLEFORMAT_UINT)
{
if (1 == bps)
fmt_iio = IIO_TYPE_UINT1;
else if (2 == bps)
fmt_iio = IIO_TYPE_UINT2;
else if (4 == bps)
fmt_iio = IIO_TYPE_UINT4;
else if (8 == bps)
fmt_iio = IIO_TYPE_UINT8;
else if (16 == bps)
fmt_iio = IIO_TYPE_UINT16;
else if (32 == bps)
fmt_iio = IIO_TYPE_UINT32;
else
error ("unrecognized UINT type of size %d bits", bps);
}
else if (fmt == SAMPLEFORMAT_INT)
{
if (8 == bps)
fmt_iio = IIO_TYPE_INT8;
else if (16 == bps)
fmt_iio = IIO_TYPE_INT16;
else if (32 == bps)
fmt_iio = IIO_TYPE_INT32;
else
error ("unrecognized INT type of size %d bits", bps);
}
else if (fmt == SAMPLEFORMAT_IEEEFP)
{
IIO_DEBUG ("floating tiff!\n");
if (32 == bps)
fmt_iio = IIO_TYPE_FLOAT;
else if (64 == bps)
fmt_iio = IIO_TYPE_DOUBLE;
else
error ("unrecognized FLOAT type of size %d bits", bps);
}
else
error ("unrecognized tiff sample format %d (see tiff.h)", fmt);
if (bps >= 8 && bps != 8 * iio_type_size (fmt_iio))
{
IIO_DEBUG ("bps = %d\n", bps);
IIO_DEBUG ("fmt_iio = %d\n", fmt_iio);
IIO_DEBUG ("ts = %zu\n", iio_type_size (fmt_iio));
IIO_DEBUG ("8*ts = %zu\n", 8 * iio_type_size (fmt_iio));
}
if (bps >= 8)
assert (bps == 8 * iio_type_size (fmt_iio));
// acquire memory block
uint32_t scanline_size = (w * spp * bps) / 8;
int rbps = bps / 8 ? bps / 8 : 1;
uint32_t uscanline_size = w * spp * rbps;
IIO_DEBUG ("bps = %d\n", (int) bps);
IIO_DEBUG ("spp = %d\n", (int) spp);
IIO_DEBUG ("sls = %d\n", (int) scanline_size);
int sls = TIFFScanlineSize (tif);
IIO_DEBUG ("sls(r) = %d\n", (int) sls);
assert ((int) scanline_size == sls);
scanline_size = sls;
uint8_t *data = xmalloc (w * h * spp * rbps);
//FORI(h*scanline_size) data[i] = 42;
uint8_t *buf = xmalloc (scanline_size);
// dump scanline data
FORI (h)
{
//r = TIFFReadScanline(tif, data + i * scanline_size, i, 0);
r = TIFFReadScanline (tif, buf, i, 0);
if (r < 0)
error ("error reading tiff row %d/%d", i, (int) h);
if (bps < 8)
{
fprintf (stderr, "unpacking %dth scanline\n", i);
unpack_to_bytes_here (data + i * uscanline_size, buf,
scanline_size, bps);
fmt_iio = IIO_TYPE_UINT8;
}
else
{
//assert(uscanline_size == scanline_size);
memcpy (data + i * scanline_size, buf, scanline_size);
}
}
TIFFClose (tif);
xfree (buf);
// fill struct fields
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = spp;
x->type = fmt_iio;
x->format = x->meta = -42;
x->data = data;
x->contiguous_data = false;
return 0;
}
// Note: TIFF library only reads from a named file. The only way to use the
// library if you have your image in a stream, is to write the data to a
// temporary file, and read it from there. This can be optimized in the future
// by recovering the original filename through hacks, in case it was not a pipe.
static int
read_beheaded_tiff (struct iio_image *x,
FILE * fin, char *header, int nheader)
{
if (global_variable_containing_the_name_of_the_last_opened_file)
{
int r = read_whole_tiff (x,
global_variable_containing_the_name_of_the_last_opened_file);
if (r)
error ("read whole tiff returned %d", r);
return 0;
}
long filesize;
void *filedata = load_rest_of_file (&filesize, fin, header, nheader);
char *filename = put_data_into_temporary_file (filedata, filesize);
xfree (filedata);
//IIO_DEBUG("tmpfile = \"%s\"\n", filename);
int r = read_whole_tiff (x, filename);
if (r)
error ("read whole tiff returned %d", r);
delete_temporary_file (filename);
return 0;
}
#endif //I_CAN_HAS_LIBTIFF
// QNM readers {{{2
#include <ctype.h>
static void
llegeix_floats_en_bytes (FILE * don, float *on, int quants)
{
for (int i = 0; i < quants; i++)
{
float c;
c = pilla_caracter_segur (don); //iw810
on[i] = c;
}
}
static void
llegeix_floats_en_shorts (FILE * don, float *on, int quants)
{
for (int i = 0; i < quants; i++)
{
float c;
c = pilla_caracter_segur (don);
c *= 256;
c += pilla_caracter_segur (don);
on[i] = c;
}
}
static void
llegeix_floats_en_ascii (FILE * don, float *on, int quants)
{
for (int i = 0; i < quants; i++)
{
int r;
float c;
r = fscanf (don, "%f ", &c);
if (r != 1)
error ("no s'han pogut llegir %d numerets del fitxer &%p\n",
quants, (void *) don);
on[i] = c;
}
}
static int
read_qnm_numbers (float *data, FILE * f, int n, int m, bool use_ascii)
{
if (use_ascii)
llegeix_floats_en_ascii (f, data, n);
else
{
if (m < 0x100)
llegeix_floats_en_bytes (f, data, n);
else if (m < 0x10000)
llegeix_floats_en_shorts (f, data, n);
else
error ("too large maxval %d", m);
}
// TODO: error checking
return n;
}
// qnm_types:
// 2 P2 (ascii 2d grayscale pgm)
// 5 P5 (binary 2d grayscale pgm)
// 3 P3 (ascii 2d color ppm)
// 6 P6 (binary 2d color ppm)
// 12 Q2 (ascii 3d grayscale pgm)
// 15 Q5 (binary 3d grayscale pgm)
// 13 Q3 (ascii 3d color ppm)
// 16 Q6 (binary 3d color ppm)
// 17 Q7 (ascii 3d nd )
// 19 Q9 (binary 3d nd )
static int
read_beheaded_qnm (struct iio_image *x, FILE * f, char *header, int nheader)
{
assert (nheader == 2);
int w, h, d = 1, m, pd = 1;
int c1 = header[0];
int c2 = header[1] - '0';
IIO_DEBUG ("QNM reader (%c %d)...\n", c1, c2);
menja_espais_i_comentaris (f);
if (1 != fscanf (f, "%d", &w))
return -1;
menja_espais_i_comentaris (f);
if (1 != fscanf (f, "%d", &h))
return -2;
if (c1 == 'Q')
{
if (1 != fscanf (f, "%d", &d))
return -3;
menja_espais_i_comentaris (f);
}
if (c2 == 7 || c2 == 9)
{
if (1 != fscanf (f, "%d", &pd))
return -4;
menja_espais_i_comentaris (f);
}
if (1 != fscanf (f, "%d", &m))
return -5;
// maxval is ignored and the image is always read into floats
if (!isspace (pilla_caracter_segur (f)))
return -6;
bool use_ascii = (c2 == 2 || c2 == 3 || c2 == 7);
bool use_2d = (d == 1);
if (!use_2d)
assert (c1 == 'Q');
if (c2 == 3 || c2 == 6)
pd = 3;
size_t nn = w * h * d * pd; // number of numbers
float *data = xmalloc (nn * sizeof *data);
IIO_DEBUG ("QNM reader w = %d\n", w);
IIO_DEBUG ("QNM reader h = %d\n", h);
IIO_DEBUG ("QNM reader d = %d\n", d);
IIO_DEBUG ("QNM reader pd = %d\n", pd);
IIO_DEBUG ("QNM reader m = %d\n", m);
IIO_DEBUG ("QNM reader use_2d = %d\n", use_2d);
IIO_DEBUG ("QNM reader use_ascii = %d\n", use_ascii);
int r = read_qnm_numbers (data, f, nn, m, use_ascii);
if (nn - r)
return -7;
x->dimension = use_2d ? 2 : 3;
x->sizes[0] = w;
x->sizes[1] = h;
if (d > 1)
x->sizes[2] = d;
x->pixel_dimension = pd;
x->type = IIO_TYPE_FLOAT;
x->contiguous_data = false;
x->data = data;
return 0;
}
// PCM reader {{{2
// PCM is a file format to store complex float images
// it is used by some people also for optical flow fields
static int
read_beheaded_pcm (struct iio_image *x, FILE * f, char *header, int nheader)
{
assert (nheader == 2);
int w, h;
float scale;
//menja_espais_i_comentaris(f);
if (1 != fscanf (f, " %d", &w))
return -1;
//menja_espais_i_comentaris(f);
if (1 != fscanf (f, " %d", &h))
return -2;
//menja_espais_i_comentaris(f);
if (1 != fscanf (f, " %g", &scale))
return -3;
if (!isspace (pilla_caracter_segur (f)))
return -6;
fprintf (stderr, "%d PCM w h scale = %d %d %g\n", nheader, w, h, scale);
assert (sizeof (float) == 4);
float *data = xmalloc (w * h * 2 * sizeof (float));
int r = fread (data, sizeof (float), w * h * 2, f);
if (r != w * h * 2)
return -7;
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = 2;
x->type = IIO_TYPE_FLOAT;
x->contiguous_data = false;
x->data = data;
return 0;
}
// RIM reader {{{2
// CIMAGE header bytes: ("IMG" format)
// short 0: 'MI'
// short 1: comment length
// short 2: image width
// short 3: image height
//
// FIMAGE header bytes: ("RIM" format)
// short 0: 'IR'
// short 1: comment length
// short 2: image width
// short 3: image height
//
// CCIMAGE header bytes: ("MTI" format)
//
//
//
static uint16_t
rim_getshort (FILE * f, bool swp)
{
int a = pilla_caracter_segur (f);
int b = pilla_caracter_segur (f);
IIO_DEBUG ("rgs %.2x%.2x\n", a, b);
assert (a >= 0);
assert (b >= 0);
assert (a < 256);
assert (b < 256);
uint16_t r = swp ? b * 0x100 + a : a * 0x100 + b;
return r;
}
// Note: different order than for shorts.
// Fascinating braindeadness.
static uint32_t
rim_getint (FILE * f, bool swp)
{
int a = pilla_caracter_segur (f);
int b = pilla_caracter_segur (f);
int c = pilla_caracter_segur (f);
int d = pilla_caracter_segur (f);
IIO_DEBUG ("rgi %.2x%.2x %.2x%.2x\n", a, b, c, d);
assert (a >= 0);
assert (b >= 0);
assert (c >= 0);
assert (d >= 0);
assert (a < 256);
assert (b < 256);
assert (c < 256);
assert (d < 256);
uint32_t r = swp ?
a * 0x1000000 + b * 0x10000 + c * 0x100 + d :
d * 0x1000000 + c * 0x10000 + b * 0x100 + a;
return r;
}
static int
read_beheaded_rim_cimage (struct iio_image *x, FILE * f, bool swp)
{
uint16_t lencomm = rim_getshort (f, swp);
uint16_t dx = rim_getshort (f, swp);
uint16_t dy = rim_getshort (f, swp);
IIO_DEBUG ("RIM READER lencomm = %d\n", (int) lencomm);
IIO_DEBUG ("RIM READER dx = %d\n", (int) dx);
IIO_DEBUG ("RIM READER dy = %d\n", (int) dy);
FORI (28) rim_getshort (f, swp); // skip shit (ascii numbers and zeros)
FORI (lencomm)
{
int c = pilla_caracter_segur (f); // skip further shit (comments)
IIO_DEBUG ("RIM READER comment[%d] = '%c'\n", i, c);
}
float *data = xmalloc (dx * dy);
size_t r = fread (data, 1, dx * dy, f);
if (r != (size_t) (dx * dy))
error ("could not read entire RIM file:\n"
"expected %zu chars, but got only %zu", (size_t) dx * dy, r);
int s[2] = { dx, dy };
iio_wrap_image_struct_around_data (x, 2, s, 1, IIO_TYPE_UINT8, data);
return 0;
}
static void
byteswap4 (void *data, int n)
{
char *t = data;
FORI (n)
{
char *t4 = t + 4 * i;
char tt[4] = { t4[3], t4[2], t4[1], t4[0] };
FORL (4) t4[l] = tt[l];
}
}
static int
read_beheaded_rim_fimage (struct iio_image *x, FILE * f, bool swp)
{
IIO_DEBUG ("rim reader fimage swp = %d", swp);
uint16_t lencomm = rim_getshort (f, swp);
uint16_t dx = rim_getshort (f, swp);
uint16_t dy = rim_getshort (f, swp);
//IIO_DEBUG("RIM READER lencomm = %d\n", (int)lencomm);
//IIO_DEBUG("RIM READER dx = %d\n", (int)dx);
//IIO_DEBUG("RIM READER dy = %d\n", (int)dy);
FORI (28) rim_getshort (f, swp); // skip shit (ascii numbers and zeros)
FORI (lencomm)
{
int c = pilla_caracter_segur (f); // skip further shit (comments)
//IIO_DEBUG("RIM READER comment[%d] = '%c'\n", i, c);
}
// now, read dx*dy floats
float *data = xmalloc (dx * dy * sizeof *data);
size_t r = fread (data, sizeof *data, dx * dy, f);
if (r != (size_t) (dx * dy))
error ("could not read entire RIM file:\n"
"expected %zu floats, but got only %zu", (size_t) dx * dy, r);
assert (sizeof (float) == 4);
if (swp)
byteswap4 (data, r);
int s[2] = { dx, dy };
iio_wrap_image_struct_around_data (x, 2, s, 1, IIO_TYPE_FLOAT, data);
return 0;
}
static int
read_beheaded_rim_ccimage (struct iio_image *x, FILE * f, bool swp)
{
uint16_t iv = rim_getshort (f, swp);
if (iv != 0x4956 && iv != 0x5649 && iv != 0x4557 && iv != 0x5745)
error ("bad ccimage header %x", (int) iv);
uint32_t pm_np = rim_getint (f, swp);
uint32_t pm_nrow = rim_getint (f, swp);
uint32_t pm_ncol = rim_getint (f, swp);
uint32_t pm_band = rim_getint (f, swp);
uint32_t pm_form = rim_getint (f, swp);
uint32_t pm_cmtsize = rim_getint (f, swp);
IIO_DEBUG ("RIM READER pm_np = %d\n", (int) pm_np);
IIO_DEBUG ("RIM READER pm_nrow = %d\n", (int) pm_nrow);
IIO_DEBUG ("RIM READER pm_ncol = %d\n", (int) pm_ncol);
IIO_DEBUG ("RIM READER pm_band = %d\n", (int) pm_band);
IIO_DEBUG ("RIM READER pm_form = %x\n", (int) pm_form);
IIO_DEBUG ("RIM READER pm_cmtsize = %d\n", (int) pm_cmtsize);
uint32_t nsamples = pm_np * pm_nrow * pm_ncol;
if (pm_form == 0x8001)
{ // ccimage
uint8_t *data = xmalloc (nsamples);
size_t r = fread (data, 1, nsamples, f);
if (r != nsamples)
error ("rim reader failed at reading %zu "
"samples (got only %zu)\n", (size_t) nsamples, r);
uint8_t *good_data = xmalloc (nsamples);
FORJ (pm_nrow) FORI (pm_ncol) FORL (pm_np)
good_data[l + (i + j * pm_ncol) * pm_np] =
data[i + j * pm_ncol + l * pm_ncol * pm_nrow];
xfree (data);
data = good_data;
int s[2] = { pm_ncol, pm_nrow };
iio_wrap_image_struct_around_data (x, 2, s, pm_np, IIO_TYPE_UINT8,
data);
}
else if (pm_form == 0xc004)
{ // cfimage
float *data = xmalloc (4 * nsamples);
size_t r = fread (data, 4, nsamples, f);
if (r != nsamples)
error ("rim reader failed at reading %zu "
"samples (got only %zu)\n", (size_t) nsamples, r);
float *good_data = xmalloc (4 * nsamples);
FORJ (pm_nrow) FORI (pm_ncol) FORL (pm_np)
good_data[l + (i + j * pm_ncol) * pm_np] =
data[i + j * pm_ncol + l * pm_ncol * pm_nrow];
xfree (data);
data = good_data;
int s[2] = { pm_ncol, pm_nrow };
iio_wrap_image_struct_around_data (x, 2, s, pm_np, IIO_TYPE_FLOAT,
data);
}
else
error ("unsupported PM_form %x", pm_form);
return 0;
}
static int
read_beheaded_rim (struct iio_image *x, FILE * f, char *h, int nh)
{
assert (nh == 2);
if (h[0] == 'I' && h[1] == 'R')
return read_beheaded_rim_fimage (x, f, false);
if (h[0] == 'R' && h[1] == 'I')
return read_beheaded_rim_fimage (x, f, true);
if (h[0] == 'M' && h[1] == 'I')
return read_beheaded_rim_cimage (x, f, false);
if (h[0] == 'I' && h[1] == 'M')
return read_beheaded_rim_cimage (x, f, true);
if (h[0] == 'W' && h[1] == 'E')
return read_beheaded_rim_ccimage (x, f, false);
if (h[0] == 'V' && h[1] == 'I')
return read_beheaded_rim_ccimage (x, f, true);
return 1;
}
static void
switch_4endianness (void *tt, int n)
{
char *t = tt;
FORI (n)
{
char tmp[4] = { t[0], t[1], t[2], t[3] };
t[0] = tmp[3];
t[1] = tmp[2];
t[2] = tmp[1];
t[3] = tmp[0];
t += 4;
}
}
// PFM reader {{{2
static int
read_beheaded_pfm (struct iio_image *x, FILE * f, char *header, int nheader)
{
assert (4 == sizeof (float));
assert (nheader == 2);
assert ('f' == tolower (header[1]));
int w, h, pd = isupper (header[1]) ? 3 : 1;
float scale;
if (!isspace (pilla_caracter_segur (f)))
return -1;
if (3 != fscanf (f, "%d %d\n%g", &w, &h, &scale))
return -2;
if (!isspace (pilla_caracter_segur (f)))
return -3;
float *data = xmalloc (w * h * 4 * pd);
if (1 != fread (data, w * h * 4 * pd, 1, f))
return -4;
//if (scale < 0) switch_4endianness(data, w*h*pd);
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = pd;
x->type = IIO_TYPE_FLOAT;
x->contiguous_data = false;
x->data = data;
return 0;
}
// FLO reader {{{2
static int
read_beheaded_flo (struct iio_image *x, FILE * f, char *header, int nheader)
{
int w = rim_getint (f, false);
int h = rim_getint (f, false);
float *data = xmalloc (w * h * 2 * sizeof *data);
if (1 != fread (data, w * h * 4 * 2, 1, f))
return -1;
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = 2;
x->type = IIO_TYPE_FLOAT;
x->contiguous_data = false;
x->data = data;
return 0;
}
// JUV reader {{{2
static int
read_beheaded_juv (struct iio_image *x, FILE * f, char *header, int nheader)
{
char buf[255];
FORI (nheader) buf[i] = header[i];
FORI (255 - nheader) buf[i + nheader] = pilla_caracter_segur (f);
int w, h, r = sscanf (buf, "#UV {\n dimx %d dimy %d\n}\n", &w, &h);
if (r != 2)
return -1;
size_t sf = sizeof (float);
float *u = xmalloc (w * h * sf);
r = fread (u, sf, w * h, f);
if (r != w * h)
return -2;
float *v = xmalloc (w * h * sf);
r = fread (v, sf, w * h, f);
if (r != w * h)
return -2;
float *uv = xmalloc (2 * w * h * sf);
FORI (w * h) uv[2 * i] = u[i];
FORI (w * h) uv[2 * i + 1] = v[i];
xfree (u);
xfree (v);
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = 2;
x->type = IIO_TYPE_FLOAT;
x->contiguous_data = false;
x->data = uv;
return 0;
}
// LUM reader {{{2
static int
lum_pickshort (char *ss)
{
uint8_t *s = (uint8_t *) ss;
int a = s[0];
int b = s[1];
return 0x100 * a + b;
}
static int
read_beheaded_lum (struct iio_image *x, FILE * f, char *header, int nheader)
{
int w = lum_pickshort (header + 2);
int h = lum_pickshort (header + 6);
while (nheader++ < 0xf94)
pilla_caracter_segur (f);
float *data = xmalloc (w * h * sizeof *data);
if (1 != fread (data, w * h * 4, 1, f))
return -1;
switch_4endianness (data, w * h);
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = 1;
x->type = IIO_TYPE_FLOAT;
x->contiguous_data = false;
x->data = data;
return 0;
}
// BMP reader {{{2
static int
read_beheaded_bmp (struct iio_image *x, FILE * f, char *header, int nheader)
{
long len;
char *bmp = load_rest_of_file (&len, f, header, nheader);
uint32_t pix_offset = *(uint32_t *) (bmp + 0xa);
error ("BMP reader not yet finished");
xfree (bmp);
//x->dimension = 2;
//x->sizes[0] = dib_width;
//x->sizes[1] = dib_height;
//x->pixel_dimension = 1;
//x->type = IIO_TYPE_FLOAT;
//x->contiguous_data = false;
//x->data = data;
return 0;
//fprintf(stderr, "bmp reader\n");
//uint32_t aoffset = *(uint32_t*)(header+0xa);
//fprintf(stderr, "aoffset = %d\n", aoffset);
//assert(nheader == 14); // ignore the file header
//uint32_t dib_size = rim_getint(f, false);
//fprintf(stderr, "dib_size = %d\n", dib_size);
//if (dib_size != 40) error("only windows-like bitmaps ara supported");
//int32_t dib_width = rim_getint(f, false);
//int32_t dib_height = rim_getint(f, false);
//uint16_t dib_planes = rim_getshort(f, true);
//uint16_t dib_bpp = rim_getshort(f, true);
//uint32_t dib_compression = rim_getint(f, false);
//fprintf(stderr, "w,h = %dx%d, bpp=%d (p=%d), compression=%d\n",
// dib_width, dib_height,
// dib_bpp, dib_planes, dib_compression);
////if (dib_planes != 1) error("BMP READER: only one plane is supported (not %d)", dib_planes);
//if (dib_compression) error("compressed BMP are not supported");
//uint32_t dib_imsize = rim_getint(f, false);
//int32_t dib_hres = rim_getint(f, false);
//int32_t dib_vres = rim_getint(f, false);
//uint32_t dib_ncolors = rim_getint(f, false);
//uint32_t dib_nicolors = rim_getint(f, false);
//fprintf(stderr, "ncolors = %d\n", dib_ncolors);
//error("fins aquí hem arribat!");
}
// EXR reader {{{2
#ifdef I_CAN_HAS_LIBEXR
#include <ImfCRgbaFile.h>
// EXTERNALIZED TO : read_exr_float.cpp
//extern int read_whole_exr(struct iio_image *x, char *filename);
static int
read_whole_exr (struct iio_image *x, char *filename)
{
struct ImfInputFile *f = ImfOpenInputFile (filename);
if (!f)
error ("could not read exr from %s", filename);
int r;
const char *nom = ImfInputFileName (f);
IIO_DEBUG ("ImfInputFileName returned %s\n", nom);
r = ImfInputChannels (f);
IIO_DEBUG ("ImfInputChannels returned %d\n", r);
// this data is only for information. The file is always
// converted to RGB
//if (r != IMF_WRITE_RGBA)
// error("only RGBA EXR supported so far (got %d)", r);
const struct ImfHeader *header = ImfInputHeader (f);
int xmin, ymin, xmax, ymax;
ImfHeaderDataWindow (header, &xmin, &ymin, &xmax, &ymax);
IIO_DEBUG ("xmin ymin xmax ymax = %d %d %d %d\n", xmin, ymin, xmax, ymax);
int width = xmax - xmin + 1;
int height = ymax - ymin + 1;
struct ImfRgba *data = xmalloc (width * height * sizeof *data);
r = ImfInputSetFrameBuffer (f, data, 1, width);
IIO_DEBUG ("ImfInputSetFrameBuffer returned %d\n", r);
r = ImfInputReadPixels (f, ymin, ymax);
IIO_DEBUG ("ImfInputReadPixels returned %d\n", r);
r = ImfCloseInputFile (f);
IIO_DEBUG ("ImfCloseInputFile returned %d\n", r);
float *finaldata = xmalloc (4 * width * height * sizeof *data);
FORI (width * height)
{
finaldata[4 * i + 0] = ImfHalfToFloat (data[i].r);
finaldata[4 * i + 1] = ImfHalfToFloat (data[i].g);
finaldata[4 * i + 2] = ImfHalfToFloat (data[i].b);
finaldata[4 * i + 3] = ImfHalfToFloat (data[i].a);
//IIO_DEBUG("read %d rgb %g %g %g\n", i, finaldata[3*i+0], finaldata[3*i+1], finaldata[3*i+2]);
}
xfree (data);
// fill struct fields
x->dimension = 2;
x->sizes[0] = width;
x->sizes[1] = height;
x->pixel_dimension = 4;
x->type = IIO_TYPE_FLOAT;
x->format = x->meta = -42;
x->data = finaldata;
x->contiguous_data = false;
return 0;
}
// Note: OpenEXR library only reads from a named file. The only way to use the
// library if you have your image in a stream, is to write the data to a
// temporary file, and read it from there. This can be optimized in the future
// by recovering the original filename through hacks, in case it was not a pipe.
static int
read_beheaded_exr (struct iio_image *x, FILE * fin, char *header, int nheader)
{
if (global_variable_containing_the_name_of_the_last_opened_file)
{
int r = read_whole_exr (x,
global_variable_containing_the_name_of_the_last_opened_file);
if (r)
error ("read whole tiff returned %d", r);
return 0;
}
long filesize;
void *filedata = load_rest_of_file (&filesize, fin, header, nheader);
char *filename = put_data_into_temporary_file (filedata, filesize);
xfree (filedata);
//IIO_DEBUG("tmpfile = \"%s\"\n", filename);
int r = read_whole_exr (x, filename);
if (r)
error ("read whole exr returned %d", r);
delete_temporary_file (filename);
return 0;
}
#endif //I_CAN_HAS_LIBEXR
// WHATEVER reader {{{2
//static int read_image(struct iio_image*, const char *);
static int read_image_f (struct iio_image *, FILE *);
static int
read_beheaded_whatever (struct iio_image *x,
FILE * fin, char *header, int nheader)
{
// dump data to file
long filesize;
void *filedata = load_rest_of_file (&filesize, fin, header, nheader);
char *filename = put_data_into_temporary_file (filedata, filesize);
xfree (filedata);
//IIO_DEBUG("tmpfile = \"%s\"\n", filename);
//char command_format[] = "convert - %s < %s\0";
char command_format[] = "/usr/bin/convert - %s < %s\0";
char ppmname[strlen (filename) + 5];
sprintf (ppmname, "%s.ppm", filename);
char command[strlen (command_format) + 1 + 2 * strlen (filename)];
sprintf (command, command_format, ppmname, filename);
IIO_DEBUG ("COMMAND: %s\n", command);
int r = system (command);
IIO_DEBUG ("command returned %d\n", r);
if (r)
error ("could not run command \"%s\" successfully", command);
FILE *f = xfopen (ppmname, "r");
r = read_image_f (x, f);
xfclose (f);
delete_temporary_file (filename);
delete_temporary_file (ppmname);
return r;
}
// individual format writers {{{1
// PNG writer {{{2
#ifdef I_CAN_HAS_LIBPNG
static void
iio_save_image_as_png (const char *filename, struct iio_image *x)
{
png_structp pp = png_create_write_struct (PNG_LIBPNG_VER_STRING, 0, 0, 0);
if (!pp)
error ("png_create_write_struct fail");
png_infop pi = png_create_info_struct (pp);
if (!pi)
error ("png_create_info_struct fail");
if (setjmp (png_jmpbuf (pp)))
error ("png write error");
if (x->dimension != 2)
error ("can only save 2d images");
int width = x->sizes[0];
int height = x->sizes[1];
int bit_depth = 0;
switch (normalize_type (x->type))
{
case IIO_TYPE_UINT16:
case IIO_TYPE_INT16:
bit_depth = 16;
break;
case IIO_TYPE_INT8:
case IIO_TYPE_UINT8:
bit_depth = 8;
break;
default:
error ("can not yet save samples of type %s as PNG",
iio_strtyp (x->type));
}
assert (bit_depth > 0);
int color_type = PNG_COLOR_TYPE_PALETTE;
switch (x->pixel_dimension)
{
case 1:
color_type = PNG_COLOR_TYPE_GRAY;
break;
case 2:
color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
break;
case 3:
color_type = PNG_COLOR_TYPE_RGB;
break;
case 4:
color_type = PNG_COLOR_TYPE_RGB_ALPHA;
break;
default:
error ("can not save %d-dimensional samples as PNG",
x->pixel_dimension);
}
assert (color_type != PNG_COLOR_TYPE_PALETTE);
FILE *f = xfopen (filename, "w");
png_init_io (pp, f);
int ss = bit_depth / 8;
int pd = x->pixel_dimension;
png_bytepp row = xmalloc (height * sizeof (png_bytep));
FORI (height) row[i] = i * pd * width * ss + (uint8_t *) x->data;
png_set_IHDR (pp, pi, width, height, bit_depth, color_type,
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
png_set_rows (pp, pi, row);
int transforms = PNG_TRANSFORM_IDENTITY;
png_write_png (pp, pi, transforms, NULL);
xfclose (f);
png_destroy_write_struct (&pp, &pi);
xfree (row);
}
#endif //I_CAN_HAS_LIBPNG
// TIFF writer {{{2
#ifdef I_CAN_HAS_LIBTIFF
static void
iio_save_image_as_tiff (const char *filename, struct iio_image *x)
{
//fprintf(stderr, "saving image as tiff file \"%s\"\n", filename);
if (x->dimension != 2)
error ("only 2d images can be saved as TIFFs");
TIFF *tif = TIFFOpen (filename, "w");
if (!tif)
error ("could not open TIFF file \"%s\"", filename);
int ss = iio_image_sample_size (x);
int sls = x->sizes[0] * x->pixel_dimension * ss;
int tsf;
TIFFSetField (tif, TIFFTAG_IMAGEWIDTH, x->sizes[0]);
TIFFSetField (tif, TIFFTAG_IMAGELENGTH, x->sizes[1]);
TIFFSetField (tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField (tif, TIFFTAG_SAMPLESPERPIXEL, x->pixel_dimension);
TIFFSetField (tif, TIFFTAG_BITSPERSAMPLE, ss * 8);
uint16 caca[1] = { EXTRASAMPLE_UNASSALPHA };
switch (x->pixel_dimension)
{
case 1:
TIFFSetField (tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
break;
case 3:
TIFFSetField (tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
break;
case 2:
TIFFSetField (tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
//TIFFSetField(tif, TIFFTAG_EXTRASAMPLES, 1, caca);
break;
case 4:
TIFFSetField (tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
TIFFSetField (tif, TIFFTAG_EXTRASAMPLES, 1, caca);
break;
default:
TIFFSetField (tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
//error("bad pixel dimension %d for TIFF", x->pixel_dimension);
}
/////TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
TIFFSetField (tif, TIFFTAG_COMPRESSION, COMPRESSION_LZW);
//TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
switch (x->type)
{
case IIO_TYPE_FLOAT:
tsf = SAMPLEFORMAT_IEEEFP;
break;
case IIO_TYPE_INT8:
case IIO_TYPE_INT16:
case IIO_TYPE_INT32:
tsf = SAMPLEFORMAT_INT;
break;
case IIO_TYPE_UINT8:
case IIO_TYPE_UINT16:
case IIO_TYPE_UINT32:
tsf = SAMPLEFORMAT_UINT;
break;
default:
error ("can not save samples of type %s on tiff file",
iio_strtyp (x->type));
}
TIFFSetField (tif, TIFFTAG_SAMPLEFORMAT, tsf);
FORI (x->sizes[1])
{
void *line = i * sls + (char *) x->data;
int r = TIFFWriteScanline (tif, line, i, 0);
if (r < 0)
error ("error writing %dth TIFF scanline", i);
}
TIFFClose (tif);
}
static void
iio_save_image_as_tiff_smarter (const char *filename, struct iio_image *x)
{
char *tiffname = strstr (filename, "TIFF:");
if (tiffname == filename)
{
iio_save_image_as_tiff_smarter (filename + 5, x);
return;
}
if (0 == strcmp (filename, "-"))
{
#ifdef I_CAN_HAS_MKSTEMP
static char tfn[] = "/tmp/iio_temporal_tiff_XXXXXX\0";
int r = mkstemp (tfn);
if (r == -1)
error ("caca [tiff smarter]");
#else
static char buf[L_tmpnam + 1];
char *tfn = tmpnam (buf);
#endif //I_CAN_HAS_MKSTEMP
iio_save_image_as_tiff (tfn, x);
FILE *f = xfopen (tfn, "r");
int c;
while ((c = fgetc (f)) != EOF)
fputc (c, stdout);
fclose (f);
delete_temporary_file (tfn);
}
else
iio_save_image_as_tiff (filename, x);
}
#endif //I_CAN_HAS_LIBTIFF
// JUV writer {{{2
static void
iio_save_image_as_juv (const char *filename, struct iio_image *x)
{
assert (x->type == IIO_TYPE_FLOAT);
assert (x->dimension == 2);
char buf[255];
FORI (255) buf[i] = ' ';
snprintf (buf, 255, "#UV {\n dimx %d dimy %d\n}\n",
x->sizes[0], x->sizes[1]);
size_t sf = sizeof (float);
int w = x->sizes[0];
int h = x->sizes[1];
float *uv = x->data;
float *u = xmalloc (w * h * sf);
FORI (w * h) u[i] = uv[2 * i];
float *v = xmalloc (w * h * sf);
FORI (w * h) v[i] = uv[2 * i + 1];
FILE *f = xfopen (filename, "w");
fwrite (buf, 1, 255, f);
fwrite (u, sf, w * h, f);
fwrite (v, sf, w * h, f);
xfclose (f);
xfree (u);
xfree (v);
}
// FLO writer {{{2
static void
iio_save_image_as_flo (const char *filename, struct iio_image *x)
{
assert (x->type == IIO_TYPE_FLOAT);
assert (x->dimension == 2);
union
{
char s[4];
float f;
} pieh =
{
"PIEH"};
assert (sizeof (float) == 4);
assert (pieh.f == 202021.25);
uint32_t w = x->sizes[0];
uint32_t h = x->sizes[1];
FILE *f = xfopen (filename, "w");
fwrite (&pieh.f, 4, 1, f);
fwrite (&w, 4, 1, f);
fwrite (&h, 4, 1, f);
fwrite (x->data, 4, w * h * 2, f);
xfclose (f);
}
// RIM writer {{{2
static void
rim_putshort (FILE * f, uint16_t n)
{
int a = n % 0x100;
int b = n / 0x100;
assert (a >= 0);
assert (b >= 0);
assert (a < 256);
assert (b < 256);
fputc (b, f);
fputc (a, f);
}
static void
iio_save_image_as_rim_fimage (const char *fname, struct iio_image *x)
{
if (x->type != IIO_TYPE_FLOAT)
error ("fimage expects float data");
if (x->dimension != 2)
error ("fimage expects 2d image");
if (x->pixel_dimension != 1)
error ("fimage expects gray image");
FILE *f = xfopen (fname, "w");
fputc ('I', f);
fputc ('R', f);
rim_putshort (f, 2);
rim_putshort (f, x->sizes[0]);
rim_putshort (f, x->sizes[1]);
FORI (29) rim_putshort (f, 0);
int r = fwrite (x->data, sizeof (float), x->sizes[0] * x->sizes[1], f);
if (r != x->sizes[0] * x->sizes[1])
error ("could not write an entire fimage for some reason");
xfclose (f);
}
static void
iio_save_image_as_rim_cimage (const char *fname, struct iio_image *x)
{
if (x->type != IIO_TYPE_UINT8)
error ("cimage expects byte data");
if (x->dimension != 2)
error ("cimage expects 2d image");
if (x->pixel_dimension != 1)
error ("cimage expects gray image");
FILE *f = xfopen (fname, "w");
fputc ('M', f);
fputc ('I', f);
rim_putshort (f, 2);
rim_putshort (f, x->sizes[0]);
rim_putshort (f, x->sizes[1]);
FORI (29) rim_putshort (f, 0);
int r = fwrite (x->data, 1, x->sizes[0] * x->sizes[1], f);
if (r != x->sizes[0] * x->sizes[1])
error ("could not write an entire cimage for some reason");
xfclose (f);
}
// guess format using magic {{{1
static char
add_to_header_buffer (FILE * f, uint8_t * buf, int *nbuf, int bufmax)
{
int c = pilla_caracter_segur (f);
if (*nbuf >= bufmax)
error ("buffer header too small (%d)", bufmax);
buf[*nbuf] = c; //iw810
IIO_DEBUG ("ATHB[%d] = %x \"%c\"\n", *nbuf, c, c);
*nbuf += 1;
return c;
}
static int
guess_format (FILE * f, char *buf, int *nbuf, int bufmax)
{
assert (sizeof (uint8_t) == sizeof (char));
uint8_t *b = (uint8_t *) buf;
*nbuf = 0;
//
// program a state machine here
//
b[0] = add_to_header_buffer (f, b, nbuf, bufmax);
b[1] = add_to_header_buffer (f, b, nbuf, bufmax);
if (b[0] == 'P' || b[0] == 'Q')
if (b[1] >= '1' && b[1] <= '9')
return IIO_FORMAT_QNM;
if (b[0] == 'P' && (b[1] == 'F' || b[1] == 'f'))
return IIO_FORMAT_PFM;
#ifdef I_CAN_HAS_LIBTIFF
if ((b[0] == 'M' && buf[1] == 'M') || (b[0] == 'I' && buf[1] == 'I'))
return IIO_FORMAT_TIFF;
#endif //I_CAN_HAS_LIBTIFF
if (b[0] == 'I' && b[1] == 'R')
return IIO_FORMAT_RIM;
if (b[0] == 'R' && b[1] == 'I')
return IIO_FORMAT_RIM;
if (b[0] == 'M' && b[1] == 'I')
return IIO_FORMAT_RIM;
if (b[0] == 'I' && b[1] == 'M')
return IIO_FORMAT_RIM;
if (b[0] == 'W' && b[1] == 'E')
return IIO_FORMAT_RIM;
if (b[0] == 'V' && b[1] == 'I')
return IIO_FORMAT_RIM;
if (b[0] == 'P' && b[1] == 'C')
return IIO_FORMAT_PCM;
if (b[0] == 'B' && b[1] == 'M')
{
FORI (12) add_to_header_buffer (f, b, nbuf, bufmax);
return IIO_FORMAT_BMP;
}
b[2] = add_to_header_buffer (f, b, nbuf, bufmax);
b[3] = add_to_header_buffer (f, b, nbuf, bufmax);
#ifdef I_CAN_HAS_LIBPNG
if (b[1] == 'P' && b[2] == 'N' && b[3] == 'G')
return IIO_FORMAT_PNG;
#endif //I_CAN_HAS_LIBPNG
#ifdef I_CAN_HAS_LIBEXR
if (b[0] == 0x76 && b[1] == 0x2f && b[2] == 0x31 && b[3] == 0x01)
return IIO_FORMAT_EXR;
#endif //I_CAN_HAS_LIBEXR
if (b[0] == '#' && b[1] == 'U' && b[2] == 'V')
return IIO_FORMAT_JUV;
if (b[0] == 'P' && b[1] == 'I' && b[2] == 'E' && b[3] == 'H')
return IIO_FORMAT_FLO;
b[4] = add_to_header_buffer (f, b, nbuf, bufmax);
b[5] = add_to_header_buffer (f, b, nbuf, bufmax);
b[6] = add_to_header_buffer (f, b, nbuf, bufmax);
b[7] = add_to_header_buffer (f, b, nbuf, bufmax);
#ifdef I_CAN_HAS_LIBJPEG
if (b[0] == 0xff && b[1] == 0xd8 && b[2] == 0xff)
{
if (b[3] == 0xe0 && b[6] == 'J' && b[7] == 'F')
return IIO_FORMAT_JPEG;
if (b[3] == 0xe1 && b[6] == 'E' && b[7] == 'x')
return IIO_FORMAT_JPEG;
}
#endif //I_CAN_HAS_LIBPNG
b[8] = add_to_header_buffer (f, b, nbuf, bufmax);
b[9] = add_to_header_buffer (f, b, nbuf, bufmax);
b[10] = add_to_header_buffer (f, b, nbuf, bufmax);
b[11] = add_to_header_buffer (f, b, nbuf, bufmax);
if (b[8] == 'F' && b[9] == 'L' && b[10] == 'O' && b[11] == 'A')
return IIO_FORMAT_LUM;
return IIO_FORMAT_UNRECOGNIZED;
}
// dispatcher {{{1
// "centralized dispatcher"
static int
read_beheaded_image (struct iio_image *x, FILE * f, char *h, int hn, int fmt)
{
IIO_DEBUG ("rbi fmt = %d\n", fmt);
// these functions can be defined in separate, independent files
switch (fmt)
{
case IIO_FORMAT_QNM:
return read_beheaded_qnm (x, f, h, hn);
case IIO_FORMAT_RIM:
return read_beheaded_rim (x, f, h, hn);
case IIO_FORMAT_PFM:
return read_beheaded_pfm (x, f, h, hn);
case IIO_FORMAT_FLO:
return read_beheaded_flo (x, f, h, hn);
case IIO_FORMAT_JUV:
return read_beheaded_juv (x, f, h, hn);
case IIO_FORMAT_LUM:
return read_beheaded_lum (x, f, h, hn);
case IIO_FORMAT_PCM:
return read_beheaded_pcm (x, f, h, hn);
case IIO_FORMAT_BMP:
return read_beheaded_bmp (x, f, h, hn);
#ifdef I_CAN_HAS_LIBPNG
case IIO_FORMAT_PNG:
return read_beheaded_png (x, f, h, hn);
#endif
#ifdef I_CAN_HAS_LIBJPEG
case IIO_FORMAT_JPEG:
return read_beheaded_jpeg (x, f, h, hn);
#endif
#ifdef I_CAN_HAS_LIBTIFF
case IIO_FORMAT_TIFF:
return read_beheaded_tiff (x, f, h, hn);
#endif
#ifdef I_CAN_HAS_LIBEXR
case IIO_FORMAT_EXR:
return read_beheaded_exr (x, f, h, hn);
#endif
/*
case IIO_FORMAT_JP2: return read_beheaded_jp2 (x, f, h, hn);
case IIO_FORMAT_VTK: return read_beheaded_vtk (x, f, h, hn);
case IIO_FORMAT_CIMG: return read_beheaded_cimg(x, f, h, hn);
case IIO_FORMAT_PAU: return read_beheaded_pau (x, f, h, hn);
case IIO_FORMAT_DICOM: return read_beheaded_dicom(x, f, h, hn);
case IIO_FORMAT_NIFTI: return read_beheaded_nifti(x, f, h, hn);
case IIO_FORMAT_PCX: return read_beheaded_pcx (x, f, h, hn);
case IIO_FORMAT_GIF: return read_beheaded_gif (x, f, h, hn);
case IIO_FORMAT_XPM: return read_beheaded_xpm (x, f, h, hn);
case IIO_FORMAT_RAFA: return read_beheaded_rafa (x, f, h, hn);
*/
//#ifdef I_CAN_HAS_WHATEVER
case IIO_FORMAT_UNRECOGNIZED:
return read_beheaded_whatever (x, f, h, hn);
//#else
// case IIO_FORMAT_UNRECOGNIZED: return -2;
//#endif
default:
return -17;
}
}
// general image reader {{{1
//
// This function is the core of the library.
// Everything passes through here.
//
static int
read_image_f (struct iio_image *x, FILE * f)
{
int bufmax = 0x100, nbuf, format;
char buf[bufmax];
format = guess_format (f, buf, &nbuf, bufmax);
IIO_DEBUG ("iio file format guess: %s {%d}\n", iio_strfmt (format), nbuf);
assert (nbuf > 0);
return read_beheaded_image (x, f, buf, nbuf, format);
}
static int
read_image (struct iio_image *x, const char *fname)
{
#ifndef IIO_ABORT_ON_ERROR
if (setjmp (global_jump_buffer))
{
IIO_DEBUG ("SOME ERROR HAPPENED AND WAS HANDLED\n");
return 1;
}
//if (iio_single_jmpstuff(false, true)) {
// IIO_DEBUG("SOME ERROR HAPPENED AND WAS HANDLED\n");
// exit(42);
//}
#endif //IIO_ABORT_ON_ERROR
FILE *f = xfopen (fname, "r");
int r = read_image_f (x, f);
fclose (f);
IIO_DEBUG ("READ IMAGE return value = %d\n", r);
IIO_DEBUG ("READ IMAGE dimension = %d\n", x->dimension);
switch (x->dimension)
{
case 1:
IIO_DEBUG ("READ IMAGE sizes = %d\n", x->sizes[0]);
break;
case 2:
IIO_DEBUG ("READ IMAGE sizes = %d x %d\n", x->sizes[0], x->sizes[1]);
break;
case 3:
IIO_DEBUG ("READ IMAGE sizes = %d x %d x %d\n", x->sizes[0],
x->sizes[1], x->sizes[2]);
break;
case 4:
IIO_DEBUG ("READ IMAGE sizes = %d x %d x %d x %d\n", x->sizes[0],
x->sizes[1], x->sizes[2], x->sizes[3]);
break;
default:
error ("caca [dimension = %d]", x->dimension);
}
//FORI(x->dimension) IIO_DEBUG(" %d", x->sizes[i]);
//IIO_DEBUG("\n");
IIO_DEBUG ("READ IMAGE pixel_dimension = %d\n", x->pixel_dimension);
IIO_DEBUG ("READ IMAGE type = %s\n", iio_strtyp (x->type));
//IIO_DEBUG("READ IMAGE meta = %d\n", x->meta);
//IIO_DEBUG("READ IMAGE format = %d\n", x->format);
IIO_DEBUG ("READ IMAGE contiguous_data = %d\n", x->contiguous_data);
return r;
}
static void iio_save_image_default (const char *filename,
struct iio_image *x);
// API (input) {{{1
static void *
rerror (const char *fmt, ...)
{
#ifdef IIO_ABORT_ON_ERROR
va_list argp;
va_start (argp, fmt);
error (fmt, argp);
va_end (argp);
#endif
return NULL;
}
// 2D only
static void *
iio_read_image (const char *fname, int *w, int *h, int desired_sample_type)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
//error("non 2d image");
}
*w = x->sizes[0];
*h = x->sizes[1];
iio_convert_samples (x, desired_sample_type);
return x->data;
}
// API 2D
float *
iio_read_image_float_vec (const char *fname, int *w, int *h, int *pd)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
//error("non 2d image");
}
*w = x->sizes[0];
*h = x->sizes[1];
*pd = x->pixel_dimension;
iio_convert_samples (x, IIO_TYPE_FLOAT);
return x->data;
}
// API 2D
float *
iio_read_image_float_split (const char *fname, int *w, int *h, int *pd)
{
float *r = iio_read_image_float_vec (fname, w, h, pd);
float *rbroken = xmalloc (*w ** h ** pd * sizeof *rbroken);
break_pixels_float (rbroken, r, *w ** h, *pd);
xfree (r);
return rbroken;
}
// API 2D
float *
iio_read_image_float_rgb (const char *fname, int *w, int *h)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
return rerror ("non 2d image");
}
if (x->pixel_dimension != 3)
{
iio_hacky_colorize (x, 3);
}
*w = x->sizes[0];
*h = x->sizes[1];
iio_convert_samples (x, IIO_TYPE_FLOAT);
return x->data;
}
// API 2D
double *
iio_read_image_double_vec (const char *fname, int *w, int *h, int *pd)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
//error("non 2d image");
}
*w = x->sizes[0];
*h = x->sizes[1];
*pd = x->pixel_dimension;
iio_convert_samples (x, IIO_TYPE_DOUBLE);
return x->data;
}
// API 2D
uint8_t *
iio_read_image_uint8_vec (const char *fname, int *w, int *h, int *pd)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
}
*w = x->sizes[0];
*h = x->sizes[1];
*pd = x->pixel_dimension;
iio_convert_samples (x, IIO_TYPE_UINT8);
return x->data;
}
// API 2D
uint16_t *
iio_read_image_uint16_vec (const char *fname, int *w, int *h, int *pd)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
}
*w = x->sizes[0];
*h = x->sizes[1];
*pd = x->pixel_dimension;
iio_convert_samples (x, IIO_TYPE_UINT16);
return x->data;
}
// API 2D
uint8_t (*iio_read_image_uint8_rgb (const char *fname, int *w, int *h))[3]
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
error ("non 2d image");
}
if (x->pixel_dimension != 3)
error ("non-color image");
*w = x->sizes[0];
*h = x->sizes[1];
iio_convert_samples (x, IIO_TYPE_UINT8);
return x->data;
}
// API 2D
uint8_t (**iio_read_image_uint8_matrix_rgb (const char *fnam, int *w, int *h))
[3]
{
struct iio_image x[1];
int r = read_image (x, fnam);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
return rerror ("non 2d image");
}
if (x->pixel_dimension != 3)
{
iio_hacky_colorize (x, 3);
}
*w = x->sizes[0];
*h = x->sizes[1];
iio_convert_samples (x, IIO_TYPE_UINT8);
return wrap_2dmatrix_around_data (x->data, *w, *h, 3);
}
// API 2D
float (**iio_read_image_float_matrix_rgb (const char *fnam, int *w, int *h))
[3]
{
struct iio_image x[1];
int r = read_image (x, fnam);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
return rerror ("non 2d image");
}
if (x->pixel_dimension != 3)
{
iio_hacky_colorize (x, 3);
}
*w = x->sizes[0];
*h = x->sizes[1];
iio_convert_samples (x, IIO_TYPE_FLOAT);
return wrap_2dmatrix_around_data (x->data, *w, *h, 3 * sizeof (float));
}
// API 2D
uint8_t ***
iio_read_image_uint8_matrix_vec (const char *fname, int *w, int *h, int *pd)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
return rerror ("non 2d image");
}
*w = x->sizes[0];
*h = x->sizes[1];
*pd = x->pixel_dimension;
fprintf (stderr, "matrix_vec pd = %d\n", *pd);
iio_convert_samples (x, IIO_TYPE_UINT8);
return wrap_2dmatrix_around_data (x->data, *w, *h, *pd);
}
// API 2D
void *
iio_read_image_float_matrix_vec (const char *fname, int *w, int *h, int *pd)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
return rerror ("non 2d image");
}
*w = x->sizes[0];
*h = x->sizes[1];
*pd = x->pixel_dimension;
iio_convert_samples (x, IIO_TYPE_FLOAT);
return wrap_2dmatrix_around_data (x->data, *w, *h, *pd * sizeof (float));
}
// API 2D
uint8_t **
iio_read_image_uint8_matrix (const char *fname, int *w, int *h)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
return rerror ("non 2d image");
}
if (x->pixel_dimension == 3)
iio_hacky_uncolorize (x);
if (x->pixel_dimension != 1)
error ("non-scalar image");
*w = x->sizes[0];
*h = x->sizes[1];
iio_convert_samples (x, IIO_TYPE_UINT8);
return wrap_2dmatrix_around_data (x->data, *w, *h, 1);
//return x->data;
// WRONG!:
//uint8_t *f = iio_read_image_uint8(fname, w, h);
//uint8_t **a = wrap_2dmatrix_around_data(f, *w, *h, sizeof*f);
//return a;
}
float **
iio_read_image_float_matrix (const char *fname, int *w, int *h)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
return rerror ("non 2d image");
}
if (x->pixel_dimension == 3)
iio_hacky_uncolorize (x);
if (x->pixel_dimension != 1)
return rerror ("non-scalar image");
*w = x->sizes[0];
*h = x->sizes[1];
iio_convert_samples (x, IIO_TYPE_FLOAT);
return wrap_2dmatrix_around_data (x->data, *w, *h, sizeof (float));
}
// API nd general
void *
iio_read_nd_image_as_stored (char *fname,
int *dimension, int *sizes,
int *samples_per_pixel, int *sample_size,
bool * ieefp_samples, bool * signed_samples)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("so much fail");
*dimension = x->dimension;
FORI (x->dimension) sizes[i] = x->sizes[i];
*samples_per_pixel = x->pixel_dimension;
iio_type_unid (sample_size, ieefp_samples, signed_samples, x->type);
return x->data;
}
// API nd general
void *
iio_read_nd_image_as_desired (char *fname,
int *dimension, int *sizes,
int *samples_per_pixel, int desired_sample_size,
bool desired_ieeefp_samples,
bool desired_signed_samples)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("so much fail");
int desired_type = iio_type_id (desired_sample_size,
desired_ieeefp_samples,
desired_signed_samples);
iio_convert_samples (x, desired_type);
*dimension = x->dimension;
FORI (x->dimension) sizes[i] = x->sizes[i];
*samples_per_pixel = x->pixel_dimension;
return x->data;
}
//// API 2D general
//void *iio_read_image_numbers_as_they_are_stored(char *fname, int *w, int *h,
// int *samples_per_pixel, int *sample_size,
// bool *ieeefp_samples, bool *signed_samples)
//{
//}
// API 2D
float *
iio_read_image_float (const char *fname, int *w, int *h)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
return rerror ("non 2d image");
}
if (x->pixel_dimension == 3)
iio_hacky_uncolorize (x);
if (x->pixel_dimension == 4)
iio_hacky_uncolorizea (x);
if (x->pixel_dimension != 1)
return rerror ("non-scalarizable image");
*w = x->sizes[0];
*h = x->sizes[1];
iio_convert_samples (x, IIO_TYPE_FLOAT);
return x->data;
}
// API 2D
double *
iio_read_image_double (const char *fname, int *w, int *h)
{
struct iio_image x[1];
int r = read_image (x, fname);
if (r)
return rerror ("could not read image");
if (x->dimension != 2)
{
x->dimension = 2;
return rerror ("non 2d image");
}
if (x->pixel_dimension == 3)
iio_hacky_uncolorize (x);
if (x->pixel_dimension != 1)
return rerror ("non-scalar image");
*w = x->sizes[0];
*h = x->sizes[1];
iio_convert_samples (x, IIO_TYPE_DOUBLE);
return x->data;
}
//// API 2D
//char *iio_read_image_char(const char *fname, int *w, int *h)
//{
// return iio_read_image(fname, w, h, IIO_TYPE_CHAR);
//}
// API 2D
uint8_t *
iio_read_image_uint8 (const char *fname, int *w, int *h)
{
return iio_read_image (fname, w, h, IIO_TYPE_UINT8);
}
// API 2D
//float **iio_read_image_float_matrix(const char *fname, int *w, int *h)
//{
// float *f = iio_read_image_float(fname, w, h);
// float **a = wrap_2dmatrix_around_data(f, *w, *h, sizeof*f);
// return a;
//}
// API (output) {{{1
static bool
this_float_is_actually_a_byte (float x)
{
return (x == floorf (x)) && (x >= 0) && (x < 256);
}
static bool
these_floats_are_actually_bytes (float *t, int n)
{
IIO_DEBUG ("checking %d floats for byteness (%p)\n", n, (void *) t);
FORI (n) if (!this_float_is_actually_a_byte (t[i]))
return false;
return true;
}
//// returns the un-prefixed string, or NULL
//static const char *hasprefix(const char *haystack, const char *needle)
//{
// const char *r = strstr(haystack, needle);
// if (r == haystack)
// return r + strlen(needle);
// else
// return NULL;
//}
//
//// returns the first argument, or NULL
//static const char *hassufix(const char *haystack, const char *needle)
//{
// const char *r =
//}
static bool
string_suffix (const char *s, const char *suf)
{
int len_s = strlen (s);
int len_suf = strlen (suf);
if (len_s < len_suf)
return false;
return 0 == strcmp (suf, s + (len_s - len_suf));
}
// Note:
// This function was written without being designed. See file "saving.txt" for
// an attempt at designing it.
static void
iio_save_image_default (const char *filename, struct iio_image *x)
{
int typ = normalize_type (x->type);
if (x->dimension != 2)
error ("de moment només escrivim 2D");
//static bool silly = true;
if (string_suffix (filename, ".uv") && typ == IIO_TYPE_FLOAT
&& x->pixel_dimension == 2)
{
iio_save_image_as_juv (filename, x);
return;
}
if (string_suffix (filename, ".flo") && typ == IIO_TYPE_FLOAT
&& x->pixel_dimension == 2)
{
iio_save_image_as_flo (filename, x);
return;
}
if (string_suffix (filename, ".mw") && typ == IIO_TYPE_FLOAT
&& x->pixel_dimension == 1)
{
iio_save_image_as_rim_fimage (filename, x);
return;
}
if (string_suffix (filename, ".mw") && typ == IIO_TYPE_UINT8
&& x->pixel_dimension == 1)
{
iio_save_image_as_rim_cimage (filename, x);
return;
}
if (x->pixel_dimension != 1 && x->pixel_dimension != 3
&& x->pixel_dimension != 4 && x->pixel_dimension != 2)
{
iio_save_image_as_tiff_smarter (filename, x);
return;
//error("de moment només escrivim gris ó RGB");
}
if (typ != IIO_TYPE_FLOAT && typ != IIO_TYPE_UINT8 && typ != IIO_TYPE_INT16
&& typ != IIO_TYPE_INT8)
error ("de moment només fem floats o bytes (got %d)", typ);
int nsamp = iio_image_number_of_samples (x);
if (typ == IIO_TYPE_FLOAT &&
these_floats_are_actually_bytes (x->data, nsamp))
{
void *old_data = x->data;
x->data = xmalloc (nsamp * sizeof (float));
memcpy (x->data, old_data, nsamp * sizeof (float));
iio_convert_samples (x, IIO_TYPE_UINT8);
//silly=false;
iio_save_image_default (filename, x); // recursive call
//silly=true;
xfree (x->data);
x->data = old_data;
return;
}
if (true)
{
if (false
|| string_suffix (filename, ".tiff")
|| string_suffix (filename, ".tif")
|| string_suffix (filename, ".TIFF")
|| string_suffix (filename, ".TIF"))
{
iio_save_image_as_tiff_smarter (filename, x);
return;
}
}
if (true)
{
char *tiffname = strstr (filename, "TIFF:");
if (tiffname == filename)
{
iio_save_image_as_tiff_smarter (filename + 5, x);
return;
}
}
if (true)
{
char *pngname = strstr (filename, "PNG:");
if (pngname == filename)
{
if (typ == IIO_TYPE_FLOAT)
{
void *old_data = x->data;
x->data = xmalloc (nsamp * sizeof (float));
memcpy (x->data, old_data, nsamp * sizeof (float));
iio_convert_samples (x, IIO_TYPE_UINT8);
iio_save_image_default (filename, x); //recursive
xfree (x->data);
x->data = old_data;
return;
}
iio_save_image_as_png (filename + 4, x);
return;
}
}
if (true)
{
if (false
|| string_suffix (filename, ".png")
|| string_suffix (filename, ".PNG")
|| (typ == IIO_TYPE_UINT8 && x->pixel_dimension == 4)
// || (typ==IIO_TYPE_FLOAT&&x->pixel_dimension==4)
|| (typ == IIO_TYPE_UINT8 && x->pixel_dimension == 2)
// || (typ==IIO_TYPE_FLOAT&&x->pixel_dimension==2)
)
{
if (typ == IIO_TYPE_FLOAT)
{
void *old_data = x->data;
x->data = xmalloc (nsamp * sizeof (float));
memcpy (x->data, old_data, nsamp * sizeof (float));
iio_convert_samples (x, IIO_TYPE_UINT8);
iio_save_image_default (filename, x); //recursive
xfree (x->data);
x->data = old_data;
return;
}
iio_save_image_as_png (filename, x);
return;
}
}
IIO_DEBUG ("SIDEF:\n");
#ifdef IIO_SHOW_DEBUG_MESSAGES
iio_print_image_info (stderr, x);
#endif
FILE *f = xfopen (filename, "w");
if (x->pixel_dimension == 1 && typ == IIO_TYPE_FLOAT)
{
int m =
these_floats_are_actually_bytes (x->data,
x->sizes[0] *
x->sizes[1]) ? 255 : 65535;
fprintf (f, "P2\n%d %d\n%d\n", x->sizes[0], x->sizes[1], m);
float *data = x->data;
FORI (x->sizes[0] * x->sizes[1]) fprintf (f, "%a\n", data[i]);
}
else if (x->pixel_dimension == 3 && typ == IIO_TYPE_FLOAT)
{
int m =
these_floats_are_actually_bytes (x->data,
3 * x->sizes[0] *
x->sizes[1]) ? 255 : 65535;
float *data = x->data;
fprintf (f, "P3\n%d %d\n%d\n", x->sizes[0], x->sizes[1], m);
FORI (3 * x->sizes[0] * x->sizes[1])
{
fprintf (f, "%g\n", data[i]);
}
}
else if (x->pixel_dimension == 3 && typ == IIO_TYPE_UINT8)
{
uint8_t *data = x->data;
int w = x->sizes[0];
int h = x->sizes[1];
if (w * h <= 10000)
{
fprintf (f, "P3\n%d %d\n255\n", w, h);
FORI (3 * w * h)
{
int datum = data[i];
fprintf (f, "%d\n", datum);
}
}
else
{
fprintf (f, "P6\n%d %d\n255\n", w, h);
fwrite (data, 3 * w * h, 1, f);
}
}
else if (x->pixel_dimension == 4 && typ == IIO_TYPE_UINT8)
{
fprintf (stderr, "IIO WARNING: assuming 4 chanels mean RGBA\n");
uint8_t *data = x->data;
fprintf (f, "P3\n%d %d\n255\n", x->sizes[0], x->sizes[1]);
//error("write correctly here");
FORI (4 * x->sizes[0] * x->sizes[1])
{
if (i % 4 == 3)
continue;
int datum = data[i];
fprintf (f, "%d\n", datum);
}
}
else if (x->pixel_dimension == 1 && typ == IIO_TYPE_UINT8)
{
uint8_t *data = x->data;
int w = x->sizes[0];
int h = x->sizes[1];
if (w * h <= 10000)
{
fprintf (f, "P2\n%d %d\n255\n", w, h);
FORI (w * h)
{
int datum = data[i];
fprintf (f, "%d\n", datum);
}
}
else
{
fprintf (f, "P5\n%d %d\n255\n", w, h);
fwrite (data, w * h, 1, f);
}
}
else
iio_save_image_as_tiff_smarter (filename, x);
// error("\n\n\nThis particular data format can not yet be saved."
// "\nPlease, ask enric.\n");
xfclose (f);
}
void
iio_save_image_uint8_matrix_rgb (char *filename, uint8_t (**data)[3],
int w, int h)
{
struct iio_image x[1];
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = 3;
x->type = IIO_TYPE_UINT8;
x->data = data[0][0];
iio_save_image_default (filename, x);
}
void
iio_save_image_uint8_matrix (char *filename, uint8_t ** data, int w, int h)
{
struct iio_image x[1];
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = 1;
x->type = IIO_TYPE_UINT8;
x->data = data[0];
iio_save_image_default (filename, x);
}
void
iio_save_image_float_vec (char *filename, float *data, int w, int h, int pd)
{
struct iio_image x[1];
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = pd;
x->type = IIO_TYPE_FLOAT;
x->data = data;
x->contiguous_data = false;
iio_save_image_default (filename, x);
}
void
iio_save_image_float_split (char *filename, float *data, int w, int h, int pd)
{
float *rdata = xmalloc (w * h * pd * sizeof *rdata);
recover_broken_pixels_float (rdata, data, w * h, pd);
iio_save_image_float_vec (filename, rdata, w, h, pd);
xfree (rdata);
}
void
iio_save_image_double_vec (char *filename, double *data, int w, int h, int pd)
{
struct iio_image x[1];
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = pd;
x->type = IIO_TYPE_DOUBLE;
x->data = data;
x->contiguous_data = false;
iio_save_image_default (filename, x);
}
void
iio_save_image_float (char *filename, float *data, int w, int h)
{
struct iio_image x[1];
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = 1;
x->type = IIO_TYPE_FLOAT;
x->data = data;
x->contiguous_data = false;
iio_save_image_default (filename, x);
}
void
iio_save_image_double (char *filename, double *data, int w, int h)
{
struct iio_image x[1];
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = 1;
x->type = IIO_TYPE_DOUBLE;
x->data = data;
x->contiguous_data = false;
iio_save_image_default (filename, x);
}
void
iio_save_image_uint8_vec (char *filename, uint8_t * data,
int w, int h, int pd)
{
struct iio_image x[1];
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = pd;
x->type = IIO_TYPE_UINT8;
x->data = data;
x->contiguous_data = false;
iio_save_image_default (filename, x);
}
void
iio_save_image_uint16_vec (char *filename, uint16_t * data,
int w, int h, int pd)
{
struct iio_image x[1];
x->dimension = 2;
x->sizes[0] = w;
x->sizes[1] = h;
x->pixel_dimension = pd;
x->type = IIO_TYPE_UINT16;
x->data = data;
x->contiguous_data = false;
iio_save_image_default (filename, x);
}
// misc debugging stuff {{{1
//void try_iio(void);
//void try_iio(void)
//{
//#ifdef _XOPEN_SOURCE
// IIO_DEBUG("IIO compiled with _XOPEN_SOURCE = %d\n",_XOPEN_SOURCE);
//#endif
// int w, h;
// float **t = iio_read_image_float_matrix("-", &w, &h);
// printf("we read a %dx%d image!\n", w, h);
// xfree(t);
//
// /*
// FILE *f = stdin;
// struct iio_image x[1]; read_image_f(x, f);
// printf("we read a %dx%d image!\n", x->sizes[0], x->sizes[1]);
// iio_print_image_info(stdout, x);
// xfree(x->data);
// */
// /*
// FILE *f = stdin;
// struct iio_image *x = read_whole_jpeg(f);
// printf("we read a %dx%d jpg!\n", x->sizes[0], x->sizes[1]);
// unsigned char *data = x->data;
// FORJ(x->sizes[1]) FORI(x->sizes[0])
// FORL(x->pixel_dimension)
// printf("%g%c", (float)data[(x->sizes[0]*j+i)*x->pixel_dimension+l],
// l==x->pixel_dimension-1?'\n':' ');
// xfree(x);
// */
// /*
// FILE *f = stdin;
// //struct iio_image x[1];
// char buf[4];
// FORI(4) buf[i] = fgetc(f);
// struct iio_image *x = read_beheaded_image_png(f, buf, 4);
// printf("we read a %dx%d png!\n", x->sizes[0], x->sizes[1]);
// float *data = x->data;
// //FORJ(x->sizes[1]) FORI(x->sizes[0])
// // FORL(x->pixel_dimension)
// // printf("%g%c", data[(x->sizes[0]*j+i)*x->pixel_dimension+l],
// // l==x->pixel_dimension-1?'\n':' ');
// xfree(x);
// */
//}
// }}}1
// vim:set foldmethod=marker:
