X-Git-Url: http://git.code-monkey.de/?a=blobdiff_plain;f=ext%2Fext.c;h=bf1c4f03572c08089f1df51d823fcaf4efbabedd;hb=2ab5c94a4033ecc44f0eabe58c6f792c49c9f169;hp=94df85d4e8ff2d601c580ca91531228201331326;hpb=c2f066281c7c4b2bff662aab05d934bff2155223;p=ruby-eet.git diff --git a/ext/ext.c b/ext/ext.c index 94df85d..bf1c4f0 100644 --- a/ext/ext.c +++ b/ext/ext.c @@ -1,5 +1,5 @@ /* - * $Id: ext.c 28 2005-04-11 20:58:23Z tilman $ + * $Id: ext.c 71 2005-07-16 12:28:17Z tilman $ * * Copyright (c) 2005 Tilman Sauerbeck (tilman at code-monkey de) * @@ -25,16 +25,35 @@ #include #include +#include +#include #define CHECK_KEY(key) \ - StringValue((key)); \ -\ - if (rb_funcall (key, rb_intern ("include?"), \ - 1, INT2FIX (0)) == Qtrue) \ + if (rb_funcall (key, id_include, 1, INT2FIX (0)) == Qtrue) \ rb_raise (rb_eArgError, "key must not contain binary zeroes"); +#define CHECK_CLOSED(ef) \ + if (!*(ef)) \ + rb_raise (rb_eIOError, "closed stream"); + +#ifdef WORDS_BIGENDIAN +# define BSWAP32(x) \ + ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \ + (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24)) +#else /* !WORDS_BIGENDIAN */ +# define BSWAP32(x) (x) +#endif /* WORDS_BIGENDIAN */ + static VALUE c_close (VALUE self); +static VALUE cStream, cChunk, + eEetError, eNameError, ePropError, + sym_lossy, sym_level, sym_quality, sym_char, sym_short, + sym_long_long, sym_double; +static ID id_include, id_serialize, id_keys, id_pack, + id_to_eet_chunks, id_to_eet_name, id_to_eet_properties, + id_tag, id_data; + static void c_free (Eet_File **ef) { @@ -95,17 +114,15 @@ c_init (int argc, VALUE *argv, VALUE self) VALUE file = Qnil, mode = Qnil; Eet_File **ef = NULL; Eet_File_Mode m = EET_FILE_MODE_READ; - const char *tmp; + const char *tmp, *cfile; Data_Get_Struct (self, Eet_File *, ef); rb_scan_args (argc, argv, "11", &file, &mode); - StringValue (file); + cfile = StringValuePtr (file); if (!NIL_P (mode)) { - StringValue (mode); - tmp = StringValuePtr (mode); if (!strcmp (tmp, "r+")) m = EET_FILE_MODE_READ_WRITE; @@ -117,7 +134,7 @@ c_init (int argc, VALUE *argv, VALUE self) eet_init (); - *ef = eet_open (StringValuePtr (file), m); + *ef = eet_open (cfile, m); if (!*ef) { switch (m) { case EET_FILE_MODE_READ_WRITE: @@ -129,7 +146,7 @@ c_init (int argc, VALUE *argv, VALUE self) break; } - rb_raise (rb_eRuntimeError, tmp, file); + rb_raise (rb_eRuntimeError, tmp, cfile); } return self; @@ -152,15 +169,12 @@ c_close (VALUE self) Eet_File **ef = NULL; Data_Get_Struct (self, Eet_File *, ef); + CHECK_CLOSED (ef); - if (!*ef) - rb_raise (rb_eIOError, "closed stream"); - else { - eet_close (*ef); - *ef = NULL; + eet_close (*ef); + *ef = NULL; - eet_shutdown (); - } + eet_shutdown (); return self; } @@ -181,9 +195,7 @@ c_list (int argc, VALUE *argv, VALUE self) int i, count = 0; Data_Get_Struct (self, Eet_File *, ef); - - if (!*ef) - rb_raise (rb_eIOError, "closed stream"); + CHECK_CLOSED (ef); switch (eet_mode_get (*ef)) { case EET_FILE_MODE_READ: @@ -222,19 +234,16 @@ static VALUE c_delete (VALUE self, VALUE key) { Eet_File **ef = NULL; - char *tmp; + char *ckey; Data_Get_Struct (self, Eet_File *, ef); + CHECK_CLOSED (ef); - if (!*ef) - rb_raise (rb_eIOError, "closed stream"); - + ckey = StringValuePtr (key); CHECK_KEY (key); - tmp = StringValuePtr (key); - - if (!eet_delete (*ef, tmp)) - rb_raise (rb_eIOError, "cannot delete entry - %s", tmp); + if (!eet_delete (*ef, ckey)) + rb_raise (rb_eIOError, "cannot delete entry - %s", ckey); return self; } @@ -253,18 +262,18 @@ c_read (VALUE self, VALUE key) VALUE ret; Eet_File **ef = NULL; void *data; + char *ckey; int size = 0; Data_Get_Struct (self, Eet_File *, ef); + CHECK_CLOSED (ef); - if (!*ef) - rb_raise (rb_eIOError, "closed stream"); - + ckey = StringValuePtr (key); CHECK_KEY (key); - data = eet_read (*ef, StringValuePtr (key), &size); + data = eet_read (*ef, ckey, &size); if (!data) - rb_raise (rb_eIOError, "cannot read entry - %s", key); + rb_raise (rb_eIOError, "cannot read entry - %s", ckey); ret = rb_str_new (data, size); @@ -288,23 +297,23 @@ c_write (int argc, VALUE *argv, VALUE self) { VALUE key = Qnil, buf = Qnil, comp = Qnil; Eet_File **ef = NULL; + char *ckey, *cbuf; int n; Data_Get_Struct (self, Eet_File *, ef); - - if (!*ef) - rb_raise (rb_eIOError, "closed stream"); + CHECK_CLOSED (ef); rb_scan_args (argc, argv, "21", &key, &buf, &comp); if (NIL_P (comp)) comp = Qtrue; + ckey = StringValuePtr (key); CHECK_KEY (key); - StringValue (buf); + cbuf = StringValuePtr (buf); - n = eet_write (*ef, StringValuePtr (key), - StringValuePtr (buf), RSTRING (buf)->len, + n = eet_write (*ef, ckey, + cbuf, RSTRING (buf)->len, comp == Qtrue); if (!n) rb_raise (rb_eIOError, "couldn't write to file"); @@ -330,25 +339,25 @@ c_read_image (VALUE self, VALUE key) VALUE ret, comp; Eet_File **ef = NULL; void *data; + char *ckey; int w = 0, h = 0, has_alpha = 0, level = 0, quality = 0, lossy = 0; Data_Get_Struct (self, Eet_File *, ef); + CHECK_CLOSED (ef); - if (!*ef) - rb_raise (rb_eIOError, "closed stream"); - + ckey = StringValuePtr (key); CHECK_KEY (key); - data = eet_data_image_read (*ef, StringValuePtr (key), &w, &h, + data = eet_data_image_read (*ef, ckey, &w, &h, &has_alpha, &level, &quality, &lossy); if (!data) - rb_raise (rb_eIOError, "cannot read entry - %s", key); + rb_raise (rb_eIOError, "cannot read entry - %s", ckey); comp = rb_hash_new (); - rb_hash_aset (comp, ID2SYM (rb_intern ("lossy")), INT2FIX (lossy)); - rb_hash_aset (comp, ID2SYM (rb_intern ("level")), INT2FIX (level)); - rb_hash_aset (comp, ID2SYM (rb_intern ("quality")), INT2FIX (quality)); + rb_hash_aset (comp, sym_lossy, INT2FIX (lossy)); + rb_hash_aset (comp, sym_level, INT2FIX (level)); + rb_hash_aset (comp, sym_quality, INT2FIX (quality)); ret = rb_ary_new3 (5, rb_str_new (data, w * h * 4), INT2FIX (w), INT2FIX (h), @@ -380,12 +389,11 @@ c_write_image (int argc, VALUE *argv, VALUE self) VALUE key = Qnil, buf = Qnil, w = Qnil, h = Qnil, has_alpha = Qnil; VALUE comp = Qnil, tmp; Eet_File **ef = NULL; + char *ckey, *cbuf; int n, lossy = 0, level = 9, quality = 100; Data_Get_Struct (self, Eet_File *, ef); - - if (!*ef) - rb_raise (rb_eIOError, "closed stream"); + CHECK_CLOSED (ef); rb_scan_args (argc, argv, "42", &key, &buf, &w, &h, &has_alpha, &comp); @@ -393,23 +401,24 @@ c_write_image (int argc, VALUE *argv, VALUE self) if (NIL_P (has_alpha)) has_alpha = Qfalse; + ckey = StringValuePtr (key); CHECK_KEY (key); - StringValue (buf); + cbuf = StringValuePtr (buf); Check_Type (w, T_FIXNUM); Check_Type (h, T_FIXNUM); if (!NIL_P (comp)) { Check_Type (comp, T_HASH); - tmp = rb_hash_aref (comp, ID2SYM (rb_intern ("lossy"))); + tmp = rb_hash_aref (comp, sym_lossy); if (!NIL_P (tmp)) lossy = FIX2INT (tmp); - tmp = rb_hash_aref (comp, ID2SYM (rb_intern ("level"))); + tmp = rb_hash_aref (comp, sym_level); if (!NIL_P (tmp)) level = FIX2INT (tmp); - tmp = rb_hash_aref (comp, ID2SYM (rb_intern ("quality"))); + tmp = rb_hash_aref (comp, sym_quality); if (!NIL_P (tmp)) quality = FIX2INT (tmp); } @@ -417,8 +426,7 @@ c_write_image (int argc, VALUE *argv, VALUE self) if (!RSTRING (buf)->len) return INT2FIX (0); - n = eet_data_image_write (*ef, StringValuePtr (key), - StringValuePtr (buf), + n = eet_data_image_write (*ef, ckey, cbuf, FIX2INT (w), FIX2INT (h), has_alpha == Qtrue, level, quality, lossy); @@ -428,6 +436,220 @@ c_write_image (int argc, VALUE *argv, VALUE self) return INT2FIX (n); } +static VALUE +stream_serialize (VALUE self) +{ + VALUE ret; + struct RArray *stream; + long i; + + stream = RARRAY (self); + if (!stream->len) + return rb_str_new2 (""); + + ret = rb_ary_new (); + + for (i = 0; i < stream->len; i++) { + VALUE str; + + str = rb_funcall (stream->ptr[i], id_serialize, 0, NULL); + + rb_ary_push (ret, str); + } + + return rb_ary_join (ret, Qnil); +} + +static VALUE +chunk_init (VALUE self, VALUE tag, VALUE data) +{ + long tag_len, data_len, tmp; + + StringValue (tag); + StringValue (data); + + if (rb_funcall (tag, id_include, 1, INT2FIX (0)) == Qtrue) + rb_raise (rb_eArgError, "tag must not contain binary zeroes"); + + /* libeet uses a signed 32bit integer to store the + * chunk size, so make sure we don't overflow it + */ + tag_len = RSTRING (tag)->len; + data_len = RSTRING (data)->len; + tmp = tag_len + 1 + data_len; + + if (tmp < tag_len || tmp < data_len || tmp < 1 || tmp >= 2147483647L) + rb_raise (rb_eArgError, "tag or data too long"); + + rb_ivar_set (self, id_tag, rb_str_dup_frozen (tag)); + rb_ivar_set (self, id_data, rb_str_dup_frozen (data)); + + return self; +} + +static VALUE +chunk_serialize (VALUE self) +{ + VALUE tmp, ret; + unsigned int size, buf_len; + unsigned char *buf; + struct RString *tag, *data; + + tmp = rb_ivar_get (self, id_tag); + tag = RSTRING (tmp); + + tmp = rb_ivar_get (self, id_data); + data = RSTRING (tmp); + + buf_len = 9 + tag->len + data->len; + ret = rb_str_buf_new (buf_len); + + buf = RSTRING (ret)->ptr; + RSTRING (ret)->len = buf_len; + + memcpy (buf, "CHnK", 4); + buf += 4; + + size = tag->len + data->len + 1; + size = BSWAP32 (size); + memcpy (buf, &size, 4); + buf += 4; + + memcpy (buf, tag->ptr, tag->len); + buf += tag->len; + + *buf++ = 0; + + memcpy (buf, data->ptr, data->len); + + return ret; +} + +static int +for_each_prop (VALUE tag, VALUE arg, VALUE stream) +{ + VALUE value, type, tmp; + + if (rb_obj_is_kind_of (arg, rb_cArray) == Qfalse) + rb_raise (ePropError, "hash value is not an array"); + + value = rb_ary_entry (arg, 0); + if (NIL_P (value)) + return ST_CONTINUE; + + type = rb_ary_entry (arg, 1); + tmp = rb_funcall (value, id_to_eet_chunks, 2, tag, type); + + rb_ary_concat (stream, tmp); + + return ST_CONTINUE; +} + +/* + * call-seq: + * object.to_eet -> string + * + * Serializes the receiver to EET format. + */ +static VALUE +c_to_eet (VALUE self) +{ + VALUE props, name, stream, chunk, args[2]; +#ifndef HAVE_RB_HASH_FOREACH + struct RArray *keys; + long i; +#endif + + props = rb_funcall (self, id_to_eet_properties, 0); + + if (rb_obj_is_kind_of (props, rb_cHash) == Qfalse || + !RHASH (props)->tbl->num_entries) + rb_raise (ePropError, "invalid EET properties"); + + name = rb_funcall (self, id_to_eet_name, 0); + StringValue (name); + + if (!RSTRING (name)->len || + rb_funcall (name, id_include, 1, INT2FIX (0))) + rb_raise (eNameError, "invalid EET name"); + + stream = rb_class_new_instance (0, NULL, cStream); + +#ifdef HAVE_RB_HASH_FOREACH + rb_hash_foreach (props, for_each_prop, stream); +#else + keys = RARRAY (rb_funcall (props, id_keys, 0)); + + for (i = 0; i < keys->len; i++) + for_each_prop (keys->ptr[i], + rb_hash_aref (props, keys->ptr[i]), + stream); +#endif + + args[0] = name; + args[1] = rb_funcall (stream, id_serialize, 0); + + rb_ary_clear (stream); /* give the GC a hand... */ + + chunk = rb_class_new_instance (2, args, cChunk); + + return rb_funcall (chunk, id_serialize, 0); +} + +static VALUE +int_to_eet_chunks (int argc, VALUE *argv, VALUE self) +{ + VALUE tag, type = Qnil, ary, args[2], chunk; + char *cfmt = "V"; + + rb_scan_args (argc, argv, "11", &tag, &type); + + ary = rb_ary_new3 (1, self); + + if (type == sym_char) + cfmt = "c"; + else if (type == sym_short) + cfmt = "v"; + else if (type == sym_long_long) + cfmt = "q"; + + args[0] = tag; + args[1] = rb_funcall (ary, id_pack, 1, rb_str_new2 (cfmt)); + chunk = rb_class_new_instance (2, args, cChunk); + + return rb_ary_new3 (1, chunk); +} + +static VALUE +float_to_eet_chunks (int argc, VALUE *argv, VALUE self) +{ + VALUE tag, type = Qnil, args[2], chunk; + char buf[65], *loc; + double d; + int len; + + rb_scan_args (argc, argv, "11", &tag, &type); + + d = NUM2DBL (self); + + /* switch locale to make sure we get proper snprintf output */ + loc = setlocale (LC_NUMERIC, "C"); + + len = snprintf (buf, sizeof (buf) - 1, "%a", + type == sym_double ? d : (float) d); + + if (loc) + setlocale (LC_NUMERIC, loc); + + buf[++len] = '\0'; + + args[0] = tag; + args[1] = rb_str_new (buf, len); + chunk = rb_class_new_instance (2, args, cChunk); + + return rb_ary_new3 (1, chunk); +} + void Init_eet_ext () { @@ -446,4 +668,40 @@ Init_eet_ext () rb_define_method (c, "write", c_write, -1); rb_define_method (c, "read_image", c_read_image, 1); rb_define_method (c, "write_image", c_write_image, -1); + + cStream = rb_define_class_under (m, "Stream", rb_cArray); + rb_define_method (cStream, "serialize", stream_serialize, 0); + + cChunk = rb_define_class_under (m, "Chunk", rb_cObject); + rb_define_method (cChunk, "initialize", chunk_init, 2); + rb_define_method (cChunk, "serialize", chunk_serialize, 0); + + rb_define_attr (cChunk, "tag", 1, 0); + rb_define_attr (cChunk, "data", 1, 0); + + rb_define_method (rb_cObject, "to_eet", c_to_eet, 0); + + rb_define_method (rb_cInteger, "to_eet_chunks", int_to_eet_chunks, -1); + rb_define_method (rb_cFloat, "to_eet_chunks", float_to_eet_chunks, -1); + + eEetError = rb_define_class_under (m, "EetError", rb_eStandardError); + eNameError = rb_define_class_under (m, "NameError", eEetError); + ePropError = rb_define_class_under (m, "PropertyError", eEetError); + + id_include = rb_intern ("include?"); + id_serialize = rb_intern ("serialize"); + id_keys = rb_intern ("keys"); + id_pack = rb_intern ("pack"); + id_to_eet_chunks = rb_intern ("to_eet_chunks"); + id_to_eet_name = rb_intern ("to_eet_name"); + id_to_eet_properties = rb_intern ("to_eet_properties"); + id_tag = rb_intern ("@tag"); + id_data = rb_intern ("@data"); + sym_lossy = ID2SYM (rb_intern ("lossy")); + sym_level = ID2SYM (rb_intern ("level")); + sym_quality = ID2SYM (rb_intern ("quality")); + sym_char = ID2SYM (rb_intern ("char")); + sym_short = ID2SYM (rb_intern ("short")); + sym_long_long = ID2SYM (rb_intern ("long_long")); + sym_double = ID2SYM (rb_intern ("double")); }