"

 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.

"

ImageReader subclass:#JPEGReader

		colorComponents forceGrayscale forceDitherMode'

	classVariableNames:''

	poolDictionaries:''

	category:'Graphics-Images-Support'

!

!JPEGReader primitiveDefinitions!

%{

/*

 * includes, defines, structure definitions

 * and typedefs come here.

 */

#include <stdio.h>

#ifndef NO_TESTING

# include "../../support/libjpeg-6a/jpeglib.h"

# include "../../support/libjpeg-6a/jerror.h"

#else

# include <jpeglib.h>

# include <jerror.h>

#endif

%}

! !

!JPEGReader primitiveFunctions!

%{

/* 

 * any local C (helper) functions

 * come here (please, define as static)

 */

/*

 * 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) {

      fprintf(stderr, "\rPass %d/%d: %3d%% ",

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

              total_passes, percent_done);

    } else {

      fprintf(stderr, "\r %3d%% ", percent_done);

    }

    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) {

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

    fflush(stderr);

  }

}

#endif

%}

! !

!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."

    Image addReader:self suffix:'jpg'.

    Image addReader:self suffix:'jpeg'.

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

! !

!JPEGReader class methodsFor:'testing'!

isValidImageFile:aFileName

    "return true, if aFileName contains a JPG image.

     Only look at the files name here ..."

    (aFileName asLowercase endsWith:'.jpg') ifTrue:[^ true].

    (aFileName asLowercase endsWith:'.jpeg') ifTrue:[^ true].

    ^ false

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

! !

!JPEGReader methodsFor:'accessing'!

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'!

create_jpeg_decompress_struct

    |errMgrStructSize decompressStructSize fp|

    fp := inStream filePointer.

    fp isNil ifTrue:[

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

        ^ self.

    ].

%{

    errMgrStructSize = __MKSMALLINT(sizeof(struct jpeg_error_mgr));

    decompressStructSize = __MKSMALLINT(sizeof(struct jpeg_decompress_struct));

%}.

    jpeg_error_mgr_struct := ExternalBytes unprotectedNew:errMgrStructSize.

    jpeg_decompress_struct := ExternalBytes unprotectedNew:decompressStructSize.

%{

    struct jpeg_decompress_struct *cinfoPtr;

    struct jpeg_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 (__isExternalBytes(j_d_s)

     && __isExternalBytes(j_e_m)) {

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

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

        /* 

         * Initialize the JPEG decompression object with default error handling.

         */

        cinfoPtr->err = jpeg_std_error(jerrPtr);

        jpeg_create_decompress(cinfoPtr);

#if 0

        /* 

         * Insert custom COM marker processor.

         */

        jpeg_set_marker_processor(cinfoPtr, JPEG_COM, COM_handler);

#endif

        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

        /* Specify data source for decompression */

        jpeg_stdio_src(cinfoPtr, f);

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

        (void) jpeg_read_header(cinfoPtr, TRUE);

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

        jpeg_calc_output_dimensions(cinfoPtr);

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

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

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

        printf("colorComponents: %d\n", cinfoPtr->output_components);

#if 0

        /* could now set additional values in cinfo

         * (colormap)

         */

#endif

    }

%} 

!

decompressChunkInto:aByteArray startingAt:index

%{

    struct jpeg_decompress_struct *cinfoPtr;

    char *rowPtr;

    OBJ j_d_s = __INST(jpeg_decompress_struct);

    int num_scanlines;

    char *rowPointers[4];

    if (__isExternalBytes(j_d_s)

     && __isByteArray(aByteArray)) {

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

        rowPtr = (char *)(__ByteArrayInstPtr(aByteArray)->ba_element);

        rowPtr += __intVal(index) - 1;

        rowPointers[0] = rowPtr;

        rowPointers[1] = NULL;

        rowPointers[2] = NULL;

        rowPointers[3] = NULL;

        if (cinfoPtr->output_scanline < cinfoPtr->output_height) {

            num_scanlines = jpeg_read_scanlines(cinfoPtr, 

                                                rowPointers,

                                                1);

            RETURN (__MKSMALLINT(num_scanlines));

        }

        RETURN (__MKSMALLINT(0));

    }

%}.

    self halt.

!

finish_decompress

%{

    struct jpeg_decompress *cinfoPtr;

    OBJ j_d_s = __INST(jpeg_decompress_struct);

    if (__isExternalBytes(j_d_s)) {

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

        /* Start decompressor */

        (void) jpeg_finish_decompress(cinfoPtr);

        (void) jpeg_destroy_decompress(cinfoPtr);

    }

%}

!

start_decompress

%{

    struct jpeg_decompress *cinfoPtr;

    OBJ j_d_s = __INST(jpeg_decompress_struct);

    if (__isExternalBytes(j_d_s)) {

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

        /* Start decompressor */

        (void) jpeg_start_decompress(cinfoPtr);

    }

%}

! !

!JPEGReader methodsFor:'reading from stream'!

fromStream:aStream

    "read a JPG image from a stream"

    |dataIdx bytesPerRow|

    inStream := aStream.

    self create_jpeg_decompress_struct.

    self start_decompress.

    data := ByteArray uninitializedNew:(width * height * colorComponents).

    dataIdx := 1.

    bytesPerRow := colorComponents * width.

    [(self decompressChunkInto:data startingAt:dataIdx) ~~ 0] whileTrue:[

        "/ got a row in the buffer ...

        dataIdx := dataIdx + bytesPerRow

    ].    

    self finish_decompress.

    colorComponents == 3 ifTrue:[

        photometric := #rgb.

        samplesPerPixel := 3.

        bitsPerSample := #(8 8 8).

    ] ifFalse:[

        self halt:'unexpected value'

    ].

    "

     JPEGReader fromFile:'../../support/libjpeg-6a/testimg.jpg'

    "

    "

     |stream reader|

     stream := '../../support/libjpeg-6a/testimg.jpg' asFilename readStream.

     reader := JPEGReader new.

     reader forceGrayscale:true.

     reader forceDitherMode:#ordered.

     reader fromStream:stream.

     ^ reader image

    "

    "Modified: 16.4.1997 / 20:36:12 / cg"

! !

!JPEGReader class methodsFor:'documentation'!

version

! !

JPEGReader initialize!