"

 COPYRIGHT (c) 1993 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libview2' }"

ImageReader subclass:#JPEGReader

	instanceVariableNames:'jpeg_decompress_struct jpeg_compress_struct jpeg_error_mgr_struct colorComponents

		forceGrayscale forceDitherMode app1SegmentHandler compressQuality bytesPerRow'

	classVariableNames:'ErrorPrinting'

	poolDictionaries:''

	category:'Graphics-Images-Readers'

!

!JPEGReader primitiveDefinitions!

%{

/*

 * includes, defines, structure definitions

 * and typedefs come here.

 */

#include <stdio.h>

#ifdef sunos

# include <sys/types.h>

#endif

#include <jpeglib.h>

#include <jerror.h>

struct my_error_mgr {

	struct jpeg_error_mgr pub;

	jmp_buf setjmp_buffer;

};

%}

! !

!JPEGReader primitiveFunctions!

%{

/*

 * any local C (helper) functions

 * come here (please, define as static)

 */

static void

my_error_exit(cinfo)

    j_common_ptr cinfo;

{

    struct my_error_mgr *myerrPtr = (struct my_error_mgr *) cinfo->err;

    if (@global(ErrorPrinting) == true) {

	console_fprintf(stderr, "JPEGReader [warning]: jpeg error\n");

    }

    longjmp(myerrPtr->setjmp_buffer, 1);

}

static void

my_output_message(cinfo)

    j_common_ptr cinfo;

{

    char buffer[JMSG_LENGTH_MAX];

    if (@global(ErrorPrinting) == true) {

	console_fprintf(stderr, "libJPEG [error]: ");

       /* Create the message */

       (*cinfo->err->format_message) (cinfo, buffer);

       /* Send it to stderr, adding a newline */

       console_fprintf(stderr, "%s\n", buffer);

    }

}

/*

 * Optional progress monitor: display a percent-done figure on stderr.

 */

#ifdef PROGRESS_REPORT

void

JPG_progress_monitor (j_common_ptr cinfo)

{

  cd_progress_ptr prog = (cd_progress_ptr) cinfo->progress;

  int total_passes = prog->pub.total_passes + prog->total_extra_passes;

  int percent_done = (int) (prog->pub.pass_counter*100L/prog->pub.pass_limit);

  if (percent_done != prog->percent_done) {

    prog->percent_done = percent_done;

    if (total_passes > 1) {

      console_fprintf("\rPass %d/%d: %3d%% ",

	      prog->pub.completed_passes + prog->completed_extra_passes + 1,

	      total_passes, percent_done);

    } else {

      console_fprintf("\r %3d%% ", percent_done);

    }

    console_fflush(stderr);

  }

}

void

JPG_start_progress_monitor (j_common_ptr cinfo, cd_progress_ptr progress)

{

  /* Enable progress display, unless trace output is on */

  if (cinfo->err->trace_level == 0) {

    progress->pub.progress_monitor = progress_monitor;

    progress->completed_extra_passes = 0;

    progress->total_extra_passes = 0;

    progress->percent_done = -1;

    cinfo->progress = &progress->pub;

  }

}

void

JPG_end_progress_monitor (j_common_ptr cinfo)

{

  /* Clear away progress display */

  if (cinfo->err->trace_level == 0) {

    console_fprintf(stderr, "\r                \r");

  }

}

#endif /* PROGRESS_REPORT */

/* fetch a byte from the stream */

unsigned int

JPG_jpeg_getc (j_decompress_ptr cinfo)

/* Read next byte */

{

  struct jpeg_source_mgr *datasrc = cinfo->src;

  if (datasrc->bytes_in_buffer == 0) {

    if (! (*datasrc->fill_input_buffer) (cinfo))

      return -1;

  }

  datasrc->bytes_in_buffer--;

  return (*datasrc->next_input_byte++) & 0xFF;

}

%}

! !

!JPEGReader class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1993 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    Reader for JPEG images.

    This uses the libpeg library to read the image

    Only reading of files is supported.

    [See also:]

	Image Form Icon

	BlitImageReader FaceReader GIFReader PBMReader PCXReader

	ST80FormReader SunRasterReader TargaReader TIFFReader WindowsIconReader

	XBMReader XPMReader XWDReader

"

! !

!JPEGReader class methodsFor:'initialization'!

