ryan/mozjpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Get rid of the HAVE_PROTOTYPES configuration option, as well as the related JMETHOD and JPP macros. libjpeg-turbo has never supported compilers that don't handle prototypes. Doing so requires ansi2knr, which isn't even supported in the IJG code anymore.

Browse Source
This commit is contained in:
DRC
2014-05-16 10:43:44 +00:00
parent 2c0b793539
commit f8301c92dd
42 changed files with 1077 additions and 1332 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
cdjpeg.h
View File

@@ -24,12 +24,9 @@
typedef struct cjpeg_source_struct * cjpeg_source_ptr; typedef struct cjpeg_source_struct * cjpeg_source_ptr;
struct cjpeg_source_struct { struct cjpeg_source_struct {
JMETHOD(void, start_input, (j_compress_ptr cinfo, void (*start_input) (j_compress_ptr cinfo, cjpeg_source_ptr sinfo);
cjpeg_source_ptr sinfo)); JDIMENSION (*get_pixel_rows) (j_compress_ptr cinfo, cjpeg_source_ptr sinfo);
JMETHOD(JDIMENSION, get_pixel_rows, (j_compress_ptr cinfo, void (*finish_input) (j_compress_ptr cinfo, cjpeg_source_ptr sinfo);
cjpeg_source_ptr sinfo));
JMETHOD(void, finish_input, (j_compress_ptr cinfo,
cjpeg_source_ptr sinfo));
FILE *input_file; FILE *input_file;
@@ -48,15 +45,12 @@ struct djpeg_dest_struct {
/* start_output is called after jpeg_start_decompress finishes. /* start_output is called after jpeg_start_decompress finishes.
* The color map will be ready at this time, if one is needed. * The color map will be ready at this time, if one is needed.
*/ */
JMETHOD(void, start_output, (j_decompress_ptr cinfo, void (*start_output) (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo);
djpeg_dest_ptr dinfo));
/* Emit the specified number of pixel rows from the buffer. */ /* Emit the specified number of pixel rows from the buffer. */
JMETHOD(void, put_pixel_rows, (j_decompress_ptr cinfo, void (*put_pixel_rows) (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
djpeg_dest_ptr dinfo, JDIMENSION rows_supplied);
JDIMENSION rows_supplied));
/* Finish up at the end of the image. */ /* Finish up at the end of the image. */
JMETHOD(void, finish_output, (j_decompress_ptr cinfo, void (*finish_output) (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo);
djpeg_dest_ptr dinfo));
/* Target file spec; filled in by djpeg.c after object is created. */ /* Target file spec; filled in by djpeg.c after object is created. */
FILE * output_file; FILE * output_file;
@@ -91,41 +85,41 @@ typedef struct cdjpeg_progress_mgr * cd_progress_ptr;
/* Module selection routines for I/O modules. */ /* Module selection routines for I/O modules. */
EXTERN(cjpeg_source_ptr) jinit_read_bmp JPP((j_compress_ptr cinfo)); EXTERN(cjpeg_source_ptr) jinit_read_bmp (j_compress_ptr cinfo);
EXTERN(djpeg_dest_ptr) jinit_write_bmp JPP((j_decompress_ptr cinfo, EXTERN(djpeg_dest_ptr) jinit_write_bmp (j_decompress_ptr cinfo,
boolean is_os2)); boolean is_os2);
EXTERN(cjpeg_source_ptr) jinit_read_gif JPP((j_compress_ptr cinfo)); EXTERN(cjpeg_source_ptr) jinit_read_gif (j_compress_ptr cinfo);
EXTERN(djpeg_dest_ptr) jinit_write_gif JPP((j_decompress_ptr cinfo)); EXTERN(djpeg_dest_ptr) jinit_write_gif (j_decompress_ptr cinfo);
EXTERN(cjpeg_source_ptr) jinit_read_ppm JPP((j_compress_ptr cinfo)); EXTERN(cjpeg_source_ptr) jinit_read_ppm (j_compress_ptr cinfo);
EXTERN(djpeg_dest_ptr) jinit_write_ppm JPP((j_decompress_ptr cinfo)); EXTERN(djpeg_dest_ptr) jinit_write_ppm (j_decompress_ptr cinfo);
EXTERN(cjpeg_source_ptr) jinit_read_rle JPP((j_compress_ptr cinfo)); EXTERN(cjpeg_source_ptr) jinit_read_rle (j_compress_ptr cinfo);
EXTERN(djpeg_dest_ptr) jinit_write_rle JPP((j_decompress_ptr cinfo)); EXTERN(djpeg_dest_ptr) jinit_write_rle (j_decompress_ptr cinfo);
EXTERN(cjpeg_source_ptr) jinit_read_targa JPP((j_compress_ptr cinfo)); EXTERN(cjpeg_source_ptr) jinit_read_targa (j_compress_ptr cinfo);
EXTERN(djpeg_dest_ptr) jinit_write_targa JPP((j_decompress_ptr cinfo)); EXTERN(djpeg_dest_ptr) jinit_write_targa (j_decompress_ptr cinfo);
/* cjpeg support routines (in rdswitch.c) */ /* cjpeg support routines (in rdswitch.c) */
EXTERN(boolean) read_quant_tables JPP((j_compress_ptr cinfo, char * filename, EXTERN(boolean) read_quant_tables (j_compress_ptr cinfo, char * filename,
boolean force_baseline)); boolean force_baseline);
EXTERN(boolean) read_scan_script JPP((j_compress_ptr cinfo, char * filename)); EXTERN(boolean) read_scan_script (j_compress_ptr cinfo, char * filename);
EXTERN(boolean) set_quality_ratings JPP((j_compress_ptr cinfo, char *arg, EXTERN(boolean) set_quality_ratings (j_compress_ptr cinfo, char *arg,
boolean force_baseline)); boolean force_baseline);
EXTERN(boolean) set_quant_slots JPP((j_compress_ptr cinfo, char *arg)); EXTERN(boolean) set_quant_slots (j_compress_ptr cinfo, char *arg);
EXTERN(boolean) set_sample_factors JPP((j_compress_ptr cinfo, char *arg)); EXTERN(boolean) set_sample_factors (j_compress_ptr cinfo, char *arg);
/* djpeg support routines (in rdcolmap.c) */ /* djpeg support routines (in rdcolmap.c) */
EXTERN(void) read_color_map JPP((j_decompress_ptr cinfo, FILE * infile)); EXTERN(void) read_color_map (j_decompress_ptr cinfo, FILE * infile);
/* common support routines (in cdjpeg.c) */ /* common support routines (in cdjpeg.c) */
EXTERN(void) enable_signal_catcher JPP((j_common_ptr cinfo)); EXTERN(void) enable_signal_catcher (j_common_ptr cinfo);
EXTERN(void) start_progress_monitor JPP((j_common_ptr cinfo, EXTERN(void) start_progress_monitor (j_common_ptr cinfo,
cd_progress_ptr progress)); cd_progress_ptr progress);
EXTERN(void) end_progress_monitor JPP((j_common_ptr cinfo)); EXTERN(void) end_progress_monitor (j_common_ptr cinfo);
EXTERN(boolean) keymatch JPP((char * arg, const char * keyword, int minchars)); EXTERN(boolean) keymatch (char * arg, const char * keyword, int minchars);
EXTERN(FILE *) read_stdin JPP((void)); EXTERN(FILE *) read_stdin (void);
EXTERN(FILE *) write_stdout JPP((void)); EXTERN(FILE *) write_stdout (void);
/* miscellaneous useful macros */ /* miscellaneous useful macros */

53
coderules.txt
View File

@@ -1,7 +1,11 @@
IJG JPEG LIBRARY: CODING RULES IJG JPEG LIBRARY: CODING RULES
Copyright (C) 1991-1996, Thomas G. Lane. Copyright (C) 1991-1996, Thomas G. Lane.
This file is part of the Independent JPEG Group's software. This file was part of the Independent JPEG Group's software.
It was modified by The libjpeg-turbo Project to include only information
relevant to libjpeg-turbo.
For conditions of distribution and use, see the accompanying README file. For conditions of distribution and use, see the accompanying README file.
@@ -32,22 +36,7 @@ handled automatically by GNU Emacs and many other text editors.)
Multi-word names should be written in lower case with underscores, e.g., Multi-word names should be written in lower case with underscores, e.g.,
multi_word_name (not multiWordName). Preprocessor symbols and enum constants multi_word_name (not multiWordName). Preprocessor symbols and enum constants
are similar but upper case (MULTI_WORD_NAME). Names should be unique within are similar but upper case (MULTI_WORD_NAME). Names should be unique within
the first fifteen characters. (On some older systems, global names must be the first fifteen characters.
unique within six characters. We accommodate this without cluttering the
source code by using macros to substitute shorter names.)
We use function prototypes everywhere; we rely on automatic source code
transformation to feed prototype-less C compilers. Transformation is done
by the simple and portable tool 'ansi2knr.c' (courtesy of Ghostscript).
ansi2knr is not very bright, so it imposes a format requirement on function
declarations: the function name MUST BEGIN IN COLUMN 1. Thus all functions
should be written in the following style:
LOCAL(int *)
function_name (int a, char *b)
{
code...
}
Note that each function definition must begin with GLOBAL(type), LOCAL(type), Note that each function definition must begin with GLOBAL(type), LOCAL(type),
or METHODDEF(type). These macros expand to "static type" or just "type" as or METHODDEF(type). These macros expand to "static type" or just "type" as
@@ -55,27 +44,8 @@ appropriate. They provide a readable indication of the routine's usage and
can readily be changed for special needs. (For instance, special linkage can readily be changed for special needs. (For instance, special linkage
keywords can be inserted for use in Windows DLLs.) keywords can be inserted for use in Windows DLLs.)
ansi2knr does not transform method declarations (function pointers in A similar solution is used for external function declarations (see the EXTERN
structs). We handle these with a macro JMETHOD, defined as macro.)
#ifdef HAVE_PROTOTYPES
#define JMETHOD(type,methodname,arglist) type (*methodname) arglist
#else
#define JMETHOD(type,methodname,arglist) type (*methodname) ()
#endif
which is used like this:
struct function_pointers {
JMETHOD(void, init_entropy_encoder, (int somearg, jparms *jp));
JMETHOD(void, term_entropy_encoder, (void));
};
Note the set of parentheses surrounding the parameter list.
A similar solution is used for forward and external function declarations
(see the EXTERN and JPP macros).
If the code is to work on non-ANSI compilers, we cannot rely on a prototype
declaration to coerce actual parameters into the right types. Therefore, use
explicit casts on actual parameters whenever the actual parameter type is not
identical to the formal parameter. Beware of implicit conversions to "int".
It seems there are some non-ANSI compilers in which the sizeof() operator It seems there are some non-ANSI compilers in which the sizeof() operator
is defined to return int, yet size_t is defined as long. Needless to say, is defined to return int, yet size_t is defined as long. Needless to say,
@@ -105,10 +75,9 @@ the system architecture document, structure.txt).
5. Source file names should begin with "j" for files that are part of the 5. Source file names should begin with "j" for files that are part of the
library proper; source files that are not part of the library, such as cjpeg.c library proper; source files that are not part of the library, such as cjpeg.c
and djpeg.c, do not begin with "j". Keep source file names to eight and djpeg.c, do not begin with "j". Keep compression and decompression code in
characters (plus ".c" or ".h", etc) to make life easy for MS-DOSers. Keep separate source files --- some applications may want only one half of the
compression and decompression code in separate source files --- some library.
applications may want only one half of the library.
Note: these rules (particularly #4) are not followed religiously in the Note: these rules (particularly #4) are not followed religiously in the
modules that are used in cjpeg/djpeg but are not part of the JPEG library modules that are used in cjpeg/djpeg but are not part of the JPEG library

3
configure.ac
View File

@@ -8,9 +8,6 @@ BUILD=`date +%Y%m%d`
AM_INIT_AUTOMAKE([-Wall foreign dist-bzip2]) AM_INIT_AUTOMAKE([-Wall foreign dist-bzip2])
AC_PREFIX_DEFAULT(/opt/libjpeg-turbo) AC_PREFIX_DEFAULT(/opt/libjpeg-turbo)
# Always build with prototypes
AC_DEFINE([HAVE_PROTOTYPES], 1, [Define if your compiler supports prototypes])
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
# Checks for programs. # Checks for programs.

2
jcapimin.c
View File

@@ -204,7 +204,7 @@ GLOBAL(void)
jpeg_write_marker (j_compress_ptr cinfo, int marker, jpeg_write_marker (j_compress_ptr cinfo, int marker,
const JOCTET *dataptr, unsigned int datalen) const JOCTET *dataptr, unsigned int datalen)
{ {
JMETHOD(void, write_marker_byte, (j_compress_ptr info, int val)); void (*write_marker_byte) (j_compress_ptr info, int val);
if (cinfo->next_scanline != 0 || if (cinfo->next_scanline != 0 ||
(cinfo->global_state != CSTATE_SCANNING && (cinfo->global_state != CSTATE_SCANNING &&

6
jccoefct.c
View File

@@ -59,12 +59,12 @@ typedef my_coef_controller * my_coef_ptr;
/* Forward declarations */ /* Forward declarations */
METHODDEF(boolean) compress_data METHODDEF(boolean) compress_data
JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf)); (j_compress_ptr cinfo, JSAMPIMAGE input_buf);
#ifdef FULL_COEF_BUFFER_SUPPORTED #ifdef FULL_COEF_BUFFER_SUPPORTED
METHODDEF(boolean) compress_first_pass METHODDEF(boolean) compress_first_pass
JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf)); (j_compress_ptr cinfo, JSAMPIMAGE input_buf);
METHODDEF(boolean) compress_output METHODDEF(boolean) compress_output
JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf)); (j_compress_ptr cinfo, JSAMPIMAGE input_buf);
#endif #endif

27
jcdctmgr.c
View File

@@ -24,22 +24,21 @@
/* Private subobject for this module */ /* Private subobject for this module */
typedef JMETHOD(void, forward_DCT_method_ptr, (DCTELEM * data)); typedef void (*forward_DCT_method_ptr) (DCTELEM * data);
typedef JMETHOD(void, float_DCT_method_ptr, (FAST_FLOAT * data)); typedef void (*float_DCT_method_ptr) (FAST_FLOAT * data);
typedef JMETHOD(void, convsamp_method_ptr, typedef void (*convsamp_method_ptr) (JSAMPARRAY sample_data,
(JSAMPARRAY sample_data, JDIMENSION start_col, JDIMENSION start_col,
DCTELEM * workspace)); DCTELEM * workspace);
typedef JMETHOD(void, float_convsamp_method_ptr, typedef void (*float_convsamp_method_ptr) (JSAMPARRAY sample_data,
(JSAMPARRAY sample_data, JDIMENSION start_col, JDIMENSION start_col,
FAST_FLOAT *workspace)); FAST_FLOAT *workspace);
typedef JMETHOD(void, quantize_method_ptr, typedef void (*quantize_method_ptr) (JCOEFPTR coef_block, DCTELEM * divisors,
(JCOEFPTR coef_block, DCTELEM * divisors, DCTELEM * workspace);
DCTELEM * workspace)); typedef void (*float_quantize_method_ptr) (JCOEFPTR coef_block,
typedef JMETHOD(void, float_quantize_method_ptr, FAST_FLOAT * divisors,
(JCOEFPTR coef_block, FAST_FLOAT * divisors, FAST_FLOAT * workspace);
FAST_FLOAT * workspace));
METHODDEF(void) quantize (JCOEFPTR, DCTELEM *, DCTELEM *); METHODDEF(void) quantize (JCOEFPTR, DCTELEM *, DCTELEM *);

11
jchuff.c
View File

@@ -123,13 +123,12 @@ typedef struct {
/* Forward declarations */ /* Forward declarations */
METHODDEF(boolean) encode_mcu_huff JPP((j_compress_ptr cinfo, METHODDEF(boolean) encode_mcu_huff (j_compress_ptr cinfo, JBLOCKROW *MCU_data);
JBLOCKROW *MCU_data)); METHODDEF(void) finish_pass_huff (j_compress_ptr cinfo);
METHODDEF(void) finish_pass_huff JPP((j_compress_ptr cinfo));
#ifdef ENTROPY_OPT_SUPPORTED #ifdef ENTROPY_OPT_SUPPORTED
METHODDEF(boolean) encode_mcu_gather JPP((j_compress_ptr cinfo, METHODDEF(boolean) encode_mcu_gather (j_compress_ptr cinfo,
JBLOCKROW *MCU_data)); JBLOCKROW *MCU_data);
METHODDEF(void) finish_pass_gather JPP((j_compress_ptr cinfo)); METHODDEF(void) finish_pass_gather (j_compress_ptr cinfo);
#endif #endif

6
jchuff.h
View File

@@ -32,9 +32,9 @@ typedef struct {
/* Expand a Huffman table definition into the derived format */ /* Expand a Huffman table definition into the derived format */
EXTERN(void) jpeg_make_c_derived_tbl EXTERN(void) jpeg_make_c_derived_tbl
JPP((j_compress_ptr cinfo, boolean isDC, int tblno, (j_compress_ptr cinfo, boolean isDC, int tblno,
c_derived_tbl ** pdtbl)); c_derived_tbl ** pdtbl);
/* Generate an optimal table definition given the specified counts */ /* Generate an optimal table definition given the specified counts */
EXTERN(void) jpeg_gen_optimal_table EXTERN(void) jpeg_gen_optimal_table
JPP((j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])); (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[]);

8
jcmainct.c
View File

@@ -52,12 +52,12 @@ typedef my_main_controller * my_main_ptr;
/* Forward declarations */ /* Forward declarations */
METHODDEF(void) process_data_simple_main METHODDEF(void) process_data_simple_main
JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf, (j_compress_ptr cinfo, JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail)); JDIMENSION in_rows_avail);
#ifdef FULL_MAIN_BUFFER_SUPPORTED #ifdef FULL_MAIN_BUFFER_SUPPORTED
METHODDEF(void) process_data_buffer_main METHODDEF(void) process_data_buffer_main
JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf, (j_compress_ptr cinfo, JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail)); JDIMENSION in_rows_avail);
#endif #endif

