pikl 0.2.2-x86-mswin32

data/ext/pikl/pikl_effect.c

@@ -0,0 +1,191 @@
+#include "pikl_effect.h"
+
+//=================================================================================
+// pkl_unsharp
+//=================================================================================
+PKLExport int pkl_unsharp(PKLImage pkl, int threshold, double edge)
+{
+	int i, j, p, q, k;
+	int cnt, value, stock[PKL_CHANNEL];
+	unsigned char *wrk;
+	
+	wrk = malloc(pkl->height * pkl->width * pkl->channel);
+	if(!wrk) return(1);
+	memset(wrk, 0, pkl->height * pkl->width * pkl->channel);
+	
+	for(i=0; i<pkl->height; i++){
+		for(j=0; j<pkl->width; j++){
+			cnt = 0;
+			memset(stock, 0, sizeof(stock));
+			
+			for(p=-RADIUS; p<=RADIUS; p++){
+				for(q=-RADIUS; q<=RADIUS; q++){
+					if(j+q>=0 && j+q<pkl->width && i+p>=0 && i+p<pkl->height){
+						for(k=0; k<pkl->channel; k++) stock[k] += pkl->image[((i+p)*pkl->width+(j+q))*pkl->channel+k];
+						cnt++;
+					}
+				}
+			}
+			for(k=0; k<pkl->channel; k++){
+				wrk[(i * pkl->width + j) * pkl->channel+k] = stock[k] / cnt;
+			}
+		}
+	}
+	
+	for(i=0; i<pkl->height*pkl->width*pkl->channel; i++){
+		value = abs(pkl->image[i]-wrk[i])<threshold ? pkl->image[i] : pkl->image[i]+(pkl->image[i]-wrk[i])*edge;
+		pkl->image[i] = PKL_RGB(value);
+	}
+	free(wrk);
+	return(0);
+}
+
+//=================================================================================
+// pkl_contrast
+//=================================================================================
+PKLExport int pkl_contrast(PKLImage pkl, int rate)
+{
+	unsigned char ct[PKL_COLOR];
+	int value, i;
+
+	if(rate < -127 || rate > 127) return(1);
+
+	if(rate < 0.0){
+		//�d�݂������̎��͒����I�ɕ��R��
+		for(i=0; i<PKL_COLOR; i++){
+			value = i + (i-127) * rate/127;
+			ct[i] = PKL_RGB(value);
+		}
+	}else{
+		//�d�݂������̎��͎��g��
+		for(i=0; i<PKL_COLOR; i++){
+			value = i - rate*rate/127 * sin(M_PI/2+M_PI*i/255);
+			ct[i] = PKL_RGB(value);
+		}
+	}
+
+	for(i=0; i<pkl->width*pkl->height*pkl->channel; i++) pkl->image[i] = ct[pkl->image[i]];
+
+	return(0);
+}
+
+//=================================================================================
+// pkl_level def=0.0050
+//=================================================================================
+PKLExport int pkl_level(PKLImage pkl, double low, double high, double coeff)
+{
+	PKL_HISTGRAM hst[PKL_CHANNEL];
+	int i, j, cnt, value;
+
+	if((low  < 0.0 && low  > 100.0) ||
+	   (high < 0.0 && high > 100.0) ||
+	   (coeff< 0.0 && coeff> 2.0)) return(1);
+	
+	memset(&hst, 0, sizeof(hst));
+	for(i=0; i<pkl->height*pkl->width; i++){
+		for(j=0; j<pkl->channel; j++){
+			hst[j].data[ pkl->image[i*pkl->channel+j] ]++;
+		}
+	}
+
+	for(i=0; i<pkl->channel; i++){
+		cnt=0;
+		for(j=0; j<PKL_COLOR; j++){
+			cnt += hst[i].data[j];
+			if(cnt > low/100*pkl->height*pkl->width){
+				hst[i].min = j;
+				break;
+			}
+		}
+		cnt=0;
+		for(j=PKL_COLOR-1; j>=0; j--){
+			cnt += hst[i].data[j];
+			if(cnt > high/100*pkl->height*pkl->width){
+				hst[i].max = j;
+				break;
+			}
+		}
+	}
+
+	for(i=0; i<pkl->width*pkl->height; i++){
+		for(j=0; j<pkl->channel; j++){
+			value = ((coeff * pkl->image[i*pkl->channel+j])-hst[j].min)/(hst[j].max-hst[j].min) * 255;
+			pkl->image[i*pkl->channel+j] = PKL_RGB(value);
+		}
+	}
+
+	return(0);
+}
+
+//=============================================================================
+// pkl_brightness
+//=============================================================================
+PKLExport int pkl_brightness(PKLImage pkl, int color)
+{
+	int i;
+	for(i=0; i<pkl->width*pkl->height*pkl->channel; i++){
+		pkl->image[i] = PKL_RGB(pkl->image[i] + color);
+	}
+	return(0);
+}
+
+//=============================================================================
+// pkl_hls
+//=============================================================================
+PKLExport int pkl_hls(PKLImage pkl, double ym, double sm, double hd)
+{
+	int i;
+	double c1, c2;	//�F�M��
+	double y, s, h;	//y=�P�x, s=�ʓx, h=�F��
+	
+	if(pkl->color != PKL_RGB) return(1);
+	
+	for(i=0; i<pkl->width*pkl->height; i++){
+		/* �P�x,�F�M��1,2 */
+		y  = 0.299 * pkl->image[i*pkl->channel]   +
+			 0.587 * pkl->image[i*pkl->channel+1] +
+			 0.114 * pkl->image[i*pkl->channel+2];
+		c1 = pkl->image[i*pkl->channel]   - y;
+		c2 = pkl->image[i*pkl->channel+2] - y;
+		
+		/* �ʓx */
+		s = sqrt(c1*c1 + c2*c2);
+		
+		/* �F�� */
+		if(s < 0.0) h = 0.0;
+		else        h = atan2(c1, c2) * 180.0 / M_PI;
+		
+		/* ������������ */
+		y *= (1 + ym);
+		s *= (1 + sm);
+		h += hd;
+		
+		/* �����l����RGB�ɖ߂� */
+		c1 = s * sin(M_PI * h / 180.0);
+		c2 = s * cos(M_PI * h / 180.0);
+
+		pkl->image[i*pkl->channel]   = PKL_RGB(c1 + y);
+		pkl->image[i*pkl->channel+1] = PKL_RGB(y - (0.299*c1 + 0.114*c2)/0.587);
+		pkl->image[i*pkl->channel+2] = PKL_RGB(c2 + y);
+	}
+	return(0);
+}
+
+//=================================================================================
+// pkl_gamma
+//=================================================================================
+PKLExport int pkl_gamma(PKLImage pkl, double gm)
+{
+	unsigned char gt[PKL_COLOR];
+	int i;
+	
+	if(gm < 0.0) return(1);
+	
+	for(i=0; i<PKL_COLOR; i++)
+		gt[i] = PKL_RGB(255.0 * pow(i/255.0, 1.0/gm));
+	
+	for(i=0; i<pkl->width*pkl->height*pkl->channel; i++)
+		pkl->image[i] = gt[pkl->image[i]];
+
+	return(0);
+}

