X-Git-Url: http://git.code-monkey.de/?a=blobdiff_plain;f=ext%2Fext.c;h=674220f1d968f3288f2f4fb4bae1650f2ce4ab11;hb=8e881f67984232c0a116ce0cda57d828a2b49b7b;hp=02ddba9454dd2789c3e08b86cb7bd9f5747a492a;hpb=2c5f0577496dbb429a327fc85e72e7f4dcf4250c;p=ruby-eet.git diff --git a/ext/ext.c b/ext/ext.c index 02ddba9..674220f 100644 --- a/ext/ext.c +++ b/ext/ext.c @@ -1,5 +1,5 @@ /* - * $Id: ext.c 35 2005-05-10 18:58:49Z tilman $ + * $Id: ext.c 54 2005-06-02 20:05:38Z tilman $ * * Copyright (c) 2005 Tilman Sauerbeck (tilman at code-monkey de) * @@ -25,6 +25,7 @@ #include #include +#include #define CHECK_KEY(key) \ if (rb_funcall (key, id_include, 1, INT2FIX (0)) == Qtrue) \ @@ -39,13 +40,17 @@ ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \ (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24)) #else /* !WORDS_BIGENDIAN */ -# define BSWAP16(x) (x) # define BSWAP32(x) (x) #endif /* WORDS_BIGENDIAN */ static VALUE c_close (VALUE self); -static VALUE id_include; +static VALUE cStream, cChunk, + eEetError, eNameError, ePropError, + sym_lossy, sym_level, sym_quality; +static ID id_include, id_serialize, id_push, id_keys, + id_to_eet_chunks, id_to_eet_name, id_to_eet_properties, + id_tag, id_data; static void c_free (Eet_File **ef) @@ -348,9 +353,9 @@ c_read_image (VALUE self, VALUE 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), @@ -403,15 +408,15 @@ c_write_image (int argc, VALUE *argv, VALUE self) 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); } @@ -434,7 +439,6 @@ stream_serialize (VALUE self) { VALUE ret; struct RArray *stream; - static ID id_serialize; long i; ret = rb_str_new2 (""); @@ -443,9 +447,6 @@ stream_serialize (VALUE self) if (!stream->len) return ret; - if (!id_serialize) - id_serialize = rb_intern ("serialize"); - for (i = 0; i < stream->len; i++) { VALUE str = rb_funcall (stream->ptr[i], id_serialize, 0, NULL); @@ -455,6 +456,30 @@ stream_serialize (VALUE self) return ret; } +static VALUE +chunk_init (VALUE self, VALUE tag, VALUE data) +{ + unsigned long len; + + 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 + */ + len = RSTRING (tag)->len + 1 + RSTRING (data)->len; + if (len < 0 || len >= 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) { @@ -462,13 +487,6 @@ chunk_serialize (VALUE self) unsigned int size, buf_len; unsigned char *buf; struct RString *tag, *data; - static ID id_tag, id_data; - - if (!id_tag) - id_tag = rb_intern ("@tag"); - - if (!id_data) - id_data = rb_intern ("@data"); tmp = rb_ivar_get (self, id_tag); StringValue (tmp); @@ -502,6 +520,80 @@ chunk_serialize (VALUE self) return ret; } +static int +for_each_prop (VALUE tag, VALUE arg, VALUE stream) +{ + VALUE value, type, chunks; + long len, i; + + 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); + chunks = rb_funcall (value, id_to_eet_chunks, 2, tag, type); + + len = RARRAY (chunks)->len; + + for (i = 0; i < len; i++) + rb_funcall (stream, id_push, 1, rb_ary_entry (chunks, i)); + + 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); + chunk = rb_class_new_instance (2, args, cChunk); + + stream = rb_class_new_instance (1, &chunk, cStream); + + return rb_funcall (stream, id_serialize, 0); +} + void Init_eet_ext () { @@ -521,11 +613,32 @@ Init_eet_ext () rb_define_method (c, "read_image", c_read_image, 1); rb_define_method (c, "write_image", c_write_image, -1); - c = rb_define_class_under (m, "Stream", rb_cArray); - rb_define_method (c, "serialize", stream_serialize, 0); + 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); - c = rb_define_class_under (m, "Chunk", rb_cObject); - rb_define_method (c, "serialize", chunk_serialize, 0); + 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_push = rb_intern ("push"); + id_keys = rb_intern ("keys"); + 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")); }