3
jconfig.h.in
View File

@@ -15,9 +15,6 @@
/* Define to 1 if you have the <locale.h> header file. */ /* Define to 1 if you have the <locale.h> header file. */
#undef HAVE_LOCALE_H #undef HAVE_LOCALE_H
/* Define if your compiler supports prototypes */
#undef HAVE_PROTOTYPES
/* Define to 1 if you have the <stddef.h> header file. */ /* Define to 1 if you have the <stddef.h> header file. */
#undef HAVE_STDDEF_H #undef HAVE_STDDEF_H

5
jconfig.txt
View File

@@ -23,11 +23,6 @@
* #define the symbol if yes, #undef it if no. * #define the symbol if yes, #undef it if no.
*/ */
/* Does your compiler support function prototypes?
* (If not, you also need to use ansi2knr, see install.txt)
*/
#define HAVE_PROTOTYPES
/* Does your compiler support the declaration "unsigned char" ? /* Does your compiler support the declaration "unsigned char" ?
* How about "unsigned short" ? * How about "unsigned short" ?
*/ */

20
jcphuff.c
View File

@@ -86,16 +86,16 @@ typedef phuff_entropy_encoder * phuff_entropy_ptr;
#endif #endif
/* Forward declarations */ /* Forward declarations */
METHODDEF(boolean) encode_mcu_DC_first JPP((j_compress_ptr cinfo, METHODDEF(boolean) encode_mcu_DC_first (j_compress_ptr cinfo,
JBLOCKROW *MCU_data)); JBLOCKROW *MCU_data);
METHODDEF(boolean) encode_mcu_AC_first JPP((j_compress_ptr cinfo, METHODDEF(boolean) encode_mcu_AC_first (j_compress_ptr cinfo,
JBLOCKROW *MCU_data)); JBLOCKROW *MCU_data);
METHODDEF(boolean) encode_mcu_DC_refine JPP((j_compress_ptr cinfo, METHODDEF(boolean) encode_mcu_DC_refine (j_compress_ptr cinfo,
JBLOCKROW *MCU_data)); JBLOCKROW *MCU_data);
METHODDEF(boolean) encode_mcu_AC_refine JPP((j_compress_ptr cinfo, METHODDEF(boolean) encode_mcu_AC_refine (j_compress_ptr cinfo,
JBLOCKROW *MCU_data)); JBLOCKROW *MCU_data);
METHODDEF(void) finish_pass_phuff JPP((j_compress_ptr cinfo)); METHODDEF(void) finish_pass_phuff (j_compress_ptr cinfo);
METHODDEF(void) finish_pass_gather_phuff JPP((j_compress_ptr cinfo)); METHODDEF(void) finish_pass_gather_phuff (j_compress_ptr cinfo);
/* /*

7
jcsample.c
View File

@@ -53,9 +53,10 @@
/* Pointer to routine to downsample a single component */ /* Pointer to routine to downsample a single component */
typedef JMETHOD(void, downsample1_ptr, typedef void (*downsample1_ptr) (j_compress_ptr cinfo,
(j_compress_ptr cinfo, jpeg_component_info * compptr, jpeg_component_info * compptr,
JSAMPARRAY input_data, JSAMPARRAY output_data)); JSAMPARRAY input_data,
JSAMPARRAY output_data);
/* Private subobject */ /* Private subobject */

4
jctrans.c
View File

@@ -18,9 +18,9 @@
/* Forward declarations */ /* Forward declarations */
LOCAL(void) transencode_master_selection LOCAL(void) transencode_master_selection
JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)); (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays);
LOCAL(void) transencode_coef_controller LOCAL(void) transencode_coef_controller
JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)); (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays);
/* /*

2
jdapistd.c
View File

@@ -23,7 +23,7 @@
/* Forward declarations */ /* Forward declarations */
LOCAL(boolean) output_pass_setup JPP((j_decompress_ptr cinfo)); LOCAL(boolean) output_pass_setup (j_decompress_ptr cinfo);
/* /*

4
jdatadst-tj.c
View File

@@ -23,8 +23,8 @@
#include "jerror.h" #include "jerror.h"
#ifndef HAVE_STDLIB_H /* <stdlib.h> should declare malloc(),free() */ #ifndef HAVE_STDLIB_H /* <stdlib.h> should declare malloc(),free() */
extern void * malloc JPP((size_t size)); extern void * malloc (size_t size);
extern void free JPP((void *ptr)); extern void free (void *ptr);
#endif #endif

4
jdatadst.c
View File

@@ -23,8 +23,8 @@
#include "jerror.h" #include "jerror.h"
#ifndef HAVE_STDLIB_H /* <stdlib.h> should declare malloc(),free() */ #ifndef HAVE_STDLIB_H /* <stdlib.h> should declare malloc(),free() */
extern void * malloc JPP((size_t size)); extern void * malloc (size_t size);
extern void free JPP((void *ptr)); extern void free (void *ptr);
#endif #endif

8
jdcoefct.c
View File