data/ext/pikl/pikl_effect.h

@@ -0,0 +1,20 @@
+#ifndef _LIB_PIKL_EFFECT_
+#define _LIB_PIKL_EFFECT_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "pikl.h"
+#include "pikl_private.h"
+
+//unsharp target pixel
+#define RADIUS 1
+
+typedef struct {
+	int max, min;
+	long data[PKL_COLOR];
+} PKL_HISTGRAM;
+
+#endif

data/ext/pikl/pikl_io.c

@@ -0,0 +1,137 @@
+#include "pikl_io.h"
+
+static int format_type(PKLImage pkl, FILE *image);
+//=============================================================================
+// pkl_open
+//=============================================================================
+PKLExport PKLImage pkl_open(const char *in)
+{
+	PKLImage pkl;
+	FILE *image;
+	int result=0;
+	
+	pkl = malloc( sizeof(struct _PKLImage) );
+	if(!pkl) return(NULL);
+	memset(pkl, 0, sizeof(struct _PKLImage));
+	
+	pkl->compress = -1;
+	
+	image = fopen(in, "rb");
+	if(!image) return(NULL);
+	
+	format_type(pkl, image);
+
+	switch(pkl->format){
+		case PKL_FORMAT_JPEG:
+			result = load_jpeg(pkl, image);
+			break;
+		case PKL_FORMAT_PNG:
+			result = load_png(pkl, image);
+			break;
+		case PKL_FORMAT_BITMAP:
+			result = load_bitmap(pkl, image);
+			break;
+		default:
+			result = 1;
+	}
+	fclose(image);
+	
+	if(result){
+		free(pkl);
+		pkl = NULL;
+	}
+	
+	return(pkl);
+}
+
+//=============================================================================
+// pkl_close
+//=============================================================================
+PKLExport void pkl_close(PKLImage pkl)
+{
+	if(pkl->image) free(pkl->image);
+	free(pkl);
+}
+
+//=============================================================================
+// format_type
+//=============================================================================
+static int format_type(PKLImage pkl, FILE *image)
+{
+	unsigned char mark[PKL_HEADER_SIZE];
+	int count, i;
+
+	if( fread(mark, 1, PKL_HEADER_SIZE, image) < PKL_HEADER_SIZE ) return(1);
+
+	count = sizeof(pklheader) /sizeof(struct PKL_HEADER);
+	for(i=0; i<count; i++){
+		if( !memcmp(mark, pklheader[i].mark, pklheader[i].size) ){
+			pkl->format = pklheader[i].format;
+			fseek(image, 0, SEEK_SET);
+			return(0);
+		}
+	}
+	return(1);
+}
+
+//=============================================================================
+// pkl_format
+//=============================================================================
+PKLExport PKL_FORMAT pkl_format(PKLImage pkl)
+{
+	return(pkl->format);
+}
+
+//=================================================================================
+// pkl_width
+//=================================================================================
+PKLExport int pkl_width(PKLImage pkl)
+{
+	return(pkl->width);
+}
+
+//=================================================================================
+// pkl_height
+//=================================================================================
+PKLExport int pkl_height(PKLImage pkl)
+{
+	return(pkl->height);
+}
+
+//=============================================================================
+// pkl_compress
+//=============================================================================
+PKLExport int pkl_compress(PKLImage pkl, int level)
+{
+	if(level < 0 || level > 10) return(pkl->compress);
+	pkl->compress = level;
+	return(pkl->compress);
+}
+
+//=================================================================================
+// pkl_save
+//=================================================================================
+PKLExport int pkl_save(PKLImage pkl, const char *out, PKL_FORMAT format)
+{
+	FILE *image;
+	int result=0;
+	
+	image = fopen(out, "wb");
+	if(!image) return(1);
+	
+	switch(format){
+		case PKL_FORMAT_JPEG:
+			result = save_jpeg(pkl, image);
+			break;
+		case PKL_FORMAT_PNG:
+			result = save_png(pkl, image);
+			break;
+		case PKL_FORMAT_BITMAP:
+			result = save_bitmap(pkl, image);
+			break;
+		default:
+			result=1;
+	}
+	fclose(image);
+	return(result);
+}

