src/parsec/disk-image/parsec/parsec-benchmark/pkgs/netapps/netferret/src/server/image/image.c - public/gem5-resources - Git at Google

 /* AUTORIGHTS
 Copyright (C) 2007 Princeton University

 This file is part of Ferret Toolkit.

 Ferret Toolkit is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software Foundation,
 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <jpeglib.h>
 #include "image.h"

 #define DEFAULT_SIZE          128
 #define EPSILON               1e-6F
 #define RESIZE_FILTER_SUPPORT 3.0F

 static inline float sinc(float x)
 {
   if (x == 0.0)
     return(1.0);
   return(sin(M_PI*(double)x)/(M_PI*(double) x));
 }

 static inline float weight(float x)
 {
   x=fabs(x);
   return(sinc(x/RESIZE_FILTER_SUPPORT)*sinc(x));
 }

 static inline double Max(double x,double y)
 {
     return x > y ? x : y;
 }

 static inline double Min(double x,double y)
 {
     return y > x ? x : y;
 }

 static inline unsigned char myround (float v) {
     if (v <= 0) return 0;
     if (v >= 255) return 255;
     return v + 0.5;
 }

 int horizontal(const unsigned char *image, int orig_width, int orig_height, unsigned char *resize_image, int width)
 {
   float *contrib;
   float factor=(float)width/(float)orig_width;
   float scale=Max(1.0/factor,1.0);
   float support=scale*RESIZE_FILTER_SUPPORT;
   long x;
   if (support < 0.5) // sampling
   {
     support=(float) 0.5;
     scale=1.0;
   }
   contrib=(float *)malloc((size_t) (2.0*support+3.0) * sizeof(float));
   if (contrib == NULL) fatal("out of memory");
   scale=1.0/scale;
   for (x=0; x < (long) width; x++)
   {
     long i, n, start, stop;
     float center, density;
     register long y;
     center=(float) (x+0.5)/factor;
     start=(long) (Max(center-support-EPSILON,0.0)+0.5);
     stop=(long) (Min(center+support,(double) orig_width)+0.5);
     density=0.0;
     for (n=0; n < (stop-start); n++)
     {
       contrib[n]=weight(scale*((float)(start+n)-center+0.5));
       density+=contrib[n];
     }
     for (i=0; i < n; i++) {
           contrib[i]/=density;
     }
     for (y=0; y < (long) orig_height; y++)
     {
         const unsigned char *p = image + CHAN * (y * orig_width + start);
         unsigned char *q = resize_image + CHAN * (y * width + x);
         float r = 0, g = 0, b = 0;
           for (i=0; i < n; i++)
           {
             float alpha =contrib[i];
             r += alpha * *p++;
             g += alpha * *p++;
             b += alpha * *p++;
           }
           *q++ = myround(r);
           *q++ = myround(g);
           *q++ = myround(b);
     }
   }
   free(contrib);
   return 0;
 }

 int vertical(const unsigned char *image, int orig_width, int orig_height, unsigned char *resize_image, int height) {
   long y;
   float *contrib;
   float factor=(float)height/(float)orig_height;
   float scale=Max(1.0/factor,1.0);
   float support=scale*RESIZE_FILTER_SUPPORT;
   if (support < 0.5) // sampling
   {
     support=(float) 0.5;
     scale=1.0;
   }
   contrib=(float *)malloc((size_t) (2.0*support+3.0) * sizeof(float));
   if (contrib == NULL) fatal("out of memory");
   scale=1.0/scale;
   for (y=0; y < (long) height; y++)
   {
     long i, n, start, stop;
     float center, density;
     register long x;
     center=(float) (y+0.5)/factor;
     start=(long) (Max(center-support-EPSILON,0.0)+0.5);
     stop=(long) (Min(center+support,(double) orig_height)+0.5);
     density=0.0;
     for (n=0; n < (stop-start); n++)
     {
       contrib[n]=weight(scale*((float)(start+n)-center+0.5));
       density+=contrib[n];
     }
     for (i=0; i < n; i++) {
           contrib[i]/=density;
     }
     for (x=0; x < (long) orig_width; x++)
     {
         const unsigned char *p = image + CHAN * (start * orig_width + x);
         unsigned char *q = resize_image + CHAN * (y * orig_width + x);
         float r = 0, g = 0, b = 0;
           for (i=0; i < n; i++)
           {
             float alpha =contrib[i];
             r += alpha * *p;
             g += alpha * *(p+1);
             b += alpha * *(p+2);
             p += orig_width * CHAN;
           }
           *q++ = myround(r);
           *q++ = myround(g);
           *q++ = myround(b);
     }
   }
   free(contrib);
   return 0;
 }

 unsigned char *resize (unsigned char *image, int orig_width, int orig_height, int width, int height)
 {
   unsigned char *filter_image, *resize_image;
   if (width * orig_height > height * orig_width) {
     filter_image=(unsigned char *)malloc(width * orig_height * CHAN);
     resize_image=(unsigned char *)malloc(width * height * CHAN);
     if ((filter_image == NULL) || (resize_image == NULL)) fatal("out of memory");
     horizontal(image, orig_width, orig_height, filter_image, width);
     vertical(filter_image, width, orig_height, resize_image, height);
   }
   else {
     filter_image=(unsigned char *)malloc(orig_width * height * CHAN);
     resize_image=(unsigned char *)malloc(width * height * CHAN);
     if ((filter_image == NULL) || (resize_image == NULL)) fatal("out of memory");
     vertical(image, orig_width, orig_height, filter_image, height);
     horizontal(filter_image, orig_width, height, resize_image, width);
   }
   free(filter_image);
   return resize_image;
 }


 int image_init (const char *path)
 {
     return 0;
 }

 int image_cleanup (void)
 {
     return 0;
 }

 void pixel_rgb2hsv (const unsigned char *rgb, unsigned char *hsv)
 {
      unsigned char r = rgb[0];
      unsigned char g = rgb[1];
      unsigned char b = rgb[2];
      float h = 0, s = 0, v = 0;
      unsigned char delta = 0;
      unsigned char mn = r, mx = r;

      hsv[0] = hsv[1] = hsv[2] = 0;

      if (g > mx) { mx = g; }
      if (g < mn) { mn = g; }
      if (b > mx) { mx = b;}
      if (b < mn) { mn = b;}

      delta = mx - mn;

      hsv[2] = mx;       // V

      if (mx == 0) return;

      hsv[1] = (unsigned)delta * 255 / (unsigned)mx;

      if (delta == 0) return;

      float hue = 0;
      if (mx == r) {
          hue = ((float)g - (float)b) / (float)delta;
      }
      else if (mx == g) {
          hue = 2.0 + ((float)b - (float)r) / (float)delta;
      }
      else {
          hue = 4.0 + ((float)r - (float)g) / (float)delta;
      }
      if (hue < 0) hue += 6.0;
      hsv[0] = 255 * hue / 6.0;
 }

 void pixel_hsv2rgb (const unsigned char *hsv, unsigned char *rgb)
 {
      unsigned char h = hsv[0];
      unsigned char s = hsv[1];
      unsigned char v = hsv[2];
      rgb[0] = rgb[1] = rgb[2];

      if (s == 0) {
          rgb[0] = rgb[1] = rgb[2] = v;
      }

      float hue = h * 6.0 / 255;
      float f = hue - floor(hue);
      unsigned p = v * (255.0 - s) / 255;
      unsigned q = v * (255.0 - s * f) / 255;
      unsigned t = v * (255.0 - s * (1.0 - f)) / 255;
      switch ((int)hue) {
         case 0:
         default:
             rgb[0] = v;
             rgb[1] = t;
             rgb[2] = p;
             break;
         case 1:
             rgb[0] = q;
             rgb[1] = v;
             rgb[2] = p;
             break;
         case 2:
             rgb[0] = p;
             rgb[1] = v;
             rgb[2] = t;
             break;
         case 3:
             rgb[0] = p;
             rgb[1] = q;
             rgb[2] = v;
             break;
         case 4:
             rgb[0] = t;
             rgb[1] = p;
             rgb[2] = v;
             break;
         case 5:
             rgb[0] = v;
             rgb[1] = p;
             rgb[2] = q;
             break;
      }
 }


 void rgb2hsv (const unsigned char *rgb, int width, int height, unsigned char *hsv) {
  int i;
  for (i = 0; i < width * height; i++) {
     pixel_rgb2hsv(rgb, hsv);
     rgb += CHAN;
     hsv += CHAN;
  }
 }

 void hsv2rgb (const unsigned char *hsv, int width, int height, unsigned char *rgb) {
  int i;
  for (i = 0; i < width * height; i++) {
     pixel_hsv2rgb(hsv, rgb);
     rgb += CHAN;
     hsv += CHAN;
  }
 }


 /*
  * Sample routine for JPEG decompression.  We assume that the source file name
  * is passed in.  We want to return 1 on success, 0 on error.
  */

 int image_read_rgb_hsv (const char *filename, int *width, int *height, unsigned char **data_rgb, unsigned char **data_hsv)
 {
   struct jpeg_decompress_struct cinfo;
   struct jpeg_error_mgr jerr;
   FILE * infile;        /* source file */
   unsigned char *orig;
   unsigned char *rgb;        /* Output row buffer */
   unsigned char *hsv;
   JSAMPROW row_pointer[1];  /* pointer to JSAMPLE row[s] */
   int row_stride;       /* physical row width in output buffer */
   if ((infile = fopen(filename, "rb")) == NULL) {
     fprintf(stderr, "can't open %s\n", filename);
     return 1;
   }
   cinfo.err = jpeg_std_error(&jerr);
   jpeg_create_decompress(&cinfo);
   jpeg_stdio_src(&cinfo, infile);
   (void) jpeg_read_header(&cinfo, TRUE);
   (void) jpeg_start_decompress(&cinfo);
   row_stride = cinfo.output_width * cinfo.output_components;
   orig = (unsigned char *)malloc(cinfo.output_width * cinfo.output_height * cinfo.output_components);
   if (orig == NULL) fatal("out of memory");
   row_pointer[0] = orig;
   while (cinfo.output_scanline < cinfo.output_height) {
     (void) jpeg_read_scanlines(&cinfo, row_pointer, 1);
     row_pointer[0] += row_stride;
   }
   (void) jpeg_finish_decompress(&cinfo);
   jpeg_destroy_decompress(&cinfo);
   fclose(infile);

   rgb = resize(orig, cinfo.output_width, cinfo.output_height, DEFAULT_SIZE, DEFAULT_SIZE);
   hsv = (unsigned char *)malloc(DEFAULT_SIZE * DEFAULT_SIZE * CHAN);
   rgb2hsv(rgb, DEFAULT_SIZE, DEFAULT_SIZE, hsv);

   free(orig);

   *width = DEFAULT_SIZE;
   *height = DEFAULT_SIZE;
   *data_rgb = rgb;
   *data_hsv = hsv;
   return 0;
 }

 int image_write_rgb (const char *filename, int width, int height, unsigned char *data)
 {
   struct jpeg_compress_struct cinfo;
   struct jpeg_error_mgr jerr;
   FILE * outfile;       /* target file */
   JSAMPROW row_pointer[1];  /* pointer to JSAMPLE row[s] */
   int row_stride;       /* physical row width in image buffer */

   cinfo.err = jpeg_std_error(&jerr);
   jpeg_create_compress(&cinfo);
   if ((outfile = fopen(filename, "wb")) == NULL) {
     fprintf(stderr, "can't open %s\n", filename);
     exit(1);
   }
   jpeg_stdio_dest(&cinfo, outfile);
   cinfo.image_width = width;
   cinfo.image_height = height;
   cinfo.input_components = 3;
   cinfo.in_color_space = JCS_RGB;
   jpeg_set_defaults(&cinfo);
   jpeg_start_compress(&cinfo, TRUE);
   row_stride = width * 3;
   row_pointer[0] = data;
   while (cinfo.next_scanline < cinfo.image_height) {
     (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
     row_pointer[0] += row_stride;
   }
   jpeg_finish_compress(&cinfo);
   fclose(outfile);
   jpeg_destroy_compress(&cinfo);
 }

 /***************************************//**
  *
  * An implementation of jpeg source manager
  *
  ***************************************/
 static void
 net_init_source (j_decompress_ptr cinfo)
 {
 	/* no work here */
 }


 static boolean
 net_fill_input_buffer (j_decompress_ptr cinfo)
 {
   struct jpeg_source_mgr *src = (struct jpeg_source_mgr*) cinfo->src;

   printf("net_fill_input_buffer: should not reach here\n");

   return TRUE;
 }

 static void
 net_skip_input_data (j_decompress_ptr cinfo, long num_bytes)
 {
 	/* no work here */
 	printf("Warning: net_skip_input_data() not implemented\n");
 }

 static void
 net_term_source (j_decompress_ptr cinfo)
 {
 	/* no work here */
 }

 /*
  * Prepare for input from a stdio stream.
  * The caller must have already opened the stream, and is responsible
  * for closing it after finishing decompression.
  */

 static void
 net_jpeg_stdio_src (j_decompress_ptr cinfo, char* buf, int bufsize)
 {
   struct jpeg_source_mgr * src;

   /* The source object and input buffer are made permanent so that a series
    * of JPEG images can be read from the same file by calling jpeg_stdio_src
    * only before the first one.  (If we discarded the buffer at the end of
    * one image, we'd likely lose the start of the next one.)
    * This makes it unsafe to use this manager and a different source
    * manager serially with the same JPEG object.  Caveat programmer.
    */
   if (cinfo->src == NULL) {	/* first time for this JPEG object? */
     cinfo->src = (struct jpeg_source_mgr *)
       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
 				  sizeof(struct jpeg_source_mgr));
     src = cinfo->src;
   }

   src->init_source = net_init_source;
   src->fill_input_buffer = net_fill_input_buffer;
   src->skip_input_data = net_skip_input_data;
   src->resync_to_restart = jpeg_resync_to_restart; /* use default method */
   src->term_source = net_term_source;

   src->bytes_in_buffer = bufsize;
   src->next_input_byte = buf;
 }


 /*
  * Sample routine for JPEG decompression.  We assume that the source file name
  * is passed in.  We want to return 1 on success, 0 on error.
  */

 int image_read_rgb_hsv_buf (const char *buf, int bufsize, int *width, int *height, unsigned char **data_rgb, unsigned char **data_hsv)
 {
   struct jpeg_decompress_struct cinfo;
   struct jpeg_error_mgr jerr;
   unsigned char *orig;
   unsigned char *rgb;        /* Output row buffer */
   unsigned char *hsv;
   JSAMPROW row_pointer[1];  /* pointer to JSAMPLE row[s] */
   int row_stride;       /* physical row width in output buffer */

   cinfo.err = jpeg_std_error(&jerr);
   jpeg_create_decompress(&cinfo);
   net_jpeg_stdio_src(&cinfo, buf, bufsize);

   (void) jpeg_read_header(&cinfo, TRUE);
   (void) jpeg_start_decompress(&cinfo);
   row_stride = cinfo.output_width * cinfo.output_components;
   orig = (unsigned char *)malloc(cinfo.output_width * cinfo.output_height * cinfo.output_components);
   if (orig == NULL) fatal("out of memory");
   row_pointer[0] = orig;

   while (cinfo.output_scanline < cinfo.output_height) {
     (void) jpeg_read_scanlines(&cinfo, row_pointer, 1);
     row_pointer[0] += row_stride;
   }

   (void) jpeg_finish_decompress(&cinfo);
   jpeg_destroy_decompress(&cinfo);

   rgb = resize(orig, cinfo.output_width, cinfo.output_height, DEFAULT_SIZE, DEFAULT_SIZE);
   hsv = (unsigned char *)malloc(DEFAULT_SIZE * DEFAULT_SIZE * CHAN);
   rgb2hsv(rgb, DEFAULT_SIZE, DEFAULT_SIZE, hsv);

   free(orig);

   *width = DEFAULT_SIZE;
   *height = DEFAULT_SIZE;
   *data_rgb = rgb;
   *data_hsv = hsv;
   return 0;
 }
	/* AUTORIGHTS
	Copyright (C) 2007 Princeton University

	This file is part of Ferret Toolkit.

	Ferret Toolkit is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software Foundation,
	Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	*/
	#include <assert.h>
	#include <stdlib.h>
	#include <string.h>
	#include <stdio.h>
	#include <jpeglib.h>
	#include "image.h"

	#define DEFAULT_SIZE 128
	#define EPSILON 1e-6F
	#define RESIZE_FILTER_SUPPORT 3.0F

	static inline float sinc(float x)
	{
	if (x == 0.0)
	return(1.0);
	return(sin(M_PI(double)x)/(M_PI(double) x));
	}

	static inline float weight(float x)
	{
	x=fabs(x);
	return(sinc(x/RESIZE_FILTER_SUPPORT)*sinc(x));
	}

	static inline double Max(double x,double y)
	{
	return x > y ? x : y;
	}

	static inline double Min(double x,double y)
	{
	return y > x ? x : y;
	}

	static inline unsigned char myround (float v) {
	if (v <= 0) return 0;
	if (v >= 255) return 255;
	return v + 0.5;
	}

	int horizontal(const unsigned char image, int orig_width, int orig_height, unsigned char resize_image, int width)
	{
	float *contrib;
	float factor=(float)width/(float)orig_width;
	float scale=Max(1.0/factor,1.0);
	float support=scale*RESIZE_FILTER_SUPPORT;
	long x;
	if (support < 0.5) // sampling
	{
	support=(float) 0.5;
	scale=1.0;
	}
	contrib=(float )malloc((size_t) (2.0support+3.0) * sizeof(float));
	if (contrib == NULL) fatal("out of memory");
	scale=1.0/scale;
	for (x=0; x < (long) width; x++)
	{
	long i, n, start, stop;
	float center, density;
	register long y;
	center=(float) (x+0.5)/factor;
	start=(long) (Max(center-support-EPSILON,0.0)+0.5);
	stop=(long) (Min(center+support,(double) orig_width)+0.5);
	density=0.0;
	for (n=0; n < (stop-start); n++)
	{
	contrib[n]=weight(scale*((float)(start+n)-center+0.5));
	density+=contrib[n];
	}
	for (i=0; i < n; i++) {
	contrib[i]/=density;
	}
	for (y=0; y < (long) orig_height; y++)
	{
	const unsigned char p = image + CHAN (y * orig_width + start);
	unsigned char q = resize_image + CHAN (y * width + x);
	float r = 0, g = 0, b = 0;
	for (i=0; i < n; i++)
	{
	float alpha =contrib[i];
	r += alpha * *p++;
	g += alpha * *p++;
	b += alpha * *p++;
	}
	*q++ = myround(r);
	*q++ = myround(g);
	*q++ = myround(b);
	}
	}
	free(contrib);
	return 0;
	}

	int vertical(const unsigned char image, int orig_width, int orig_height, unsigned char resize_image, int height) {
	long y;
	float *contrib;
	float factor=(float)height/(float)orig_height;
	float scale=Max(1.0/factor,1.0);
	float support=scale*RESIZE_FILTER_SUPPORT;
	if (support < 0.5) // sampling
	{
	support=(float) 0.5;
	scale=1.0;
	}
	contrib=(float )malloc((size_t) (2.0support+3.0) * sizeof(float));
	if (contrib == NULL) fatal("out of memory");
	scale=1.0/scale;
	for (y=0; y < (long) height; y++)
	{
	long i, n, start, stop;
	float center, density;
	register long x;
	center=(float) (y+0.5)/factor;
	start=(long) (Max(center-support-EPSILON,0.0)+0.5);
	stop=(long) (Min(center+support,(double) orig_height)+0.5);
	density=0.0;
	for (n=0; n < (stop-start); n++)
	{
	contrib[n]=weight(scale*((float)(start+n)-center+0.5));
	density+=contrib[n];
	}
	for (i=0; i < n; i++) {
	contrib[i]/=density;
	}
	for (x=0; x < (long) orig_width; x++)
	{
	const unsigned char p = image + CHAN (start * orig_width + x);
	unsigned char q = resize_image + CHAN (y * orig_width + x);
	float r = 0, g = 0, b = 0;
	for (i=0; i < n; i++)
	{
	float alpha =contrib[i];
	r += alpha * *p;
	g += alpha * *(p+1);
	b += alpha * *(p+2);
	p += orig_width * CHAN;
	}
	*q++ = myround(r);
	*q++ = myround(g);
	*q++ = myround(b);
	}
	}
	free(contrib);
	return 0;
	}

	unsigned char resize (unsigned char image, int orig_width, int orig_height, int width, int height)
	{
	unsigned char filter_image, resize_image;
	if (width * orig_height > height * orig_width) {
	filter_image=(unsigned char )malloc(width orig_height * CHAN);
	resize_image=(unsigned char )malloc(width height * CHAN);
	if ((filter_image == NULL) \|\| (resize_image == NULL)) fatal("out of memory");
	horizontal(image, orig_width, orig_height, filter_image, width);
	vertical(filter_image, width, orig_height, resize_image, height);
	}
	else {
	filter_image=(unsigned char )malloc(orig_width height * CHAN);
	resize_image=(unsigned char )malloc(width height * CHAN);
	if ((filter_image == NULL) \|\| (resize_image == NULL)) fatal("out of memory");
	vertical(image, orig_width, orig_height, filter_image, height);
	horizontal(filter_image, orig_width, height, resize_image, width);
	}
	free(filter_image);
	return resize_image;
	}


	int image_init (const char *path)
	{
	return 0;
	}

	int image_cleanup (void)
	{
	return 0;
	}

	void pixel_rgb2hsv (const unsigned char rgb, unsigned char hsv)
	{
	unsigned char r = rgb[0];
	unsigned char g = rgb[1];
	unsigned char b = rgb[2];
	float h = 0, s = 0, v = 0;
	unsigned char delta = 0;
	unsigned char mn = r, mx = r;

	hsv[0] = hsv[1] = hsv[2] = 0;

	if (g > mx) { mx = g; }
	if (g < mn) { mn = g; }
	if (b > mx) { mx = b;}
	if (b < mn) { mn = b;}

	delta = mx - mn;

	hsv[2] = mx; // V

	if (mx == 0) return;

	hsv[1] = (unsigned)delta * 255 / (unsigned)mx;

	if (delta == 0) return;

	float hue = 0;
	if (mx == r) {
	hue = ((float)g - (float)b) / (float)delta;
	}
	else if (mx == g) {
	hue = 2.0 + ((float)b - (float)r) / (float)delta;
	}
	else {
	hue = 4.0 + ((float)r - (float)g) / (float)delta;
	}
	if (hue < 0) hue += 6.0;
	hsv[0] = 255 * hue / 6.0;
	}

	void pixel_hsv2rgb (const unsigned char hsv, unsigned char rgb)
	{
	unsigned char h = hsv[0];
	unsigned char s = hsv[1];
	unsigned char v = hsv[2];
	rgb[0] = rgb[1] = rgb[2];

	if (s == 0) {
	rgb[0] = rgb[1] = rgb[2] = v;
	}

	float hue = h * 6.0 / 255;
	float f = hue - floor(hue);
	unsigned p = v * (255.0 - s) / 255;
	unsigned q = v * (255.0 - s * f) / 255;
	unsigned t = v * (255.0 - s * (1.0 - f)) / 255;
	switch ((int)hue) {
	case 0:
	default:
	rgb[0] = v;
	rgb[1] = t;
	rgb[2] = p;
	break;
	case 1:
	rgb[0] = q;
	rgb[1] = v;
	rgb[2] = p;
	break;
	case 2:
	rgb[0] = p;
	rgb[1] = v;
	rgb[2] = t;
	break;
	case 3:
	rgb[0] = p;
	rgb[1] = q;
	rgb[2] = v;
	break;
	case 4:
	rgb[0] = t;
	rgb[1] = p;
	rgb[2] = v;
	break;
	case 5:
	rgb[0] = v;
	rgb[1] = p;
	rgb[2] = q;
	break;
	}
	}


	void rgb2hsv (const unsigned char rgb, int width, int height, unsigned char hsv) {
	int i;
	for (i = 0; i < width * height; i++) {
	pixel_rgb2hsv(rgb, hsv);
	rgb += CHAN;
	hsv += CHAN;
	}
	}

	void hsv2rgb (const unsigned char hsv, int width, int height, unsigned char rgb) {
	int i;
	for (i = 0; i < width * height; i++) {
	pixel_hsv2rgb(hsv, rgb);
	rgb += CHAN;
	hsv += CHAN;
	}
	}


	/*
	* Sample routine for JPEG decompression. We assume that the source file name
	* is passed in. We want to return 1 on success, 0 on error.
	*/

	int image_read_rgb_hsv (const char filename, int width, int height, unsigned char data_rgb, unsigned char *data_hsv)
	{
	struct jpeg_decompress_struct cinfo;
	struct jpeg_error_mgr jerr;
	FILE * infile; /* source file */
	unsigned char *orig;
	unsigned char rgb; / Output row buffer */
	unsigned char *hsv;
	JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */
	int row_stride; /* physical row width in output buffer */
	if ((infile = fopen(filename, "rb")) == NULL) {
	fprintf(stderr, "can't open %s\n", filename);
	return 1;
	}
	cinfo.err = jpeg_std_error(&jerr);
	jpeg_create_decompress(&cinfo);
	jpeg_stdio_src(&cinfo, infile);
	(void) jpeg_read_header(&cinfo, TRUE);
	(void) jpeg_start_decompress(&cinfo);
	row_stride = cinfo.output_width * cinfo.output_components;
	orig = (unsigned char )malloc(cinfo.output_width cinfo.output_height * cinfo.output_components);
	if (orig == NULL) fatal("out of memory");
	row_pointer[0] = orig;
	while (cinfo.output_scanline < cinfo.output_height) {
	(void) jpeg_read_scanlines(&cinfo, row_pointer, 1);
	row_pointer[0] += row_stride;
	}
	(void) jpeg_finish_decompress(&cinfo);
	jpeg_destroy_decompress(&cinfo);
	fclose(infile);

	rgb = resize(orig, cinfo.output_width, cinfo.output_height, DEFAULT_SIZE, DEFAULT_SIZE);
	hsv = (unsigned char )malloc(DEFAULT_SIZE DEFAULT_SIZE * CHAN);
	rgb2hsv(rgb, DEFAULT_SIZE, DEFAULT_SIZE, hsv);

	free(orig);

	*width = DEFAULT_SIZE;
	*height = DEFAULT_SIZE;
	*data_rgb = rgb;
	*data_hsv = hsv;
	return 0;
	}

	int image_write_rgb (const char filename, int width, int height, unsigned char data)
	{
	struct jpeg_compress_struct cinfo;
	struct jpeg_error_mgr jerr;
	FILE * outfile; /* target file */
	JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */
	int row_stride; /* physical row width in image buffer */

	cinfo.err = jpeg_std_error(&jerr);
	jpeg_create_compress(&cinfo);
	if ((outfile = fopen(filename, "wb")) == NULL) {
	fprintf(stderr, "can't open %s\n", filename);
	exit(1);
	}
	jpeg_stdio_dest(&cinfo, outfile);
	cinfo.image_width = width;
	cinfo.image_height = height;
	cinfo.input_components = 3;
	cinfo.in_color_space = JCS_RGB;
	jpeg_set_defaults(&cinfo);
	jpeg_start_compress(&cinfo, TRUE);
	row_stride = width * 3;
	row_pointer[0] = data;
	while (cinfo.next_scanline < cinfo.image_height) {
	(void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
	row_pointer[0] += row_stride;
	}
	jpeg_finish_compress(&cinfo);
	fclose(outfile);
	jpeg_destroy_compress(&cinfo);
	}

	/*************************************//
	*
	* An implementation of jpeg source manager
	*
	***************************************/
	static void
	net_init_source (j_decompress_ptr cinfo)
	{
	/* no work here */
	}


	static boolean
	net_fill_input_buffer (j_decompress_ptr cinfo)
	{
	struct jpeg_source_mgr src = (struct jpeg_source_mgr) cinfo->src;

	printf("net_fill_input_buffer: should not reach here\n");

	return TRUE;
	}

	static void
	net_skip_input_data (j_decompress_ptr cinfo, long num_bytes)
	{
	/* no work here */
	printf("Warning: net_skip_input_data() not implemented\n");
	}

	static void
	net_term_source (j_decompress_ptr cinfo)
	{
	/* no work here */
	}

	/*
	* Prepare for input from a stdio stream.
	* The caller must have already opened the stream, and is responsible
	* for closing it after finishing decompression.
	*/

	static void
	net_jpeg_stdio_src (j_decompress_ptr cinfo, char* buf, int bufsize)
	{
	struct jpeg_source_mgr * src;

	/* The source object and input buffer are made permanent so that a series
	* of JPEG images can be read from the same file by calling jpeg_stdio_src
	* only before the first one. (If we discarded the buffer at the end of
	* one image, we'd likely lose the start of the next one.)
	* This makes it unsafe to use this manager and a different source
	* manager serially with the same JPEG object. Caveat programmer.
	*/
	if (cinfo->src == NULL) { /* first time for this JPEG object? */
	cinfo->src = (struct jpeg_source_mgr *)
	(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
	sizeof(struct jpeg_source_mgr));
	src = cinfo->src;
	}

	src->init_source = net_init_source;
	src->fill_input_buffer = net_fill_input_buffer;
	src->skip_input_data = net_skip_input_data;
	src->resync_to_restart = jpeg_resync_to_restart; /* use default method */
	src->term_source = net_term_source;

	src->bytes_in_buffer = bufsize;
	src->next_input_byte = buf;
	}



	/*
	* Sample routine for JPEG decompression. We assume that the source file name
	* is passed in. We want to return 1 on success, 0 on error.
	*/

	int image_read_rgb_hsv_buf (const char buf, int bufsize, int width, int height, unsigned char data_rgb, unsigned char *data_hsv)
	{
	struct jpeg_decompress_struct cinfo;
	struct jpeg_error_mgr jerr;
	unsigned char *orig;
	unsigned char rgb; / Output row buffer */
	unsigned char *hsv;
	JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */
	int row_stride; /* physical row width in output buffer */

	cinfo.err = jpeg_std_error(&jerr);
	jpeg_create_decompress(&cinfo);
	net_jpeg_stdio_src(&cinfo, buf, bufsize);

	(void) jpeg_read_header(&cinfo, TRUE);
	(void) jpeg_start_decompress(&cinfo);
	row_stride = cinfo.output_width * cinfo.output_components;
	orig = (unsigned char )malloc(cinfo.output_width cinfo.output_height * cinfo.output_components);
	if (orig == NULL) fatal("out of memory");
	row_pointer[0] = orig;

	while (cinfo.output_scanline < cinfo.output_height) {
	(void) jpeg_read_scanlines(&cinfo, row_pointer, 1);
	row_pointer[0] += row_stride;
	}

	(void) jpeg_finish_decompress(&cinfo);
	jpeg_destroy_decompress(&cinfo);

	rgb = resize(orig, cinfo.output_width, cinfo.output_height, DEFAULT_SIZE, DEFAULT_SIZE);
	hsv = (unsigned char )malloc(DEFAULT_SIZE DEFAULT_SIZE * CHAN);
	rgb2hsv(rgb, DEFAULT_SIZE, DEFAULT_SIZE, hsv);

	free(orig);

	*width = DEFAULT_SIZE;
	*height = DEFAULT_SIZE;
	*data_rgb = rgb;
	*data_hsv = hsv;
	return 0;
	}