@@ -69,15 +69,15 @@ typedef my_coef_controller * my_coef_ptr;
/* Forward declarations */ /* Forward declarations */
METHODDEF(int) decompress_onepass METHODDEF(int) decompress_onepass
JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf)); (j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
#ifdef D_MULTISCAN_FILES_SUPPORTED #ifdef D_MULTISCAN_FILES_SUPPORTED
METHODDEF(int) decompress_data METHODDEF(int) decompress_data
JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf)); (j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
#endif #endif
#ifdef BLOCK_SMOOTHING_SUPPORTED #ifdef BLOCK_SMOOTHING_SUPPORTED
LOCAL(boolean) smoothing_ok JPP((j_decompress_ptr cinfo)); LOCAL(boolean) smoothing_ok (j_decompress_ptr cinfo);
METHODDEF(int) decompress_smooth_data METHODDEF(int) decompress_smooth_data
JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf)); (j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
#endif #endif

78
jdct.h
View File

@@ -88,64 +88,64 @@ typedef FAST_FLOAT FLOAT_MULT_TYPE; /* preferred floating type */
/* Extern declarations for the forward and inverse DCT routines. */ /* Extern declarations for the forward and inverse DCT routines. */
EXTERN(void) jpeg_fdct_islow JPP((DCTELEM * data)); EXTERN(void) jpeg_fdct_islow (DCTELEM * data);
EXTERN(void) jpeg_fdct_ifast JPP((DCTELEM * data)); EXTERN(void) jpeg_fdct_ifast (DCTELEM * data);
EXTERN(void) jpeg_fdct_float JPP((FAST_FLOAT * data)); EXTERN(void) jpeg_fdct_float (FAST_FLOAT * data);
EXTERN(void) jpeg_idct_islow EXTERN(void) jpeg_idct_islow
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_ifast EXTERN(void) jpeg_idct_ifast
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_float EXTERN(void) jpeg_idct_float
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_7x7 EXTERN(void) jpeg_idct_7x7
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_6x6 EXTERN(void) jpeg_idct_6x6
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_5x5 EXTERN(void) jpeg_idct_5x5
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_4x4 EXTERN(void) jpeg_idct_4x4
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_3x3 EXTERN(void) jpeg_idct_3x3
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_2x2 EXTERN(void) jpeg_idct_2x2
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_1x1 EXTERN(void) jpeg_idct_1x1
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_9x9 EXTERN(void) jpeg_idct_9x9
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_10x10 EXTERN(void) jpeg_idct_10x10
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_11x11 EXTERN(void) jpeg_idct_11x11
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_12x12 EXTERN(void) jpeg_idct_12x12
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_13x13 EXTERN(void) jpeg_idct_13x13
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_14x14 EXTERN(void) jpeg_idct_14x14
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_15x15 EXTERN(void) jpeg_idct_15x15
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
EXTERN(void) jpeg_idct_16x16 EXTERN(void) jpeg_idct_16x16
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col);
/* /*

12
jdhuff.h
View File

@@ -45,8 +45,8 @@ typedef struct {
/* Expand a Huffman table definition into the derived format */ /* Expand a Huffman table definition into the derived format */
EXTERN(void) jpeg_make_d_derived_tbl EXTERN(void) jpeg_make_d_derived_tbl
JPP((j_decompress_ptr cinfo, boolean isDC, int tblno, (j_decompress_ptr cinfo, boolean isDC, int tblno,
d_derived_tbl ** pdtbl)); d_derived_tbl ** pdtbl);
/* /*
@@ -159,8 +159,8 @@ typedef struct { /* Bitreading working state within an MCU */
/* Load up the bit buffer to a depth of at least nbits */ /* Load up the bit buffer to a depth of at least nbits */
EXTERN(boolean) jpeg_fill_bit_buffer EXTERN(boolean) jpeg_fill_bit_buffer
JPP((bitread_working_state * state, register bit_buf_type get_buffer, (bitread_working_state * state, register bit_buf_type get_buffer,
register int bits_left, int nbits)); register int bits_left, int nbits);
/* /*
@@ -223,5 +223,5 @@ slowlabel: \
/* Out-of-line case for Huffman code fetching */ /* Out-of-line case for Huffman code fetching */
EXTERN(int) jpeg_huff_decode EXTERN(int) jpeg_huff_decode
JPP((bitread_working_state * state, register bit_buf_type get_buffer, (bitread_working_state * state, register bit_buf_type get_buffer,
register int bits_left, d_derived_tbl * htbl, int min_bits)); register int bits_left, d_derived_tbl * htbl, int min_bits);

2
jdinput.c
View File