data/ext/pikl/pikl_io.h

@@ -0,0 +1,27 @@
+#ifndef _LIB_PIKL_IO_
+#define _LIB_PIKL_IO_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "pikl.h"
+#include "pikl_private.h"
+#include "pikl_jpeg.h"
+#include "pikl_bitmap.h"
+#include "pikl_png.h"
+
+#define PKL_HEADER_SIZE 8
+struct PKL_HEADER {
+	PKL_FORMAT format;
+	int size;
+	unsigned char mark[PKL_HEADER_SIZE];
+};
+
+static struct PKL_HEADER pklheader[] = {
+	{ PKL_FORMAT_JPEG,   2, {0xFF, 0xD8} },
+	{ PKL_FORMAT_PNG,    8, {0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A} },
+	{ PKL_FORMAT_BITMAP, 2, {0x42, 0x4D} },
+};
+
+#endif

data/ext/pikl/pikl_jpeg.c

@@ -0,0 +1,161 @@
+#include "pikl_jpeg.h"
+
+static void pkljpeg_error_exit(j_common_ptr cinfo);
+static int color_p2j(int color);
+static int color_j2p(int color);
+static int compress_p2j(int level);
+
+//=============================================================================
+// pkljpeg_error_exit
+//=============================================================================
+static void pkljpeg_error_exit(j_common_ptr cinfo)
+{
+	struct err_mgr *jp_err = (struct err_mgr *)cinfo->err;
+	longjmp(jp_err->setjmp_buffer, 1);
+}
+
+//=============================================================================
+// load_jpeg
+//=============================================================================
+int load_jpeg(PKLImage pkl, FILE *image)
+{
+	struct jpeg_decompress_struct cinfo;
+	struct err_mgr jerr;
+	unsigned char *p;
+	
+	cinfo.err = jpeg_std_error(&jerr.pub);
+	jerr.pub.error_exit = pkljpeg_error_exit;
+	
+	if( setjmp(jerr.setjmp_buffer) ){
+		jpeg_destroy_decompress(&cinfo);
+		return(1);
+	}
+
+	jpeg_create_decompress(&cinfo);
+	jpeg_stdio_src(&cinfo, image);
+	jpeg_read_header(&cinfo, TRUE);
+	jpeg_start_decompress(&cinfo);
+	
+	pkl->width   = cinfo.output_width;
+	pkl->height  = cinfo.output_height;
+	pkl->color   = color_j2p(cinfo.out_color_space);
+	pkl->channel = cinfo.output_components;
+	if(pkl->color == PKL_UNKNOWN) return(1);
+	
+	pkl->image = malloc(cinfo.output_height * cinfo.output_width * cinfo.output_components);
+	if(!pkl->image) return(1);
+	
+	p = pkl->image;
+	while(cinfo.output_scanline < cinfo.output_height){
+		jpeg_read_scanlines(&cinfo, &p, 1);
+		p += (cinfo.output_width * cinfo.output_components);
+	}
+	jpeg_finish_decompress(&cinfo);
+	jpeg_destroy_decompress(&cinfo);
+
+	return(0);
+}
+
+//=============================================================================
+// save_jpg
+//=============================================================================
+int save_jpeg(PKLImage pkl, FILE *image)
+{
+	struct jpeg_compress_struct oinfo;
+	struct err_mgr jerr;
+	JSAMPROW   row_pointer[1];
+	int i;
+
+	if(pkl->color == PKL_UNKNOWN) return(1);
+	
+	oinfo.err = jpeg_std_error(&jerr.pub);
+	jerr.pub.error_exit = pkljpeg_error_exit;
+	
+	if( setjmp(jerr.setjmp_buffer) ){
+		jpeg_destroy_compress(&oinfo);
+		return(1);
+	}
+
+	jpeg_create_compress(&oinfo);
+	jpeg_stdio_dest(&oinfo, image);
+
+	oinfo.image_width      = pkl->width;
+	oinfo.image_height     = pkl->height;
+	oinfo.in_color_space   = color_p2j(pkl->color);
+	oinfo.input_components = pkl->channel;
+	jpeg_set_defaults(&oinfo);
+	jpeg_set_quality(&oinfo, compress_p2j(pkl->compress), TRUE);
+	oinfo.write_JFIF_header= TRUE;
+	oinfo.density_unit     = 1;			//(1)dots/inch, (2)dots/cm
+	
+	jpeg_start_compress(&oinfo, TRUE);
+	
+	for(i=0; i<pkl->height ; i++){
+		row_pointer[0] = &pkl->image[i*pkl->width*pkl->channel];
+		jpeg_write_scanlines(&oinfo, row_pointer, 1);
+	}
+	
+	jpeg_finish_compress(&oinfo);
+	jpeg_destroy_compress(&oinfo);
+	
+
+	return(0);
+}
+
+//=============================================================================
+// color_p2j
+//=============================================================================
+static int color_p2j(int color)
+{
+	switch(color){
+		case PKL_GRAYSCALE:
+			return JCS_GRAYSCALE;
+		case PKL_RGB:
+			return JCS_RGB;
+		//case PKL_YCbCr:
+		//	return JCS_YCbCr;
+		case PKL_CMYK:
+			return JCS_CMYK;
+		//case PKL_YCCK:
+		//	return JCS_YCCK;
+		//case PKL_RGBA:
+		default:
+			return JCS_UNKNOWN;
+	}
+	return JCS_UNKNOWN;
+}
+
+//=============================================================================
+// color_j2p
+//=============================================================================
+static int color_j2p(int color)
+{
+	switch(color){
+		case JCS_GRAYSCALE:
+			return PKL_GRAYSCALE;
+		case JCS_RGB:
+			return PKL_RGB;
+		//case JCS_YCbCr:
+		//	return PKL_CMYK;
+		case JCS_CMYK:
+			return PKL_CMYK;
+		//case JCS_YCCK:
+		//	return PKL_YCCK;
+		default:
+			return PKL_UNKNOWN;
+	}
+	return PKL_UNKNOWN;
+}
+
+//=============================================================================
+// compress_p2j
+//=============================================================================
+static int compress_p2j(int level)
+{
+	int comp;
+	
+	if(level < 0) return(90);
+	comp = 100 - (level*10);
+	if(comp <= 0) return(1);
+	return(comp);
+}

data/ext/pikl/pikl_jpeg.h

@@ -0,0 +1,22 @@
+#ifndef _LIB_PIKL_JPEG_
+#define _LIB_PIKL_JPEG_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <setjmp.h>
+#include <jpeglib.h>
+
+#include "pikl.h"
+#include "pikl_private.h"
+
+/* libjpeg error handler */
+struct err_mgr {
+	struct jpeg_error_mgr pub;
+	jmp_buf setjmp_buffer;
+};
+
+int load_jpeg(PKLImage pkl, FILE *image);
+int save_jpeg(PKLImage pkl, FILE *image);
+
+#endif