| /*====================================================================* |
| - Copyright (C) 2001 Leptonica. All rights reserved. |
| - This software is distributed in the hope that it will be |
| - useful, but with NO WARRANTY OF ANY KIND. |
| - No author or distributor accepts responsibility to anyone for the |
| - consequences of using this software, or for whether it serves any |
| - particular purpose or works at all, unless he or she says so in |
| - writing. Everyone is granted permission to copy, modify and |
| - redistribute this source code, for commercial or non-commercial |
| - purposes, with the following restrictions: (1) the origin of this |
| - source code must not be misrepresented; (2) modified versions must |
| - be plainly marked as such; and (3) this notice may not be removed |
| - or altered from any source or modified source distribution. |
| *====================================================================*/ |
| |
| /* |
| * jpegio.c |
| * |
| * Read jpeg from file |
| * PIX *pixReadJpeg() [ special top level ] |
| * PIX *pixReadStreamJpeg() |
| * |
| * Write jpeg to file |
| * l_int32 pixWriteJpeg() [ special top level ] |
| * l_int32 pixWriteStreamJpeg() |
| * |
| * Extraction of jpeg header information |
| * l_int32 extractJpegDataFromFile() |
| * l_int32 extractJpegDataFromArray() |
| * static l_int32 locateJpegImageParameters() |
| * static l_int32 getNextJpegMarker() |
| * static l_int32 getTwoByteParameter() |
| * |
| * Read/write to memory [not on windows] |
| * PIX *pixReadMemJpeg() |
| * l_int32 pixWriteMemJpeg() |
| * |
| * Static system helpers |
| * static void jpeg_error_do_not_exit() |
| * static l_uint8 jpeg_getc() |
| * static l_int32 jpeg_comment_callback() |
| * |
| * Documentation: libjpeg.doc can be found, along with all |
| * source code, at ftp://ftp.uu.net/graphics/jpeg |
| * Download and untar the file: jpegsrc.v6b.tar.gz |
| * A good paper on jpeg can also be found there: wallace.ps.gz |
| * |
| * The functions in libjpeg make it very simple to compress |
| * and decompress images. On input (decompression from file), |
| * 3 component color images can be read into either an 8 bpp Pix |
| * with a colormap or a 32 bpp Pix with RGB components. For output |
| * (compression to file), all color Pix, whether 8 bpp with a |
| * colormap or 32 bpp, are written compressed as a set of three |
| * 8 bpp (rgb) images. |
| * |
| * The default behavior of the jpeg library is to call exit. |
| * This is often undesirable, and the caller should make the |
| * decision when to abort a process. So I inserted setjmp(s) |
| * in the reader and writer, wrote a static error handler that |
| * does not exit, and set up the cinfo structure so that the |
| * low-level jpeg library will call this error handler instead |
| * of the default function error_exit(). |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include "allheaders.h" |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config_auto.h" |
| #endif /* HAVE_CONFIG_H */ |
| |
| /* --------------------------------------------*/ |
| #if HAVE_LIBJPEG /* defined in environ.h */ |
| /* --------------------------------------------*/ |
| |
| #include <setjmp.h> |
| #include "jpeglib.h" |
| |
| static void jpeg_error_do_not_exit(j_common_ptr cinfo); |
| static l_uint8 jpeg_getc(j_decompress_ptr cinfo); |
| static jmp_buf jpeg_jmpbuf; |
| |
| /* Note: 'boolean' is defined in jmorecfg.h. We use it explicitly |
| * here because for windows where __MINGW32__ is defined, |
| * the prototype for jpeg_comment_callback() is given as |
| * returning a boolean. */ |
| static boolean jpeg_comment_callback(j_decompress_ptr cinfo); |
| |
| /* Helpers for extraction of jpeg data */ |
| static l_int32 locateJpegImageParameters(l_uint8 *, l_int32, l_int32 *); |
| static l_int32 getNextJpegMarker(l_uint8 *, l_int32, l_int32 *); |
| static l_int32 getTwoByteParameter(l_uint8 *, l_int32); |
| |
| #ifndef NO_CONSOLE_IO |
| #define DEBUG_INFO 0 |
| #endif /* ~NO_CONSOLE_IO */ |
| |
| |
| /*---------------------------------------------------------------------* |
| * Reading Jpeg * |
| *---------------------------------------------------------------------*/ |
| /*! |
| * pixReadJpeg() |
| * |
| * Input: filename |
| * colormap flag (0 means return RGB image if color; |
| * 1 means create colormap and return 8 bpp |
| * palette image if color) |
| * reduction (scaling factor: 1, 2, 4 or 8) |
| * &pnwarn (<optional return> number of warnings about |
| * corrupted data) |
| * Return: pix, or null on error |
| * |
| * Images reduced by factors of 2, 4 or 8 can be returned |
| * significantly faster than full resolution images. |
| * |
| * The jpeg library will return warnings (or exit) if |
| * the jpeg data is bad. Use this function if you want the |
| * jpeg library to create an 8 bpp palette image, or to |
| * tell if the jpeg data has been corrupted. For corrupt jpeg |
| * data, there are two possible outcomes: |
| * (1) a damaged pix will be returned, along with a nonzero |
| * number of warnings, or |
| * (2) for sufficiently serious problems, the library will attempt |
| * to exit (caught by our error handler) and no pix will be returned. |
| */ |
| PIX * |
| pixReadJpeg(const char *filename, |
| l_int32 cmflag, |
| l_int32 reduction, |
| l_int32 *pnwarn) |
| { |
| FILE *fp; |
| PIX *pix; |
| |
| PROCNAME("pixReadJpeg"); |
| |
| if (!filename) |
| return (PIX *)ERROR_PTR("filename not defined", procName, NULL); |
| if (pnwarn) |
| *pnwarn = 0; /* init */ |
| if (cmflag != 0 && cmflag != 1) |
| cmflag = 0; /* default */ |
| if (reduction != 1 && reduction != 2 && reduction != 4 && reduction != 8) |
| return (PIX *)ERROR_PTR("reduction not in {1,2,4,8}", procName, NULL); |
| |
| if ((fp = fopenReadStream(filename)) == NULL) |
| return (PIX *)ERROR_PTR("image file not found", procName, NULL); |
| pix = pixReadStreamJpeg(fp, cmflag, reduction, pnwarn, 0); |
| fclose(fp); |
| |
| if (!pix) |
| return (PIX *)ERROR_PTR("image not returned", procName, NULL); |
| return pix; |
| } |
| |
| |
| /*! |
| * pixReadStreamJpeg() |
| * |
| * Input: stream |
| * colormap flag (0 means return RGB image if color; |
| * 1 means create colormap and return 8 bpp |
| * palette image if color) |
| * reduction (scaling factor: 1, 2, 4 or 8) |
| * &pnwarn (<optional return> number of warnings) |
| * hint: a bitwise OR of L_HINT_* values |
| * Return: pix, or null on error |
| * |
| * Usage: see pixReadJpeg() |
| */ |
| PIX * |
| pixReadStreamJpeg(FILE *fp, |
| l_int32 cmflag, |
| l_int32 reduction, |
| l_int32 *pnwarn, |
| l_int32 hint) |
| { |
| l_uint8 cyan, yellow, magenta, black, white; |
| l_int32 rval, gval, bval; |
| l_int32 i, j, k; |
| l_int32 w, h, wpl, spp, ncolors, cindex, ycck, cmyk; |
| l_uint32 *data; |
| l_uint32 *line, *ppixel; |
| JSAMPROW rowbuffer; |
| PIX *pix; |
| PIXCMAP *cmap; |
| struct jpeg_decompress_struct cinfo; |
| struct jpeg_error_mgr jerr; |
| l_uint8 *comment = NULL; |
| |
| PROCNAME("pixReadStreamJpeg"); |
| |
| if (!fp) |
| return (PIX *)ERROR_PTR("fp not defined", procName, NULL); |
| if (pnwarn) |
| *pnwarn = 0; /* init */ |
| if (cmflag != 0 && cmflag != 1) |
| cmflag = 0; /* default */ |
| if (reduction != 1 && reduction != 2 && reduction != 4 && reduction != 8) |
| return (PIX *)ERROR_PTR("reduction not in {1,2,4,8}", procName, NULL); |
| |
| if (BITS_IN_JSAMPLE != 8) /* set in jmorecfg.h */ |
| return (PIX *)ERROR_PTR("BITS_IN_JSAMPLE != 8", procName, NULL); |
| |
| rewind(fp); |
| |
| pix = NULL; /* init */ |
| if (setjmp(jpeg_jmpbuf)) { |
| pixDestroy(&pix); |
| FREE(rowbuffer); |
| return (PIX *)ERROR_PTR("internal jpeg error", procName, NULL); |
| } |
| |
| rowbuffer = NULL; |
| cinfo.err = jpeg_std_error(&jerr); |
| jerr.error_exit = jpeg_error_do_not_exit; /* catch error; do not exit! */ |
| |
| jpeg_create_decompress(&cinfo); |
| |
| cinfo.client_data = &comment; |
| jpeg_set_marker_processor(&cinfo, JPEG_COM, jpeg_comment_callback); |
| jpeg_stdio_src(&cinfo, fp); |
| jpeg_read_header(&cinfo, TRUE); |
| cinfo.scale_denom = reduction; |
| if (hint & L_HINT_GRAY) |
| cinfo.out_color_space = JCS_GRAYSCALE; |
| jpeg_calc_output_dimensions(&cinfo); |
| |
| /* Allocate the image and a row buffer */ |
| spp = cinfo.out_color_components; |
| w = cinfo.output_width; |
| h = cinfo.output_height; |
| ycck = (cinfo.jpeg_color_space == JCS_YCCK && spp == 4 && cmflag == 0); |
| cmyk = (cinfo.jpeg_color_space == JCS_CMYK && spp == 4 && cmflag == 0); |
| if (spp != 1 && spp != 3 && !ycck && !cmyk) { |
| if (comment) FREE(comment); |
| return (PIX *)ERROR_PTR("spp must be 1 or 3, or YCCK or CMYK", |
| procName, NULL); |
| } |
| if ((spp == 3 && cmflag == 0) || ycck || cmyk) { /* rgb or 4 bpp color */ |
| rowbuffer = (JSAMPROW)CALLOC(sizeof(JSAMPLE), spp * w); |
| pix = pixCreate(w, h, 32); |
| } |
| else { /* 8 bpp gray or colormapped */ |
| rowbuffer = (JSAMPROW)CALLOC(sizeof(JSAMPLE), w); |
| pix = pixCreate(w, h, 8); |
| } |
| if (!rowbuffer || !pix) { |
| if (comment) FREE(comment); |
| if (rowbuffer) FREE(rowbuffer); |
| pixDestroy(&pix); |
| return (PIX *)ERROR_PTR("rowbuffer or pix not made", procName, NULL); |
| } |
| |
| if (comment) { |
| pixSetText(pix, (char *)comment); |
| FREE(comment); |
| } |
| |
| if (spp == 1) /* Grayscale or colormapped */ |
| jpeg_start_decompress(&cinfo); |
| else { /* Color; spp == 3 or YCCK or CMYK */ |
| if (cmflag == 0) { /* -- 24 bit color in 32 bit pix or YCCK/CMYK -- */ |
| cinfo.quantize_colors = FALSE; |
| jpeg_start_decompress(&cinfo); |
| } |
| else { /* Color quantize to 8 bits */ |
| cinfo.quantize_colors = TRUE; |
| cinfo.desired_number_of_colors = 256; |
| jpeg_start_decompress(&cinfo); |
| |
| /* Construct a pix cmap */ |
| cmap = pixcmapCreate(8); |
| ncolors = cinfo.actual_number_of_colors; |
| for (cindex = 0; cindex < ncolors; cindex++) |
| { |
| rval = cinfo.colormap[0][cindex]; |
| gval = cinfo.colormap[1][cindex]; |
| bval = cinfo.colormap[2][cindex]; |
| pixcmapAddColor(cmap, rval, gval, bval); |
| } |
| pixSetColormap(pix, cmap); |
| } |
| } |
| wpl = pixGetWpl(pix); |
| data = pixGetData(pix); |
| |
| /* Decompress */ |
| if ((spp == 3 && cmflag == 0) || ycck || cmyk) { /* -- 24 bit color -- */ |
| for (i = 0; i < h; i++) { |
| if (jpeg_read_scanlines(&cinfo, &rowbuffer, (JDIMENSION)1) != 1) |
| return (PIX *)ERROR_PTR("bad read scanline", procName, NULL); |
| ppixel = data + i * wpl; |
| if (spp == 3) { |
| for (j = k = 0; j < w; j++) { |
| SET_DATA_BYTE(ppixel, COLOR_RED, rowbuffer[k++]); |
| SET_DATA_BYTE(ppixel, COLOR_GREEN, rowbuffer[k++]); |
| SET_DATA_BYTE(ppixel, COLOR_BLUE, rowbuffer[k++]); |
| ppixel++; |
| } |
| } else { |
| /* This is a conversion from CMYK -> RGB that ignores |
| color profiles, and is invoked when the image header |
| claims to be in CMYK or YCCK colorspace. If in YCCK, |
| libjpeg may be doing YCCK -> CMYK under the hood. |
| To understand why the colors are inverted on read-in, |
| see the "Special color spaces" section of |
| "Using the IJG JPEG Library" by Thomas G. Lane. */ |
| for (j = k = 0; j < w; j++) { |
| cyan = 255 - rowbuffer[k++]; |
| magenta = 255 - rowbuffer[k++]; |
| yellow = 255 - rowbuffer[k++]; |
| white = rowbuffer[k++]; |
| black = 255 - white; |
| rval = 255 - (cyan * white) / 255 - black; |
| gval = 255 - (magenta * white) / 255 - black; |
| bval = 255 - (yellow * white) / 255 - black; |
| rval = L_MIN(L_MAX(rval, 0), 255); |
| gval = L_MIN(L_MAX(gval, 0), 255); |
| bval = L_MIN(L_MAX(bval, 0), 255); |
| composeRGBPixel(rval, gval, bval, ppixel); |
| ppixel++; |
| } |
| } |
| } |
| } |
| else { /* 8 bpp grayscale or colormapped pix */ |
| for (i = 0; i < h; i++) { |
| if (jpeg_read_scanlines(&cinfo, &rowbuffer, (JDIMENSION)1) != 1) |
| return (PIX *)ERROR_PTR("bad read scanline", procName, NULL); |
| line = data + i * wpl; |
| for (j = 0; j < w; j++) |
| SET_DATA_BYTE(line, j, rowbuffer[j]); |
| } |
| } |
| |
| if (pnwarn) |
| *pnwarn = cinfo.err->num_warnings; |
| |
| switch (cinfo.density_unit) |
| { |
| case 1: /* pixels per inch */ |
| pixSetXRes(pix, cinfo.X_density); |
| pixSetYRes(pix, cinfo.Y_density); |
| break; |
| case 2: /* pixels per centimeter */ |
| pixSetXRes(pix, (l_int32)((l_float32)cinfo.X_density * 2.54 + 0.5)); |
| pixSetYRes(pix, (l_int32)((l_float32)cinfo.Y_density * 2.54 + 0.5)); |
| break; |
| default: /* the pixel density may not be defined; ignore */ |
| break; |
| } |
| |
| jpeg_finish_decompress(&cinfo); |
| jpeg_destroy_decompress(&cinfo); |
| FREE(rowbuffer); |
| |
| return pix; |
| } |
| |
| |
| |
| /*---------------------------------------------------------------------* |
| * Writing Jpeg * |
| *---------------------------------------------------------------------*/ |
| /*! |
| * pixWriteJpeg() |
| * |
| * Input: filename |
| * pix |
| * quality (1 - 100; 75 is default) |
| * progressive (0 for baseline sequential; 1 for progressive) |
| * Return: 0 if OK; 1 on error |
| */ |
| l_int32 |
| pixWriteJpeg(const char *filename, |
| PIX *pix, |
| l_int32 quality, |
| l_int32 progressive) |
| { |
| FILE *fp; |
| |
| PROCNAME("pixWriteJpeg"); |
| |
| if (!pix) |
| return ERROR_INT("pix not defined", procName, 1); |
| if (!filename) |
| return ERROR_INT("filename not defined", procName, 1); |
| |
| if ((fp = fopen(filename, "wb+")) == NULL) |
| return ERROR_INT("stream not opened", procName, 1); |
| |
| if (pixWriteStreamJpeg(fp, pix, quality, progressive)) { |
| fclose(fp); |
| return ERROR_INT("pix not written to stream", procName, 1); |
| } |
| |
| fclose(fp); |
| return 0; |
| } |
| |
| |
| /*! |
| * pixWriteStreamJpeg() |
| * |
| * Input: stream |
| * pix (8 or 32 bpp) |
| * quality (1 - 100; 75 is default value; 0 is also default) |
| * progressive (0 for baseline sequential; 1 for progressive) |
| * Return: 0 if OK, 1 on error |
| * |
| * Notes: |
| * (1) Under the covers, the library transforms rgb to a |
| * luminence-chromaticity triple, each component of which is |
| * also 8 bits, and compresses that. It uses 2 Huffman tables, |
| * a higher resolution one (with more quantization levels) |
| * for luminosity and a lower resolution one for the chromas. |
| * (2) Progressive encoding gives better compression, at the |
| * expense of slower encoding and decoding. |
| * (3) There are three possibilities: |
| * * Grayscale image, no colormap: compress as 8 bpp image. |
| * * rgb full color image: copy each line into the color |
| * line buffer, and compress as three 8 bpp images. |
| * * 8 bpp colormapped image: convert each line to three |
| * 8 bpp line images in the color line buffer, and |
| * compress as three 8 bpp images. |
| * (4) The only valid pixel depths in leptonica are 1, 2, 4, 8, 16 |
| * and 32 bpp. However, it is possible, and in some cases desirable, |
| * to write out a jpeg file using an rgb pix that has 24 bpp. |
| * This can be created by appending the raster data for a 24 bpp |
| * image (with proper scanline padding) directly to a 24 bpp |
| * pix that was created without a data array. See note in |
| * pixWriteStreamPng() for an example. |
| */ |
| l_int32 |
| pixWriteStreamJpeg(FILE *fp, |
| PIX *pix, |
| l_int32 quality, |
| l_int32 progressive) |
| { |
| l_uint8 byteval; |
| l_int32 xres, yres; |
| l_int32 i, j, k; |
| l_int32 w, h, d, wpl, spp, colorflg, rowsamples; |
| l_int32 *rmap, *gmap, *bmap; |
| l_uint32 *ppixel, *line, *data; |
| JSAMPROW rowbuffer; |
| PIXCMAP *cmap; |
| struct jpeg_compress_struct cinfo; |
| struct jpeg_error_mgr jerr; |
| const char *text; |
| |
| PROCNAME("pixWriteStreamJpeg"); |
| |
| if (!fp) |
| return ERROR_INT("stream not open", procName, 1); |
| if (!pix) |
| return ERROR_INT("pix not defined", procName, 1); |
| rewind(fp); |
| |
| if (setjmp(jpeg_jmpbuf)) { |
| FREE(rowbuffer); |
| if (colorflg == 1) { |
| FREE(rmap); |
| FREE(gmap); |
| FREE(bmap); |
| } |
| return ERROR_INT("internal jpeg error", procName, 1); |
| } |
| |
| rowbuffer = NULL; |
| rmap = NULL; |
| gmap = NULL; |
| bmap = NULL; |
| w = pixGetWidth(pix); |
| h = pixGetHeight(pix); |
| d = pixGetDepth(pix); |
| if (d != 8 && d != 24 && d != 32) |
| return ERROR_INT("bpp must be 8, 24 or 32", procName, 1); |
| |
| if (quality <= 0) |
| quality = 75; /* default */ |
| |
| if (d == 32 || d == 24) |
| colorflg = 2; /* rgb; no colormap */ |
| else if ((cmap = pixGetColormap(pix)) == NULL) |
| colorflg = 0; /* 8 bpp grayscale; no colormap */ |
| else { |
| colorflg = 1; /* 8 bpp; colormap */ |
| pixcmapToArrays(cmap, &rmap, &gmap, &bmap); |
| } |
| |
| cinfo.err = jpeg_std_error(&jerr); |
| jerr.error_exit = jpeg_error_do_not_exit; /* catch error; do not exit! */ |
| |
| jpeg_create_compress(&cinfo); |
| jpeg_stdio_dest(&cinfo, fp); |
| |
| cinfo.image_width = w; |
| cinfo.image_height = h; |
| |
| if (colorflg == 0) { |
| cinfo.input_components = 1; |
| cinfo.in_color_space = JCS_GRAYSCALE; |
| } |
| else { /* colorflg == 1 or 2 */ |
| cinfo.input_components = 3; |
| cinfo.in_color_space = JCS_RGB; |
| } |
| |
| jpeg_set_defaults(&cinfo); |
| |
| /* Setting optimize_coding to TRUE seems to improve compression |
| * by approx 2-4 percent, and increases comp time by approx 20%. */ |
| cinfo.optimize_coding = FALSE; |
| |
| xres = pixGetXRes(pix); |
| yres = pixGetYRes(pix); |
| if ((xres != 0) && (yres != 0)) { |
| cinfo.density_unit = 1; /* designates pixels per inch */ |
| cinfo.X_density = xres; |
| cinfo.Y_density = yres; |
| } |
| |
| jpeg_set_quality(&cinfo, quality, TRUE); |
| if (progressive) { |
| jpeg_simple_progression(&cinfo); |
| } |
| |
| jpeg_start_compress(&cinfo, TRUE); |
| |
| if ((text = pixGetText(pix))) { |
| jpeg_write_marker(&cinfo, JPEG_COM, (const JOCTET *)text, strlen(text)); |
| } |
| |
| /* Allocate row buffer */ |
| spp = cinfo.input_components; |
| rowsamples = spp * w; |
| if ((rowbuffer = (JSAMPROW)CALLOC(sizeof(JSAMPLE), rowsamples)) == NULL) |
| return ERROR_INT("calloc fail for rowbuffer", procName, 1); |
| |
| data = pixGetData(pix); |
| wpl = pixGetWpl(pix); |
| for (i = 0; i < h; i++) { |
| line = data + i * wpl; |
| if (colorflg == 0) { /* 8 bpp gray */ |
| for (j = 0; j < w; j++) |
| rowbuffer[j] = GET_DATA_BYTE(line, j); |
| } |
| else if (colorflg == 1) { /* 8 bpp colormapped */ |
| for (j = 0; j < w; j++) { |
| byteval = GET_DATA_BYTE(line, j); |
| rowbuffer[3 * j + COLOR_RED] = rmap[byteval]; |
| rowbuffer[3 * j + COLOR_GREEN] = gmap[byteval]; |
| rowbuffer[3 * j + COLOR_BLUE] = bmap[byteval]; |
| } |
| } |
| else { /* colorflg == 2 */ |
| if (d == 24) { /* See note 4 above; special case of 24 bpp rgb */ |
| jpeg_write_scanlines(&cinfo, (JSAMPROW *)&line, 1); |
| } |
| else { /* standard 32 bpp rgb */ |
| ppixel = line; |
| for (j = k = 0; j < w; j++) { |
| rowbuffer[k++] = GET_DATA_BYTE(ppixel, COLOR_RED); |
| rowbuffer[k++] = GET_DATA_BYTE(ppixel, COLOR_GREEN); |
| rowbuffer[k++] = GET_DATA_BYTE(ppixel, COLOR_BLUE); |
| ppixel++; |
| } |
| } |
| } |
| if (d != 24) |
| jpeg_write_scanlines(&cinfo, &rowbuffer, 1); |
| } |
| |
| jpeg_finish_compress(&cinfo); |
| |
| FREE(rowbuffer); |
| if (colorflg == 1) { |
| FREE(rmap); |
| FREE(gmap); |
| FREE(bmap); |
| } |
| |
| jpeg_destroy_compress(&cinfo); |
| return 0; |
| } |
| |
| |
| /*---------------------------------------------------------------------* |
| * Extraction of jpeg header information * |
| *---------------------------------------------------------------------*/ |
| /*! |
| * extractJpegDataFromFile() |
| * |
| * Input: filein |
| * &data (<return> binary data consisting of the entire jpeg file) |
| * &nbytes (<return> size of binary data) |
| * &w (<optional return> image width) |
| * &h (<optional return> image height) |
| * &bps (<optional return> bits/sample; should be 8) |
| * &spp (<optional return> samples/pixel; should be 1 or 3) |
| * Return: 0 if OK, 1 on error |
| */ |
| l_int32 |
| extractJpegDataFromFile(const char *filein, |
| l_uint8 **pdata, |
| l_int32 *pnbytes, |
| l_int32 *pw, |
| l_int32 *ph, |
| l_int32 *pbps, |
| l_int32 *pspp) |
| { |
| l_uint8 *data; |
| l_int32 format, nbytes; |
| FILE *fpin; |
| |
| PROCNAME("extractJpegDataFromFile"); |
| |
| if (!filein) |
| return ERROR_INT("filein not defined", procName, 1); |
| if (!pdata) |
| return ERROR_INT("&data not defined", procName, 1); |
| if (!pnbytes) |
| return ERROR_INT("&nbytes not defined", procName, 1); |
| if (!pw && !ph && !pbps && !pspp) |
| return ERROR_INT("no output data requested", procName, 1); |
| *pdata = NULL; |
| *pnbytes = 0; |
| |
| if ((fpin = fopen(filein, "r")) == NULL) |
| return ERROR_INT("filein not defined", procName, 1); |
| format = findFileFormat(fpin); |
| fclose(fpin); |
| if (format != IFF_JFIF_JPEG) |
| return ERROR_INT("filein not jfif jpeg", procName, 1); |
| |
| if ((data = arrayRead(filein, &nbytes)) == NULL) |
| return ERROR_INT("inarray not made", procName, 1); |
| *pnbytes = nbytes; |
| *pdata = data; |
| |
| /* On error, free the data */ |
| if (extractJpegDataFromArray(data, nbytes, pw, ph, pbps, pspp)) { |
| FREE(data); |
| *pdata = NULL; |
| *pnbytes = 0; |
| } |
| |
| return 0; |
| } |
| |
| |
| /*! |
| * extractJpegDataFromArray() |
| * |
| * Input: data (binary data consisting of the entire jpeg file) |
| * nbytes (size of binary data) |
| * &w (<optional return> image width) |
| * &h (<optional return> image height) |
| * &bps (<optional return> bits/sample; should be 8) |
| * &spp (<optional return> samples/pixel; should be 1, 3 or 4) |
| * Return: 0 if OK, 1 on error |
| */ |
| l_int32 |
| extractJpegDataFromArray(const void *data, |
| l_int32 nbytes, |
| l_int32 *pw, |
| l_int32 *ph, |
| l_int32 *pbps, |
| l_int32 *pspp) |
| { |
| l_uint8 *data8; |
| l_int32 imeta, msize, bps, w, h, spp; |
| |
| PROCNAME("extractJpegDataFromArray"); |
| |
| if (!data) |
| return ERROR_INT("data not defined", procName, 1); |
| if (!pw && !ph && !pbps && !pspp) |
| return ERROR_INT("no output data requested", procName, 1); |
| data8 = (l_uint8 *)data; |
| |
| /* Find where the image metadata begins in header: |
| * 0xc0 is start of metadata for baseline DCT; |
| * 0xc1 is start of metadata for extended sequential DCT; |
| * ... */ |
| imeta = 0; |
| if (locateJpegImageParameters(data8, nbytes, &imeta)) |
| return ERROR_INT("metadata not found", procName, 1); |
| |
| /* Save the metadata */ |
| msize = getTwoByteParameter(data8, imeta); /* metadata size */ |
| bps = data8[imeta + 2]; |
| h = getTwoByteParameter(data8, imeta + 3); |
| w = getTwoByteParameter(data8, imeta + 5); |
| spp = data8[imeta + 7]; |
| if (pbps) *pbps = bps; |
| if (ph) *ph = h; |
| if (pw) *pw = w; |
| if (pspp) *pspp = spp; |
| |
| #if DEBUG_INFO |
| fprintf(stderr, "w = %d, h = %d, bps = %d, spp = %d\n", w, h, bps, spp); |
| fprintf(stderr, "imeta = %d, msize = %d\n", imeta, msize); |
| #endif /* DEBUG_INFO */ |
| |
| /* Is the data obviously bad? */ |
| if (h <= 0 || w <= 0 || bps != 8 || (spp != 1 && spp !=3 && spp != 4)) { |
| fprintf(stderr, "h = %d, w = %d, bps = %d, spp = %d\n", h, w, bps, spp); |
| return ERROR_INT("image parameters not valid", procName, 1); |
| } |
| |
| return 0; |
| } |
| |
| |
| /* |
| * locateJpegImageParameters() |
| * |
| * Input: inarray (binary jpeg) |
| * size (of the data array) |
| * &index (<return> location of image metadata) |
| * Return: 0 if OK, 1 on error. Caller must check this! |
| * |
| * Notes: |
| * (1) The parameters listed here appear to be the only jpeg flags |
| * we need to worry about. It would have been nice to have |
| * avoided the switch with all these parameters, but |
| * unfortunately the parser for the jpeg header is set |
| * to accept any old flag that's not on the approved list! |
| * So we have to look for a flag that's not on the list |
| * (and is not 0), and then interpret the size of the |
| * data chunk and skip it. Sometimes such a chunk contains |
| * a thumbnail version of the image, so if we don't skip it, |
| * we will find a pair of bytes such as 0xffc0, followed |
| * by small w and h dimensions. |
| */ |
| static l_int32 |
| locateJpegImageParameters(l_uint8 *inarray, |
| l_int32 size, |
| l_int32 *pindex) |
| { |
| l_uint8 val; |
| l_int32 index, skiplength; |
| |
| PROCNAME("locateJpegImageParameters"); |
| |
| if (!inarray) |
| return ERROR_INT("inarray not defined", procName, 1); |
| if (!pindex) |
| return ERROR_INT("&index not defined", procName, 1); |
| |
| index = *pindex; |
| while (1) { |
| if (getNextJpegMarker(inarray, size, &index)) |
| break; |
| if ((val = inarray[index]) == 0) /* ignore if "escaped" */ |
| continue; |
| /* fprintf(stderr, " marker %x at %o, %d\n", val, index, index); */ |
| switch(val) |
| { |
| case 0xc0: /* M_SOF0 */ |
| case 0xc1: /* M_SOF1 */ |
| case 0xc2: /* M_SOF2 */ |
| case 0xc3: /* M_SOF3 */ |
| case 0xc5: /* M_SOF5 */ |
| case 0xc6: /* M_SOF6 */ |
| case 0xc7: /* M_SOF7 */ |
| case 0xc9: /* M_SOF9 */ |
| case 0xca: /* M_SOF10 */ |
| case 0xcd: /* M_SOF13 */ |
| case 0xce: /* M_SOF14 */ |
| case 0xcf: /* M_SOF15 */ |
| *pindex = index + 1; /* found it */ |
| return 0; |
| |
| case 0x01: /* M_TEM */ |
| case 0xd0: /* M_RST0 */ |
| case 0xd1: /* M_RST1 */ |
| case 0xd2: /* M_RST2 */ |
| case 0xd3: /* M_RST3 */ |
| case 0xd4: /* M_RST4 */ |
| case 0xd5: /* M_RST5 */ |
| case 0xd6: /* M_RST6 */ |
| case 0xd7: /* M_RST7 */ |
| case 0xd8: /* M_SOI */ |
| case 0xd9: /* M_EOI */ |
| case 0xe0: /* M_APP0 */ |
| case 0xee: /* M_APP14 */ |
| break; |
| |
| default: |
| skiplength = getTwoByteParameter(inarray, index + 1); |
| index += skiplength; |
| break; |
| } |
| } |
| |
| return 1; /* not found */ |
| } |
| |
| |
| /* |
| * getNextJpegMarker() |
| * |
| * Input: array (jpeg data) |
| * size (from current point to the end) |
| * &index (<return> the last position searched. If it |
| * is not at the end of the array, we return |
| * the first byte that is not 0xff, after |
| * having encountered at least one 0xff.) |
| * Return: 0 if a marker is found, 1 if the end of the array is reached |
| * |
| * Notes: |
| * (1) In jpeg, 0xff is used to mark the end of a data segment. |
| * There may be more than one 0xff in succession. But not every |
| * 0xff marks the end of a segment. It is possible, though |
| * rare, that 0xff can occur within some data. In that case, |
| * the marker is "escaped", by following it with 0x00. |
| * (2) This function parses a jpeg data stream. It doesn't |
| * _really_ get the next marker, because it doesn't check if |
| * the 0xff is escaped. But the caller checks for this escape |
| * condition, and ignores the marker if escaped. |
| */ |
| static l_int32 |
| getNextJpegMarker(l_uint8 *array, |
| l_int32 size, |
| l_int32 *pindex) |
| { |
| l_uint8 val; |
| l_int32 index; |
| |
| PROCNAME("getNextJpegMarker"); |
| |
| if (!array) |
| return ERROR_INT("array not defined", procName, 1); |
| if (!pindex) |
| return ERROR_INT("&index not defined", procName, 1); |
| |
| index = *pindex; |
| |
| while (index < size) { /* skip to 0xff */ |
| val = array[index++]; |
| if (val == 0xff) |
| break; |
| } |
| |
| while (index < size) { /* skip repeated 0xff */ |
| val = array[index++]; |
| if (val != 0xff) |
| break; |
| } |
| |
| *pindex = index - 1; |
| if (index >= size) |
| return 1; |
| else |
| return 0; |
| } |
| |
| |
| static l_int32 |
| getTwoByteParameter(l_uint8 *array, |
| l_int32 index) |
| { |
| return (l_int32)((array[index]) << 8) + (l_int32)(array[index + 1]); |
| } |
| |
| |
| |
| /*---------------------------------------------------------------------* |
| * Read/write to memory * |
| *---------------------------------------------------------------------*/ |
| #if HAVE_FMEMOPEN |
| |
| #include "_stdio.h" |
| /* extern FILE *open_memstream(char **data, size_t *size); */ |
| /* extern FILE *fmemopen(void *data, size_t size, const char *mode); */ |
| |
| /*! |
| * pixReadMemJpeg() |
| * |
| * Input: cdata (const; jpeg-encoded) |
| * size (of data) |
| * colormap flag (0 means return RGB image if color; |
| * 1 means create colormap and return 8 bpp |
| * palette image if color) |
| * reduction (scaling factor: 1, 2, 4 or 8) |
| * &pnwarn (<optional return> number of warnings) |
| * hint (bitwise OR of L_HINT_* values; use 0 for no hint) |
| * Return: pix, or null on error |
| * |
| * Notes: |
| * (1) The @size byte of @data must be a null character. |
| * (2) See pixReadJpeg() for usage. |
| */ |
| PIX * |
| pixReadMemJpeg(const l_uint8 *cdata, |
| size_t size, |
| l_int32 cmflag, |
| l_int32 reduction, |
| l_int32 *pnwarn, |
| l_int32 hint) |
| { |
| l_uint8 *data; |
| FILE *fp; |
| PIX *pix; |
| |
| PROCNAME("pixReadMemJpeg"); |
| |
| if (!cdata) |
| return (PIX *)ERROR_PTR("cdata not defined", procName, NULL); |
| |
| data = (l_uint8 *)cdata; /* we're really not going to change this */ |
| if ((fp = fmemopen(data, size, "r")) == NULL) |
| return (PIX *)ERROR_PTR("stream not opened", procName, NULL); |
| pix = pixReadStreamJpeg(fp, cmflag, reduction, pnwarn, hint); |
| fclose(fp); |
| return pix; |
| } |
| |
| |
| /*! |
| * pixWriteMemJpeg() |
| * |
| * Input: &data (<return> data of tiff compressed image) |
| * &size (<return> size of returned data) |
| * pix |
| * quality (1 - 100; 75 is default value; 0 is also default) |
| * progressive (0 for baseline sequential; 1 for progressive) |
| * Return: 0 if OK, 1 on error |
| * |
| * Notes: |
| * (1) See pixWriteStreamJpeg() for usage. This version writes to |
| * memory instead of to a file stream. |
| */ |
| l_int32 |
| pixWriteMemJpeg(l_uint8 **pdata, |
| size_t *psize, |
| PIX *pix, |
| l_int32 quality, |
| l_int32 progressive) |
| { |
| l_int32 ret; |
| FILE *fp; |
| |
| PROCNAME("pixWriteMemJpeg"); |
| |
| if (!pdata) |
| return ERROR_INT("&data not defined", procName, 1 ); |
| if (!psize) |
| return ERROR_INT("&size not defined", procName, 1 ); |
| if (!pix) |
| return ERROR_INT("&pix not defined", procName, 1 ); |
| |
| if ((fp = open_memstream((char **)pdata, psize)) == NULL) |
| return ERROR_INT("stream not opened", procName, 1); |
| ret = pixWriteStreamJpeg(fp, pix, quality, progressive); |
| fclose(fp); |
| return ret; |
| } |
| |
| #else |
| |
| PIX * |
| pixReadMemJpeg(const l_uint8 *cdata, |
| size_t size, |
| l_int32 cmflag, |
| l_int32 reduction, |
| l_int32 *pnwarn, |
| l_int32 hint) |
| { |
| return (PIX *)ERROR_PTR( |
| "jpeg read from memory not implemented on this platform", |
| "pixReadMemJpeg", NULL); |
| } |
| |
| |
| l_int32 |
| pixWriteMemJpeg(l_uint8 **pdata, |
| size_t *psize, |
| PIX *pix, |
| l_int32 quality, |
| l_int32 progressive) |
| { |
| return ERROR_INT( |
| "jpeg write to memory not implemented on this platform", |
| "pixWriteMemJpeg", 1); |
| } |
| |
| #endif /* HAVE_FMEMOPEN */ |
| |
| |
| /*---------------------------------------------------------------------* |
| * Static helpers * |
| *---------------------------------------------------------------------*/ |
| /* The default jpeg error_exit() kills the process. |
| * We don't want leptonica to allow this to happen. |
| * If you want this default behavior, remove the |
| * calls to this in the functions above. */ |
| static void |
| jpeg_error_do_not_exit(j_common_ptr cinfo) |
| { |
| (*cinfo->err->output_message) (cinfo); |
| jpeg_destroy(cinfo); |
| longjmp(jpeg_jmpbuf, 0); |
| return; |
| } |
| |
| /* This function was borrowed from libjpeg. */ |
| static l_uint8 |
| jpeg_getc(j_decompress_ptr cinfo) |
| { |
| struct jpeg_source_mgr *datasrc; |
| |
| datasrc = cinfo->src; |
| if (datasrc->bytes_in_buffer == 0) { |
| if (! (*datasrc->fill_input_buffer) (cinfo)) { |
| return 0; |
| } |
| } |
| datasrc->bytes_in_buffer--; |
| return GETJOCTET(*datasrc->next_input_byte++); |
| } |
| |
| |
| /* This function is required for reading jpeg comments, and |
| * was contributed by Antony Dovgal. Why 'boolean'? See |
| * note above the declaration. */ |
| static boolean |
| jpeg_comment_callback(j_decompress_ptr cinfo) |
| { |
| l_int32 length, i; |
| l_uint32 c; |
| l_uint8 **comment; |
| |
| comment = (l_uint8 **)cinfo->client_data; |
| length = jpeg_getc(cinfo) << 8; |
| length += jpeg_getc(cinfo); |
| length -= 2; |
| |
| if (length <= 0) |
| return 1; |
| |
| *comment = (l_uint8 *)MALLOC(length + 1); |
| if (!(*comment)) |
| return 0; |
| |
| for (i = 0; i < length; i++) { |
| c = jpeg_getc(cinfo); |
| (*comment)[i] = c; |
| } |
| (*comment)[length] = 0; |
| |
| return 1; |
| } |
| |
| /* --------------------------------------------*/ |
| #endif /* HAVE_LIBJPEG */ |
| /* --------------------------------------------*/ |
| |