@@ -31,7 +31,7 @@ typedef my_input_controller * my_inputctl_ptr;
/* Forward declarations */ /* Forward declarations */
METHODDEF(int) consume_markers JPP((j_decompress_ptr cinfo)); METHODDEF(int) consume_markers (j_decompress_ptr cinfo);
/* /*

12
jdmainct.c
View File

@@ -144,15 +144,15 @@ typedef my_main_controller * my_main_ptr;
/* Forward declarations */ /* Forward declarations */
METHODDEF(void) process_data_simple_main METHODDEF(void) process_data_simple_main
JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf, (j_decompress_ptr cinfo, JSAMPARRAY output_buf,
JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
METHODDEF(void) process_data_context_main METHODDEF(void) process_data_context_main
JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf, (j_decompress_ptr cinfo, JSAMPARRAY output_buf,
JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
#ifdef QUANT_2PASS_SUPPORTED #ifdef QUANT_2PASS_SUPPORTED
METHODDEF(void) process_data_crank_post METHODDEF(void) process_data_crank_post
JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf, (j_decompress_ptr cinfo, JSAMPARRAY output_buf,
JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
#endif #endif

5
jdmerge.c
View File

@@ -83,9 +83,8 @@ typedef struct {
struct jpeg_upsampler pub; /* public fields */ struct jpeg_upsampler pub; /* public fields */
/* Pointer to routine to do actual upsampling/conversion of one row group */ /* Pointer to routine to do actual upsampling/conversion of one row group */
JMETHOD(void, upmethod, (j_decompress_ptr cinfo, void (*upmethod) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf);
JSAMPARRAY output_buf));
/* Private state for YCC->RGB conversion */ /* Private state for YCC->RGB conversion */
int * Cr_r_tab; /* => table for Cr to R conversion */ int * Cr_r_tab; /* => table for Cr to R conversion */

16
jdphuff.c
View File

@@ -74,14 +74,14 @@ typedef struct {
typedef phuff_entropy_decoder * phuff_entropy_ptr; typedef phuff_entropy_decoder * phuff_entropy_ptr;
/* Forward declarations */ /* Forward declarations */
METHODDEF(boolean) decode_mcu_DC_first JPP((j_decompress_ptr cinfo, METHODDEF(boolean) decode_mcu_DC_first (j_decompress_ptr cinfo,
JBLOCKROW *MCU_data)); JBLOCKROW *MCU_data);
METHODDEF(boolean) decode_mcu_AC_first JPP((j_decompress_ptr cinfo, METHODDEF(boolean) decode_mcu_AC_first (j_decompress_ptr cinfo,
JBLOCKROW *MCU_data)); JBLOCKROW *MCU_data);
METHODDEF(boolean) decode_mcu_DC_refine JPP((j_decompress_ptr cinfo, METHODDEF(boolean) decode_mcu_DC_refine (j_decompress_ptr cinfo,
JBLOCKROW *MCU_data)); JBLOCKROW *MCU_data);
METHODDEF(boolean) decode_mcu_AC_refine JPP((j_decompress_ptr cinfo, METHODDEF(boolean) decode_mcu_AC_refine (j_decompress_ptr cinfo,
JBLOCKROW *MCU_data)); JBLOCKROW *MCU_data);
/* /*

27
jdpostct.c
View File

@@ -44,24 +44,21 @@ typedef my_post_controller * my_post_ptr;
/* Forward declarations */ /* Forward declarations */
METHODDEF(void) post_process_1pass METHODDEF(void) post_process_1pass
JPP((j_decompress_ptr cinfo, (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail,
JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
JDIMENSION out_rows_avail));
#ifdef QUANT_2PASS_SUPPORTED #ifdef QUANT_2PASS_SUPPORTED
METHODDEF(void) post_process_prepass METHODDEF(void) post_process_prepass
JPP((j_decompress_ptr cinfo, (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail,
JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
JDIMENSION out_rows_avail));
METHODDEF(void) post_process_2pass METHODDEF(void) post_process_2pass
JPP((j_decompress_ptr cinfo, (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail,
JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
JDIMENSION out_rows_avail));
#endif #endif

7
jdsample.c
View File

@@ -29,9 +29,10 @@
/* Pointer to routine to upsample a single component */ /* Pointer to routine to upsample a single component */
typedef JMETHOD(void, upsample1_ptr, typedef void (*upsample1_ptr) (j_decompress_ptr cinfo,
(j_decompress_ptr cinfo, jpeg_component_info * compptr, jpeg_component_info * compptr,
JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)); JSAMPARRAY input_data,
JSAMPARRAY * output_data_ptr);
/* Private subobject */ /* Private subobject */

2
jdtrans.c
View File

@@ -16,7 +16,7 @@
/* Forward declarations */ /* Forward declarations */
LOCAL(void) transdecode_master_selection JPP((j_decompress_ptr cinfo)); LOCAL(void) transdecode_master_selection (j_decompress_ptr cinfo);
/* /*

2
jmemmgr.c
View File

@@ -32,7 +32,7 @@
#ifndef NO_GETENV #ifndef NO_GETENV
#ifndef HAVE_STDLIB_H /* <stdlib.h> should declare getenv() */ #ifndef HAVE_STDLIB_H /* <stdlib.h> should declare getenv() */
extern char * getenv JPP((const char * name)); extern char * getenv (const char * name);
#endif #endif
#endif #endif

4
jmemnobs.c
View File

@@ -21,8 +21,8 @@
#include "jmemsys.h" /* import the system-dependent declarations */ #include "jmemsys.h" /* import the system-dependent declarations */
#ifndef HAVE_STDLIB_H /* <stdlib.h> should declare malloc(),free() */ #ifndef HAVE_STDLIB_H /* <stdlib.h> should declare malloc(),free() */
extern void * malloc JPP((size_t size)); extern void * malloc (size_t size);
extern void free JPP((void *ptr)); extern void free (void *ptr);
#endif #endif

47
jmemsys.h
View File

@@ -30,9 +30,9 @@
* On an 80x86 machine using small-data memory model, these manage near heap. * On an 80x86 machine using small-data memory model, these manage near heap.
*/ */
EXTERN(void *) jpeg_get_small JPP((j_common_ptr cinfo, size_t sizeofobject)); EXTERN(void *) jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject);
EXTERN(void) jpeg_free_small JPP((j_common_ptr cinfo, void * object, EXTERN(void) jpeg_free_small (j_common_ptr cinfo, void * object,
size_t sizeofobject)); size_t sizeofobject);
/* /*
* These two functions are used to allocate and release large chunks of * These two functions are used to allocate and release large chunks of
@@ -43,10 +43,9 @@ EXTERN(void) jpeg_free_small JPP((j_common_ptr cinfo, void * object,
* in case a different allocation strategy is desirable for large chunks. * in case a different allocation strategy is desirable for large chunks.
*/ */
EXTERN(void FAR *) jpeg_get_large JPP((j_common_ptr cinfo, EXTERN(void FAR *) jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject);
size_t sizeofobject)); EXTERN(void) jpeg_free_large (j_common_ptr cinfo, void FAR * object,
EXTERN(void) jpeg_free_large JPP((j_common_ptr cinfo, void FAR * object, size_t sizeofobject);
size_t sizeofobject));
/* /*
* The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may * The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may
@@ -86,10 +85,9 @@ EXTERN(void) jpeg_free_large JPP((j_common_ptr cinfo, void FAR * object,
* Conversely, zero may be returned to always use the minimum amount of memory. * Conversely, zero may be returned to always use the minimum amount of memory.
*/ */
EXTERN(size_t) jpeg_mem_available JPP((j_common_ptr cinfo, EXTERN(size_t) jpeg_mem_available (j_common_ptr cinfo, size_t min_bytes_needed,
size_t min_bytes_needed, size_t max_bytes_needed,
size_t max_bytes_needed, size_t already_allocated);
size_t already_allocated));
/* /*
@@ -124,16 +122,13 @@ typedef struct backing_store_struct * backing_store_ptr;
typedef struct backing_store_struct { typedef struct backing_store_struct {
/* Methods for reading/writing/closing this backing-store object */ /* Methods for reading/writing/closing this backing-store object */
JMETHOD(void, read_backing_store, (j_common_ptr cinfo, void (*read_backing_store) (j_common_ptr cinfo, backing_store_ptr info,
backing_store_ptr info, void FAR * buffer_address, long file_offset,
void FAR * buffer_address, long byte_count);
long file_offset, long byte_count)); void (*write_backing_store) (j_common_ptr cinfo, backing_store_ptr info,
JMETHOD(void, write_backing_store, (j_common_ptr cinfo, void FAR * buffer_address, long file_offset,
backing_store_ptr info, long byte_count);
void FAR * buffer_address, void (*close_backing_store) (j_common_ptr cinfo, backing_store_ptr info);
long file_offset, long byte_count));
JMETHOD(void, close_backing_store, (j_common_ptr cinfo,
backing_store_ptr info));
/* Private fields for system-dependent backing-store management */ /* Private fields for system-dependent backing-store management */
#ifdef USE_MSDOS_MEMMGR #ifdef USE_MSDOS_MEMMGR
@@ -163,9 +158,9 @@ typedef struct backing_store_struct {
* just take an error exit.) * just take an error exit.)
*/ */
EXTERN(void) jpeg_open_backing_store JPP((j_common_ptr cinfo, EXTERN(void) jpeg_open_backing_store (j_common_ptr cinfo,
backing_store_ptr info, backing_store_ptr info,
long total_bytes_needed)); long total_bytes_needed);
/* /*
@@ -180,5 +175,5 @@ EXTERN(void) jpeg_open_backing_store JPP((j_common_ptr cinfo,
* all opened backing-store objects have been closed. * all opened backing-store objects have been closed.
*/ */
EXTERN(long) jpeg_mem_init JPP((j_common_ptr cinfo)); EXTERN(long) jpeg_mem_init (j_common_ptr cinfo);
EXTERN(void) jpeg_mem_term JPP((j_common_ptr cinfo)); EXTERN(void) jpeg_mem_term (j_common_ptr cinfo);

20
jmorecfg.h
View File

@@ -192,19 +192,6 @@ typedef unsigned int JDIMENSION;
#define EXTERN(type) extern type #define EXTERN(type) extern type
/* This macro is used to declare a "method", that is, a function pointer.
* We want to supply prototype parameters if the compiler can cope.
* Note that the arglist parameter must be parenthesized!
* Again, you can customize this if you need special linkage keywords.
*/
#ifdef HAVE_PROTOTYPES
#define JMETHOD(type,methodname,arglist) type (*methodname) arglist
#else
#define JMETHOD(type,methodname,arglist) type (*methodname) ()
#endif
/* Here is the pseudo-keyword for declaring pointers that must be "far" /* Here is the pseudo-keyword for declaring pointers that must be "far"
* on 80x86 machines. Most of the specialized coding for 80x86 is handled * on 80x86 machines. Most of the specialized coding for 80x86 is handled
* by just saying "FAR *" where such a pointer is needed. In a few places * by just saying "FAR *" where such a pointer is needed. In a few places
@@ -402,17 +389,10 @@ static const int rgb_pixelsize[JPEG_NUMCS] = {
/* FAST_FLOAT should be either float or double, whichever is done faster /* FAST_FLOAT should be either float or double, whichever is done faster
* by your compiler. (Note that this type is only used in the floating point * by your compiler. (Note that this type is only used in the floating point
* DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.) * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
* Typically, float is faster in ANSI C compilers, while double is faster in
* pre-ANSI compilers (because they insist on converting to double anyway).
* The code below therefore chooses float if we have ANSI-style prototypes.
*/ */
#ifndef FAST_FLOAT #ifndef FAST_FLOAT
#ifdef HAVE_PROTOTYPES
#define FAST_FLOAT float #define FAST_FLOAT float
#else
#define FAST_FLOAT double
#endif
#endif #endif
#endif /* JPEG_INTERNAL_OPTIONS */ #endif /* JPEG_INTERNAL_OPTIONS */

262
jpegint.h
View File

@@ -44,9 +44,9 @@ typedef enum { /* Operating modes for buffer controllers */
/* Master control module */ /* Master control module */
struct jpeg_comp_master { struct jpeg_comp_master {
JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo)); void (*prepare_for_pass) (j_compress_ptr cinfo);
JMETHOD(void, pass_startup, (j_compress_ptr cinfo)); void (*pass_startup) (j_compress_ptr cinfo);
JMETHOD(void, finish_pass, (j_compress_ptr cinfo)); void (*finish_pass) (j_compress_ptr cinfo);
/* State variables made visible to other modules */ /* State variables made visible to other modules */
boolean call_pass_startup; /* True if pass_startup must be called */ boolean call_pass_startup; /* True if pass_startup must be called */
@@ -55,80 +55,74 @@ struct jpeg_comp_master {
/* Main buffer control (downsampled-data buffer) */ /* Main buffer control (downsampled-data buffer) */
struct jpeg_c_main_controller { struct jpeg_c_main_controller {
JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); void (*start_pass) (j_compress_ptr cinfo, J_BUF_MODE pass_mode);
JMETHOD(void, process_data, (j_compress_ptr cinfo, void (*process_data) (j_compress_ptr cinfo, JSAMPARRAY input_buf,
JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail);
JDIMENSION in_rows_avail));
}; };
/* Compression preprocessing (downsampling input buffer control) */ /* Compression preprocessing (downsampling input buffer control) */
struct jpeg_c_prep_controller { struct jpeg_c_prep_controller {
JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); void (*start_pass) (j_compress_ptr cinfo, J_BUF_MODE pass_mode);
JMETHOD(void, pre_process_data, (j_compress_ptr cinfo, void (*pre_process_data) (j_compress_ptr cinfo, JSAMPARRAY input_buf,
JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail,
JDIMENSION *in_row_ctr, JSAMPIMAGE output_buf,
JDIMENSION in_rows_avail, JDIMENSION *out_row_group_ctr,
JSAMPIMAGE output_buf, JDIMENSION out_row_groups_avail);
JDIMENSION *out_row_group_ctr,
JDIMENSION out_row_groups_avail));
}; };
/* Coefficient buffer control */ /* Coefficient buffer control */
struct jpeg_c_coef_controller { struct jpeg_c_coef_controller {
JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); void (*start_pass) (j_compress_ptr cinfo, J_BUF_MODE pass_mode);
JMETHOD(boolean, compress_data, (j_compress_ptr cinfo, boolean (*compress_data) (j_compress_ptr cinfo, JSAMPIMAGE input_buf);
JSAMPIMAGE input_buf));
}; };
/* Colorspace conversion */ /* Colorspace conversion */
struct jpeg_color_converter { struct jpeg_color_converter {
JMETHOD(void, start_pass, (j_compress_ptr cinfo)); void (*start_pass) (j_compress_ptr cinfo);
JMETHOD(void, color_convert, (j_compress_ptr cinfo, void (*color_convert) (j_compress_ptr cinfo, JSAMPARRAY input_buf,
JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JSAMPIMAGE output_buf, JDIMENSION output_row,
JDIMENSION output_row, int num_rows)); int num_rows);
}; };
/* Downsampling */ /* Downsampling */
struct jpeg_downsampler { struct jpeg_downsampler {
JMETHOD(void, start_pass, (j_compress_ptr cinfo)); void (*start_pass) (j_compress_ptr cinfo);
JMETHOD(void, downsample, (j_compress_ptr cinfo, void (*downsample) (j_compress_ptr cinfo, JSAMPIMAGE input_buf,
JSAMPIMAGE input_buf, JDIMENSION in_row_index, JDIMENSION in_row_index, JSAMPIMAGE output_buf,
JSAMPIMAGE output_buf, JDIMENSION out_row_group_index);
JDIMENSION out_row_group_index));
boolean need_context_rows; /* TRUE if need rows above & below */ boolean need_context_rows; /* TRUE if need rows above & below */
}; };
/* Forward DCT (also controls coefficient quantization) */ /* Forward DCT (also controls coefficient quantization) */
struct jpeg_forward_dct { struct jpeg_forward_dct {
JMETHOD(void, start_pass, (j_compress_ptr cinfo)); void (*start_pass) (j_compress_ptr cinfo);
/* perhaps this should be an array??? */ /* perhaps this should be an array??? */
JMETHOD(void, forward_DCT, (j_compress_ptr cinfo, void (*forward_DCT) (j_compress_ptr cinfo, jpeg_component_info * compptr,
jpeg_component_info * compptr, JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
JSAMPARRAY sample_data, JBLOCKROW coef_blocks, JDIMENSION start_row, JDIMENSION start_col,
JDIMENSION start_row, JDIMENSION start_col, JDIMENSION num_blocks);
JDIMENSION num_blocks));
}; };
/* Entropy encoding */ /* Entropy encoding */
struct jpeg_entropy_encoder { struct jpeg_entropy_encoder {
JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics)); void (*start_pass) (j_compress_ptr cinfo, boolean gather_statistics);
JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data)); boolean (*encode_mcu) (j_compress_ptr cinfo, JBLOCKROW *MCU_data);
JMETHOD(void, finish_pass, (j_compress_ptr cinfo)); void (*finish_pass) (j_compress_ptr cinfo);
}; };
/* Marker writing */ /* Marker writing */
struct jpeg_marker_writer { struct jpeg_marker_writer {
JMETHOD(void, write_file_header, (j_compress_ptr cinfo)); void (*write_file_header) (j_compress_ptr cinfo);
JMETHOD(void, write_frame_header, (j_compress_ptr cinfo)); void (*write_frame_header) (j_compress_ptr cinfo);
JMETHOD(void, write_scan_header, (j_compress_ptr cinfo)); void (*write_scan_header) (j_compress_ptr cinfo);
JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo)); void (*write_file_trailer) (j_compress_ptr cinfo);
JMETHOD(void, write_tables_only, (j_compress_ptr cinfo)); void (*write_tables_only) (j_compress_ptr cinfo);
/* These routines are exported to allow insertion of extra markers */ /* These routines are exported to allow insertion of extra markers */
/* Probably only COM and APPn markers should be written this way */ /* Probably only COM and APPn markers should be written this way */
JMETHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker, void (*write_marker_header) (j_compress_ptr cinfo, int marker,
unsigned int datalen)); unsigned int datalen);
JMETHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val)); void (*write_marker_byte) (j_compress_ptr cinfo, int val);
}; };
@@ -136,8 +130,8 @@ struct jpeg_marker_writer {
/* Master control module */ /* Master control module */
struct jpeg_decomp_master { struct jpeg_decomp_master {
JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo)); void (*prepare_for_output_pass) (j_decompress_ptr cinfo);
JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo)); void (*finish_output_pass) (j_decompress_ptr cinfo);
/* State variables made visible to other modules */ /* State variables made visible to other modules */
boolean is_dummy_pass; /* True during 1st pass for 2-pass quant */ boolean is_dummy_pass; /* True during 1st pass for 2-pass quant */
@@ -145,10 +139,10 @@ struct jpeg_decomp_master {
/* Input control module */ /* Input control module */
struct jpeg_input_controller { struct jpeg_input_controller {
JMETHOD(int, consume_input, (j_decompress_ptr cinfo)); int (*consume_input) (j_decompress_ptr cinfo);
JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo)); void (*reset_input_controller) (j_decompress_ptr cinfo);
JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); void (*start_input_pass) (j_decompress_ptr cinfo);
JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo)); void (*finish_input_pass) (j_decompress_ptr cinfo);
/* State variables made visible to other modules */ /* State variables made visible to other modules */
boolean has_multiple_scans; /* True if file has multiple scans */ boolean has_multiple_scans; /* True if file has multiple scans */
@@ -157,43 +151,39 @@ struct jpeg_input_controller {
/* Main buffer control (downsampled-data buffer) */ /* Main buffer control (downsampled-data buffer) */
struct jpeg_d_main_controller { struct jpeg_d_main_controller {
JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); void (*start_pass) (j_decompress_ptr cinfo, J_BUF_MODE pass_mode);
JMETHOD(void, process_data, (j_decompress_ptr cinfo, void (*process_data) (j_decompress_ptr cinfo, JSAMPARRAY output_buf,
JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
JDIMENSION out_rows_avail));
}; };
/* Coefficient buffer control */ /* Coefficient buffer control */
struct jpeg_d_coef_controller { struct jpeg_d_coef_controller {
JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); void (*start_input_pass) (j_decompress_ptr cinfo);
JMETHOD(int, consume_data, (j_decompress_ptr cinfo)); int (*consume_data) (j_decompress_ptr cinfo);
JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo)); void (*start_output_pass) (j_decompress_ptr cinfo);
JMETHOD(int, decompress_data, (j_decompress_ptr cinfo, int (*decompress_data) (j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
JSAMPIMAGE output_buf));
/* Pointer to array of coefficient virtual arrays, or NULL if none */ /* Pointer to array of coefficient virtual arrays, or NULL if none */
jvirt_barray_ptr *coef_arrays; jvirt_barray_ptr *coef_arrays;
}; };
/* Decompression postprocessing (color quantization buffer control) */ /* Decompression postprocessing (color quantization buffer control) */
struct jpeg_d_post_controller { struct jpeg_d_post_controller {
JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); void (*start_pass) (j_decompress_ptr cinfo, J_BUF_MODE pass_mode);
JMETHOD(void, post_process_data, (j_decompress_ptr cinfo, void (*post_process_data) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail,
JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
JSAMPARRAY output_buf, JDIMENSION out_rows_avail);
JDIMENSION *out_row_ctr,
JDIMENSION out_rows_avail));
}; };
/* Marker reading & parsing */ /* Marker reading & parsing */
struct jpeg_marker_reader { struct jpeg_marker_reader {
JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo)); void (*reset_marker_reader) (j_decompress_ptr cinfo);
/* Read markers until SOS or EOI. /* Read markers until SOS or EOI.
* Returns same codes as are defined for jpeg_consume_input: * Returns same codes as are defined for jpeg_consume_input:
* JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
*/ */
JMETHOD(int, read_markers, (j_decompress_ptr cinfo)); int (*read_markers) (j_decompress_ptr cinfo);
/* Read a restart marker --- exported for use by entropy decoder only */ /* Read a restart marker --- exported for use by entropy decoder only */
jpeg_marker_parser_method read_restart_marker; jpeg_marker_parser_method read_restart_marker;
@@ -208,9 +198,8 @@ struct jpeg_marker_reader {
/* Entropy decoding */ /* Entropy decoding */
struct jpeg_entropy_decoder { struct jpeg_entropy_decoder {
JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); void (*start_pass) (j_decompress_ptr cinfo);
JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo, boolean (*decode_mcu) (j_decompress_ptr cinfo, JBLOCKROW *MCU_data);
JBLOCKROW *MCU_data));
/* This is here to share code between baseline and progressive decoders; */ /* This is here to share code between baseline and progressive decoders; */
/* other modules probably should not use it */ /* other modules probably should not use it */
@@ -218,47 +207,44 @@ struct jpeg_entropy_decoder {
}; };
/* Inverse DCT (also performs dequantization) */ /* Inverse DCT (also performs dequantization) */
typedef JMETHOD(void, inverse_DCT_method_ptr, typedef void (*inverse_DCT_method_ptr) (j_decompress_ptr cinfo,
(j_decompress_ptr cinfo, jpeg_component_info * compptr, jpeg_component_info * compptr,
JCOEFPTR coef_block, JCOEFPTR coef_block,
JSAMPARRAY output_buf, JDIMENSION output_col)); JSAMPARRAY output_buf,
JDIMENSION output_col);
struct jpeg_inverse_dct { struct jpeg_inverse_dct {
JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); void (*start_pass) (j_decompress_ptr cinfo);
/* It is useful to allow each component to have a separate IDCT method. */ /* It is useful to allow each component to have a separate IDCT method. */
inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS]; inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
}; };
/* Upsampling (note that upsampler must also call color converter) */ /* Upsampling (note that upsampler must also call color converter) */
struct jpeg_upsampler { struct jpeg_upsampler {
JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); void (*start_pass) (j_decompress_ptr cinfo);
JMETHOD(void, upsample, (j_decompress_ptr cinfo, void (*upsample) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
JDIMENSION in_row_groups_avail, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
JSAMPARRAY output_buf,
JDIMENSION *out_row_ctr,
JDIMENSION out_rows_avail));
boolean need_context_rows; /* TRUE if need rows above & below */ boolean need_context_rows; /* TRUE if need rows above & below */
}; };
/* Colorspace conversion */ /* Colorspace conversion */
struct jpeg_color_deconverter { struct jpeg_color_deconverter {
JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); void (*start_pass) (j_decompress_ptr cinfo);
JMETHOD(void, color_convert, (j_decompress_ptr cinfo, void (*color_convert) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
JSAMPIMAGE input_buf, JDIMENSION input_row, JDIMENSION input_row, JSAMPARRAY output_buf,
JSAMPARRAY output_buf, int num_rows)); int num_rows);
}; };
/* Color quantization or color precision reduction */ /* Color quantization or color precision reduction */
struct jpeg_color_quantizer { struct jpeg_color_quantizer {
JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan)); void (*start_pass) (j_decompress_ptr cinfo, boolean is_pre_scan);
JMETHOD(void, color_quantize, (j_decompress_ptr cinfo, void (*color_quantize) (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
JSAMPARRAY input_buf, JSAMPARRAY output_buf, JSAMPARRAY output_buf, int num_rows);
int num_rows)); void (*finish_pass) (j_decompress_ptr cinfo);
JMETHOD(void, finish_pass, (j_decompress_ptr cinfo)); void (*new_color_map) (j_decompress_ptr cinfo);
JMETHOD(void, new_color_map, (j_decompress_ptr cinfo));
}; };
@@ -293,53 +279,53 @@ struct jpeg_color_quantizer {
/* Compression module initialization routines */ /* Compression module initialization routines */
EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_compress_master (j_compress_ptr cinfo);
EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo, EXTERN(void) jinit_c_master_control (j_compress_ptr cinfo,
boolean transcode_only)); boolean transcode_only);
EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo, EXTERN(void) jinit_c_main_controller (j_compress_ptr cinfo,
boolean need_full_buffer)); boolean need_full_buffer);
EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo, EXTERN(void) jinit_c_prep_controller (j_compress_ptr cinfo,
boolean need_full_buffer)); boolean need_full_buffer);
EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo, EXTERN(void) jinit_c_coef_controller (j_compress_ptr cinfo,
boolean need_full_buffer)); boolean need_full_buffer);
EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_color_converter (j_compress_ptr cinfo);
EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_downsampler (j_compress_ptr cinfo);
EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_forward_dct (j_compress_ptr cinfo);
EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_huff_encoder (j_compress_ptr cinfo);
EXTERN(void) jinit_phuff_encoder JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_phuff_encoder (j_compress_ptr cinfo);
EXTERN(void) jinit_arith_encoder JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_arith_encoder (j_compress_ptr cinfo);
EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_marker_writer (j_compress_ptr cinfo);
/* Decompression module initialization routines */ /* Decompression module initialization routines */
EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_master_decompress (j_decompress_ptr cinfo);
EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo, EXTERN(void) jinit_d_main_controller (j_decompress_ptr cinfo,
boolean need_full_buffer)); boolean need_full_buffer);
EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo, EXTERN(void) jinit_d_coef_controller (j_decompress_ptr cinfo,
boolean need_full_buffer)); boolean need_full_buffer);
EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo, EXTERN(void) jinit_d_post_controller (j_decompress_ptr cinfo,
boolean need_full_buffer)); boolean need_full_buffer);
EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_input_controller (j_decompress_ptr cinfo);
EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_marker_reader (j_decompress_ptr cinfo);
EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_huff_decoder (j_decompress_ptr cinfo);
EXTERN(void) jinit_phuff_decoder JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_phuff_decoder (j_decompress_ptr cinfo);
EXTERN(void) jinit_arith_decoder JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_arith_decoder (j_decompress_ptr cinfo);
EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_inverse_dct (j_decompress_ptr cinfo);
EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_upsampler (j_decompress_ptr cinfo);
EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_color_deconverter (j_decompress_ptr cinfo);
EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_1pass_quantizer (j_decompress_ptr cinfo);
EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_2pass_quantizer (j_decompress_ptr cinfo);
EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_merged_upsampler (j_decompress_ptr cinfo);
/* Memory manager initialization */ /* Memory manager initialization */
EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo)); EXTERN(void) jinit_memory_mgr (j_common_ptr cinfo);
/* Utility routines in jutils.c */ /* Utility routines in jutils.c */
EXTERN(long) jdiv_round_up JPP((long a, long b)); EXTERN(long) jdiv_round_up (long a, long b);
EXTERN(long) jround_up JPP((long a, long b)); EXTERN(long) jround_up (long a, long b);
EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row, EXTERN(void) jcopy_sample_rows (JSAMPARRAY input_array, int source_row,
JSAMPARRAY output_array, int dest_row, JSAMPARRAY output_array, int dest_row,
int num_rows, JDIMENSION num_cols)); int num_rows, JDIMENSION num_cols);
EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row, EXTERN(void) jcopy_block_row (JBLOCKROW input_row, JBLOCKROW output_row,
JDIMENSION num_blocks)); JDIMENSION num_blocks);
EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero)); EXTERN(void) jzero_far (void FAR * target, size_t bytestozero);
/* Constant tables in jutils.c */ /* Constant tables in jutils.c */
#if 0 /* This table is not actually needed in v6a */ #if 0 /* This table is not actually needed in v6a */
extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */ extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */

