1766 lines
39 KiB
C
1766 lines
39 KiB
C
#include "Eet.h"
|
|
#define _GNU_SOURCE /* need this for fmemopen & open_memstream */
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <limits.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
#include <sys/types.h>
|
|
#include <fcntl.h>
|
|
#include <netinet/in.h>
|
|
#include <zlib.h>
|
|
#include <string.h>
|
|
#include <fnmatch.h>
|
|
#include <jpeglib.h>
|
|
#include <setjmp.h>
|
|
#include <zlib.h>
|
|
#include <locale.h>
|
|
|
|
|
|
/*
|
|
* rotuines for doing data -> struct and struct -> data conversion
|
|
*
|
|
* types:
|
|
*
|
|
* basic types:
|
|
* a sequence of...
|
|
*
|
|
* char
|
|
* short
|
|
* int
|
|
* long long
|
|
* float
|
|
* double
|
|
* unsigned char
|
|
* unsigned short
|
|
* unsigned int
|
|
* unsgined long long
|
|
* string
|
|
*
|
|
* groupings:
|
|
* multiple entries ordered as...
|
|
*
|
|
* fixed size array [ of basic types ]
|
|
* variable size array [ of basic types ]
|
|
* linked list [ of basic types ]
|
|
* hash table [ of basic types ]
|
|
*
|
|
* need to provide builder/accessor funcs for:
|
|
*
|
|
* list_next
|
|
* list_append
|
|
*
|
|
* hash_foreach
|
|
* hash_add
|
|
*
|
|
*/
|
|
|
|
/*---*/
|
|
|
|
typedef struct _Eet_Data_Element Eet_Data_Element;
|
|
typedef struct _Eet_Data_Basic_Type_Decoder Eet_Data_Basic_Type_Decoder;
|
|
typedef struct _Eet_Data_Chunk Eet_Data_Chunk;
|
|
typedef struct _Eet_Data_Stream Eet_Data_Stream;
|
|
typedef struct _JPEG_error_mgr *emptr;
|
|
|
|
/*---*/
|
|
|
|
struct _Eet_Data_Basic_Type_Decoder
|
|
{
|
|
int size;
|
|
int (*get) (void *src, void *src_end, void *dest);
|
|
void *(*put) (void *src, int *size_ret);
|
|
};
|
|
|
|
struct _Eet_Data_Chunk
|
|
{
|
|
char *name;
|
|
int size;
|
|
void *data;
|
|
};
|
|
|
|
struct _Eet_Data_Stream
|
|
{
|
|
void *data;
|
|
int size;
|
|
int pos;
|
|
};
|
|
|
|
struct _Eet_Data_Descriptor
|
|
{
|
|
char *name;
|
|
int size;
|
|
struct {
|
|
void *(*list_next) (void *l);
|
|
void *(*list_append) (void *l, void *d);
|
|
void *(*list_data) (void *l);
|
|
void (*hash_foreach) (void *h, int (*func) (void *h, const char *k, void *dt, void *fdt), void *fdt);
|
|
void *(*hash_add) (void *h, const char *k, void *d);
|
|
} func;
|
|
struct {
|
|
int num;
|
|
Eet_Data_Element *set;
|
|
} elements;
|
|
};
|
|
|
|
struct _Eet_Data_Element
|
|
{
|
|
char *name;
|
|
int type;
|
|
int group_type;
|
|
int offset;
|
|
int count;
|
|
char *counter_name;
|
|
Eet_Data_Descriptor *subtype;
|
|
};
|
|
|
|
struct _JPEG_error_mgr
|
|
{
|
|
struct jpeg_error_mgr pub;
|
|
jmp_buf setjmp_buffer;
|
|
};
|
|
|
|
/*---*/
|
|
|
|
static void _JPEGFatalErrorHandler(j_common_ptr cinfo);
|
|
static void _JPEGErrorHandler(j_common_ptr cinfo);
|
|
static void _JPEGErrorHandler2(j_common_ptr cinfo, int msg_level);
|
|
|
|
static void *eet_data_image_jpeg_rgb_decode(void *data, int size, int *w, int *h);
|
|
static void *eet_data_image_jpeg_alpha_decode(void *data, int size, unsigned int *d, int *w, int *h);
|
|
static void *eet_data_image_lossless_convert(int *size, void *data, int w, int h, int alpha);
|
|
static void *eet_data_image_lossless_compressed_convert(int *size, void *data, int w, int h, int alpha, int compression);
|
|
static void *eet_data_image_jpeg_convert(int *size, void *data, int w, int h, int alpha, int quality);
|
|
static void *eet_data_image_jpeg_alpha_convert(int *size, void *data, int w, int h, int alpha, int quality);
|
|
|
|
static int eet_data_get_char(void *src, void *src_end, void *dest);
|
|
static void *eet_data_put_char(void *src, int *size_ret);
|
|
static int eet_data_get_short(void *src, void *src_end, void *dest);
|
|
static void *eet_data_put_short(void *src, int *size_ret);
|
|
static int eet_data_get_int(void *src, void *src_end, void *dest);
|
|
static void *eet_data_put_int(void *src, int *size_ret);
|
|
static int eet_data_get_long_long(void *src, void *src_end, void *dest);
|
|
static void *eet_data_put_long_long(void *src, int *size_ret);
|
|
static int eet_data_get_float(void *src, void *src_end, void *dest);
|
|
static void *eet_data_put_float(void *src, int *size_ret);
|
|
static int eet_data_get_double(void *src, void *src_end, void *dest);
|
|
static void *eet_data_put_double(void *src, int *size_ret);
|
|
static int eet_data_get_string(void *src, void *src_end, void *dest);
|
|
static void *eet_data_put_string(void *src, int *size_ret);
|
|
|
|
static int eet_data_get_type(int type, void *src, void *src_end, void *dest);
|
|
static void *eet_data_put_type(int type, void *src, int *size_ret);
|
|
|
|
static Eet_Data_Chunk *eet_data_chunk_get(void *src, int size);
|
|
static Eet_Data_Chunk *eet_data_chunk_new(void *data, int size, char *name);
|
|
static void eet_data_chunk_free(Eet_Data_Chunk *chnk);
|
|
|
|
static Eet_Data_Stream *eet_data_stream_new(void);
|
|
static void eet_data_stream_write(Eet_Data_Stream *ds, void *data, int size);
|
|
static void eet_data_stream_free(Eet_Data_Stream *ds);
|
|
|
|
static void eet_data_chunk_put(Eet_Data_Chunk *chnk, Eet_Data_Stream *ds);
|
|
|
|
/*---*/
|
|
|
|
const Eet_Data_Basic_Type_Decoder eet_coder[] =
|
|
{
|
|
{sizeof(char), eet_data_get_char, eet_data_put_char },
|
|
{sizeof(short), eet_data_get_short, eet_data_put_short },
|
|
{sizeof(int), eet_data_get_int, eet_data_put_int },
|
|
{sizeof(long long), eet_data_get_long_long, eet_data_put_long_long},
|
|
{sizeof(float), eet_data_get_float, eet_data_put_float },
|
|
{sizeof(double), eet_data_get_double, eet_data_put_double },
|
|
{sizeof(char), eet_data_get_char, eet_data_put_char },
|
|
{sizeof(short), eet_data_get_short, eet_data_put_short },
|
|
{sizeof(int), eet_data_get_int, eet_data_put_int },
|
|
{sizeof(long long), eet_data_get_long_long, eet_data_put_long_long},
|
|
{sizeof(char *), eet_data_get_string, eet_data_put_string }
|
|
};
|
|
|
|
static int words_bigendian = -1;
|
|
|
|
/*---*/
|
|
|
|
#define SWAP64(x) (x) = \
|
|
((((x) & 0x00000000000000ff ) << 56) |\
|
|
(((x) & 0x000000000000ff00 ) << 40) |\
|
|
(((x) & 0x0000000000ff0000 ) << 24) |\
|
|
(((x) & 0x00000000ff000000 ) << 8) |\
|
|
(((x) & 0x000000ff00000000 ) >> 8) |\
|
|
(((x) & 0x0000ff0000000000 ) >> 24) |\
|
|
(((x) & 0x00ff000000000000 ) >> 40) |\
|
|
(((x) & 0xff00000000000000 ) >> 56))
|
|
#define SWAP32(x) (x) = \
|
|
((((x) & 0x000000ff ) << 24) |\
|
|
(((x) & 0x0000ff00 ) << 8) |\
|
|
(((x) & 0x00ff0000 ) >> 8) |\
|
|
(((x) & 0xff000000 ) >> 24))
|
|
#define SWAP16(x) (x) = \
|
|
((((x) & 0x00ff ) << 8) |\
|
|
(((x) & 0xff00 ) >> 8))
|
|
|
|
#define CONV8(x)
|
|
#define CONV16(x) {if (words_bigendian) SWAP16(x);}
|
|
#define CONV32(x) {if (words_bigendian) SWAP32(x);}
|
|
#define CONV64(x) {if (words_bigendian) SWAP64(x);}
|
|
|
|
/*---*/
|
|
|
|
static void
|
|
_JPEGFatalErrorHandler(j_common_ptr cinfo)
|
|
{
|
|
emptr errmgr;
|
|
|
|
errmgr = (emptr) cinfo->err;
|
|
/* cinfo->err->output_message(cinfo);*/
|
|
longjmp(errmgr->setjmp_buffer, 1);
|
|
return;
|
|
}
|
|
|
|
static void
|
|
_JPEGErrorHandler(j_common_ptr cinfo)
|
|
{
|
|
emptr errmgr;
|
|
|
|
errmgr = (emptr) cinfo->err;
|
|
/* cinfo->err->output_message(cinfo);*/
|
|
/* longjmp(errmgr->setjmp_buffer, 1);*/
|
|
return;
|
|
}
|
|
|
|
static void
|
|
_JPEGErrorHandler2(j_common_ptr cinfo, int msg_level)
|
|
{
|
|
emptr errmgr;
|
|
|
|
errmgr = (emptr) cinfo->err;
|
|
/* cinfo->err->output_message(cinfo);*/
|
|
/* longjmp(errmgr->setjmp_buffer, 1);*/
|
|
return;
|
|
msg_level = 0;
|
|
}
|
|
|
|
static void *
|
|
eet_data_image_jpeg_rgb_decode(void *data, int size, int *w, int *h)
|
|
{
|
|
unsigned int *d;
|
|
struct jpeg_decompress_struct cinfo;
|
|
struct _JPEG_error_mgr jerr;
|
|
unsigned char *ptr, *line[16], *tdata;
|
|
unsigned int *ptr2;
|
|
int x, y, l, i, scans, count, prevy;
|
|
FILE *f;
|
|
|
|
f = fmemopen(data, (size_t)size, "r");
|
|
if (!f) return NULL;
|
|
cinfo.err = jpeg_std_error(&(jerr.pub));
|
|
jerr.pub.error_exit = _JPEGFatalErrorHandler;
|
|
jerr.pub.emit_message = _JPEGErrorHandler2;
|
|
jerr.pub.output_message = _JPEGErrorHandler;
|
|
if (setjmp(jerr.setjmp_buffer))
|
|
{
|
|
jpeg_destroy_decompress(&cinfo);
|
|
fclose(f);
|
|
return NULL;
|
|
}
|
|
jpeg_create_decompress(&cinfo);
|
|
jpeg_stdio_src(&cinfo, f);
|
|
jpeg_read_header(&cinfo, TRUE);
|
|
cinfo.do_fancy_upsampling = FALSE;
|
|
cinfo.do_block_smoothing = FALSE;
|
|
jpeg_start_decompress(&cinfo);
|
|
|
|
/* head decoding */
|
|
*w = cinfo.output_width;
|
|
*h = cinfo.output_height;
|
|
/* end head decoding */
|
|
/* data decoding */
|
|
if (cinfo.rec_outbuf_height > 16)
|
|
{
|
|
jpeg_destroy_decompress(&cinfo);
|
|
fclose(f);
|
|
return NULL;
|
|
}
|
|
tdata = malloc((*w) * 16 * 3);
|
|
if (!tdata)
|
|
{
|
|
jpeg_destroy_decompress(&cinfo);
|
|
fclose(f);
|
|
return NULL;
|
|
}
|
|
d = malloc((*w) * (*h) * 4);
|
|
if (!d)
|
|
{
|
|
free(tdata);
|
|
jpeg_destroy_decompress(&cinfo);
|
|
fclose(f);
|
|
return NULL;
|
|
}
|
|
ptr2 = d;
|
|
count = 0;
|
|
prevy = 0;
|
|
if (cinfo.output_components == 3)
|
|
{
|
|
for (i = 0; i < cinfo.rec_outbuf_height; i++)
|
|
line[i] = tdata + (i * (*w) * 3);
|
|
for (l = 0; l < (*h); l += cinfo.rec_outbuf_height)
|
|
{
|
|
jpeg_read_scanlines(&cinfo, line, cinfo.rec_outbuf_height);
|
|
scans = cinfo.rec_outbuf_height;
|
|
if (((*h) - l) < scans) scans = (*h) - l;
|
|
ptr = tdata;
|
|
for (y = 0; y < scans; y++)
|
|
{
|
|
for (x = 0; x < (*w); x++)
|
|
{
|
|
*ptr2 =
|
|
(0xff000000) | ((ptr[0]) << 16) | ((ptr[1]) << 8) | (ptr[2]);
|
|
ptr += 3;
|
|
ptr2++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (cinfo.output_components == 1)
|
|
{
|
|
for (i = 0; i < cinfo.rec_outbuf_height; i++)
|
|
line[i] = tdata + (i * (*w));
|
|
for (l = 0; l < (*h); l += cinfo.rec_outbuf_height)
|
|
{
|
|
jpeg_read_scanlines(&cinfo, line, cinfo.rec_outbuf_height);
|
|
scans = cinfo.rec_outbuf_height;
|
|
if (((*h) - l) < scans) scans = (*h) - l;
|
|
ptr = tdata;
|
|
for (y = 0; y < scans; y++)
|
|
{
|
|
for (x = 0; x < (*w); x++)
|
|
{
|
|
*ptr2 =
|
|
(0xff000000) | ((ptr[0]) << 16) | ((ptr[0]) << 8) | (ptr[0]);
|
|
ptr++;
|
|
ptr2++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
free(tdata);
|
|
fclose(f);
|
|
/* end data decoding */
|
|
jpeg_finish_decompress(&cinfo);
|
|
jpeg_destroy_decompress(&cinfo);
|
|
return d;
|
|
}
|
|
|
|
static void *
|
|
eet_data_image_jpeg_alpha_decode(void *data, int size, unsigned int *d, int *w, int *h)
|
|
{
|
|
struct jpeg_decompress_struct cinfo;
|
|
struct _JPEG_error_mgr jerr;
|
|
unsigned char *ptr, *line[16], *tdata;
|
|
unsigned int *ptr2;
|
|
int x, y, l, i, scans, count, prevy;
|
|
FILE *f;
|
|
|
|
f = fmemopen(data, (size_t)size, "r");
|
|
if (!f) return NULL;
|
|
cinfo.err = jpeg_std_error(&(jerr.pub));
|
|
jerr.pub.error_exit = _JPEGFatalErrorHandler;
|
|
jerr.pub.emit_message = _JPEGErrorHandler2;
|
|
jerr.pub.output_message = _JPEGErrorHandler;
|
|
if (setjmp(jerr.setjmp_buffer))
|
|
{
|
|
jpeg_destroy_decompress(&cinfo);
|
|
fclose(f);
|
|
return NULL;
|
|
}
|
|
jpeg_create_decompress(&cinfo);
|
|
jpeg_stdio_src(&cinfo, f);
|
|
jpeg_read_header(&cinfo, TRUE);
|
|
cinfo.do_fancy_upsampling = FALSE;
|
|
cinfo.do_block_smoothing = FALSE;
|
|
jpeg_start_decompress(&cinfo);
|
|
|
|
/* head decoding */
|
|
if ((*w) != cinfo.output_width)
|
|
{
|
|
jpeg_destroy_decompress(&cinfo);
|
|
fclose(f);
|
|
return NULL;
|
|
}
|
|
if ((*h) != cinfo.output_height)
|
|
{
|
|
jpeg_destroy_decompress(&cinfo);
|
|
fclose(f);
|
|
return NULL;
|
|
}
|
|
*w = cinfo.output_width;
|
|
*h = cinfo.output_height;
|
|
/* end head decoding */
|
|
/* data decoding */
|
|
if (cinfo.rec_outbuf_height > 16)
|
|
{
|
|
jpeg_destroy_decompress(&cinfo);
|
|
fclose(f);
|
|
return NULL;
|
|
}
|
|
tdata = malloc((*w) * 16 * 3);
|
|
if (!tdata)
|
|
{
|
|
jpeg_destroy_decompress(&cinfo);
|
|
fclose(f);
|
|
return NULL;
|
|
}
|
|
ptr2 = d;
|
|
count = 0;
|
|
prevy = 0;
|
|
if (cinfo.output_components == 3)
|
|
{
|
|
for (i = 0; i < cinfo.rec_outbuf_height; i++)
|
|
line[i] = tdata + (i * (*w) * 3);
|
|
for (l = 0; l < (*h); l += cinfo.rec_outbuf_height)
|
|
{
|
|
jpeg_read_scanlines(&cinfo, line, cinfo.rec_outbuf_height);
|
|
scans = cinfo.rec_outbuf_height;
|
|
if (((*h) - l) < scans) scans = (*h) - l;
|
|
ptr = tdata;
|
|
for (y = 0; y < scans; y++)
|
|
{
|
|
for (x = 0; x < (*w); x++)
|
|
{
|
|
*ptr2 =
|
|
((*ptr2) & 0x00ffffff) |
|
|
(((ptr[0] + ptr[1] + ptr[2]) / 3) << 24);
|
|
ptr += 3;
|
|
ptr2++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (cinfo.output_components == 1)
|
|
{
|
|
for (i = 0; i < cinfo.rec_outbuf_height; i++)
|
|
line[i] = tdata + (i * (*w));
|
|
for (l = 0; l < (*h); l += cinfo.rec_outbuf_height)
|
|
{
|
|
jpeg_read_scanlines(&cinfo, line, cinfo.rec_outbuf_height);
|
|
scans = cinfo.rec_outbuf_height;
|
|
if (((*h) - l) < scans) scans = (*h) - l;
|
|
ptr = tdata;
|
|
for (y = 0; y < scans; y++)
|
|
{
|
|
for (x = 0; x < (*w); x++)
|
|
{
|
|
*ptr2 =
|
|
((*ptr2) & 0x00ffffff) |
|
|
((ptr[0]) << 24);
|
|
ptr++;
|
|
ptr2++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
free(tdata);
|
|
fclose(f);
|
|
/* end data decoding */
|
|
jpeg_finish_decompress(&cinfo);
|
|
jpeg_destroy_decompress(&cinfo);
|
|
return d;
|
|
}
|
|
|
|
static void *
|
|
eet_data_image_lossless_convert(int *size, void *data, int w, int h, int alpha)
|
|
{
|
|
if (words_bigendian == -1)
|
|
{
|
|
unsigned long int v;
|
|
|
|
v = htonl(0x12345678);
|
|
if (v == 0x12345678) words_bigendian = 1;
|
|
else words_bigendian = 0;
|
|
}
|
|
{
|
|
unsigned char *d;
|
|
int *header;
|
|
|
|
d = malloc((w * h * 4) + (8 * 4));
|
|
if (!d) return NULL;
|
|
header = (int *)d;
|
|
header[0] = 0xac1dfeed;
|
|
header[1] = w;
|
|
header[2] = h;
|
|
header[3] = alpha;
|
|
header[4] = 0;
|
|
memcpy(d + 32, data, w * h * 4);
|
|
|
|
if (words_bigendian)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ((w * h) + 8); i++) SWAP32(header[i]);
|
|
}
|
|
*size = ((w * h * 4) + (8 * 4));
|
|
return d;
|
|
}
|
|
}
|
|
|
|
static void *
|
|
eet_data_image_lossless_compressed_convert(int *size, void *data, int w, int h, int alpha, int compression)
|
|
{
|
|
if (words_bigendian == -1)
|
|
{
|
|
unsigned long int v;
|
|
|
|
v = htonl(0x12345678);
|
|
if (v == 0x12345678) words_bigendian = 1;
|
|
else words_bigendian = 0;
|
|
}
|
|
|
|
{
|
|
unsigned char *d;
|
|
unsigned char *comp;
|
|
int *header;
|
|
int ret;
|
|
uLongf buflen;
|
|
|
|
d = malloc((w * h * 4) + (8 * 4));
|
|
if (!d) return NULL;
|
|
buflen = (((w * h * 101) / 100) + 3) * 4;
|
|
comp = malloc(buflen);
|
|
if (!comp)
|
|
{
|
|
free(d);
|
|
return NULL;
|
|
}
|
|
header = (int *)d;
|
|
header[0] = 0xac1dfeed;
|
|
header[1] = w;
|
|
header[2] = h;
|
|
header[3] = alpha;
|
|
header[4] = compression;
|
|
memcpy(d + 32, data, w * h * 4);
|
|
|
|
if (words_bigendian)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ((w * h) + 8); i++) SWAP32(header[i]);
|
|
}
|
|
ret = compress2((Bytef *)comp, &buflen,
|
|
(Bytef *)(d + 32),
|
|
(uLong)(w * h * 4),
|
|
compression);
|
|
if (buflen > (w * h * 4))
|
|
{
|
|
free(comp);
|
|
*size = ((w * h * 4) + (8 * 4));
|
|
return d;
|
|
}
|
|
memcpy(d + 32, comp, buflen);
|
|
*size = (8 * 4) + buflen;
|
|
free(comp);
|
|
return d;
|
|
}
|
|
}
|
|
|
|
static void *
|
|
eet_data_image_jpeg_convert(int *size, void *data, int w, int h, int alpha, int quality)
|
|
{
|
|
int *ptr;
|
|
char *d = NULL;
|
|
size_t sz = 0;
|
|
struct _JPEG_error_mgr jerr;
|
|
JSAMPROW *jbuf;
|
|
struct jpeg_compress_struct cinfo;
|
|
FILE *f;
|
|
unsigned char *buf;
|
|
|
|
f = open_memstream(&d, &sz);
|
|
if (!f) return NULL;
|
|
|
|
buf = malloc(3 * w);
|
|
if (!buf)
|
|
{
|
|
fclose(f);
|
|
if (d) free(d);
|
|
return NULL;
|
|
}
|
|
|
|
cinfo.err = jpeg_std_error(&(jerr.pub));
|
|
jerr.pub.error_exit = _JPEGFatalErrorHandler;
|
|
jerr.pub.emit_message = _JPEGErrorHandler2;
|
|
jerr.pub.output_message = _JPEGErrorHandler;
|
|
if (setjmp(jerr.setjmp_buffer))
|
|
{
|
|
jpeg_destroy_compress(&cinfo);
|
|
if (buf) free(buf);
|
|
fclose(f);
|
|
if (d) free(d);
|
|
return NULL;
|
|
}
|
|
jpeg_create_compress(&cinfo);
|
|
jpeg_stdio_dest(&cinfo, f);
|
|
cinfo.image_width = w;
|
|
cinfo.image_height = h;
|
|
cinfo.input_components = 3;
|
|
cinfo.in_color_space = JCS_RGB;
|
|
jpeg_set_defaults(&cinfo);
|
|
jpeg_set_quality(&cinfo, quality, TRUE);
|
|
jpeg_start_compress(&cinfo, TRUE);
|
|
|
|
ptr = data;
|
|
while (cinfo.next_scanline < cinfo.image_height)
|
|
{
|
|
int i, j;
|
|
|
|
/* convert scaline from ARGB to RGB packed */
|
|
for (j = 0, i = 0; i < w; i++)
|
|
{
|
|
buf[j++] = ((*ptr) >> 16) & 0xff;
|
|
buf[j++] = ((*ptr) >> 8) & 0xff;
|
|
buf[j++] = ((*ptr)) & 0xff;
|
|
ptr++;
|
|
}
|
|
jbuf = (JSAMPROW *) (&buf);
|
|
jpeg_write_scanlines(&cinfo, jbuf, 1);
|
|
}
|
|
|
|
jpeg_finish_compress(&cinfo);
|
|
jpeg_destroy_compress(&cinfo);
|
|
|
|
*size = sz;
|
|
if (buf) free(buf);
|
|
fclose(f);
|
|
return d;
|
|
}
|
|
|
|
static void *
|
|
eet_data_image_jpeg_alpha_convert(int *size, void *data, int w, int h, int alpha, int quality)
|
|
{
|
|
unsigned char *d1, *d2;
|
|
unsigned char *d;
|
|
int *header;
|
|
int sz1, sz2;
|
|
|
|
if (words_bigendian == -1)
|
|
{
|
|
unsigned long int v;
|
|
|
|
v = htonl(0x12345678);
|
|
if (v == 0x12345678) words_bigendian = 1;
|
|
else words_bigendian = 0;
|
|
}
|
|
|
|
{
|
|
int *ptr;
|
|
char *d = NULL;
|
|
size_t sz = 0;
|
|
struct _JPEG_error_mgr jerr;
|
|
JSAMPROW *jbuf;
|
|
struct jpeg_compress_struct cinfo;
|
|
FILE *f;
|
|
unsigned char *buf;
|
|
|
|
f = open_memstream(&d, &sz);
|
|
if (!f) return NULL;
|
|
|
|
buf = malloc(3 * w);
|
|
if (!buf)
|
|
{
|
|
fclose(f);
|
|
if (d) free(d);
|
|
return NULL;
|
|
}
|
|
|
|
cinfo.err = jpeg_std_error(&(jerr.pub));
|
|
jerr.pub.error_exit = _JPEGFatalErrorHandler;
|
|
jerr.pub.emit_message = _JPEGErrorHandler2;
|
|
jerr.pub.output_message = _JPEGErrorHandler;
|
|
if (setjmp(jerr.setjmp_buffer))
|
|
{
|
|
jpeg_destroy_compress(&cinfo);
|
|
if (buf) free(buf);
|
|
fclose(f);
|
|
if (d) free(d);
|
|
return NULL;
|
|
}
|
|
jpeg_create_compress(&cinfo);
|
|
jpeg_stdio_dest(&cinfo, f);
|
|
cinfo.image_width = w;
|
|
cinfo.image_height = h;
|
|
cinfo.input_components = 3;
|
|
cinfo.in_color_space = JCS_RGB;
|
|
jpeg_set_defaults(&cinfo);
|
|
jpeg_set_quality(&cinfo, quality, TRUE);
|
|
jpeg_start_compress(&cinfo, TRUE);
|
|
|
|
ptr = data;
|
|
while (cinfo.next_scanline < cinfo.image_height)
|
|
{
|
|
int i, j;
|
|
|
|
/* convert scaline from ARGB to RGB packed */
|
|
for (j = 0, i = 0; i < w; i++)
|
|
{
|
|
buf[j++] = ((*ptr) >> 16) & 0xff;
|
|
buf[j++] = ((*ptr) >> 8) & 0xff;
|
|
buf[j++] = ((*ptr)) & 0xff;
|
|
ptr++;
|
|
}
|
|
jbuf = (JSAMPROW *) (&buf);
|
|
jpeg_write_scanlines(&cinfo, jbuf, 1);
|
|
}
|
|
|
|
jpeg_finish_compress(&cinfo);
|
|
jpeg_destroy_compress(&cinfo);
|
|
|
|
if (buf) free(buf);
|
|
fclose(f);
|
|
d1 = d;
|
|
sz1 = sz;
|
|
}
|
|
{
|
|
int *ptr;
|
|
char *d = NULL;
|
|
size_t sz = 0;
|
|
struct _JPEG_error_mgr jerr;
|
|
JSAMPROW *jbuf;
|
|
struct jpeg_compress_struct cinfo;
|
|
FILE *f;
|
|
unsigned char *buf;
|
|
|
|
f = open_memstream(&d, &sz);
|
|
if (!f)
|
|
{
|
|
free(d1);
|
|
return NULL;
|
|
}
|
|
|
|
buf = malloc(3 * w);
|
|
if (!buf)
|
|
{
|
|
fclose(f);
|
|
if (d) free(d);
|
|
free(d1);
|
|
return NULL;
|
|
}
|
|
|
|
cinfo.err = jpeg_std_error(&(jerr.pub));
|
|
jerr.pub.error_exit = _JPEGFatalErrorHandler;
|
|
jerr.pub.emit_message = _JPEGErrorHandler2;
|
|
jerr.pub.output_message = _JPEGErrorHandler;
|
|
if (setjmp(jerr.setjmp_buffer))
|
|
{
|
|
jpeg_destroy_compress(&cinfo);
|
|
if (buf) free(buf);
|
|
fclose(f);
|
|
if (d) free(d);
|
|
free(d1);
|
|
return NULL;
|
|
}
|
|
jpeg_create_compress(&cinfo);
|
|
jpeg_stdio_dest(&cinfo, f);
|
|
cinfo.image_width = w;
|
|
cinfo.image_height = h;
|
|
cinfo.input_components = 1;
|
|
cinfo.in_color_space = JCS_GRAYSCALE;
|
|
jpeg_set_defaults(&cinfo);
|
|
jpeg_set_quality(&cinfo, quality, TRUE);
|
|
jpeg_start_compress(&cinfo, TRUE);
|
|
|
|
ptr = data;
|
|
while (cinfo.next_scanline < cinfo.image_height)
|
|
{
|
|
int i, j;
|
|
|
|
/* convert scaline from ARGB to RGB packed */
|
|
for (j = 0, i = 0; i < w; i++)
|
|
{
|
|
buf[j++] = ((*ptr) >> 24) & 0xff;
|
|
ptr++;
|
|
}
|
|
jbuf = (JSAMPROW *) (&buf);
|
|
jpeg_write_scanlines(&cinfo, jbuf, 1);
|
|
}
|
|
|
|
jpeg_finish_compress(&cinfo);
|
|
jpeg_destroy_compress(&cinfo);
|
|
|
|
if (buf) free(buf);
|
|
fclose(f);
|
|
d2 = d;
|
|
sz2 = sz;
|
|
}
|
|
d = malloc(12 + sz1 + sz2);
|
|
if (!d)
|
|
{
|
|
free(d1);
|
|
free(d2);
|
|
return NULL;
|
|
}
|
|
header = (int *)d;
|
|
header[0] = 0xbeeff00d;
|
|
header[1] = sz1;
|
|
header[2] = sz2;
|
|
if (words_bigendian)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ((w * h) + 3); i++) SWAP32(header[i]);
|
|
}
|
|
memcpy(d + 12, d1, sz1);
|
|
memcpy(d + 12 + sz1, d2, sz2);
|
|
|
|
free(d1);
|
|
free(d2);
|
|
*size = 12 + sz1 + sz2;
|
|
return d;
|
|
}
|
|
|
|
|
|
/* CHAR TYPE */
|
|
static int
|
|
eet_data_get_char(void *src, void *src_end, void *dst)
|
|
{
|
|
char *s, *d;
|
|
|
|
if ((src + sizeof(char)) > src_end) return -1;
|
|
s = (char *)src;
|
|
d = (char *)dst;
|
|
*s = *d;
|
|
CONV8(*s);
|
|
return sizeof(char);
|
|
}
|
|
|
|
static void *
|
|
eet_data_put_char(void *src, int *size_ret)
|
|
{
|
|
char *s, *d;
|
|
|
|
d = (char *)malloc(sizeof(char));
|
|
if (!d) return NULL;
|
|
s = (char *)src;
|
|
*d = *s;
|
|
CONV8(*d);
|
|
*size_ret = sizeof(char);
|
|
return d;
|
|
}
|
|
|
|
/* SHORT TYPE */
|
|
static int
|
|
eet_data_get_short(void *src, void *src_end, void *dst)
|
|
{
|
|
short *s, *d;
|
|
short tmp;
|
|
|
|
if ((src + sizeof(short)) > src_end) return -1;
|
|
s = (short *)src;
|
|
d = (short *)dst;
|
|
/* alignment fixup */
|
|
if ((int)s & (sizeof(short) - 1))
|
|
{
|
|
memcpy(&tmp, s, sizeof(short));
|
|
s = &tmp;
|
|
}
|
|
*d = *s;
|
|
CONV16(*d);
|
|
return sizeof(short);
|
|
}
|
|
|
|
static void *
|
|
eet_data_put_short(void *src, int *size_ret)
|
|
{
|
|
short *s, *d;
|
|
|
|
d = (short *)malloc(sizeof(short));
|
|
if (!d) return NULL;
|
|
s = (short *)src;
|
|
*d = *s;
|
|
CONV16(*d);
|
|
*size_ret = sizeof(short);
|
|
return d;
|
|
}
|
|
|
|
/* INT TYPE */
|
|
static int
|
|
eet_data_get_int(void *src, void *src_end, void *dst)
|
|
{
|
|
int *s, *d;
|
|
int tmp;
|
|
|
|
if ((src + sizeof(int)) > src_end) return -1;
|
|
s = (int *)src;
|
|
d = (int *)dst;
|
|
/* alignment fixup */
|
|
if ((int)s & (sizeof(int) - 1))
|
|
{
|
|
memcpy(&tmp, s, sizeof(int));
|
|
s = &tmp;
|
|
}
|
|
*d = *s;
|
|
CONV32(*d);
|
|
return sizeof(int);
|
|
}
|
|
|
|
static void *
|
|
eet_data_put_int(void *src, int *size_ret)
|
|
{
|
|
int *s, *d;
|
|
|
|
d = (int *)malloc(sizeof(int));
|
|
if (!d) return NULL;
|
|
s = (int *)src;
|
|
*d = *s;
|
|
CONV32(*d);
|
|
*size_ret = sizeof(int);
|
|
return d;
|
|
}
|
|
|
|
/* LONG LONG TYPE */
|
|
static int
|
|
eet_data_get_long_long(void *src, void *src_end, void *dst)
|
|
{
|
|
long long *s, *d;
|
|
long long tmp;
|
|
|
|
if ((src + sizeof(long long)) > src_end) return -1;
|
|
s = (long long *)src;
|
|
d = (long long *)dst;
|
|
/* alignment fixup */
|
|
if ((int)s & (sizeof(long long) - 1))
|
|
{
|
|
memcpy(&tmp, s, sizeof(long long));
|
|
s = &tmp;
|
|
}
|
|
*d = *s;
|
|
CONV64(*d);
|
|
return sizeof(long long);
|
|
}
|
|
|
|
static void *
|
|
eet_data_put_long_long(void *src, int *size_ret)
|
|
{
|
|
long long *s, *d;
|
|
|
|
d = (long long *)malloc(sizeof(long long));
|
|
if (!d) return NULL;
|
|
s = (long long *)src;
|
|
*d = *s;
|
|
CONV64(*d);
|
|
*size_ret = sizeof(long long);
|
|
return d;
|
|
}
|
|
|
|
/* STRING TYPE */
|
|
static int
|
|
eet_data_get_string(void *src, void *src_end, void *dst)
|
|
{
|
|
char *s, **d, *p;
|
|
int len;
|
|
|
|
s = (char *)src;
|
|
d = (char **)dst;
|
|
p = s;
|
|
len = 0;
|
|
while ((p < (char *)src_end) && (*p != 0)) {len++; p++;}
|
|
*d = malloc(len + 1);
|
|
if (!(*d)) return -1;
|
|
memcpy(*d, s, len);
|
|
(*d)[len] = 0;
|
|
return len + 1;
|
|
}
|
|
|
|
static void *
|
|
eet_data_put_string(void *src, int *size_ret)
|
|
{
|
|
char *s, *d;
|
|
int len;
|
|
|
|
if (!src) src = "";
|
|
s = (char *)(*((char **)src));
|
|
len = strlen(s);
|
|
d = malloc(len + 1);
|
|
if (!d) return NULL;
|
|
strcpy(d, s);
|
|
*size_ret = len + 1;
|
|
return d;
|
|
}
|
|
|
|
/* FLOAT TYPE */
|
|
static int
|
|
eet_data_get_float(void *src, void *src_end, void *dst)
|
|
{
|
|
float *d;
|
|
char *s, *str, *p, *prev_locale;
|
|
int len;
|
|
|
|
s = (char *)src;
|
|
d = (float *)dst;
|
|
p = s;
|
|
len = 0;
|
|
while ((p < (char *)src_end) && (*p != 0)) {len++; p++;}
|
|
str = malloc(len + 1);
|
|
if (!str) return -1;
|
|
memcpy(str, s, len);
|
|
str[len] = 0;
|
|
|
|
prev_locale = setlocale(LC_NUMERIC, "C");
|
|
*d = (float)atof(str);
|
|
if (prev_locale) setlocale(LC_NUMERIC, prev_locale);
|
|
|
|
free(str);
|
|
return len + 1;
|
|
}
|
|
|
|
static void *
|
|
eet_data_put_float(void *src, int *size_ret)
|
|
{
|
|
float *s;
|
|
char *d, buf[64], *prev_locale;
|
|
int len;
|
|
|
|
s = (float *)src;
|
|
prev_locale = setlocale(LC_NUMERIC, "C");
|
|
snprintf(buf, sizeof(buf), "%16.16f", (double)(*s));
|
|
if (prev_locale) setlocale(LC_NUMERIC, prev_locale);
|
|
len = strlen(buf);
|
|
d = malloc(len + 1);
|
|
if (!d) return NULL;
|
|
strcpy(d, buf);
|
|
*size_ret = len + 1;
|
|
return d;
|
|
}
|
|
|
|
/* DOUBLE TYPE */
|
|
static int
|
|
eet_data_get_double(void *src, void *src_end, void *dst)
|
|
{
|
|
double *d;
|
|
char *s, *str, *p, *prev_locale;
|
|
int len;
|
|
|
|
s = (char *)src;
|
|
d = (double *)dst;
|
|
p = s;
|
|
len = 0;
|
|
while ((p < (char *)src_end) && (*p != 0)) {len++; p++;}
|
|
str = malloc(len + 1);
|
|
if (!str) return -1;
|
|
memcpy(str, s, len);
|
|
str[len] = 0;
|
|
|
|
prev_locale = setlocale(LC_NUMERIC, "C");
|
|
*d = (double)atof(str);
|
|
if (prev_locale) setlocale(LC_NUMERIC, prev_locale);
|
|
|
|
free(str);
|
|
return len + 1;
|
|
}
|
|
|
|
static void *
|
|
eet_data_put_double(void *src, int *size_ret)
|
|
{
|
|
double *s;
|
|
char *d, buf[128], *prev_locale;
|
|
int len;
|
|
|
|
s = (double *)src;
|
|
prev_locale = setlocale(LC_NUMERIC, "C");
|
|
snprintf(buf, sizeof(buf), "%32.32f", (double)(*s));
|
|
if (prev_locale) setlocale(LC_NUMERIC, prev_locale);
|
|
len = strlen(buf);
|
|
d = malloc(len + 1);
|
|
if (!d) return NULL;
|
|
strcpy(d, buf);
|
|
*size_ret = len + 1;
|
|
return d;
|
|
}
|
|
|
|
static int
|
|
eet_data_get_type(int type, void *src, void *src_end, void *dest)
|
|
{
|
|
int ret;
|
|
|
|
ret = eet_coder[type - 1].get(src, src_end, dest);
|
|
return ret;
|
|
}
|
|
|
|
static void *
|
|
eet_data_put_type(int type, void *src, int *size_ret)
|
|
{
|
|
void *ret;
|
|
|
|
ret = eet_coder[type - 1].put(src, size_ret);
|
|
return ret;
|
|
}
|
|
|
|
/* chunk format...
|
|
*
|
|
* char[4] = "CHnK";
|
|
* int = chunk size (including magic string);
|
|
* char[] = chuck magic/name string (0 byte terminated);
|
|
* ... sub-chunks (a chunk can contain chuncks recusrively) ...
|
|
* or
|
|
* ... payload data ...
|
|
*
|
|
*/
|
|
|
|
static Eet_Data_Chunk *
|
|
eet_data_chunk_get(void *src, int size)
|
|
{
|
|
Eet_Data_Chunk *chnk;
|
|
char *s;
|
|
int ret1, ret2;
|
|
|
|
if (!src) return NULL;
|
|
if (size <= 8) return NULL;
|
|
|
|
chnk = calloc(1, sizeof(Eet_Data_Chunk));
|
|
if (!chnk) return NULL;
|
|
|
|
s = src;
|
|
if ((s[0] != 'C') || (s[1] != 'H') || (s[2] != 'n') || (s[3] != 'K'))
|
|
{
|
|
free(chnk);
|
|
return NULL;
|
|
}
|
|
ret1 = eet_data_get_type(EET_T_INT, (void *)(s + 4), (void *)(s + size), &(chnk->size));
|
|
if (ret1 <= 0)
|
|
{
|
|
free(chnk);
|
|
return NULL;
|
|
}
|
|
if ((chnk->size < 0) || ((chnk->size + 8) > size))
|
|
{
|
|
free(chnk);
|
|
return NULL;
|
|
}
|
|
ret2 = eet_data_get_type(EET_T_STRING, (void *)(s + 8), (void *)(s + size), &(chnk->name));
|
|
if (ret2 <= 0)
|
|
{
|
|
free(chnk);
|
|
return NULL;
|
|
}
|
|
chnk->data = src + 4 + ret1 + ret2;
|
|
chnk->size -= ret2;
|
|
return chnk;
|
|
}
|
|
|
|
static Eet_Data_Chunk *
|
|
eet_data_chunk_new(void *data, int size, char *name)
|
|
{
|
|
Eet_Data_Chunk *chnk;
|
|
|
|
if (!name) return NULL;
|
|
chnk = calloc(1, sizeof(Eet_Data_Chunk));
|
|
if (!chnk) return NULL;
|
|
|
|
chnk->name = strdup(name);
|
|
chnk->size = size;
|
|
chnk->data = data;
|
|
|
|
return chnk;
|
|
}
|
|
|
|
static void
|
|
eet_data_chunk_free(Eet_Data_Chunk *chnk)
|
|
{
|
|
if (chnk->name) free(chnk->name);
|
|
free(chnk);
|
|
}
|
|
|
|
static Eet_Data_Stream *
|
|
eet_data_stream_new(void)
|
|
{
|
|
Eet_Data_Stream *ds;
|
|
|
|
ds = calloc(1, sizeof(Eet_Data_Stream));
|
|
if (!ds) return NULL;
|
|
return ds;
|
|
}
|
|
|
|
static void
|
|
eet_data_stream_free(Eet_Data_Stream *ds)
|
|
{
|
|
if (ds->data) free(ds->data);
|
|
free(ds);
|
|
}
|
|
|
|
static void
|
|
eet_data_stream_write(Eet_Data_Stream *ds, void *data, int size)
|
|
{
|
|
char *p;
|
|
|
|
if ((ds->pos + size) > ds->size)
|
|
{
|
|
ds->data = realloc(ds->data, ds->size + size + 256);
|
|
if (!ds->data)
|
|
{
|
|
ds->pos = 0;
|
|
ds->size = 0;
|
|
return;
|
|
}
|
|
ds->size = ds->size + size + 256;
|
|
}
|
|
p = ds->data;
|
|
memcpy(p + ds->pos, data, size);
|
|
ds->pos += size;
|
|
}
|
|
|
|
static void
|
|
eet_data_chunk_put(Eet_Data_Chunk *chnk, Eet_Data_Stream *ds)
|
|
{
|
|
int *size;
|
|
int s;
|
|
int size_ret;
|
|
|
|
if (!chnk->data) return;
|
|
/* chunk head */
|
|
eet_data_stream_write(ds, "CHnK", 4);
|
|
/* size of chunk payload data + name */
|
|
s = strlen(chnk->name) + 1 + chnk->size;
|
|
size = eet_data_put_int(&s, &size_ret);
|
|
if (size)
|
|
{
|
|
eet_data_stream_write(ds, size, size_ret);
|
|
free(size);
|
|
}
|
|
/* write chunk name */
|
|
eet_data_stream_write(ds, chnk->name, strlen(chnk->name) + 1);
|
|
/* write payload */
|
|
eet_data_stream_write(ds, chnk->data, chnk->size);
|
|
}
|
|
|
|
/*---*/
|
|
|
|
int
|
|
eet_data_image_write(Eet_File *ef, char *name,
|
|
void *data, int w, int h, int alpha,
|
|
int compress, int quality, int lossy)
|
|
{
|
|
void *d = NULL;
|
|
int size = 0;
|
|
|
|
d = eet_data_image_encode(data, &size, w, h, alpha, compress, quality, lossy);
|
|
if (d)
|
|
{
|
|
int v;
|
|
|
|
v = eet_write(ef, name, d, size, 0);
|
|
free(d);
|
|
return v;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void *
|
|
eet_data_image_read(Eet_File *ef, char *name,
|
|
int *w, int *h, int *alpha,
|
|
int *compress, int *quality, int *lossy)
|
|
{
|
|
void *data;
|
|
int size;
|
|
unsigned int *d = NULL;
|
|
int header[8];
|
|
|
|
data = eet_read(ef, name, &size);
|
|
if (!data) return NULL;
|
|
d = eet_data_image_decode(data, size, w, h, alpha, compress, quality, lossy);
|
|
free(data);
|
|
return d;
|
|
}
|
|
|
|
void *
|
|
eet_data_image_encode(void *data, int *size_ret, int w, int h, int alpha, int compress, int quality, int lossy)
|
|
{
|
|
void *d = NULL;
|
|
int size = 0;
|
|
|
|
if (lossy == 0)
|
|
{
|
|
if (compress <= 0)
|
|
d = eet_data_image_lossless_convert(&size, data, w, h, alpha);
|
|
else
|
|
d = eet_data_image_lossless_compressed_convert(&size, data, w, h, alpha, compress);
|
|
}
|
|
else
|
|
{
|
|
if (!alpha)
|
|
d = eet_data_image_jpeg_convert(&size, data, w, h, alpha, quality);
|
|
else
|
|
d = eet_data_image_jpeg_alpha_convert(&size, data, w, h, alpha, quality);
|
|
}
|
|
if (size_ret) *size_ret = size;
|
|
return d;
|
|
}
|
|
|
|
void *
|
|
eet_data_image_decode(void *data, int size, int *w, int *h, int *alpha, int *compress, int *quality, int *lossy)
|
|
{
|
|
unsigned int *d = NULL;
|
|
int header[8];
|
|
|
|
if (words_bigendian == -1)
|
|
{
|
|
unsigned long int v;
|
|
|
|
v = htonl(0x12345678);
|
|
if (v == 0x12345678) words_bigendian = 1;
|
|
else words_bigendian = 0;
|
|
}
|
|
|
|
if (size < 32) return NULL;
|
|
|
|
memcpy(header, data, 32);
|
|
if (words_bigendian)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++) SWAP32(header[i]);
|
|
}
|
|
if (header[0] == 0xac1dfeed)
|
|
{
|
|
int iw, ih, al, cp;
|
|
unsigned int *body;
|
|
|
|
iw = header[1];
|
|
ih = header[2];
|
|
al = header[3];
|
|
cp = header[4];
|
|
if ((iw > 8192) || (ih > 8192)) return NULL;
|
|
if ((cp == 0) && (size < ((iw * ih * 4) + 32))) return NULL;
|
|
body = ((unsigned int *)data) + 8;
|
|
d = malloc(iw * ih * 4);
|
|
if (!d) return NULL;
|
|
if (!cp)
|
|
{
|
|
memcpy(d, body, iw * ih * 4);
|
|
if (words_bigendian)
|
|
{
|
|
int x;
|
|
|
|
for (x = 0; x < (iw * ih); x++) SWAP32(d[x]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
uLongf dlen;
|
|
|
|
dlen = iw * ih * 4;
|
|
uncompress((Bytef *)d, &dlen, (Bytef *)body,
|
|
(uLongf)(size - 32));
|
|
if (words_bigendian)
|
|
{
|
|
int x;
|
|
|
|
for (x = 0; x < (iw * ih); x++) SWAP32(d[x]);
|
|
}
|
|
}
|
|
if (d)
|
|
{
|
|
if (w) *w = iw;
|
|
if (h) *h = ih;
|
|
if (alpha) *alpha = al;
|
|
if (compress) *compress = cp;
|
|
if (lossy) *lossy = 0;
|
|
if (quality) *quality = 100;
|
|
}
|
|
}
|
|
else if (header[0] == 0xbeeff00d)
|
|
{
|
|
int iw = 0, ih = 0;
|
|
int sz1, sz2;
|
|
unsigned char *dt;
|
|
|
|
sz1 = header[1];
|
|
sz2 = header[2];
|
|
dt = data;
|
|
dt += 12;
|
|
d = eet_data_image_jpeg_rgb_decode(dt, sz1, &iw, &ih);
|
|
if (d)
|
|
{
|
|
dt += sz1;
|
|
eet_data_image_jpeg_alpha_decode(dt, sz2, d, &iw, &ih);
|
|
}
|
|
if (d)
|
|
{
|
|
if (w) *w = iw;
|
|
if (h) *h = ih;
|
|
if (alpha) *alpha = 1;
|
|
if (compress) *compress = 0;
|
|
if (lossy) *lossy = 1;
|
|
if (quality) *quality = 75;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int iw = 0, ih = 0;
|
|
|
|
d = eet_data_image_jpeg_rgb_decode(data, size, &iw, &ih);
|
|
if (d)
|
|
{
|
|
if (w) *w = iw;
|
|
if (h) *h = ih;
|
|
if (alpha) *alpha = 0;
|
|
if (compress) *compress = 0;
|
|
if (lossy) *lossy = 1;
|
|
if (quality) *quality = 75;
|
|
}
|
|
}
|
|
return d;
|
|
}
|
|
|
|
Eet_Data_Descriptor *
|
|
eet_data_descriptor_new(char *name,
|
|
int size,
|
|
void *(*func_list_next) (void *l),
|
|
void *(*func_list_append) (void *l, void *d),
|
|
void *(*func_list_data) (void *l),
|
|
void (*func_hash_foreach) (void *h, int (*func) (void *h, const char *k, void *dt, void *fdt), void *fdt),
|
|
void *(*func_hash_add) (void *h, const char *k, void *d))
|
|
{
|
|
Eet_Data_Descriptor *edd;
|
|
|
|
edd = calloc(1, sizeof(Eet_Data_Descriptor));
|
|
edd->name = strdup(name);
|
|
edd->size = size;
|
|
edd->func.list_next = func_list_next;
|
|
edd->func.list_append = func_list_append;
|
|
edd->func.list_data = func_list_data;
|
|
edd->func.hash_foreach = func_hash_foreach;
|
|
edd->func.hash_add = func_hash_add;
|
|
return edd;
|
|
}
|
|
|
|
void
|
|
eet_data_descriptor_free(Eet_Data_Descriptor *edd)
|
|
{
|
|
int i;
|
|
|
|
if (edd->name) free(edd->name);
|
|
for (i = 0; i < edd->elements.num; i++)
|
|
{
|
|
if (edd->elements.set[i].name) free(edd->elements.set[i].name);
|
|
if (edd->elements.set[i].counter_name) free(edd->elements.set[i].counter_name);
|
|
}
|
|
if (edd->elements.set) free(edd->elements.set);
|
|
free(edd);
|
|
}
|
|
|
|
void
|
|
eet_data_descriptor_element_add(Eet_Data_Descriptor *edd, char *name, int type,
|
|
int group_type,
|
|
int offset,
|
|
int count, char *counter_name,
|
|
Eet_Data_Descriptor *subtype)
|
|
{
|
|
Eet_Data_Element *ede;
|
|
|
|
edd->elements.num++;
|
|
edd->elements.set = realloc(edd->elements.set, edd->elements.num * sizeof(Eet_Data_Element));
|
|
if (!edd->elements.set) return;
|
|
ede = &(edd->elements.set[edd->elements.num - 1]);
|
|
ede->name = strdup(name);
|
|
ede->type = type;
|
|
ede->group_type = group_type;
|
|
ede->offset = offset;
|
|
ede->count = count;
|
|
if (counter_name)
|
|
ede->counter_name = strdup(counter_name);
|
|
else ede->counter_name = NULL;
|
|
ede->subtype = subtype;
|
|
}
|
|
|
|
void *
|
|
eet_data_read(Eet_File *ef, Eet_Data_Descriptor *edd, char *name)
|
|
{
|
|
void *data_dec;
|
|
void *data;
|
|
int size;
|
|
|
|
data = eet_read(ef, name, &size);
|
|
if (!data) return NULL;
|
|
data_dec = eet_data_descriptor_decode(edd, data, size);
|
|
free(data);
|
|
return data_dec;
|
|
}
|
|
|
|
int
|
|
eet_data_write(Eet_File *ef, Eet_Data_Descriptor *edd, char *name, void *data, int compress)
|
|
{
|
|
void *data_enc;
|
|
int size;
|
|
int val;
|
|
|
|
data_enc = eet_data_descriptor_encode(edd, data, &size);
|
|
if (!data_enc) return 0;
|
|
val = eet_write(ef, name, data_enc, size, compress);
|
|
free(data_enc);
|
|
return val;
|
|
}
|
|
|
|
void *
|
|
eet_data_descriptor_decode(Eet_Data_Descriptor *edd,
|
|
void *data_in,
|
|
int size_in)
|
|
{
|
|
void *data;
|
|
char *p;
|
|
int size;
|
|
Eet_Data_Chunk *chnk;
|
|
|
|
if (words_bigendian == -1)
|
|
{
|
|
unsigned long int v;
|
|
|
|
v = htonl(0x12345678);
|
|
if (v == 0x12345678) words_bigendian = 1;
|
|
else words_bigendian = 0;
|
|
}
|
|
|
|
data = calloc(1, edd->size);
|
|
if (!data) return NULL;
|
|
chnk = eet_data_chunk_get(data_in, size_in);
|
|
if (!chnk)
|
|
{
|
|
free(data);
|
|
return NULL;
|
|
}
|
|
if (strcmp(chnk->name, edd->name))
|
|
{
|
|
eet_data_chunk_free(chnk);
|
|
free(data);
|
|
return NULL;
|
|
}
|
|
p = chnk->data;
|
|
size = size_in - (4 + 4 + strlen(chnk->name) + 1);
|
|
while (size > 0)
|
|
{
|
|
Eet_Data_Chunk *echnk;
|
|
int i;
|
|
|
|
/* get next data chunk */
|
|
echnk = eet_data_chunk_get(p, size);
|
|
if (!echnk)
|
|
{
|
|
/* FIXME: partially built data struct - leak!!!! */
|
|
free(data);
|
|
eet_data_chunk_free(chnk);
|
|
return NULL;
|
|
}
|
|
for (i = 0; i < edd->elements.num; i++)
|
|
{
|
|
Eet_Data_Element *ede;
|
|
|
|
ede = &(edd->elements.set[i]);
|
|
if (!strcmp(echnk->name, ede->name))
|
|
{
|
|
if (ede->group_type == EET_G_UNKNOWN)
|
|
{
|
|
int ret;
|
|
void *data_ret;
|
|
|
|
if ((ede->type >= EET_T_CHAR) &&
|
|
(ede->type <= EET_T_STRING))
|
|
{
|
|
ret = eet_data_get_type(ede->type,
|
|
echnk->data,
|
|
((char *)echnk->data) + echnk->size,
|
|
((char *)data) + ede->offset);
|
|
}
|
|
else if (ede->subtype)
|
|
{
|
|
void **ptr;
|
|
|
|
data_ret = eet_data_descriptor_decode(ede->subtype,
|
|
echnk->data,
|
|
echnk->size);
|
|
ptr = (void **)(((char *)data) + ede->offset);
|
|
*ptr = (void *)data_ret;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (ede->group_type)
|
|
{
|
|
case EET_G_ARRAY:
|
|
case EET_G_VAR_ARRAY:
|
|
{
|
|
printf("ARRAY TYPE NOT IMPLIMENTED YET!!!\n");
|
|
}
|
|
break;
|
|
case EET_G_LIST:
|
|
{
|
|
int ret;
|
|
void *list = NULL;
|
|
void **ptr;
|
|
void *data_ret;
|
|
|
|
ptr = (void **)(((char *)data) + ede->offset);
|
|
list = *ptr;
|
|
data_ret = NULL;
|
|
if ((ede->type >= EET_T_CHAR) &&
|
|
(ede->type <= EET_T_STRING))
|
|
{
|
|
data_ret = calloc(1, eet_coder[ede->type].size);
|
|
if (data_ret)
|
|
{
|
|
ret = eet_data_get_type(ede->type,
|
|
echnk->data,
|
|
((char *)echnk->data) + echnk->size,
|
|
data_ret);
|
|
if (ret <= 0)
|
|
{
|
|
free(data_ret);
|
|
data_ret = NULL;
|
|
}
|
|
}
|
|
}
|
|
else if (ede->subtype)
|
|
{
|
|
data_ret = eet_data_descriptor_decode(ede->subtype,
|
|
echnk->data,
|
|
echnk->size);
|
|
}
|
|
if (data_ret)
|
|
{
|
|
list = edd->func.list_append(list, data_ret);
|
|
*ptr = list;
|
|
}
|
|
}
|
|
break;
|
|
case EET_G_HASH:
|
|
printf("HASH TYPE NOT IMPLIMENTED YET!!!\n");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
/* advance to next chunk */
|
|
p += (4 + 4 + strlen(echnk->name) + 1 + echnk->size);
|
|
size -= (4 + 4 + strlen(echnk->name) + 1 + echnk->size);
|
|
eet_data_chunk_free(echnk);
|
|
}
|
|
eet_data_chunk_free(chnk);
|
|
return data;
|
|
}
|
|
|
|
void *
|
|
eet_data_descriptor_encode(Eet_Data_Descriptor *edd,
|
|
void *data_in,
|
|
int *size_ret)
|
|
{
|
|
Eet_Data_Chunk *chnk;
|
|
Eet_Data_Stream *ds;
|
|
int i;
|
|
void *cdata;
|
|
int csize;
|
|
|
|
if (words_bigendian == -1)
|
|
{
|
|
unsigned long int v;
|
|
|
|
v = htonl(0x12345678);
|
|
if (v == 0x12345678) words_bigendian = 1;
|
|
else words_bigendian = 0;
|
|
}
|
|
|
|
ds = eet_data_stream_new();
|
|
for (i = 0; i < edd->elements.num; i++)
|
|
{
|
|
Eet_Data_Element *ede;
|
|
Eet_Data_Chunk *echnk;
|
|
void *data;
|
|
int size;
|
|
|
|
ede = &(edd->elements.set[i]);
|
|
data = NULL;
|
|
if (ede->group_type == EET_G_UNKNOWN)
|
|
{
|
|
if ((ede->type >= EET_T_CHAR) &&
|
|
(ede->type <= EET_T_STRING))
|
|
data = eet_data_put_type(ede->type,
|
|
((char *)data_in) + ede->offset,
|
|
&size);
|
|
else if (ede->subtype)
|
|
data = eet_data_descriptor_encode(ede->subtype,
|
|
*((char **)(((char *)data_in) + ede->offset)),
|
|
&size);
|
|
if (data)
|
|
{
|
|
echnk = eet_data_chunk_new(data, size, ede->name);
|
|
eet_data_chunk_put(echnk, ds);
|
|
eet_data_chunk_free(echnk);
|
|
free(data);
|
|
data = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (ede->group_type)
|
|
{
|
|
case EET_G_ARRAY:
|
|
case EET_G_VAR_ARRAY:
|
|
{
|
|
printf("ARRAY TYPE NOT IMPLIMENTED YET!!!\n");
|
|
}
|
|
break;
|
|
case EET_G_LIST:
|
|
{
|
|
void *l;
|
|
|
|
l = *((void **)(((char *)data_in) + ede->offset));
|
|
for (; l; l = edd->func.list_next(l))
|
|
{
|
|
if ((ede->type >= EET_T_CHAR) &&
|
|
(ede->type <= EET_T_STRING))
|
|
data = eet_data_put_type(ede->type,
|
|
edd->func.list_data(l),
|
|
&size);
|
|
else if (ede->subtype)
|
|
data = eet_data_descriptor_encode(ede->subtype,
|
|
edd->func.list_data(l),
|
|
&size);
|
|
if (data)
|
|
{
|
|
echnk = eet_data_chunk_new(data, size, ede->name);
|
|
eet_data_chunk_put(echnk, ds);
|
|
eet_data_chunk_free(echnk);
|
|
free(data);
|
|
data = NULL;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case EET_G_HASH:
|
|
{
|
|
printf("HASH TYPE NOT IMPLIMENTED YET!!!\n");
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
chnk = eet_data_chunk_new(ds->data, ds->pos, edd->name);
|
|
ds->data = NULL;
|
|
ds->size = 0;
|
|
eet_data_stream_free(ds);
|
|
|
|
ds = eet_data_stream_new();
|
|
eet_data_chunk_put(chnk, ds);
|
|
cdata = ds->data;
|
|
csize = ds->pos;
|
|
|
|
ds->data = NULL;
|
|
ds->size = 0;
|
|
eet_data_stream_free(ds);
|
|
*size_ret = csize;
|
|
eet_data_chunk_free(chnk);
|
|
|
|
return cdata;
|
|
}
|