Move color conversion code to s3util

Author: paulwedeck

invert.c

@@ -6,7 +6,7 @@ void invert_handler(s3dat_extracthandler_t* me, s3dat_res_t* res, s3util_excepti
 
 	int pixel_count = s3dat_width(res->res)*s3dat_height(res->res);
 
-	s3dat_color_t* bmp_data = s3dat_bmpdata(res->res);
+	s3util_color_t* bmp_data = s3dat_bmpdata(res->res);
 	for(uint16_t i = 0;i != pixel_count;i++) {
 		bmp_data[i].red = 256-bmp_data[i].red;
 		bmp_data[i].green = 256-bmp_data[i].green;

libs3util

@@ -167,7 +167,7 @@ void s3dat_pack_bitmap(s3dat_t* handle, s3dat_bitmap_t* bitmap, s3dat_content_ty
 
 	uint8_t stat = 0;
 	for(uint32_t y = 0;y != bitmap->height;y++) {
-		s3dat_color_t* color;
+		s3util_color_t* color;
 
 		for(uint32_t x = 0;x != bitmap->width;x++) {
 			color = bitmap->data+(y*bitmap->width+x);
@@ -225,7 +225,7 @@ void s3dat_pack_bitmap(s3dat_t* handle, s3dat_bitmap_t* bitmap, s3dat_content_ty
 		for(uint32_t x = 0;x != bitmap->width;x++) {
 			if(bitmap->data[y*bitmap->width+x].alpha > 127) {
 				stat = 2;
-				s3dat_internal_8b_to_native(bitmap->data+(y*bitmap->width+x), data, bitmap->type);
+				s3util_internal_8b_to_native(bitmap->data + (y * bitmap->width + x), data, bitmap->type);
 				data += pixel_size;
 				current_data++;
 			} else {
@@ -256,72 +256,9 @@ void s3dat_pack_bitmap(s3dat_t* handle, s3dat_bitmap_t* bitmap, s3dat_content_ty
 	}
 }
 
-s3dat_color_t s3dat_internal_ex(void* addr, s3dat_color_type type) {
-	s3dat_color_t color = {0, 0, 0, 0xFF};
-	if(type == s3dat_alpha1) return color;
+s3util_color_t s3dat_internal_error_color = {0, 0, 0, 0};
 
-	
-	double d58 = 255.0/31.0;
-	double d68 = 255.0/63.0;
-
-	if(type == s3dat_gray5) {
-		color.red = color.green = color.blue = (int)((*((uint8_t*)addr) & 0x1F)*d58);
-		return color;
-	}
-
-	uint16_t raw = s3util_le16p(addr);
-
-	if(type == s3dat_rgb555) {
-		color.red = (uint8_t)(((raw >> 10) & 0x1F)*d58);
-		color.green = (uint8_t)(((raw >> 5) & 0x1F)*d58);
-	} else {
-		color.red = (uint8_t)(((raw >> 11)& 0x1F)*d58);
-		color.green = (uint8_t)(((raw >> 5) & 0x3F)*d68);
-	}
-	color.blue = (uint8_t)((raw & 0x1F)*d58);
-
-	return color;
-}
-
-void s3dat_internal_8b_to_native(s3dat_color_t* color, void* to, s3dat_color_type type) {
-	if(type == s3dat_alpha1) return;
-
-	uint8_t* ptr8 = to;
-	uint16_t* ptr16 = to;
-
-	double d85 = 31.0/255.0;
-	double d86 = 63.0/255.0;
-
-	if(type == s3dat_gray5) {
-		uint8_t gray5 = ((color->red+color->green+color->blue)/3)*d85;
-		*ptr8 = (gray5 & 0x1F);
-		return;
-	}
-
-	uint16_t red, green;
-
-	uint16_t blue = (uint16_t)(color->blue*d85);
-
-	if(type == s3dat_rgb555) {
-		red = color->red*d85;
-		green = color->green*d85;
-
-		red = (red) << 10;
-		green = (green) << 5;
-	} else {
-		red = color->red*d85;
-		green = color->green*d86;
-
-		red = (red) << 11;
-		green = (green) << 5;
-	}
-
-	*ptr16 = s3util_le16(red + green + blue);
-}
-
-s3dat_color_t s3dat_internal_error_color = {0, 0, 0, 0};
-
-s3dat_color_t s3dat_extract_palette_color(s3dat_t* handle, uint16_t palette, uint8_t brightness, uint32_t x, s3util_exception_t** throws) {
+s3util_color_t s3dat_extract_palette_color(s3dat_t* handle, uint16_t palette, uint8_t brightness, uint32_t x, s3util_exception_t** throws) {
 	if(palette > handle->palette_index->len) {
 		s3util_throw(s3dat_memset(handle), throws, S3UTIL_EXCEPTION_OUT_OF_RANGE, __FILE__, __func__, __LINE__);
 		return s3dat_internal_error_color;
@@ -339,7 +276,7 @@ s3dat_color_t s3dat_extract_palette_color(s3dat_t* handle, uint16_t palette, uin
 		return s3dat_internal_error_color;
 	}
 
-	return s3dat_internal_ex(&color, handle->green_6b ? s3dat_rgb565 : s3dat_rgb555);
+	return s3util_native_to_8b(&color, handle->green_6b ? s3util_rgb565 : s3util_rgb555);
 }
 
 uint16_t s3dat_width(s3dat_ref_t* bmp) {
@@ -373,7 +310,7 @@ uint32_t* s3dat_gui_meta(s3dat_ref_t* bmp) {
 	return &bmp->data.bmp->gui_type;
 }
 
-s3dat_color_t* s3dat_bmpdata(s3dat_ref_t* bmp) {
+s3util_color_t* s3dat_bmpdata(s3dat_ref_t* bmp) {
 	if(!s3dat_is_bitmap(bmp)) return NULL;
 	return bmp->data.bmp->data;
 }

src/bitmap.c

@@ -142,12 +142,12 @@ void s3dat_unpack_handler(s3dat_extracthandler_t* me, s3dat_res_t* res, s3util_e
 		s3dat_ref_t* palette = s3dat_new_bitmap(handle, handle->palette_line_length, 8, throws);
 		S3UTIL_HANDLE_EXCEPTION(s3dat_memset(handle), throws, __FILE__, __func__, __LINE__);
 
-		palette->data.bmp->type = handle->green_6b ? s3dat_rgb565 : s3dat_rgb555;
+		palette->data.bmp->type = handle->green_6b ? s3util_rgb565 : s3util_rgb555;
 
 		uint32_t colors = handle->palette_line_length*8;
 		uint16_t* color_addr = package->data;
 		for(uint32_t i = 0;i != colors;i++) {
-			palette->data.bmp->data[i] = s3dat_internal_ex(color_addr++, palette->data.bmp->type);
+			palette->data.bmp->data[i] = s3util_native_to_8b(color_addr++, palette->data.bmp->type);
 		}
 		new_ref = palette;
 	} else if(res->type == s3dat_string) {
@@ -168,17 +168,17 @@ void s3dat_unpack_handler(s3dat_extracthandler_t* me, s3dat_res_t* res, s3util_e
 		uint16_t landscape_type = 0;
 		uint32_t gui_type = 0;
 
-		s3dat_color_type color_type;
+		s3util_color_type color_type;
 		uint32_t pixel_size;
 
 		if(res->type == s3dat_torso) {
-			color_type = s3dat_gray5;
+			color_type = s3util_gray5;
 			pixel_size = 1;
 		} else if(res->type == s3dat_shadow) {
-			color_type = s3dat_alpha1;
+			color_type = s3util_alpha1;
 			pixel_size = 0;
 		} else {
-			color_type = handle->green_6b ? s3dat_rgb565 : s3dat_rgb555;
+			color_type = handle->green_6b ? s3util_rgb565 : s3util_rgb555;
 			pixel_size = 2;
 		}
 
@@ -230,7 +230,7 @@ void s3dat_unpack_handler(s3dat_extracthandler_t* me, s3dat_res_t* res, s3util_e
 		uint16_t x = 0;
 		uint16_t y = 0;
 
-		s3dat_color_t trans_color = {0, 0, 0, 0};
+		s3util_color_t trans_color = {0, 0, 0, 0};
 
 		while(y < height) {
 			uint16_t meta = s3util_le16p(data_ptr);
@@ -245,7 +245,7 @@ void s3dat_unpack_handler(s3dat_extracthandler_t* me, s3dat_res_t* res, s3util_e
 
 			uint8_t datalen = meta & 0xFF;
 			while(datalen > 0) {
-				image->data.bmp->data[y*width+x] = s3dat_internal_ex(data_ptr, color_type);
+				image->data.bmp->data[y*width+x] = s3util_native_to_8b(data_ptr, color_type);
 				data_ptr += pixel_size;
 				datalen--;
 				x++;

src/extract.c

@@ -51,15 +51,6 @@ typedef enum {
 	s3dat_landscape_big2 = 0x501,
 } s3dat_landscape_type;
 
-typedef enum {
-	s3dat_alpha1,
-	s3dat_rgb565,
-	s3dat_rgb555,
-	s3dat_gray5,
-	s3dat_unknown_color, // s3dat_new_bitmap in s3dat_ext.h
-} s3dat_color_type;
-
-
 //internal types
 typedef struct s3dat_animation_t s3dat_animation_t;
 typedef struct s3dat_string_t s3dat_string_t;
@@ -76,7 +67,6 @@ typedef struct s3dat_ref_t s3dat_ref_t;
 typedef struct s3dat_res_t s3dat_res_t;
 
 typedef struct s3dat_frame_t s3dat_frame_t;
-typedef struct s3dat_color_t s3dat_color_t;
 
 
 struct s3dat_frame_t {
@@ -98,13 +88,6 @@ struct s3dat_frame_t {
 	uint16_t flag2;
 };
 
-struct s3dat_color_t {
-	uint8_t red;
-	uint8_t green;
-	uint8_t blue;
-	uint8_t alpha;
-};
-
 void s3dat_writefile_name(s3dat_t* handle, char* name, s3util_exception_t** throws);
 void s3dat_writefile_fd(s3dat_t* handle, uint32_t* file, s3util_exception_t** throws);
 void s3dat_writefile_ioset(s3dat_t* handle, void* io_arg, s3util_ioset_t* ioset, bool use_openclose_func, s3util_exception_t** throws);
@@ -138,7 +121,7 @@ s3dat_ref_t* s3dat_extract_palette(s3dat_t* handle, uint16_t palette, s3util_exc
 s3dat_ref_t* s3dat_extract_sound(s3dat_t* handle, uint16_t soundtype, uint32_t altindex, s3util_exception_t** throws);
 
 
-s3dat_color_t s3dat_extract_palette_color(s3dat_t* handle, uint16_t palette, uint8_t brightness, uint32_t x, s3util_exception_t** throws);
+s3util_color_t s3dat_extract_palette_color(s3dat_t* handle, uint16_t palette, uint8_t brightness, uint32_t x, s3util_exception_t** throws);
 
 void s3dat_add_cache(s3dat_t* parent, s3util_exception_t** throws);
 void s3dat_add_utf8_encoding(s3dat_t* handle, s3util_exception_t** throws);
@@ -173,7 +156,7 @@ int16_t* s3dat_xoff(s3dat_ref_t* bmp);
 int16_t* s3dat_yoff(s3dat_ref_t* bmp);
 uint16_t* s3dat_landscape_meta(s3dat_ref_t* bmp);
 uint32_t* s3dat_gui_meta(s3dat_ref_t* bmp);
-s3dat_color_t* s3dat_bmpdata(s3dat_ref_t* bmp);
+s3util_color_t* s3dat_bmpdata(s3dat_ref_t* bmp);
 
 //animation
 bool s3dat_is_animation(s3dat_ref_t* ani);

src/s3dat.h

@@ -34,9 +34,9 @@ struct s3dat_bitmap_t {
 	int16_t yoff;
 
 	s3dat_t* src;
-	s3dat_color_type type;
+	s3util_color_type type;
 
-	s3dat_color_t* data;
+	s3util_color_t* data;
 
 };
 
@@ -149,9 +149,8 @@ void s3dat_internal_delete_index32(s3dat_t* handle, s3dat_index32_t* index);
 void s3dat_internal_delete_seq(s3dat_t* handle, s3dat_seq_index_t* seq);
 void s3dat_internal_delete_seq32(s3dat_t* handle, s3dat_seq_index32_t* seq);
 
-void s3dat_internal_read_bitmap_data(s3dat_t* handle, s3dat_color_type type, uint16_t width, uint16_t height, s3dat_color_t** re_pixdata, s3util_exception_t** throws);
+void s3dat_internal_read_bitmap_data(s3dat_t* handle, s3util_color_type type, uint16_t width, uint16_t height, s3util_color_t** re_pixdata, s3util_exception_t** throws);
 void s3dat_internal_read_bitmap_header(s3dat_t* handle, s3dat_content_type type, uint32_t from, uint16_t* width, uint16_t* height, uint16_t* xoff, uint16_t* yoff, s3util_exception_t** throws);
-s3dat_color_t s3dat_internal_ex(void* addr, s3dat_color_type type);
 
 void s3dat_internal_extract_string(s3dat_t* handle, uint16_t text, uint16_t language, s3dat_ref_t** to, s3util_exception_t** throws);
 void s3dat_internal_extract_bitmap(s3dat_extracthandler_t* me, s3dat_res_t* res, s3util_exception_t** throws);
@@ -162,8 +161,6 @@ void s3dat_pack_bitmap(s3dat_t* handle, s3dat_bitmap_t* bitmap, s3dat_content_ty
 void s3dat_pack_string(s3dat_t* handle, s3dat_string_t* string, s3dat_packed_t* packed, s3util_exception_t** throws);
 void s3dat_pack_sound(s3dat_t* handle, s3dat_sound_t* sound, s3dat_packed_t* packed, s3util_exception_t** throws);
 
-void s3dat_internal_8b_to_native(s3dat_color_t* color, void* to, s3dat_color_type type);
-
 void s3dat_unpack_handler(s3dat_extracthandler_t* me, s3dat_res_t* res, s3util_exception_t** throws);
 void s3dat_read_packed_handler(s3dat_extracthandler_t* me, s3dat_res_t* res, s3util_exception_t** throws);
 void s3dat_utf8_encoding_handler(s3dat_extracthandler_t* me, s3dat_res_t* res, s3util_exception_t** throws);

src/s3dat_internal.h

@@ -150,8 +150,8 @@ s3dat_ref_t* s3dat_new_bitmap(s3dat_t* parent, uint16_t width, uint16_t height,
 
 	ref->data.bmp->width = width;
 	ref->data.bmp->height = height;
-	ref->data.bmp->type = s3dat_unknown_color;
-	ref->data.bmp->data = s3util_alloc_func(s3dat_memset(parent), width*height*sizeof(s3dat_color_t), throws);
+	ref->data.bmp->type = s3util_unknown_color;
+	ref->data.bmp->data = s3util_alloc_func(s3dat_memset(parent), width*height*sizeof(s3util_color_t), throws);
 	if(*throws != NULL) {
 		s3dat_unref(ref);
 		s3util_add_to_stack(s3dat_memset(parent), throws, __FILE__, __func__, __LINE__);

src/structure.c

@@ -331,7 +331,7 @@ void s3dat_pack_palette(s3dat_t* handle, s3dat_bitmap_t* palette, s3dat_packed_t
 
 	uint16_t* ptr16 = packed->data;
 	for(uint32_t i = 0;i != pixel_count;i++) {
-		s3dat_internal_8b_to_native(palette->data+i, ptr16+i, palette->type);
+		s3util_internal_8b_to_native(palette->data + i, ptr16 + i, palette->type);
 		ptr16[i] = s3util_le16(ptr16[i]);
 	}
 }