271
jpeglib.h
View File

@@ -719,16 +719,16 @@ struct jpeg_decompress_struct {
struct jpeg_error_mgr { struct jpeg_error_mgr {
/* Error exit handler: does not return to caller */ /* Error exit handler: does not return to caller */
JMETHOD(void, error_exit, (j_common_ptr cinfo)); void (*error_exit) (j_common_ptr cinfo);
/* Conditionally emit a trace or warning message */ /* Conditionally emit a trace or warning message */
JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level)); void (*emit_message) (j_common_ptr cinfo, int msg_level);
/* Routine that actually outputs a trace or error message */ /* Routine that actually outputs a trace or error message */
JMETHOD(void, output_message, (j_common_ptr cinfo)); void (*output_message) (j_common_ptr cinfo);
/* Format a message string for the most recent JPEG error or message */ /* Format a message string for the most recent JPEG error or message */
JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer)); void (*format_message) (j_common_ptr cinfo, char * buffer);
#define JMSG_LENGTH_MAX 200 /* recommended size of format_message buffer */ #define JMSG_LENGTH_MAX 200 /* recommended size of format_message buffer */
/* Reset error state variables at start of a new image */ /* Reset error state variables at start of a new image */
JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo)); void (*reset_error_mgr) (j_common_ptr cinfo);
/* The message ID code and any parameters are saved here. /* The message ID code and any parameters are saved here.
* A message can have one string parameter or up to 8 int parameters. * A message can have one string parameter or up to 8 int parameters.
@@ -776,7 +776,7 @@ struct jpeg_error_mgr {
/* Progress monitor object */ /* Progress monitor object */
struct jpeg_progress_mgr { struct jpeg_progress_mgr {
JMETHOD(void, progress_monitor, (j_common_ptr cinfo)); void (*progress_monitor) (j_common_ptr cinfo);
long pass_counter; /* work units completed in this pass */ long pass_counter; /* work units completed in this pass */
long pass_limit; /* total number of work units in this pass */ long pass_limit; /* total number of work units in this pass */
@@ -791,9 +791,9 @@ struct jpeg_destination_mgr {
JOCTET * next_output_byte; /* => next byte to write in buffer */ JOCTET * next_output_byte; /* => next byte to write in buffer */
size_t free_in_buffer; /* # of byte spaces remaining in buffer */ size_t free_in_buffer; /* # of byte spaces remaining in buffer */
JMETHOD(void, init_destination, (j_compress_ptr cinfo)); void (*init_destination) (j_compress_ptr cinfo);
JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo)); boolean (*empty_output_buffer) (j_compress_ptr cinfo);
JMETHOD(void, term_destination, (j_compress_ptr cinfo)); void (*term_destination) (j_compress_ptr cinfo);
}; };
@@ -803,11 +803,11 @@ struct jpeg_source_mgr {
const JOCTET * next_input_byte; /* => next byte to read from buffer */ const JOCTET * next_input_byte; /* => next byte to read from buffer */
size_t bytes_in_buffer; /* # of bytes remaining in buffer */ size_t bytes_in_buffer; /* # of bytes remaining in buffer */
JMETHOD(void, init_source, (j_decompress_ptr cinfo)); void (*init_source) (j_decompress_ptr cinfo);
JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo)); boolean (*fill_input_buffer) (j_decompress_ptr cinfo);
JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes)); void (*skip_input_data) (j_decompress_ptr cinfo, long num_bytes);
JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired)); boolean (*resync_to_restart) (j_decompress_ptr cinfo, int desired);
JMETHOD(void, term_source, (j_decompress_ptr cinfo)); void (*term_source) (j_decompress_ptr cinfo);
}; };
@@ -832,41 +832,32 @@ typedef struct jvirt_barray_control * jvirt_barray_ptr;
struct jpeg_memory_mgr { struct jpeg_memory_mgr {
/* Method pointers */ /* Method pointers */
JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id, void * (*alloc_small) (j_common_ptr cinfo, int pool_id, size_t sizeofobject);
size_t sizeofobject)); void FAR * (*alloc_large) (j_common_ptr cinfo, int pool_id,
JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id, size_t sizeofobject);
size_t sizeofobject)); JSAMPARRAY (*alloc_sarray) (j_common_ptr cinfo, int pool_id,
JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id, JDIMENSION samplesperrow, JDIMENSION numrows);
JDIMENSION samplesperrow, JBLOCKARRAY (*alloc_barray) (j_common_ptr cinfo, int pool_id,
JDIMENSION numrows)); JDIMENSION blocksperrow, JDIMENSION numrows);
JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id, jvirt_sarray_ptr (*request_virt_sarray) (j_common_ptr cinfo, int pool_id,
JDIMENSION blocksperrow, boolean pre_zero,
JDIMENSION numrows)); JDIMENSION samplesperrow,
JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo, JDIMENSION numrows,
int pool_id, JDIMENSION maxaccess);
boolean pre_zero, jvirt_barray_ptr (*request_virt_barray) (j_common_ptr cinfo, int pool_id,
JDIMENSION samplesperrow, boolean pre_zero,
JDIMENSION numrows, JDIMENSION blocksperrow,
JDIMENSION maxaccess)); JDIMENSION numrows,
JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo, JDIMENSION maxaccess);
int pool_id, void (*realize_virt_arrays) (j_common_ptr cinfo);
boolean pre_zero, JSAMPARRAY (*access_virt_sarray) (j_common_ptr cinfo, jvirt_sarray_ptr ptr,
JDIMENSION blocksperrow, JDIMENSION start_row, JDIMENSION num_rows,
JDIMENSION numrows, boolean writable);
JDIMENSION maxaccess)); JBLOCKARRAY (*access_virt_barray) (j_common_ptr cinfo, jvirt_barray_ptr ptr,
JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo)); JDIMENSION start_row, JDIMENSION num_rows,
JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo, boolean writable);
jvirt_sarray_ptr ptr, void (*free_pool) (j_common_ptr cinfo, int pool_id);
JDIMENSION start_row, void (*self_destruct) (j_common_ptr cinfo);
JDIMENSION num_rows,
boolean writable));
JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,
jvirt_barray_ptr ptr,
JDIMENSION start_row,
JDIMENSION num_rows,
boolean writable));
JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));
JMETHOD(void, self_destruct, (j_common_ptr cinfo));
/* Limit on memory allocation for this JPEG object. (Note that this is /* Limit on memory allocation for this JPEG object. (Note that this is
* merely advisory, not a guaranteed maximum; it only affects the space * merely advisory, not a guaranteed maximum; it only affects the space
@@ -883,24 +874,11 @@ struct jpeg_memory_mgr {
/* Routine signature for application-supplied marker processing methods. /* Routine signature for application-supplied marker processing methods.
* Need not pass marker code since it is stored in cinfo->unread_marker. * Need not pass marker code since it is stored in cinfo->unread_marker.
*/ */
typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo)); typedef boolean (*jpeg_marker_parser_method) (j_decompress_ptr cinfo);
/* Declarations for routines called by application.
* The JPP macro hides prototype parameters from compilers that can't cope.
* Note JPP requires double parentheses.
*/
#ifdef HAVE_PROTOTYPES
#define JPP(arglist) arglist
#else
#define JPP(arglist) ()
#endif
/* Default error-management setup */ /* Default error-management setup */
EXTERN(struct jpeg_error_mgr *) jpeg_std_error EXTERN(struct jpeg_error_mgr *) jpeg_std_error (struct jpeg_error_mgr * err);
JPP((struct jpeg_error_mgr * err));
/* Initialization of JPEG compression objects. /* Initialization of JPEG compression objects.
* jpeg_create_compress() and jpeg_create_decompress() are the exported * jpeg_create_compress() and jpeg_create_decompress() are the exported
@@ -915,89 +893,80 @@ EXTERN(struct jpeg_error_mgr *) jpeg_std_error
#define jpeg_create_decompress(cinfo) \ #define jpeg_create_decompress(cinfo) \
jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \ jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \
(size_t) sizeof(struct jpeg_decompress_struct)) (size_t) sizeof(struct jpeg_decompress_struct))
EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo, EXTERN(void) jpeg_CreateCompress (j_compress_ptr cinfo, int version,
int version, size_t structsize)); size_t structsize);
EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo, EXTERN(void) jpeg_CreateDecompress (j_decompress_ptr cinfo, int version,
int version, size_t structsize)); size_t structsize);
/* Destruction of JPEG compression objects */ /* Destruction of JPEG compression objects */
EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo)); EXTERN(void) jpeg_destroy_compress (j_compress_ptr cinfo);
EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo)); EXTERN(void) jpeg_destroy_decompress (j_decompress_ptr cinfo);
/* Standard data source and destination managers: stdio streams. */ /* Standard data source and destination managers: stdio streams. */
/* Caller is responsible for opening the file before and closing after. */ /* Caller is responsible for opening the file before and closing after. */
EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile)); EXTERN(void) jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile);
EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile)); EXTERN(void) jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile);
#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED) #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
/* Data source and destination managers: memory buffers. */ /* Data source and destination managers: memory buffers. */
EXTERN(void) jpeg_mem_dest JPP((j_compress_ptr cinfo, EXTERN(void) jpeg_mem_dest (j_compress_ptr cinfo, unsigned char ** outbuffer,
unsigned char ** outbuffer, unsigned long * outsize);
unsigned long * outsize)); EXTERN(void) jpeg_mem_src (j_decompress_ptr cinfo, unsigned char * inbuffer,
EXTERN(void) jpeg_mem_src JPP((j_decompress_ptr cinfo, unsigned long insize);
unsigned char * inbuffer,
unsigned long insize));
#endif #endif
/* Default parameter setup for compression */ /* Default parameter setup for compression */
EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo)); EXTERN(void) jpeg_set_defaults (j_compress_ptr cinfo);
/* Compression parameter setup aids */ /* Compression parameter setup aids */
EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo, EXTERN(void) jpeg_set_colorspace (j_compress_ptr cinfo,
J_COLOR_SPACE colorspace)); J_COLOR_SPACE colorspace);
EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo)); EXTERN(void) jpeg_default_colorspace (j_compress_ptr cinfo);
EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality, EXTERN(void) jpeg_set_quality (j_compress_ptr cinfo, int quality,
boolean force_baseline)); boolean force_baseline);
EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo, EXTERN(void) jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
int scale_factor, boolean force_baseline);
boolean force_baseline));
#if JPEG_LIB_VERSION >= 70 #if JPEG_LIB_VERSION >= 70
EXTERN(void) jpeg_default_qtables JPP((j_compress_ptr cinfo, EXTERN(void) jpeg_default_qtables (j_compress_ptr cinfo,
boolean force_baseline)); boolean force_baseline);
#endif #endif
EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl, EXTERN(void) jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
const unsigned int *basic_table, const unsigned int *basic_table,
int scale_factor, int scale_factor, boolean force_baseline);
boolean force_baseline)); EXTERN(int) jpeg_quality_scaling (int quality);
EXTERN(int) jpeg_quality_scaling JPP((int quality)); EXTERN(void) jpeg_simple_progression (j_compress_ptr cinfo);
EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo)); EXTERN(void) jpeg_suppress_tables (j_compress_ptr cinfo, boolean suppress);
EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo, EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table (j_common_ptr cinfo);
boolean suppress)); EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table (j_common_ptr cinfo);
EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo));
/* Main entry points for compression */ /* Main entry points for compression */
EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo, EXTERN(void) jpeg_start_compress (j_compress_ptr cinfo,
boolean write_all_tables)); boolean write_all_tables);
EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo, EXTERN(JDIMENSION) jpeg_write_scanlines (j_compress_ptr cinfo,
JSAMPARRAY scanlines, JSAMPARRAY scanlines,
JDIMENSION num_lines)); JDIMENSION num_lines);
EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo)); EXTERN(void) jpeg_finish_compress (j_compress_ptr cinfo);
#if JPEG_LIB_VERSION >= 70 #if JPEG_LIB_VERSION >= 70
/* Precalculate JPEG dimensions for current compression parameters. */ /* Precalculate JPEG dimensions for current compression parameters. */
EXTERN(void) jpeg_calc_jpeg_dimensions JPP((j_compress_ptr cinfo)); EXTERN(void) jpeg_calc_jpeg_dimensions (j_compress_ptr cinfo);
#endif #endif
/* Replaces jpeg_write_scanlines when writing raw downsampled data. */ /* Replaces jpeg_write_scanlines when writing raw downsampled data. */
EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo, EXTERN(JDIMENSION) jpeg_write_raw_data (j_compress_ptr cinfo, JSAMPIMAGE data,
JSAMPIMAGE data, JDIMENSION num_lines);
JDIMENSION num_lines));
/* Write a special marker. See libjpeg.txt concerning safe usage. */ /* Write a special marker. See libjpeg.txt concerning safe usage. */
EXTERN(void) jpeg_write_marker EXTERN(void) jpeg_write_marker (j_compress_ptr cinfo, int marker,
JPP((j_compress_ptr cinfo, int marker, const JOCTET * dataptr, unsigned int datalen);
const JOCTET * dataptr, unsigned int datalen));
/* Same, but piecemeal. */ /* Same, but piecemeal. */
EXTERN(void) jpeg_write_m_header EXTERN(void) jpeg_write_m_header (j_compress_ptr cinfo, int marker,
JPP((j_compress_ptr cinfo, int marker, unsigned int datalen)); unsigned int datalen);
EXTERN(void) jpeg_write_m_byte EXTERN(void) jpeg_write_m_byte (j_compress_ptr cinfo, int val);
JPP((j_compress_ptr cinfo, int val));
/* Alternate compression function: just write an abbreviated table file */ /* Alternate compression function: just write an abbreviated table file */
EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo)); EXTERN(void) jpeg_write_tables (j_compress_ptr cinfo);
/* Decompression startup: read start of JPEG datastream to see what's there */ /* Decompression startup: read start of JPEG datastream to see what's there */
EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo, EXTERN(int) jpeg_read_header (j_decompress_ptr cinfo, boolean require_image);
boolean require_image));
/* Return value is one of: */ /* Return value is one of: */
#define JPEG_SUSPENDED 0 /* Suspended due to lack of input data */ #define JPEG_SUSPENDED 0 /* Suspended due to lack of input data */
#define JPEG_HEADER_OK 1 /* Found valid image datastream */ #define JPEG_HEADER_OK 1 /* Found valid image datastream */
@@ -1009,25 +978,23 @@ EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo,
*/ */
/* Main entry points for decompression */ /* Main entry points for decompression */
EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo)); EXTERN(boolean) jpeg_start_decompress (j_decompress_ptr cinfo);
EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo, EXTERN(JDIMENSION) jpeg_read_scanlines (j_decompress_ptr cinfo,
JSAMPARRAY scanlines, JSAMPARRAY scanlines,
JDIMENSION max_lines)); JDIMENSION max_lines);
EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo)); EXTERN(boolean) jpeg_finish_decompress (j_decompress_ptr cinfo);
/* Replaces jpeg_read_scanlines when reading raw downsampled data. */ /* Replaces jpeg_read_scanlines when reading raw downsampled data. */
EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo, EXTERN(JDIMENSION) jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data,
JSAMPIMAGE data, JDIMENSION max_lines);
JDIMENSION max_lines));
/* Additional entry points for buffered-image mode. */ /* Additional entry points for buffered-image mode. */
EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo)); EXTERN(boolean) jpeg_has_multiple_scans (j_decompress_ptr cinfo);
EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo, EXTERN(boolean) jpeg_start_output (j_decompress_ptr cinfo, int scan_number);
int scan_number)); EXTERN(boolean) jpeg_finish_output (j_decompress_ptr cinfo);
EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo)); EXTERN(boolean) jpeg_input_complete (j_decompress_ptr cinfo);
EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo)); EXTERN(void) jpeg_new_colormap (j_decompress_ptr cinfo);
EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo)); EXTERN(int) jpeg_consume_input (j_decompress_ptr cinfo);
EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo));
/* Return value is one of: */ /* Return value is one of: */
/* #define JPEG_SUSPENDED 0 Suspended due to lack of input data */ /* #define JPEG_SUSPENDED 0 Suspended due to lack of input data */
#define JPEG_REACHED_SOS 1 /* Reached start of new scan */ #define JPEG_REACHED_SOS 1 /* Reached start of new scan */
@@ -1037,26 +1004,25 @@ EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo));
/* Precalculate output dimensions for current decompression parameters. */ /* Precalculate output dimensions for current decompression parameters. */
#if JPEG_LIB_VERSION >= 80 #if JPEG_LIB_VERSION >= 80
EXTERN(void) jpeg_core_output_dimensions JPP((j_decompress_ptr cinfo)); EXTERN(void) jpeg_core_output_dimensions (j_decompress_ptr cinfo);
#endif #endif
EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo)); EXTERN(void) jpeg_calc_output_dimensions (j_decompress_ptr cinfo);
/* Control saving of COM and APPn markers into marker_list. */ /* Control saving of COM and APPn markers into marker_list. */
EXTERN(void) jpeg_save_markers EXTERN(void) jpeg_save_markers (j_decompress_ptr cinfo, int marker_code,
JPP((j_decompress_ptr cinfo, int marker_code, unsigned int length_limit);
unsigned int length_limit));
/* Install a special processing method for COM or APPn markers. */ /* Install a special processing method for COM or APPn markers. */
EXTERN(void) jpeg_set_marker_processor EXTERN(void) jpeg_set_marker_processor (j_decompress_ptr cinfo,
JPP((j_decompress_ptr cinfo, int marker_code, int marker_code,
jpeg_marker_parser_method routine)); jpeg_marker_parser_method routine);
/* Read or write raw DCT coefficients --- useful for lossless transcoding. */ /* Read or write raw DCT coefficients --- useful for lossless transcoding. */
EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo)); EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients (j_decompress_ptr cinfo);
EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo, EXTERN(void) jpeg_write_coefficients (j_compress_ptr cinfo,
jvirt_barray_ptr * coef_arrays)); jvirt_barray_ptr * coef_arrays);
EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo, EXTERN(void) jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
j_compress_ptr dstinfo)); j_compress_ptr dstinfo);
/* If you choose to abort compression or decompression before completing /* If you choose to abort compression or decompression before completing
* jpeg_finish_(de)compress, then you need to clean up to release memory, * jpeg_finish_(de)compress, then you need to clean up to release memory,
@@ -1064,18 +1030,17 @@ EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo,
* if you're done with the JPEG object, but if you want to clean it up and * if you're done with the JPEG object, but if you want to clean it up and
* reuse it, call this: * reuse it, call this:
*/ */
EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo)); EXTERN(void) jpeg_abort_compress (j_compress_ptr cinfo);
EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo)); EXTERN(void) jpeg_abort_decompress (j_decompress_ptr cinfo);
/* Generic versions of jpeg_abort and jpeg_destroy that work on either /* Generic versions of jpeg_abort and jpeg_destroy that work on either
* flavor of JPEG object. These may be more convenient in some places. * flavor of JPEG object. These may be more convenient in some places.
*/ */
EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo)); EXTERN(void) jpeg_abort (j_common_ptr cinfo);
EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo)); EXTERN(void) jpeg_destroy (j_common_ptr cinfo);
/* Default restart-marker-resync procedure for use by data source modules */ /* Default restart-marker-resync procedure for use by data source modules */
EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo, EXTERN(boolean) jpeg_resync_to_restart (j_decompress_ptr cinfo, int desired);
int desired));
/* These marker codes are exported since applications and data source modules /* These marker codes are exported since applications and data source modules

85
jsimd.h
View File

@@ -10,74 +10,67 @@
* *
*/ */
EXTERN(int) jsimd_can_rgb_ycc JPP((void)); EXTERN(int) jsimd_can_rgb_ycc (void);
EXTERN(int) jsimd_can_rgb_gray JPP((void)); EXTERN(int) jsimd_can_rgb_gray (void);
EXTERN(int) jsimd_can_ycc_rgb JPP((void)); EXTERN(int) jsimd_can_ycc_rgb (void);
EXTERN(int) jsimd_c_can_null_convert JPP((void)); EXTERN(int) jsimd_c_can_null_convert (void);
EXTERN(void) jsimd_rgb_ycc_convert EXTERN(void) jsimd_rgb_ycc_convert
JPP((j_compress_ptr cinfo, (j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows);
JDIMENSION output_row, int num_rows));
EXTERN(void) jsimd_rgb_gray_convert EXTERN(void) jsimd_rgb_gray_convert
JPP((j_compress_ptr cinfo, (j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows);
JDIMENSION output_row, int num_rows));
EXTERN(void) jsimd_ycc_rgb_convert EXTERN(void) jsimd_ycc_rgb_convert
JPP((j_decompress_ptr cinfo, (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION input_row,
JSAMPIMAGE input_buf, JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows);
JSAMPARRAY output_buf, int num_rows));
EXTERN(void) jsimd_c_null_convert EXTERN(void) jsimd_c_null_convert
JPP((j_compress_ptr cinfo, (j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows);
JDIMENSION output_row, int num_rows));
EXTERN(int) jsimd_can_h2v2_downsample JPP((void)); EXTERN(int) jsimd_can_h2v2_downsample (void);
EXTERN(int) jsimd_can_h2v1_downsample JPP((void)); EXTERN(int) jsimd_can_h2v1_downsample (void);
EXTERN(void) jsimd_h2v2_downsample EXTERN(void) jsimd_h2v2_downsample
JPP((j_compress_ptr cinfo, jpeg_component_info * compptr, (j_compress_ptr cinfo, jpeg_component_info * compptr,
JSAMPARRAY input_data, JSAMPARRAY output_data)); JSAMPARRAY input_data, JSAMPARRAY output_data);
EXTERN(int) jsimd_can_h2v2_smooth_downsample JPP((void)); EXTERN(int) jsimd_can_h2v2_smooth_downsample (void);
EXTERN(void) jsimd_h2v2_smooth_downsample EXTERN(void) jsimd_h2v2_smooth_downsample
JPP((j_compress_ptr cinfo, jpeg_component_info * compptr, (j_compress_ptr cinfo, jpeg_component_info * compptr,
JSAMPARRAY input_data, JSAMPARRAY output_data)); JSAMPARRAY input_data, JSAMPARRAY output_data);
EXTERN(void) jsimd_h2v1_downsample EXTERN(void) jsimd_h2v1_downsample
JPP((j_compress_ptr cinfo, jpeg_component_info * compptr, (j_compress_ptr cinfo, jpeg_component_info * compptr,
JSAMPARRAY input_data, JSAMPARRAY output_data)); JSAMPARRAY input_data, JSAMPARRAY output_data);
EXTERN(int) jsimd_can_h2v2_upsample JPP((void)); EXTERN(int) jsimd_can_h2v2_upsample (void);
EXTERN(int) jsimd_can_h2v1_upsample JPP((void)); EXTERN(int) jsimd_can_h2v1_upsample (void);
EXTERN(void) jsimd_h2v2_upsample EXTERN(void) jsimd_h2v2_upsample
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)); JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr);
EXTERN(void) jsimd_h2v1_upsample EXTERN(void) jsimd_h2v1_upsample
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)); JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr);
EXTERN(int) jsimd_can_h2v2_fancy_upsample JPP((void)); EXTERN(int) jsimd_can_h2v2_fancy_upsample (void);
EXTERN(int) jsimd_can_h2v1_fancy_upsample JPP((void)); EXTERN(int) jsimd_can_h2v1_fancy_upsample (void);
EXTERN(void) jsimd_h2v2_fancy_upsample EXTERN(void) jsimd_h2v2_fancy_upsample
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)); JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr);
EXTERN(void) jsimd_h2v1_fancy_upsample EXTERN(void) jsimd_h2v1_fancy_upsample
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr,
JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)); JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr);
EXTERN(int) jsimd_can_h2v2_merged_upsample JPP((void)); EXTERN(int) jsimd_can_h2v2_merged_upsample (void);
EXTERN(int) jsimd_can_h2v1_merged_upsample JPP((void)); EXTERN(int) jsimd_can_h2v1_merged_upsample (void);
EXTERN(void) jsimd_h2v2_merged_upsample EXTERN(void) jsimd_h2v2_merged_upsample
JPP((j_decompress_ptr cinfo, (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf);
JSAMPARRAY output_buf));
EXTERN(void) jsimd_h2v1_merged_upsample EXTERN(void) jsimd_h2v1_merged_upsample
JPP((j_decompress_ptr cinfo, (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf);
JSAMPARRAY output_buf));

