#include "JpegI.h"

#include <jerror.h>

#include <stdlib.h>

#include <X11/Intrinsic.h>

void

_XmJpegErrorExit(j_common_ptr cinfo)

{

    int rc;

    XmJpegErrorMgr err = (XmJpegErrorMgr) cinfo->err;

    switch (cinfo->err->msg_code) {

    case JERR_NO_SOI:

        rc = 1;

        break;

    case JERR_OUT_OF_MEMORY:

        rc = 4;

        break;

    default:

        rc = 2;

        break;

    }

    longjmp(err->setjmp_buffer, rc);

}

int

load_jpeg(FILE * infile, unsigned long *pWidth, unsigned long *pHeight,

          CTable ** image_data)

{

    CTable *buf;

    struct jpeg_decompress_struct cinfo;

    XmJpegErrorMgrRec jerr;

    JSAMPROW row_pointer[1];

    int x, y;

    int rc;

    *image_data = NULL;

    cinfo.err = jpeg_std_error((struct jpeg_error_mgr *) &jerr);

    jerr.pub.error_exit = _XmJpegErrorExit;

    if ((rc = setjmp(jerr.setjmp_buffer))) {

        jpeg_destroy_decompress(&cinfo);

        return rc;

    }

    jpeg_create_decompress(&cinfo);

    jpeg_stdio_src(&cinfo, infile);

    jpeg_read_header(&cinfo, TRUE);

    jpeg_calc_output_dimensions(&cinfo);

    jpeg_start_decompress(&cinfo);

    *pWidth = cinfo.output_width;

    *pHeight = cinfo.output_height;

    *image_data =

        malloc(cinfo.output_width * cinfo.output_height * sizeof(CTable));

    for (buf = *image_data;

         cinfo.output_scanline < cinfo.output_height;

         buf += cinfo.output_width)

        jpeg_read_scanlines(&cinfo, (JSAMPARRAY) (&buf), 1);

    if (cinfo.out_color_space == JCS_GRAYSCALE) {

        for (y = 0, buf = *image_data; y < cinfo.output_height;

             y++, buf += cinfo.output_width)

            for (x = cinfo.output_width - 1; x >= 0; x--)

                buf[x].red = buf[x].green = buf[x].blue =

                    ((JSAMPLE *) buf)[x];

    }

    jpeg_finish_decompress(&cinfo);

    jpeg_destroy_decompress(&cinfo);

    return 0;

}

Pixel

get_cval(unsigned char c, unsigned long mask)

{

    Pixel value = c, x;

    int i;

    for (i = 0, x = 1; i < 32; i++, x <<= 1)

        if (mask & x)

            break;

    for (; i < 32; i++, x <<= 1)

        if (!(mask & x))

            break;

    if (i < 8)

        value >>= 8 - i;

    else if (i > 8)

        value <<= i - 8;

    return (value & mask);

}

void

store_pixel(Screen * screen, CTable * p, int x, char *cdata)

{

    Pixel px = get_cval(p->red, screen->root_visual->red_mask)

        | get_cval(p->green, screen->root_visual->green_mask)

        | get_cval(p->blue, screen->root_visual->blue_mask);

    if (screen->root_depth <= 16) {

        if (ImageByteOrder(screen->display) == MSBFirst) {

            cdata[x * 2] = (px >> 8);

            cdata[x * 2 + 1] = (px & 0xff);

        } else {

            cdata[x * 2] = (px & 0xff);

            cdata[x * 2 + 1] = (px >> 8);

        }

    } else {

        if (ImageByteOrder(screen->display) == MSBFirst) {

            cdata[x * 4] = (px >> 24);

            cdata[x * 4 + 1] = (px >> 16);

            cdata[x * 4 + 2] = (px >> 8);

            cdata[x * 4 + 3] = (px & 0xff);

        } else {

            cdata[x * 4 + 3] = (px >> 24);

            cdata[x * 4 + 2] = (px >> 16);

            cdata[x * 4 + 1] = (px >> 8);

            cdata[x * 4] = (px & 0xff);

        }

    }

}

int

_XmJpegGetImage(Screen * screen, FILE * infile, XImage ** ximage)

{

    unsigned long image_width, image_height;

    unsigned char *xdata;

    int pad;

    CTable *image_data;

    int rc;

    if ((rc = load_jpeg(infile, &image_width, &image_height, &image_data)))

        return rc;

    if (screen->root_depth == 24 || screen->root_depth == 32) {

        xdata = (unsigned char *) malloc(4 * image_width * image_height);

        pad = 32;

    } else if (screen->root_depth == 16) {

        xdata = (unsigned char *) malloc(2 * image_width * image_height);

        pad = 16;

    } else {                    /* depth == 8 */

        xdata = (unsigned char *) malloc(image_width * image_height);

        pad = 8;

    }

    if (!xdata) 

        return 4;

    *ximage =

        XCreateImage(screen->display, screen->root_visual,

                     screen->root_depth, ZPixmap, 0, (char *) xdata,

                     image_width, image_height, pad, 0);

    if (!*ximage) {

        free(xdata);

        return 4;

    }

    {

        int xx, yy;

        CTable *p;

        for (yy = 0; yy < (*ximage)->height; yy++) {

            p = image_data + yy * (*ximage)->width;

            for (xx = 0; xx < (*ximage)->width; xx++, p++)

                store_pixel(screen, p, xx + yy * (*ximage)->width,

                            (*ximage)->data);

        }

    }

    if (image_data) {

        free(image_data);

        image_data = NULL;

    }

    return 0;

}