initialize

    "install myself in the Image classes fileFormat table

     for the `.jpg' and '.jpeg' extensions."

    MIMETypes defineImageType:'image/jpeg' suffix:'jpg'  reader:self.

    MIMETypes defineImageType:nil          suffix:'jpeg' reader:self.

    "Modified: 1.2.1997 / 15:01:55 / cg"

! !

!JPEGReader class methodsFor:'testing'!

isValidImageFile:aFilenameOrString

    "return true, if aFileName contains a JPG image.

     Only look at the file's name here ..."

    ^ (MIMETypes mimeTypeForSuffix:aFilenameOrString asFilename suffix) = 'image/jpeg'

    "Created: 11.4.1997 / 16:26:25 / cg"

    "

     self isValidImageFile:'xxx.jpg'

    "

! !

!JPEGReader methodsFor:'accessing'!

app1SegmentHandler:aBlock

    "set a handler block for app1 segment data (geolocation in exif format)"

    app1SegmentHandler := aBlock

!

forceDitherMode:something

    "set the dither mode, to one of #none or #ordered"

    forceDitherMode := something.

    "Modified: 16.4.1997 / 20:34:59 / cg"

!

forceGrayscale:something

    "set the forceGrayscale mode; if true, grayScale images are

     returned, even if the input contains a color image."

    forceGrayscale := something.

    "Created: 16.4.1997 / 20:33:44 / cg"

    "Modified: 16.4.1997 / 20:34:29 / cg"

! !

!JPEGReader methodsFor:'private'!

app1SegmentCallback

    "return a callback function which invokes the app1SegmentHandlerBlock if defined.

     This will be called to handle the exif segment, containing geolocation tags.

     Return nil, if there is no handler blcok defined"

    |cb|

    app1SegmentHandler isNil ifTrue:[^ nil].

    cb := ExternalFunctionCallback new.

    cb returnType:#bool argumentTypes:#(pointer).

    cb generateClosure.

    cb action:[:args | self fetchApp1SegmentData. true].

    ^ cb code.  "can be passed to C."

!

create_jpeg_decompress_struct

    |errMgrStructSize decompressStructSize fp errorOccurred app1SegmentCallbackFunction|

    fp := inStream filePointer.

    fp isNil ifTrue:[

	self error:'can only read from an external stream'.

	^ false.

    ].

    app1SegmentCallbackFunction := self app1SegmentCallback.

%{

    errMgrStructSize = __mkSmallInteger(sizeof(struct my_error_mgr));

    decompressStructSize = __mkSmallInteger(sizeof(struct jpeg_decompress_struct));

%}.

    jpeg_error_mgr_struct := ExternalBytes unprotectedNew:errMgrStructSize.

    jpeg_decompress_struct := ExternalBytes unprotectedNew:decompressStructSize.

    errorOccurred := false.

%{  /* STACK: 400000 */

    struct jpeg_decompress_struct *cinfoPtr;

    struct my_error_mgr *jerrPtr;

    OBJ j_e_m = __INST(jpeg_error_mgr_struct);

    OBJ j_d_s = __INST(jpeg_decompress_struct);

    FILE *f = __FILEVal(fp);

    if (__isExternalBytesLike(j_d_s)

     && __isExternalBytesLike(j_e_m)) {

	cinfoPtr = (struct jpeg_decompress_struct *)(__externalBytesAddress(j_d_s));

	jerrPtr = (struct my_error_mgr *)(__externalBytesAddress(j_e_m));

	/*

	 * Initialize the JPEG decompression object with default error handling.

	 */

	cinfoPtr->err = jpeg_std_error(&jerrPtr->pub);

	/*

	 * prepare to handle errors smoothly ...

	 */

	jerrPtr->pub.error_exit = my_error_exit;

	if (setjmp(jerrPtr->setjmp_buffer)) {

	    /*

	     * error occurred ...

	     */

	    jpeg_destroy_decompress(cinfoPtr);

	    RETURN (false);

	}

	/*

	 * use my message print function

	 */

	jerrPtr->pub.output_message = my_output_message;

	jpeg_create_decompress(cinfoPtr);

#if 0

	/*

	 * Insert custom COM marker processor.

	 */

	jpeg_set_marker_processor(cinfoPtr, JPEG_COM, COM_handler);

#endif

#if 0

	if (app1SegmentCallbackFunction != nil) {

	    jpeg_marker_parser_method cb = NULL;

	    if (__isExternalFunction(app1SegmentCallbackFunction)) {

		cb = (jpeg_marker_parser_method)__externalFunctionVal(app1SegmentCallbackFunction);

	    } else if (__isExternalAddress(app1SegmentCallbackFunction)) {

		cb = (jpeg_marker_parser_method)__externalAddressVal(app1SegmentCallbackFunction);

	    } else {

		/* ignore, but should report an error... */

	    }

	    jpeg_set_marker_processor(cinfoPtr, JPEG_APP0+1, cb);

	}

#endif

	/* Specify data source for decompression */

	jpeg_stdio_src(cinfoPtr, f);

	jpeg_save_markers (cinfoPtr, JPEG_APP0, 0xffff);

	jpeg_save_markers (cinfoPtr, JPEG_APP0+1, 0xffff);

	jpeg_save_markers (cinfoPtr, JPEG_APP0+13, 0xffff);

	/* Read file header, set default decompression parameters */

	(void) jpeg_read_header(cinfoPtr, TRUE);

	cinfoPtr->err->trace_level = 0;

#if 0

	/* colors setting */

	cinfoPtr->desired_number_of_colors = val;

	cinfoPtr->quantize_colors = TRUE;

#endif

#if 0

	/* dct setting */

	cinfoPtr->dct_method = JDCT_ISLOW;

	or: cinfoPtr->dct_method = JDCT_IFAST;

	or: cinfoPtr->dct_method = JDCT_FLOAT;

#endif

	/* dither setting */

	cinfoPtr->dither_mode = JDITHER_FS;

	if (__INST(forceDitherMode) == @symbol(none)) {

	    cinfoPtr->dither_mode = JDITHER_NONE;

	} else {

	    if (__INST(forceDitherMode) == @symbol(ordered)) {

		cinfoPtr->dither_mode = JDITHER_ORDERED;

	    }

	}

#if 0

	/* fast setting */

	cinfoPtr->two_pass_quantize = FALSE;

	cinfoPtr->dither_mode = JDITHER_ORDERED;

	cinfoPtr->desired_number_of_colors = 216;

	cinfoPtr->dct_method = JDCT_FASTEST;

	cinfoPtr->do_fancy_upsampling = FALSE;

#endif

	if (__INST(forceGrayscale) == true) {

	    /* grayscale setting */

	    cinfoPtr->out_color_space = JCS_GRAYSCALE;

	}

#if 0

	/* maxmemory setting */

	cinfoPtr->mem->max_memory_to_use = lval * 1000L;

#endif

#if 0

	/* nosmooth setting */

	cinfoPtr->do_fancy_upsampling = FALSE;

#endif

#if 0

	/* onepass setting */

	cinfoPtr->two_pass_quantize = FALSE;

#endif

	/* Calculate output image dimensions so we can allocate space */

	jpeg_calc_output_dimensions(cinfoPtr);

	__INST(width) = __mkSmallInteger(cinfoPtr->output_width);

	__INST(height) = __mkSmallInteger(cinfoPtr->output_height);

	__INST(colorComponents) = __mkSmallInteger(cinfoPtr->output_components);

	/* could now set additional values in cinfo

	 * (colormap)

	 */

    }

%}.

    ^ true

!

create_jpeg_compress_struct

    |errMgrStructSize compressStructSize fp errorOccurred|

    self assert:(photometric == #rgb).

    self assert:(samplesPerPixel == 3).

    self assert:(bitsPerSample asArray = #(8 8 8)).

    fp := outStream filePointer.

    fp isNil ifTrue:[

	self error:'can only write to an external stream'.

	^ false.

    ].

%{

    errMgrStructSize = __mkSmallInteger(sizeof(struct my_error_mgr));

    compressStructSize = __mkSmallInteger(sizeof(struct jpeg_compress_struct));

%}.

    jpeg_error_mgr_struct := ExternalBytes unprotectedNew:errMgrStructSize.

    jpeg_compress_struct := ExternalBytes unprotectedNew:compressStructSize.

    errorOccurred := false.

%{  /* STACK: 400000 */

    struct jpeg_compress_struct *cinfoPtr;

    struct my_error_mgr *jerrPtr;

    OBJ j_e_m = __INST(jpeg_error_mgr_struct);

    OBJ j_c_s = __INST(jpeg_compress_struct);

    FILE *f = __FILEVal(fp);

    char *outBuffer;

    if (__isExternalBytesLike(j_c_s)

     && __isExternalBytesLike(j_e_m)) {

	cinfoPtr = (struct jpeg_compress_struct *)(__externalBytesAddress(j_c_s));

	jerrPtr = (struct my_error_mgr *)(__externalBytesAddress(j_e_m));

	/*

	 * Initialize the JPEG decompression object with default error handling.

	 */

	cinfoPtr->err = jpeg_std_error(&jerrPtr->pub);

	/*

	 * prepare to handle errors smoothly ...

	 */

	jerrPtr->pub.error_exit = my_error_exit;

	if (setjmp(jerrPtr->setjmp_buffer)) {

	    /*

	     * error occurred ...

	     */

	    jpeg_destroy_compress(cinfoPtr);

	    RETURN (false);

	}

	/*

	 * use my message print function

	 */

	jerrPtr->pub.output_message = my_output_message;

	jpeg_create_compress(cinfoPtr);

	/* Specify data destination for compression */

	jpeg_stdio_dest(cinfoPtr, f);

	cinfoPtr->image_width      = __intVal(__INST(width));

	cinfoPtr->image_height     = __intVal(__INST(height));

	cinfoPtr->input_components = __intVal(__INST(samplesPerPixel));

	cinfoPtr->in_color_space   = JCS_RGB;

	jpeg_set_defaults(cinfoPtr);

	/*set the quality [0..100]  */

	jpeg_set_quality (cinfoPtr, __intVal(__INST(compressQuality)), 1);

	jpeg_start_compress(cinfoPtr, 1);

	cinfoPtr->err->trace_level = 0;

    }