119
jsimddct.h
View File

@@ -9,77 +9,66 @@
* *
*/ */
EXTERN(int) jsimd_can_convsamp JPP((void)); EXTERN(int) jsimd_can_convsamp (void);
EXTERN(int) jsimd_can_convsamp_float JPP((void)); EXTERN(int) jsimd_can_convsamp_float (void);
EXTERN(void) jsimd_convsamp JPP((JSAMPARRAY sample_data, EXTERN(void) jsimd_convsamp (JSAMPARRAY sample_data, JDIMENSION start_col,
JDIMENSION start_col, DCTELEM * workspace);
DCTELEM * workspace)); EXTERN(void) jsimd_convsamp_float (JSAMPARRAY sample_data,
EXTERN(void) jsimd_convsamp_float JPP((JSAMPARRAY sample_data, JDIMENSION start_col,
JDIMENSION start_col, FAST_FLOAT * workspace);
FAST_FLOAT * workspace));
EXTERN(int) jsimd_can_fdct_islow JPP((void)); EXTERN(int) jsimd_can_fdct_islow (void);
EXTERN(int) jsimd_can_fdct_ifast JPP((void)); EXTERN(int) jsimd_can_fdct_ifast (void);
EXTERN(int) jsimd_can_fdct_float JPP((void)); EXTERN(int) jsimd_can_fdct_float (void);
EXTERN(void) jsimd_fdct_islow JPP((DCTELEM * data)); EXTERN(void) jsimd_fdct_islow (DCTELEM * data);
EXTERN(void) jsimd_fdct_ifast JPP((DCTELEM * data)); EXTERN(void) jsimd_fdct_ifast (DCTELEM * data);
EXTERN(void) jsimd_fdct_float JPP((FAST_FLOAT * data)); EXTERN(void) jsimd_fdct_float (FAST_FLOAT * data);
EXTERN(int) jsimd_can_quantize JPP((void)); EXTERN(int) jsimd_can_quantize (void);
EXTERN(int) jsimd_can_quantize_float JPP((void)); EXTERN(int) jsimd_can_quantize_float (void);
EXTERN(void) jsimd_quantize JPP((JCOEFPTR coef_block, EXTERN(void) jsimd_quantize (JCOEFPTR coef_block, DCTELEM * divisors,
DCTELEM * divisors, DCTELEM * workspace);
DCTELEM * workspace)); EXTERN(void) jsimd_quantize_float (JCOEFPTR coef_block, FAST_FLOAT * divisors,
EXTERN(void) jsimd_quantize_float JPP((JCOEFPTR coef_block, FAST_FLOAT * workspace);
FAST_FLOAT * divisors,
FAST_FLOAT * workspace));
EXTERN(int) jsimd_can_idct_2x2 JPP((void)); EXTERN(int) jsimd_can_idct_2x2 (void);
EXTERN(int) jsimd_can_idct_4x4 JPP((void)); EXTERN(int) jsimd_can_idct_4x4 (void);
EXTERN(int) jsimd_can_idct_6x6 JPP((void)); EXTERN(int) jsimd_can_idct_6x6 (void);
EXTERN(int) jsimd_can_idct_12x12 JPP((void)); EXTERN(int) jsimd_can_idct_12x12 (void);
EXTERN(void) jsimd_idct_2x2 JPP((j_decompress_ptr cinfo, EXTERN(void) jsimd_idct_2x2 (j_decompress_ptr cinfo,
jpeg_component_info * compptr, jpeg_component_info * compptr,
JCOEFPTR coef_block, JCOEFPTR coef_block, JSAMPARRAY output_buf,
JSAMPARRAY output_buf, JDIMENSION output_col);
JDIMENSION output_col)); EXTERN(void) jsimd_idct_4x4 (j_decompress_ptr cinfo,
EXTERN(void) jsimd_idct_4x4 JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf,
JCOEFPTR coef_block, JDIMENSION output_col);
JSAMPARRAY output_buf, EXTERN(void) jsimd_idct_6x6 (j_decompress_ptr cinfo,
JDIMENSION output_col)); jpeg_component_info * compptr,
EXTERN(void) jsimd_idct_6x6 JPP((j_decompress_ptr cinfo, JCOEFPTR coef_block, JSAMPARRAY output_buf,
jpeg_component_info * compptr, JDIMENSION output_col);
JCOEFPTR coef_block, EXTERN(void) jsimd_idct_12x12 (j_decompress_ptr cinfo,
JSAMPARRAY output_buf, jpeg_component_info * compptr,
JDIMENSION output_col)); JCOEFPTR coef_block, JSAMPARRAY output_buf,
EXTERN(void) jsimd_idct_12x12 JPP((j_decompress_ptr cinfo, JDIMENSION output_col);
jpeg_component_info * compptr,
JCOEFPTR coef_block,
JSAMPARRAY output_buf,
JDIMENSION output_col));
EXTERN(int) jsimd_can_idct_islow JPP((void)); EXTERN(int) jsimd_can_idct_islow (void);
EXTERN(int) jsimd_can_idct_ifast JPP((void)); EXTERN(int) jsimd_can_idct_ifast (void);
EXTERN(int) jsimd_can_idct_float JPP((void)); EXTERN(int) jsimd_can_idct_float (void);
EXTERN(void) jsimd_idct_islow JPP((j_decompress_ptr cinfo,
jpeg_component_info * compptr,
JCOEFPTR coef_block,
JSAMPARRAY output_buf,
JDIMENSION output_col));
EXTERN(void) jsimd_idct_ifast JPP((j_decompress_ptr cinfo,
jpeg_component_info * compptr,
JCOEFPTR coef_block,
JSAMPARRAY output_buf,
JDIMENSION output_col));
EXTERN(void) jsimd_idct_float JPP((j_decompress_ptr cinfo,
jpeg_component_info * compptr,
JCOEFPTR coef_block,
JSAMPARRAY output_buf,
JDIMENSION output_col));
EXTERN(void) jsimd_idct_islow (j_decompress_ptr cinfo,
jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf,
JDIMENSION output_col);
EXTERN(void) jsimd_idct_ifast (j_decompress_ptr cinfo,
jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf,
JDIMENSION output_col);
EXTERN(void) jsimd_idct_float (j_decompress_ptr cinfo,
jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf,
JDIMENSION output_col);

5
rdtarga.c
View File

@@ -56,7 +56,7 @@ typedef struct _tga_source_struct {
JDIMENSION current_row; /* Current logical row number to read */ JDIMENSION current_row; /* Current logical row number to read */
/* Pointer to routine to extract next Targa pixel from input file */ /* Pointer to routine to extract next Targa pixel from input file */
JMETHOD(void, read_pixel, (tga_source_ptr sinfo)); void (*read_pixel) (tga_source_ptr sinfo);
/* Result of read_pixel is delivered here: */ /* Result of read_pixel is delivered here: */
U_CHAR tga_pixel[4]; U_CHAR tga_pixel[4];
@@ -68,8 +68,7 @@ typedef struct _tga_source_struct {
int dup_pixel_count; /* # of times to duplicate previous pixel */ int dup_pixel_count; /* # of times to duplicate previous pixel */
/* This saves the correct pixel-row-expansion method for preload_image */ /* This saves the correct pixel-row-expansion method for preload_image */
JMETHOD(JDIMENSION, get_pixel_rows, (j_compress_ptr cinfo, JDIMENSION (*get_pixel_rows) (j_compress_ptr cinfo, cjpeg_source_ptr sinfo);
cjpeg_source_ptr sinfo));
} tga_source_struct; } tga_source_struct;

1150
simd/jsimd.h
View File

File diff suppressed because it is too large Load Diff

25
transupp.h
View File

@@ -154,27 +154,24 @@ typedef struct {
/* Parse a crop specification (written in X11 geometry style) */ /* Parse a crop specification (written in X11 geometry style) */
EXTERN(boolean) jtransform_parse_crop_spec EXTERN(boolean) jtransform_parse_crop_spec
JPP((jpeg_transform_info *info, const char *spec)); (jpeg_transform_info *info, const char *spec);
/* Request any required workspace */ /* Request any required workspace */
EXTERN(boolean) jtransform_request_workspace EXTERN(boolean) jtransform_request_workspace
JPP((j_decompress_ptr srcinfo, jpeg_transform_info *info)); (j_decompress_ptr srcinfo, jpeg_transform_info *info);
/* Adjust output image parameters */ /* Adjust output image parameters */
EXTERN(jvirt_barray_ptr *) jtransform_adjust_parameters EXTERN(jvirt_barray_ptr *) jtransform_adjust_parameters
JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo, (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
jvirt_barray_ptr *src_coef_arrays, jvirt_barray_ptr *src_coef_arrays, jpeg_transform_info *info);
jpeg_transform_info *info));
/* Execute the actual transformation, if any */ /* Execute the actual transformation, if any */
EXTERN(void) jtransform_execute_transform EXTERN(void) jtransform_execute_transform
JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo, (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
jvirt_barray_ptr *src_coef_arrays, jvirt_barray_ptr *src_coef_arrays, jpeg_transform_info *info);
jpeg_transform_info *info));
/* Determine whether lossless transformation is perfectly /* Determine whether lossless transformation is perfectly
* possible for a specified image and transformation. * possible for a specified image and transformation.
*/ */
EXTERN(boolean) jtransform_perfect_transform EXTERN(boolean) jtransform_perfect_transform
JPP((JDIMENSION image_width, JDIMENSION image_height, (JDIMENSION image_width, JDIMENSION image_height, int MCU_width,
int MCU_width, int MCU_height, int MCU_height, JXFORM_CODE transform);
JXFORM_CODE transform));
/* jtransform_execute_transform used to be called /* jtransform_execute_transform used to be called
* jtransform_execute_transformation, but some compilers complain about * jtransform_execute_transformation, but some compilers complain about
@@ -200,8 +197,8 @@ typedef enum {
/* Setup decompression object to save desired markers in memory */ /* Setup decompression object to save desired markers in memory */
EXTERN(void) jcopy_markers_setup EXTERN(void) jcopy_markers_setup
JPP((j_decompress_ptr srcinfo, JCOPY_OPTION option)); (j_decompress_ptr srcinfo, JCOPY_OPTION option);
/* Copy markers saved in the given source object to the destination object */ /* Copy markers saved in the given source object to the destination object */
EXTERN(void) jcopy_markers_execute EXTERN(void) jcopy_markers_execute
JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo, (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
JCOPY_OPTION option)); JCOPY_OPTION option);

4
turbojpeg.c
View File

@@ -1311,8 +1311,8 @@ DLLEXPORT int DLLCALL tjDecodeYUV(tjhandle handle, unsigned char *srcBuf,
unsigned char *rgbBuf=NULL; unsigned char *rgbBuf=NULL;
unsigned char *_dstBuf=NULL; int _pitch=0; unsigned char *_dstBuf=NULL; int _pitch=0;
#endif #endif
JMETHOD(int, old_read_markers, (j_decompress_ptr)); int (*old_read_markers)(j_decompress_ptr);
JMETHOD(void, old_reset_marker_reader, (j_decompress_ptr)); void (*old_reset_marker_reader)(j_decompress_ptr);
getdinstance(handle); getdinstance(handle);

1
win/jconfig.h.in
View File

@@ -7,7 +7,6 @@
#cmakedefine D_ARITH_CODING_SUPPORTED #cmakedefine D_ARITH_CODING_SUPPORTED
#cmakedefine MEM_SRCDST_SUPPORTED #cmakedefine MEM_SRCDST_SUPPORTED
#define HAVE_PROTOTYPES
#define HAVE_UNSIGNED_CHAR #define HAVE_UNSIGNED_CHAR
#define HAVE_UNSIGNED_SHORT #define HAVE_UNSIGNED_SHORT
/* #define void char */ /* #define void char */

4
wrbmp.c
View File

@@ -60,8 +60,8 @@ typedef bmp_dest_struct * bmp_dest_ptr;
/* Forward declarations */ /* Forward declarations */
LOCAL(void) write_colormap LOCAL(void) write_colormap
JPP((j_decompress_ptr cinfo, bmp_dest_ptr dest, (j_decompress_ptr cinfo, bmp_dest_ptr dest, int map_colors,
int map_colors, int map_entry_size)); int map_entry_size);
/* /*

4
wrrle.c
View File

@@ -63,8 +63,8 @@ typedef rle_dest_struct * rle_dest_ptr;
/* Forward declarations */ /* Forward declarations */
METHODDEF(void) rle_put_pixel_rows METHODDEF(void) rle_put_pixel_rows
JPP((j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
JDIMENSION rows_supplied)); JDIMENSION rows_supplied);
/* /*